@harbour-enterprises/superdoc 1.17.0-next.11 → 1.17.0-next.13

package/dist/superdoc.umd.js

@@ -2477,7 +2477,7 @@
 		if (last >= 0 && child.isText && child.sameMarkup(target[last])) target[last] = child.withText(target[last].text + child.text);
 		else target.push(child);
 	}
-	function addRange$1($start, $end, depth, target) {
+	function addRange($start, $end, depth, target) {
 		let node$1 = ($end || $start).node(depth);
 		let startIndex = 0, endIndex = $end ? $end.index(depth) : node$1.childCount;
 		if ($start) {
@@ -2499,23 +2499,23 @@
 		let openStart = $from.depth > depth && joinable$1($from, $start, depth + 1);
 		let openEnd = $to.depth > depth && joinable$1($end, $to, depth + 1);
 		let content$2 = [];
-		addRange$1(null, $from, depth, content$2);
+		addRange(null, $from, depth, content$2);
 		if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
 			checkJoin(openStart, openEnd);
 			addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content$2);
 		} else {
 			if (openStart) addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content$2);
-			addRange$1($start, $end, depth, content$2);
+			addRange($start, $end, depth, content$2);
 			if (openEnd) addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content$2);
 		}
-		addRange$1($to, null, depth, content$2);
+		addRange($to, null, depth, content$2);
 		return new Fragment$1(content$2);
 	}
 	function replaceTwoWay($from, $to, depth) {
 		let content$2 = [];
-		addRange$1(null, $from, depth, content$2);
+		addRange(null, $from, depth, content$2);
 		if ($from.depth > depth) addNode(close(joinable$1($from, $to, depth + 1), replaceTwoWay($from, $to, depth + 1)), content$2);
-		addRange$1($to, null, depth, content$2);
+		addRange($to, null, depth, content$2);
 		return new Fragment$1(content$2);
 	}
 	function prepareSliceForReplace(slice, $along) {
@@ -33326,7 +33326,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
 	var DEFAULT_ENDPOINT = "https://ingest.superdoc.dev/v1/collect";
 	function getSuperdocVersion() {
 		try {
-			return "1.17.0-next.11";
+			return "1.17.0-next.13";
 		} catch {
 			return "unknown";
 		}
@@ -36378,7 +36378,7 @@ Please report this to https://github.com/markedjs/marked.`, e) {
 		static getStoredSuperdocVersion(docx) {
 			return SuperConverter.getStoredCustomProperty(docx, "SuperdocVersion");
 		}
-		static setStoredSuperdocVersion(docx = this.convertedXml, version$2 = "1.17.0-next.11") {
+		static setStoredSuperdocVersion(docx = this.convertedXml, version$2 = "1.17.0-next.13") {
 			return SuperConverter.setStoredCustomProperty(docx, "SuperdocVersion", version$2, false);
 		}
 		static generateWordTimestamp() {
@@ -65760,7 +65760,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			return false;
 		}
 	};
-	var summaryVersion = "1.17.0-next.11";
+	var summaryVersion = "1.17.0-next.13";
 	var nodeKeys = [
 		"group",
 		"content",
@@ -66138,6 +66138,13 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		"image",
 		"sdt"
 	];
+	const DELETABLE_BLOCK_NODE_TYPES = [
+		"paragraph",
+		"heading",
+		"listItem",
+		"table",
+		"sdt"
+	];
 	const INLINE_NODE_TYPES = [
 		"run",
 		"bookmark",
@@ -66225,6 +66232,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		"TARGET_MOVED",
 		"PLAN_CONFLICT_OVERLAP",
 		"INVALID_STEP_COMBINATION",
+		"REVISION_CHANGED_SINCE_COMPILE",
+		"INVALID_INSERTION_CONTEXT",
+		"DOCUMENT_IDENTITY_CONFLICT",
 		"CAPABILITY_UNAVAILABLE"
 	];
 	var T_QUERY_MATCH = [
@@ -66326,6 +66336,27 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			referenceDocPath: "delete.mdx",
 			referenceGroup: "core"
 		},
+		"blocks.delete": {
+			memberPath: "blocks.delete",
+			description: "Delete an entire block node (paragraph, heading, list item, table, image, or sdt) deterministically.",
+			requiresDocumentContext: true,
+			metadata: mutationOperation({
+				idempotency: "conditional",
+				supportsDryRun: true,
+				supportsTrackedMode: false,
+				possibleFailureCodes: NONE_FAILURES,
+				throws: [
+					"TARGET_NOT_FOUND",
+					"AMBIGUOUS_TARGET",
+					"CAPABILITY_UNAVAILABLE",
+					"INVALID_TARGET",
+					"INVALID_INPUT",
+					"INTERNAL_ERROR"
+				]
+			}),
+			referenceDocPath: "blocks/delete.mdx",
+			referenceGroup: "blocks"
+		},
 		"format.apply": {
 			memberPath: "format.apply",
 			description: "Apply explicit inline style changes (bold, italic, underline, strike) to the target range using boolean patch semantics.",
@@ -66900,6 +66931,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}
 	var nodeTypeValues = NODE_TYPES;
 	var blockNodeTypeValues = BLOCK_NODE_TYPES;
+	var deletableBlockNodeTypeValues = DELETABLE_BLOCK_NODE_TYPES;
 	var inlineNodeTypeValues = INLINE_NODE_TYPES;
 	objectSchema({
 		start: { type: "integer" },
@@ -66936,6 +66968,14 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		"kind",
 		"nodeType",
 		"nodeId"
+	]), objectSchema({
+		kind: { const: "block" },
+		nodeType: { enum: [...deletableBlockNodeTypeValues] },
+		nodeId: { type: "string" }
+	}, [
+		"kind",
+		"nodeType",
+		"nodeId"
 	]), objectSchema({
 		kind: { const: "block" },
 		nodeType: { const: "paragraph" },
@@ -67087,6 +67127,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	var textAddressSchema = ref$1("TextAddress");
 	var textTargetSchema = ref$1("TextTarget");
 	var blockNodeAddressSchema = ref$1("BlockNodeAddress");
+	var deletableBlockNodeAddressSchema = ref$1("DeletableBlockNodeAddress");
 	var paragraphAddressSchema = ref$1("ParagraphAddress");
 	var headingAddressSchema = ref$1("HeadingAddress");
 	var listItemAddressSchema = ref$1("ListItemAddress");
@@ -67457,6 +67498,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}, ["address", "type"]));
 	var capabilityReasonsSchema = arraySchema({ enum: [
 		"COMMAND_UNAVAILABLE",
+		"HELPER_UNAVAILABLE",
 		"OPERATION_UNAVAILABLE",
 		"TRACKED_MODE_UNAVAILABLE",
 		"DRY_RUN_UNAVAILABLE",
@@ -67546,7 +67588,13 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}, ["target", "value"]), textMutationResultSchemaFor("format.color"), textMutationFailureSchemaFor("format.color"), objectSchema({
 		target: textAddressSchema,
 		alignment: { oneOf: [{ enum: [...ALIGNMENTS] }, { type: "null" }] }
-	}, ["target", "alignment"]), textMutationResultSchemaFor("format.align"), textMutationFailureSchemaFor("format.align"), objectSchema({
+	}, ["target", "alignment"]), textMutationResultSchemaFor("format.align"), textMutationFailureSchemaFor("format.align"), objectSchema({ target: deletableBlockNodeAddressSchema }, ["target"]), objectSchema({
+		success: { const: true },
+		deleted: deletableBlockNodeAddressSchema
+	}, ["success", "deleted"]), objectSchema({
+		success: { const: true },
+		deleted: deletableBlockNodeAddressSchema
+	}, ["success", "deleted"]), preApplyFailureResultSchemaFor("blocks.delete"), objectSchema({
 		at: { oneOf: [
 			objectSchema({ kind: { const: "documentStart" } }, ["kind"]),
 			objectSchema({ kind: { const: "documentEnd" } }, ["kind"]),
@@ -67724,6 +67772,11 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			description: "Primary read and write operations.",
 			pagePath: "core/index.mdx"
 		},
+		blocks: {
+			title: "Blocks",
+			description: "Block-level structural operations.",
+			pagePath: "blocks/index.mdx"
+		},
 		capabilities: {
 			title: "Capabilities",
 			description: "Runtime support discovery for capability-aware branching.",
@@ -67772,6 +67825,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}));
 	const CAPABILITY_REASON_CODES = [
 		"COMMAND_UNAVAILABLE",
+		"HELPER_UNAVAILABLE",
 		"OPERATION_UNAVAILABLE",
 		"TRACKED_MODE_UNAVAILABLE",
 		"DRY_RUN_UNAVAILABLE",
@@ -68069,6 +68123,27 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		validateCreateLocation(normalized.at, "create.heading");
 		return adapter.heading(normalized, normalizeMutationOptions(options$1));
 	}
+	var SUPPORTED_DELETE_NODE_TYPES = new Set(DELETABLE_BLOCK_NODE_TYPES);
+	var REJECTED_DELETE_NODE_TYPES = new Set(["tableRow", "tableCell"]);
+	function validateBlocksDeleteInput(input$1) {
+		if (!input$1 || typeof input$1 !== "object") throw new DocumentApiValidationError("INVALID_INPUT", "blocks.delete requires an input object.", { fields: ["input"] });
+		if (!input$1.target) throw new DocumentApiValidationError("INVALID_INPUT", "blocks.delete requires a target.", { fields: ["target"] });
+		if (input$1.target.kind !== "block") throw new DocumentApiValidationError("INVALID_INPUT", "blocks.delete target must have kind \"block\".", { fields: ["target.kind"] });
+		if (!input$1.target.nodeId || typeof input$1.target.nodeId !== "string") throw new DocumentApiValidationError("INVALID_INPUT", "blocks.delete target requires a nodeId string.", { fields: ["target.nodeId"] });
+		const { nodeType } = input$1.target;
+		if (REJECTED_DELETE_NODE_TYPES.has(nodeType)) throw new DocumentApiValidationError("INVALID_TARGET", `blocks.delete does not support "${nodeType}" targets. Table row/column operations are out of scope.`, {
+			fields: ["target.nodeType"],
+			nodeType
+		});
+		if (!SUPPORTED_DELETE_NODE_TYPES.has(nodeType)) throw new DocumentApiValidationError("INVALID_TARGET", `blocks.delete does not support "${nodeType}" targets.`, {
+			fields: ["target.nodeType"],
+			nodeType
+		});
+	}
+	function executeBlocksDelete(adapter, input$1, options$1) {
+		validateBlocksDeleteInput(input$1);
+		return adapter.delete(input$1, normalizeMutationOptions(options$1));
+	}
 	function executeTrackChangesList(adapter, input$1) {
 		return adapter.list(input$1);
 	}
@@ -68112,6 +68187,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			insert: (input$1, options$1) => api.insert(input$1, options$1),
 			replace: (input$1, options$1) => api.replace(input$1, options$1),
 			delete: (input$1, options$1) => api.delete(input$1, options$1),
+			"blocks.delete": (input$1, options$1) => api.blocks.delete(input$1, options$1),
 			"format.apply": (input$1, options$1) => api.format.apply(input$1, options$1),
 			"format.fontSize": (input$1, options$1) => api.format.fontSize(input$1, options$1),
 			"format.fontFamily": (input$1, options$1) => api.format.fontFamily(input$1, options$1),
@@ -68237,6 +68313,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 					return executeTrackChangesDecide(adapters.trackChanges, input$1, options$1);
 				}
 			},
+			blocks: { delete(input$1, options$1) {
+				return executeBlocksDelete(adapters.blocks, input$1, options$1);
+			} },
 			create: {
 				paragraph(input$1, options$1) {
 					return executeCreateParagraph(adapters.create, input$1, options$1);
@@ -68321,6 +68400,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		"lists.outdent": ["setTextSelection", "decreaseListIndent"],
 		"lists.restart": ["setTextSelection", "restartNumbering"],
 		"lists.exit": ["exitListItemAt"],
+		"blocks.delete": ["deleteBlockNodeById"],
 		"comments.create": [
 			"addComment",
 			"setTextSelection",
@@ -68349,6 +68429,12 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		if (!required || required.length === 0) return true;
 		return required.every((command$1) => hasCommand(editor, command$1));
 	}
+	var REQUIRED_HELPERS = { "blocks.delete": (editor) => typeof editor.helpers?.blockNode?.getBlockNodeById === "function" };
+	function hasRequiredHelpers(editor, operationId) {
+		const check = REQUIRED_HELPERS[operationId];
+		if (!check) return true;
+		return check(editor);
+	}
 	function hasMarkCapability(editor, markName) {
 		return Boolean(editor.schema?.marks?.[markName]);
 	}
@@ -68394,7 +68480,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	function isOperationAvailable(editor, operationId) {
 		if (operationId === "format.apply") return MARK_KEYS.some((key$1) => hasMarkCapability(editor, STYLE_MARK_SCHEMA_NAMES[key$1] ?? key$1));
 		if (INLINE_FORMAT_OPERATIONS.has(operationId)) return hasAllCommands(editor, operationId) && hasMarkCapability(editor, "textStyle");
-		return hasAllCommands(editor, operationId);
+		return hasAllCommands(editor, operationId) && hasRequiredHelpers(editor, operationId);
 	}
 	function isCommandBackedAvailability(operationId) {
 		return !isMarkBackedOperation(operationId) && !INLINE_FORMAT_OPERATIONS.has(operationId);
@@ -68408,7 +68494,10 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			const dryRun = metadata.supportsDryRun && available;
 			const reasons = [];
 			if (!available) {
-				if (isCommandBackedAvailability(operationId)) pushReason(reasons, "COMMAND_UNAVAILABLE");
+				if (isCommandBackedAvailability(operationId)) {
+					if (!hasAllCommands(editor, operationId)) pushReason(reasons, "COMMAND_UNAVAILABLE");
+					if (!hasRequiredHelpers(editor, operationId)) pushReason(reasons, "HELPER_UNAVAILABLE");
+				}
 				pushReason(reasons, "OPERATION_UNAVAILABLE");
 			}
 			if (metadata.supportsTrackedMode && !tracked) pushReason(reasons, "TRACKED_MODE_UNAVAILABLE");
@@ -68898,13 +68987,21 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		});
 		return {
 			candidates,
-			byId
+			byId,
+			ambiguous
 		};
 	}
 	function findBlockById(index$1, address) {
 		if (address.kind !== "block") return void 0;
 		return index$1.byId.get(`${address.nodeType}:${address.nodeId}`);
 	}
+	function findBlockByIdStrict(index$1, address) {
+		const key$1 = `${address.nodeType}:${address.nodeId}`;
+		if (index$1.ambiguous.has(key$1)) throw new DocumentApiAdapterError("AMBIGUOUS_TARGET", `Multiple blocks share key "${key$1}".`, { target: address });
+		const candidate = index$1.byId.get(key$1);
+		if (!candidate) throw new DocumentApiAdapterError("TARGET_NOT_FOUND", `Block "${key$1}" was not found.`, { target: address });
+		return candidate;
+	}
 	function isTextBlockCandidate(candidate) {
 		const node$1 = candidate.node;
 		return Boolean(node$1?.inlineContent || node$1?.isTextblock);
@@ -68990,9 +69087,11 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	function checkRevision(editor, expectedRevision) {
 		if (expectedRevision === void 0) return;
 		const current = getRevision(editor);
-		if (expectedRevision !== current) throw new PlanError("REVISION_MISMATCH", `REVISION_MISMATCH — expected revision "${expectedRevision}" but document is at "${current}"`, void 0, {
+		if (expectedRevision !== current) throw new PlanError("REVISION_MISMATCH", `REVISION_MISMATCH — expected revision "${expectedRevision}" but document is at "${current}". Re-run query.match to obtain a fresh ref.`, void 0, {
 			expectedRevision,
-			currentRevision: current
+			currentRevision: current,
+			refStability: "ephemeral",
+			remediation: "Re-run query.match() to obtain a fresh ref valid for the current revision."
 		});
 	}
 	function resolveSegmentPosition(targetOffset, segmentStart, segmentLength, docFrom, docTo) {
@@ -69242,7 +69341,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				return;
 			}
 			if (node$1.isLeaf) {
+				const start$1 = offset$1;
 				offset$1 += 1;
+				maybePushRun(start$1, offset$1, []);
 				return;
 			}
 			let isFirstChild = true;
@@ -69642,12 +69743,62 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	function isAssertStep(step) {
 		return step.op === "assert";
 	}
+	function isCreateOp(op) {
+		return op === "create.heading" || op === "create.paragraph";
+	}
+	var VALID_CREATE_POSITIONS = ["before", "after"];
 	function isSelectWhere(where) {
 		return where.by === "select";
 	}
 	function isRefWhere(where) {
 		return where.by === "ref";
 	}
+	function validateCreateStepPosition(step) {
+		const args$1 = step.args;
+		if (args$1.position === void 0 || args$1.position === null) {
+			args$1.position = "after";
+			return;
+		}
+		if (!VALID_CREATE_POSITIONS.includes(args$1.position)) throw planError("INVALID_INPUT", `create step requires args.position to be 'before' or 'after'`, step.id, {
+			receivedPosition: args$1.position,
+			allowedValues: [...VALID_CREATE_POSITIONS],
+			default: "after"
+		});
+	}
+	function resolveCreateAnchorFromTargets(targets, position$3, stepId) {
+		const target = targets[0];
+		if (!target) throw planError("INVALID_INPUT", "create step has no resolved targets", stepId);
+		if (target.kind === "range") return target.blockId;
+		const segments = target.segments;
+		if (!segments.length) throw planError("INVALID_INPUT", "span target has no segments", stepId);
+		return position$3 === "before" ? segments[0].blockId : segments[segments.length - 1].blockId;
+	}
+	function validateInsertionContext(editor, index$1, step, stepIndex, anchorBlockId, position$3) {
+		const candidate = index$1.candidates.find((c$3) => c$3.nodeId === anchorBlockId);
+		if (!candidate) return;
+		const paragraphType = editor.state.schema?.nodes?.paragraph;
+		if (!paragraphType) return;
+		const resolvedPos = editor.state.doc.resolve(candidate.pos);
+		const parent = resolvedPos.parent;
+		const anchorIndex = resolvedPos.index();
+		const insertionIndex = position$3 === "before" ? anchorIndex : anchorIndex + 1;
+		if (!(typeof parent.canReplaceWith === "function" ? parent.canReplaceWith(insertionIndex, insertionIndex, paragraphType) : parent.type.contentMatch.matchType(paragraphType))) {
+			const allowedChildTypes = [];
+			const match$1 = parent.type.contentMatch;
+			for (const nodeType of Object.values(editor.state.schema.nodes)) if (match$1.matchType(nodeType)) allowedChildTypes.push(nodeType.name);
+			throw planError("INVALID_INSERTION_CONTEXT", `Cannot create ${step.op} inside ${parent.type.name}`, step.id, {
+				stepIndex,
+				stepId: step.id,
+				operation: step.op,
+				anchorBlockId,
+				parentType: parent.type.name,
+				allowedChildTypes,
+				insertionIndex,
+				requestedChildType: "paragraph",
+				requestedSemanticType: step.op === "create.heading" ? "heading" : "paragraph"
+			});
+		}
+	}
 	function isV3Ref(payload) {
 		return typeof payload === "object" && payload !== null && "v" in payload && payload.v === 3;
 	}
@@ -69860,9 +70011,13 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}
 	function resolveV3TextRef(editor, index$1, step, refData) {
 		const currentRevision = getRevision(editor);
-		if (refData.rev !== currentRevision) throw planError("REVISION_MISMATCH", `text ref was created at revision "${refData.rev}" but document is at "${currentRevision}"`, step.id, {
+		if (refData.rev !== currentRevision) throw planError("REVISION_MISMATCH", `Text ref is ephemeral and revision-scoped. Re-run query.match to obtain a fresh handle.ref for revision ${currentRevision}.`, step.id, {
 			refRevision: refData.rev,
-			currentRevision
+			currentRevision,
+			refStability: "ephemeral",
+			refScope: refData.scope,
+			blockId: refData.segments?.[0]?.blockId,
+			remediation: `Re-run query.match() to obtain a fresh ref valid for the current revision.`
 		});
 		if (!refData.segments?.length) return [];
 		const segments = refData.segments.map((s$1) => ({
@@ -69961,7 +70116,11 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			return t.blockId !== prev.blockId || t.from !== prev.from || t.to !== prev.to;
 		});
 		if (refWhere) {
-			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", `ref "${refWhere.ref}" did not resolve to any targets`, step.id);
+			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", `ref "${refWhere.ref}" did not resolve to any targets`, step.id, {
+				selectorType: "ref",
+				selectorPattern: refWhere.ref,
+				candidateCount: 0
+			});
 			if (targets.length > 1) throw planError("AMBIGUOUS_MATCH", `ref "${refWhere.ref}" resolved to ${targets.length} targets`, step.id, { matchCount: targets.length });
 			return targets;
 		}
@@ -69970,57 +70129,157 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		if (selectWhere.require === "first" && targets.length > 1) targets = [targets[0]];
 		return targets;
 	}
+	function buildMatchNotFoundDetails(step) {
+		const where = step.where;
+		const select$1 = "select" in where ? where.select : void 0;
+		const within$1 = "within" in where ? where.within : void 0;
+		return {
+			selectorType: select$1?.type ?? "unknown",
+			selectorPattern: select$1?.pattern ?? "",
+			selectorMode: select$1?.mode ?? "contains",
+			searchScope: within$1?.blockId ?? "document",
+			candidateCount: 0
+		};
+	}
 	function applyCardinalityCheck(step, targets) {
 		const where = step.where;
 		if (!("require" in where) || where.require === void 0) return;
 		const require$1 = where.require;
 		if (require$1 === "first") {
-			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id);
+			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id, buildMatchNotFoundDetails(step));
 		} else if (require$1 === "exactlyOne") {
-			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id);
+			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id, buildMatchNotFoundDetails(step));
 			if (targets.length > 1) throw planError("AMBIGUOUS_MATCH", `selector matched ${targets.length} ranges, expected exactly one`, step.id, { matchCount: targets.length });
 		} else if (require$1 === "all") {
-			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id);
-		}
-	}
-	function detectOverlaps(steps) {
-		const rangesByBlock = /* @__PURE__ */ new Map();
-		for (const compiled of steps) for (const target of compiled.targets) if (target.kind === "range") addRange(rangesByBlock, target.blockId, target.stepId, target.from, target.to);
-		else for (const seg of target.segments) addRange(rangesByBlock, seg.blockId, target.stepId, seg.from, seg.to);
-		for (const [blockId, ranges] of rangesByBlock) {
-			ranges.sort((a$1, b$2) => a$1.from - b$2.from);
-			for (let i$1 = 1; i$1 < ranges.length; i$1++) {
-				const prev = ranges[i$1 - 1];
-				const curr = ranges[i$1];
-				if (prev.stepId !== curr.stepId && prev.to > curr.from) throw planError("PLAN_CONFLICT_OVERLAP", `steps "${prev.stepId}" and "${curr.stepId}" target overlapping ranges in block "${blockId}"`, curr.stepId, {
+			if (targets.length === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", step.id, buildMatchNotFoundDetails(step));
+		}
+	}
+	const STEP_INTERACTION_MATRIX = new Map([
+		["text.rewrite::format.apply::same_target", "allow"],
+		["text.rewrite::text.rewrite::same_target", "reject"],
+		["text.rewrite::text.delete::overlapping", "reject"],
+		["text.rewrite::create.*::same_block", "allow"],
+		["text.rewrite::text.insert::same_target", "reject"],
+		["format.apply::format.apply::same_target", "allow"],
+		["format.apply::text.rewrite::same_target", "reject"],
+		["format.apply::text.delete::overlapping", "reject"],
+		["format.apply::create.*::same_block", "allow"],
+		["format.apply::text.insert::same_target", "allow"],
+		["text.delete::text.rewrite::overlapping", "reject"],
+		["text.delete::text.delete::overlapping", "reject"],
+		["text.delete::format.apply::overlapping", "reject"],
+		["text.delete::create.*::same_block", "allow"],
+		["text.delete::text.insert::overlapping", "reject"],
+		["create.*::text.rewrite::same_block", "allow"],
+		["create.*::format.apply::same_block", "allow"],
+		["create.*::text.delete::same_block", "allow"],
+		["create.*::create.*::same_block", "allow"],
+		["create.*::text.insert::same_block", "allow"],
+		["text.insert::format.apply::same_target", "allow"],
+		["text.insert::text.rewrite::same_target", "reject"],
+		["text.insert::text.delete::overlapping", "reject"],
+		["text.insert::create.*::same_block", "allow"],
+		["text.insert::text.insert::same_target", "reject"]
+	]);
+	const MATRIX_EXEMPT_OPS = new Set(["assert"]);
+	function normalizeOpForMatrix(op) {
+		return op.startsWith("create.") ? "create.*" : op;
+	}
+	function classifyOverlap(stepA, stepB) {
+		const rangesA = extractBlockRanges(stepA);
+		const rangesB = extractBlockRanges(stepB);
+		const opA = normalizeOpForMatrix(stepA.step.op);
+		const opB = normalizeOpForMatrix(stepB.step.op);
+		const isCreateA = opA === "create.*";
+		const isCreateB = opB === "create.*";
+		for (const [blockId, aEntries] of rangesA) {
+			const bEntries = rangesB.get(blockId);
+			if (!bEntries) continue;
+			for (const a$1 of aEntries) for (const b$2 of bEntries) {
+				if (isCreateA || isCreateB) return {
+					overlapClass: "same_block",
 					blockId,
-					rangeA: {
-						from: prev.from,
-						to: prev.to
-					},
-					rangeB: {
-						from: curr.from,
-						to: curr.to
-					}
-				});
+					rangeA: a$1,
+					rangeB: b$2
+				};
+				if (a$1.to <= b$2.from || b$2.to <= a$1.from) continue;
+				if (a$1.from === b$2.from && a$1.to === b$2.to) return {
+					overlapClass: "same_target",
+					blockId,
+					rangeA: a$1,
+					rangeB: b$2
+				};
+				return {
+					overlapClass: "overlapping",
+					blockId,
+					rangeA: a$1,
+					rangeB: b$2
+				};
 			}
 		}
 	}
-	function addRange(map$5, blockId, stepId, from$1, to) {
-		let blockRanges = map$5.get(blockId);
-		if (!blockRanges) {
-			blockRanges = [];
-			map$5.set(blockId, blockRanges);
+	function extractBlockRanges(compiled) {
+		const result = /* @__PURE__ */ new Map();
+		for (const target of compiled.targets) if (target.kind === "range") pushBlockRange(result, target.blockId, target.from, target.to);
+		else for (const seg of target.segments) pushBlockRange(result, seg.blockId, seg.from, seg.to);
+		return result;
+	}
+	function pushBlockRange(map$5, blockId, from$1, to) {
+		let entries = map$5.get(blockId);
+		if (!entries) {
+			entries = [];
+			map$5.set(blockId, entries);
 		}
-		blockRanges.push({
-			stepId,
+		entries.push({
 			from: from$1,
 			to
 		});
 	}
+	function validateStepInteractions(steps) {
+		for (let i$1 = 0; i$1 < steps.length; i$1++) for (let j$1 = i$1 + 1; j$1 < steps.length; j$1++) {
+			const stepA = steps[i$1];
+			const stepB = steps[j$1];
+			if (MATRIX_EXEMPT_OPS.has(stepA.step.op) || MATRIX_EXEMPT_OPS.has(stepB.step.op)) continue;
+			const overlap = classifyOverlap(stepA, stepB);
+			if (!overlap) continue;
+			const matrixKey = `${normalizeOpForMatrix(stepA.step.op)}::${normalizeOpForMatrix(stepB.step.op)}::${overlap.overlapClass}`;
+			const verdict = STEP_INTERACTION_MATRIX.get(matrixKey) ?? "reject";
+			if (verdict === "reject") throw planError("PLAN_CONFLICT_OVERLAP", `steps "${stepA.step.id}" and "${stepB.step.id}" target overlapping ranges in block "${overlap.blockId}"`, stepB.step.id, {
+				blockId: overlap.blockId,
+				stepIdA: stepA.step.id,
+				stepIdB: stepB.step.id,
+				opKeyA: stepA.step.op,
+				opKeyB: stepB.step.op,
+				rangeA: overlap.rangeA,
+				rangeB: overlap.rangeB,
+				overlapRegion: {
+					from: Math.max(overlap.rangeA.from, overlap.rangeB.from),
+					to: Math.min(overlap.rangeA.to, overlap.rangeB.to)
+				},
+				matrixVerdict: verdict,
+				matrixKey
+			});
+		}
+	}
+	function assertNoDuplicateBlockIds(index$1) {
+		const seen = /* @__PURE__ */ new Map();
+		const duplicates = [];
+		for (const candidate of index$1.candidates) {
+			const count = seen.get(candidate.nodeId) ?? 0;
+			seen.set(candidate.nodeId, count + 1);
+			if (count === 1) duplicates.push(candidate.nodeId);
+		}
+		if (duplicates.length > 0) throw planError("DOCUMENT_IDENTITY_CONFLICT", "Document contains blocks with duplicate identities. This must be resolved before mutations can be applied.", void 0, {
+			duplicateBlockIds: duplicates,
+			blockCount: duplicates.length,
+			remediation: "Re-import the document or call document.repair() to assign unique identities."
+		});
+	}
 	function compilePlan(editor, steps) {
 		if (steps.length > 200) throw planError("INVALID_INPUT", `plan contains ${steps.length} steps, maximum is 200`);
+		const compiledRevision = getRevision(editor);
 		const index$1 = getBlockIndex(editor);
+		assertNoDuplicateBlockIds(index$1);
 		const mutationSteps = [];
 		const assertSteps = [];
 		const seenIds = /* @__PURE__ */ new Set();
@@ -70030,26 +70289,41 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			seenIds.add(step.id);
 		}
 		let totalTargets = 0;
+		let stepIndex = 0;
 		for (const step of steps) {
 			if (isAssertStep(step)) {
 				assertSteps.push(step);
+				stepIndex++;
 				continue;
 			}
 			if (!hasStepExecutor(step.op)) throw planError("INVALID_INPUT", `unknown step op "${step.op}"`, step.id);
+			if (isCreateOp(step.op)) validateCreateStepPosition(step);
 			const targets = resolveStepTargets(editor, index$1, step);
+			if (isCreateOp(step.op) && targets.length > 0) {
+				const position$3 = step.args.position ?? "after";
+				const anchorBlockId = resolveCreateAnchorFromTargets(targets, position$3, step.id);
+				validateInsertionContext(editor, index$1, step, stepIndex, anchorBlockId, position$3);
+			}
 			totalTargets += targets.length;
 			mutationSteps.push({
 				step,
 				targets
 			});
+			stepIndex++;
 		}
 		if (totalTargets > 500) throw planError("INVALID_INPUT", `plan resolved ${totalTargets} total targets, maximum is 500`);
-		detectOverlaps(mutationSteps);
+		validateStepInteractions(mutationSteps);
 		return {
 			mutationSteps,
-			assertSteps
+			assertSteps,
+			compiledRevision
 		};
 	}
+	function resolveBlockInsertionPos(editor, anchorBlockId, position$3, stepId) {
+		const candidate = getBlockIndex(editor).candidates.find((c$3) => c$3.nodeId === anchorBlockId);
+		if (!candidate) throw planError("TARGET_NOT_FOUND", `block "${anchorBlockId}" not found`, stepId);
+		return position$3 === "before" ? candidate.pos : candidate.end;
+	}
 	function applyDirectMutationMeta(tr) {
 		tr.setMeta("inputType", "programmatic");
 		tr.setMeta("skipTrackChanges", true);
@@ -70094,10 +70368,28 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		if (setMarks.strike && schema.marks.strike) marks.push(schema.marks.strike.create());
 		return marks;
 	}
-	function toAbsoluteBlockInsertPos(editor, blockId, offset$1, stepId) {
-		const candidate = getBlockIndex(editor).candidates.find((c$3) => c$3.nodeId === blockId);
-		if (!candidate) throw planError("TARGET_NOT_FOUND", `block "${blockId}" not found`, stepId);
-		return candidate.pos + offset$1;
+	function applyInlineMarkPatches(editor, tr, absFrom, absTo, inline) {
+		const { schema } = editor.state;
+		let changed = false;
+		const markEntries = [
+			[inline.bold, schema.marks.bold],
+			[inline.italic, schema.marks.italic],
+			[inline.underline, schema.marks.underline],
+			[inline.strike, schema.marks.strike]
+		];
+		for (const [value, markType] of markEntries) {
+			if (value === void 0 || !markType) continue;
+			if (value) tr.addMark(absFrom, absTo, markType.create());
+			else tr.removeMark(absFrom, absTo, markType);
+			changed = true;
+		}
+		return changed;
+	}
+	function resolveCreateAnchorBlockId(target, position$3, stepId) {
+		if (target.kind === "range") return target.blockId;
+		const segments = target.segments;
+		if (!segments.length) throw planError("INVALID_INPUT", "span target has no segments", stepId);
+		return position$3 === "before" ? segments[0].blockId : segments[segments.length - 1].blockId;
 	}
 	function executeTextRewrite(editor, tr, target, step, mapping) {
 		const absFrom = mapping.map(target.absFrom);
@@ -70131,39 +70423,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		return { changed: true };
 	}
 	function executeStyleApply(editor, tr, target, step, mapping) {
-		const absFrom = mapping.map(target.absFrom);
-		const absTo = mapping.map(target.absTo);
-		const { schema } = editor.state;
-		let changed = false;
-		const markEntries = [
-			[
-				"bold",
-				step.args.inline.bold,
-				schema.marks.bold
-			],
-			[
-				"italic",
-				step.args.inline.italic,
-				schema.marks.italic
-			],
-			[
-				"underline",
-				step.args.inline.underline,
-				schema.marks.underline
-			],
-			[
-				"strike",
-				step.args.inline.strike,
-				schema.marks.strike
-			]
-		];
-		for (const [, value, markType] of markEntries) {
-			if (value === void 0 || !markType) continue;
-			if (value) tr.addMark(absFrom, absTo, markType.create());
-			else tr.removeMark(absFrom, absTo, markType);
-			changed = true;
-		}
-		return { changed };
+		return { changed: applyInlineMarkPatches(editor, tr, mapping.map(target.absFrom), mapping.map(target.absTo), step.args.inline) };
 	}
 	function validateMappedSpanContiguity(target, mapping, stepId) {
 		let lastMappedEnd = -1;
@@ -70224,41 +70484,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}
 	function executeSpanStyleApply(editor, tr, target, step, mapping) {
 		validateMappedSpanContiguity(target, mapping, step.id);
-		const { schema } = editor.state;
-		let changed = false;
 		const firstSeg = target.segments[0];
 		const lastSeg = target.segments[target.segments.length - 1];
-		const absFrom = mapping.map(firstSeg.absFrom, 1);
-		const absTo = mapping.map(lastSeg.absTo, -1);
-		const markEntries = [
-			[
-				"bold",
-				step.args.inline.bold,
-				schema.marks.bold
-			],
-			[
-				"italic",
-				step.args.inline.italic,
-				schema.marks.italic
-			],
-			[
-				"underline",
-				step.args.inline.underline,
-				schema.marks.underline
-			],
-			[
-				"strike",
-				step.args.inline.strike,
-				schema.marks.strike
-			]
-		];
-		for (const [, value, markType] of markEntries) {
-			if (value === void 0 || !markType) continue;
-			if (value) tr.addMark(absFrom, absTo, markType.create());
-			else tr.removeMark(absFrom, absTo, markType);
-			changed = true;
-		}
-		return { changed };
+		return { changed: applyInlineMarkPatches(editor, tr, mapping.map(firstSeg.absFrom, 1), mapping.map(lastSeg.absTo, -1), step.args.inline) };
 	}
 	function getReplacementText(replacement) {
 		if (replacement.blocks !== void 0) return replacement.blocks.map((b$2) => b$2.text).join("\n\n");
@@ -70370,7 +70598,8 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		});
 		return {
 			candidates,
-			byId
+			byId,
+			ambiguous
 		};
 	}
 	function resolveAssertScope(index$1, select$1, within$1) {
@@ -70428,9 +70657,11 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 	}
 	function executeCreateStep(editor, tr, step, targets, mapping) {
 		const target = targets[0];
-		if (!target || target.kind !== "range") throw planError("INVALID_INPUT", `${step.op} step requires exactly one range target`, step.id);
+		if (!target) throw planError("INVALID_INPUT", `${step.op} step requires at least one target`, step.id);
 		const args$1 = step.args;
-		const pos = mapping.map(toAbsoluteBlockInsertPos(editor, target.blockId, target.from, step.id));
+		const position$3 = args$1.position ?? "after";
+		const anchorPos = resolveBlockInsertionPos(editor, resolveCreateAnchorBlockId(target, position$3, step.id), position$3, step.id);
+		const pos = mapping.map(anchorPos);
 		const paragraphType = editor.state.schema?.nodes?.paragraph;
 		if (!paragraphType) throw planError("INVALID_INPUT", "paragraph node type not in schema", step.id);
 		const sdBlockId = args$1.sdBlockId;
@@ -70447,6 +70678,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		const node$1 = paragraphType.createAndFill(attrs, textNode ?? void 0) ?? paragraphType.create(attrs, textNode ? [textNode] : void 0);
 		if (!node$1) throw planError("INVALID_INPUT", `could not create ${step.op} node`, step.id);
 		tr.insert(pos, node$1);
+		assertNoPostInsertDuplicateIds(tr.doc, step.id);
 		return {
 			stepId: step.id,
 			op: step.op,
@@ -70458,6 +70690,27 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			}
 		};
 	}
+	function assertNoPostInsertDuplicateIds(doc$4, stepId) {
+		const seen = /* @__PURE__ */ new Set();
+		const duplicateSet = /* @__PURE__ */ new Set();
+		doc$4.descendants((node$1) => {
+			if (!node$1.isTextblock) return true;
+			const attrs = node$1.attrs ?? {};
+			const id = typeof attrs.paraId === "string" && attrs.paraId || typeof attrs.sdBlockId === "string" && attrs.sdBlockId || typeof attrs.nodeId === "string" && attrs.nodeId;
+			if (!id) return true;
+			if (seen.has(id)) duplicateSet.add(id);
+			else seen.add(id);
+			return true;
+		});
+		if (duplicateSet.size > 0) {
+			const duplicates = [...duplicateSet];
+			throw planError("INTERNAL_ERROR", `create step produced duplicate block identities: [${duplicates.join(", ")}]`, stepId, {
+				source: "executor:checkPostInsertIdentityUniqueness",
+				invariant: "post-insert block IDs must be unique",
+				duplicateBlockIds: duplicates
+			});
+		}
+	}
 	function runMutationsOnTransaction(editor, tr, compiled, options$1) {
 		const mapping = tr.mapping;
 		const stepOutcomes = [];
@@ -70513,6 +70766,13 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		const startTime = performance.now();
 		const revisionBefore = getRevision(editor);
 		checkRevision(editor, options$1.expectedRevision);
+		if (compiled.compiledRevision !== revisionBefore) throw planError("REVISION_CHANGED_SINCE_COMPILE", `Document revision changed between compile and execute. Compiled at "${compiled.compiledRevision}", now at "${revisionBefore}".`, void 0, {
+			compiledRevision: compiled.compiledRevision,
+			currentRevision: revisionBefore,
+			stepCount: compiled.mutationSteps.length,
+			failedAtStep: "pre-execution",
+			remediation: "Re-compile the plan against the current document state."
+		});
 		const tr = editor.state.tr;
 		if ((options$1.changeMode ?? "direct") === "tracked") applyTrackedMutationMeta(tr);
 		else applyDirectMutationMeta(tr);
@@ -70721,7 +70981,8 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				},
 				targets: []
 			}],
-			assertSteps: []
+			assertSteps: [],
+			compiledRevision: getRevision(editor)
 		}, { expectedRevision: options$1?.expectedRevision });
 	}
 	function validateWriteRequest(request, resolved) {
@@ -70808,7 +71069,8 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				step: stepDef,
 				targets: [toCompiledTarget(stepId, op, resolved)]
 			}],
-			assertSteps: []
+			assertSteps: [],
+			compiledRevision: getRevision(editor)
 		}, {
 			changeMode: mode,
 			expectedRevision: options$1?.expectedRevision
@@ -70874,7 +71136,8 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 					marks: []
 				}]
 			}],
-			assertSteps: []
+			assertSteps: [],
+			compiledRevision: getRevision(editor)
 		}, {
 			changeMode: mode,
 			expectedRevision: options$1?.expectedRevision
@@ -71640,6 +71903,51 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			list: (query) => listCommentsHandler(editor, query)
 		};
 	}
+	var SUPPORTED_NODE_TYPES = new Set(DELETABLE_BLOCK_NODE_TYPES);
+	var REJECTED_NODE_TYPES = new Set(["tableRow", "tableCell"]);
+	function validateTargetNodeType(nodeType) {
+		if (REJECTED_NODE_TYPES.has(nodeType)) throw new DocumentApiAdapterError("INVALID_TARGET", `blocks.delete does not support "${nodeType}" targets. Table row/column operations are out of scope.`, { nodeType });
+		if (!SUPPORTED_NODE_TYPES.has(nodeType)) throw new DocumentApiAdapterError("INVALID_TARGET", `blocks.delete does not support "${nodeType}" targets.`, { nodeType });
+	}
+	function resolveSdBlockId(candidate) {
+		const sdBlockId = candidate.node.attrs?.sdBlockId;
+		if (typeof sdBlockId === "string" && sdBlockId.length > 0) return sdBlockId;
+		throw new DocumentApiAdapterError("INTERNAL_ERROR", "Resolved block candidate is missing sdBlockId attribute. This indicates a schema/extension invariant violation.", { attrs: candidate.node.attrs });
+	}
+	function validateCommandLayerUniqueness(editor, sdBlockId) {
+		const getBlockNodeById = editor.helpers?.blockNode?.getBlockNodeById;
+		if (typeof getBlockNodeById !== "function") throw new DocumentApiAdapterError("CAPABILITY_UNAVAILABLE", "blocks.delete requires the blockNode helper to be registered.", { reason: "missing_helper" });
+		const matches$1 = getBlockNodeById(sdBlockId);
+		if (!matches$1 || Array.isArray(matches$1) && matches$1.length === 0) throw new DocumentApiAdapterError("TARGET_NOT_FOUND", `Block with sdBlockId "${sdBlockId}" was not found at the command layer.`, { sdBlockId });
+		if (Array.isArray(matches$1) && matches$1.length > 1) throw new DocumentApiAdapterError("AMBIGUOUS_TARGET", `Multiple blocks share sdBlockId "${sdBlockId}" at the command layer.`, {
+			sdBlockId,
+			count: matches$1.length
+		});
+	}
+	function blocksDeleteWrapper(editor, input$1, options$1) {
+		rejectTrackedMode("blocks.delete", options$1);
+		const candidate = findBlockByIdStrict(getBlockIndex(editor), input$1.target);
+		validateTargetNodeType(candidate.nodeType);
+		const sdBlockId = resolveSdBlockId(candidate);
+		const deleteBlockNodeById = requireEditorCommand(editor.commands?.deleteBlockNodeById, "blocks.delete");
+		validateCommandLayerUniqueness(editor, sdBlockId);
+		if (options$1?.dryRun) return {
+			success: true,
+			deleted: input$1.target
+		};
+		if (executeDomainCommand(editor, () => {
+			const didApply = deleteBlockNodeById(sdBlockId);
+			if (didApply) clearIndexCache(editor);
+			return didApply;
+		}, { expectedRevision: options$1?.expectedRevision }).steps[0]?.effect !== "changed") throw new DocumentApiAdapterError("INTERNAL_ERROR", "blocks.delete command returned false despite passing all pre-apply checks. This is an internal invariant violation.", {
+			sdBlockId,
+			target: input$1.target
+		});
+		return {
+			success: true,
+			deleted: input$1.target
+		};
+	}
 	var DERIVED_ID_LENGTH = 24;
 	function getRawTrackedMarks(editor) {
 		try {
@@ -71763,9 +72071,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		const location$2 = at ?? { kind: "documentEnd" };
 		if (location$2.kind === "documentStart") return 0;
 		if (location$2.kind === "documentEnd") return editor.state.doc.content.size;
-		const target = findBlockById(getBlockIndex(editor), location$2.target);
-		if (!target) throw new DocumentApiAdapterError("TARGET_NOT_FOUND", `Create ${operationLabel} target block was not found.`, { target: location$2.target });
-		return location$2.kind === "before" ? target.pos : target.end;
+		return resolveBlockInsertionPos(editor, location$2.target.nodeId, location$2.kind);
 	}
 	function resolveCreatedBlock(editor, nodeType, blockId) {
 		const index$1 = getBlockIndex(editor);
@@ -71867,7 +72173,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				try {
 					const paragraph$1 = resolveCreatedBlock(editor, "paragraph", paragraphId);
 					if (mode === "tracked") trackedChangeRefs = collectTrackInsertRefsInRange(editor, paragraph$1.pos, paragraph$1.end);
-				} catch {}
+				} catch (e) {
+					if (!(e instanceof DocumentApiAdapterError)) throw e;
+				}
 			}
 			return didApply;
 		}, { expectedRevision: options$1?.expectedRevision }).steps[0]?.effect !== "changed") return {
@@ -71929,7 +72237,9 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				try {
 					const heading$2 = resolveCreatedBlock(editor, "heading", headingId);
 					if (mode === "tracked") trackedChangeRefs = collectTrackInsertRefsInRange(editor, heading$2.pos, heading$2.end);
-				} catch {}
+				} catch (e) {
+					if (!(e instanceof DocumentApiAdapterError)) throw e;
+				}
 			}
 			return didApply;
 		}, { expectedRevision: options$1?.expectedRevision }).steps[0]?.effect !== "changed") return {
@@ -73141,14 +73451,15 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		return { success: true };
 	}
 	function previewPlan(editor, input$1) {
-		const evaluatedRevision = getRevision(editor);
 		checkRevision(editor, input$1.expectedRevision);
 		if (!input$1.steps?.length) throw planError("INVALID_INPUT", "plan must contain at least one step");
 		const failures = [];
 		const stepPreviews = [];
 		let currentPhase = "compile";
+		let evaluatedRevision = getRevision(editor);
 		try {
 			const compiled = compilePlan(editor, input$1.steps);
+			evaluatedRevision = compiled.compiledRevision;
 			currentPhase = "execute";
 			const tr = editor.state.tr;
 			const { stepOutcomes, assertFailures } = runMutationsOnTransaction(editor, tr, compiled, { throwOnAssertFailure: false });
@@ -73651,14 +73962,24 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 		const userOffset = input$1.offset ?? 0;
 		const paginatedMatches = isTextSelector ? applyPagination(rawMatches, userOffset, input$1.limit) : rawMatches;
 		if (require$1 === "first" || require$1 === "exactlyOne" || require$1 === "all") {
-			if (totalMatches === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges");
+			if (totalMatches === 0) throw planError("MATCH_NOT_FOUND", "selector matched zero ranges", void 0, {
+				selectorType: input$1.select?.type ?? "unknown",
+				selectorPattern: input$1.select?.pattern ?? "",
+				selectorMode: input$1.select?.mode ?? "contains",
+				searchScope: (input$1.within?.kind === "block" ? input$1.within.nodeId : void 0) ?? "document",
+				candidateCount: 0
+			});
 		}
 		if (require$1 === "exactlyOne" && totalMatches > 1) throw planError("AMBIGUOUS_MATCH", `selector matched ${totalMatches} ranges, expected exactly one`, void 0, { matchCount: totalMatches });
 		const matchItems = paginatedMatches.map((raw, pageIdx) => {
 			const id = `m:${userOffset + pageIdx}`;
 			if (isTextSelector && raw.textRanges?.length) {
 				const blocks$1 = buildMatchBlocks(editor, raw.textRanges, evaluatedRevision, id);
-				if (blocks$1.length === 0) throw planError("INTERNAL_ERROR", `text match produced no blocks for ${id}`);
+				if (blocks$1.length === 0) throw planError("INTERNAL_ERROR", `text match produced no blocks for ${id}`, void 0, {
+					source: "query-match-adapter:buildMatchEntries",
+					invariant: "text match must have at least one block after zero-width filtering",
+					context: { matchId: id }
+				});
 				const snippetResult = buildBlocksSnippet(editor, blocks$1);
 				return {
 					id,
@@ -73871,6 +74192,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 				acceptAll: (input$1, options$1) => trackChangesAcceptAllWrapper(editor, input$1, options$1),
 				rejectAll: (input$1, options$1) => trackChangesRejectAllWrapper(editor, input$1, options$1)
 			},
+			blocks: { delete: (input$1, options$1) => blocksDeleteWrapper(editor, input$1, options$1) },
 			create: {
 				paragraph: (input$1, options$1) => createParagraphWrapper(editor, input$1, options$1),
 				heading: (input$1, options$1) => createHeadingWrapper(editor, input$1, options$1)
@@ -92641,7 +92963,7 @@ while (n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 === a$3[++i$3] && n$2 ===
 			return migrations.length > 0;
 		}
 		processCollaborationMigrations() {
-			console.debug("[checkVersionMigrations] Current editor version", "1.17.0-next.11");
+			console.debug("[checkVersionMigrations] Current editor version", "1.17.0-next.13");
 			if (!this.options.ydoc) return;
 			let docVersion = this.options.ydoc.getMap("meta").get("version");
 			if (!docVersion) docVersion = "initial";
@@ -177869,7 +178191,7 @@ js: import "konva/skia-backend";
 			this.config.colors = shuffleArray(this.config.colors);
 			this.userColorMap = /* @__PURE__ */ new Map();
 			this.colorIndex = 0;
-			this.version = "1.17.0-next.11";
+			this.version = "1.17.0-next.13";
 			this.#log("🦋 [superdoc] Using SuperDoc version:", this.version);
 			this.superdocId = config$31.superdocId || v4_default();
 			this.colors = this.config.colors;