@inditextech/weave-sdk 5.7.0-SNAPSHOT.596.1 → 5.7.0-SNAPSHOT.599.1

package/dist/sdk.js

@@ -4771,12 +4771,39 @@ function registerKeyboardHandlers(ctx) {
 			}
 		}
 		if (e.code === "Backspace" || e.code === "Delete") {
-			Promise.resolve().then(() => {
+			queueMicrotask(() => {
 				ctx.removeSelectedNodes();
 			});
 			return;
 		}
 	}, { signal });
+	const isModifier = (e) => e.key === "Control" || e.key === "Meta";
+	const hideHover = () => ctx.getTransformerController().getHoverTransformer().nodes([]);
+	const restoreHover = () => {
+		const pos = stage.getPointerPosition();
+		const shape = pos ? stage.getIntersection(pos) : null;
+		if (!shape) return;
+		shape.fire("pointerover", {
+			evt: {
+				ctrlKey: false,
+				metaKey: false
+			},
+			target: shape
+		}, true);
+	};
+	window.addEventListener("keydown", (e) => {
+		if (isModifier(e)) hideHover();
+	}, {
+		signal,
+		capture: true
+	});
+	window.addEventListener("keyup", (e) => {
+		if (isModifier(e)) restoreHover();
+	}, {
+		signal,
+		capture: true
+	});
+	window.addEventListener("blur", restoreHover, { signal });
 	stage.container().addEventListener("keyup", (e) => {
 		if (e.code === "Space") ctx.setSpaceKeyPressed(false);
 	}, { signal });
@@ -6532,7 +6559,10 @@ var WeaveNode = class {
 	}
 	handleMouseOver(e, node) {
 		const stage = this.instance.getStage();
-		if (e.evt.ctrlKey || e.evt.metaKey) return false;
+		if (e.evt.ctrlKey || e.evt.metaKey) {
+			this.hideHoverState();
+			return false;
+		}
 		const user = this.instance.getStore().getUser();
 		const activeAction = this.instance.getActiveAction();
 		const isNodeSelectionEnabled = this.getSelectionPlugin()?.isEnabled();
@@ -6579,7 +6609,10 @@ var WeaveNode = class {
 		return cancelBubble;
 	}
 	handleMouseout(e, node) {
-		if (e.evt?.ctrlKey || e.evt?.metaKey) return false;
+		if (e.evt?.ctrlKey || e.evt?.metaKey) {
+			this.hideHoverState();
+			return false;
+		}
 		if (this.instance.getInstanceRecursive(node)) this.hideHoverState();
 	}
 	create(key, props) {
@@ -9502,7 +9535,7 @@ var WeaveRegisterManager = class {
 };
 //#endregion
 //#region package.json
-var version = "5.7.0-SNAPSHOT.596.1";
+var version = "5.7.0-SNAPSHOT.599.1";
 //#endregion
 //#region src/managers/setup.ts
 var WeaveSetupManager = class {
@@ -13761,7 +13794,7 @@ var WeaveTextNode = class extends WeaveNode {
 		delete cleanedAttrs.dragBoundFunc;
 		if (cleanedAttrs.link) {
 			if (typeof cleanedAttrs.linkPreviousFill === "string") cleanedAttrs.fill = cleanedAttrs.linkPreviousFill;
-			if (typeof cleanedAttrs.linkPreviousTextDecoration === "string") cleanedAttrs.textDecoration = cleanedAttrs.linkPreviousTextDecoration;
+			cleanedAttrs.textDecoration = typeof cleanedAttrs.linkPreviousTextDecoration === "string" ? cleanedAttrs.linkPreviousTextDecoration : "";
 		}
 		return {
 			key: attrs.id ?? "",
@@ -14397,6 +14430,31 @@ var WeaveTextNode = class extends WeaveNode {
 };
 //#endregion
 //#region src/nodes/text-v2/model.ts
+const MIN_LINE_HEIGHT = .5;
+/** Valid `lineHeight` mark of a run, or undefined (use the node value). */
+function runLineHeight(m) {
+	const v = m?.lineHeight;
+	return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.min(4, Math.max(MIN_LINE_HEIGHT, v)) : void 0;
+}
+/** Only absolute http(s) URLs are links (same rule as the legacy node). */
+function isSafeLink(value) {
+	if (typeof value !== "string") return false;
+	try {
+		return ["http:", "https:"].includes(new URL(value).protocol);
+	} catch {
+		return false;
+	}
+}
+/** Block fields that describe structure (not content). */
+function blockFields(block, withStart) {
+	const out = {};
+	if (!block) return out;
+	if (block.kind) out.kind = block.kind;
+	if (block.depth) out.depth = block.depth;
+	if (block.align) out.align = block.align;
+	if (withStart && block.start !== void 0) out.start = block.start;
+	return out;
+}
 function isEmptyMarks(m) {
 	return !m || Object.keys(m).length === 0;
 }
@@ -14477,7 +14535,7 @@ function marksAt(runs, offset) {
 * blocks) with plain `insert`. Marks on untouched text are preserved; the
 * inserted text inherits marks of the character before `start`.
 */
-function replaceRange(blocks, start, end, insert) {
+function replaceRange(blocks, start, end, insert, insertMarks) {
 	const total = blocksToText(blocks).length;
 	start = Math.max(0, Math.min(start, total));
 	end = Math.max(start, Math.min(end, total));
@@ -14486,6 +14544,7 @@ function replaceRange(blocks, start, end, insert) {
 	const prefixBlocks = [];
 	const suffixBlocks = [];
 	let inheritedMarks;
+	let startBlock;
 	let pos = 0;
 	blocks.forEach((block) => {
 		const len = blockText(block).length;
@@ -14498,11 +14557,13 @@ function replaceRange(blocks, start, end, insert) {
 			if (start >= bStart && start <= bEnd) {
 				const local = start - bStart;
 				before = sliceRuns(block.runs, 0, local);
+				startBlock = block;
 				inheritedMarks = marksAt(block.runs, local);
 			}
 			if (end >= bStart && end <= bEnd) after = sliceRuns(block.runs, end - bStart, len);
 		}
 	});
+	if (insertMarks !== void 0) inheritedMarks = insertMarks ?? void 0;
 	const lines = insert.split("\n");
 	const mk = (t) => t === "" ? [] : [{
 		t,
@@ -14513,7 +14574,10 @@ function replaceRange(blocks, start, end, insert) {
 		let runs = mk(line);
 		if (idx === 0) runs = [...before, ...runs];
 		if (idx === lines.length - 1) runs = [...runs, ...after];
-		middle.push({ runs: normalizeRuns(runs) });
+		middle.push({
+			...blockFields(startBlock, idx === 0),
+			runs: normalizeRuns(runs)
+		});
 	});
 	return [
 		...prefixBlocks,
@@ -14521,8 +14585,331 @@ function replaceRange(blocks, start, end, insert) {
 		...suffixBlocks
 	];
 }
+function safeBase(base) {
+	return Number.isFinite(base) && base > 0 ? base : 1;
+}
+/** px -> stored ratio (4 decimals). */
+function sizeToRatio(px, base) {
+	return Math.round(px / safeBase(base) * 1e4) / 1e4;
+}
+/** stored ratio -> px (rounded to 0.1). Invalid ratios resolve to the base. */
+function ratioToSize(ratio, base) {
+	const b = safeBase(base);
+	return Math.round((typeof ratio === "number" && ratio > 0 ? ratio : 1) * b * 10) / 10;
+}
+/** Effective ratio of a run (invalid or missing -> 1). */
+function runRatio(m) {
+	const r = m?.size;
+	return typeof r === "number" && Number.isFinite(r) && r > 0 ? r : 1;
+}
+function normalizeMarks(m) {
+	const out = {};
+	for (const [k, v] of Object.entries(m)) {
+		if (v === void 0 || v === false || v === null || v === "") continue;
+		if (k === "size" && v === 1) continue;
+		out[k] = v;
+	}
+	return Object.keys(out).length === 0 ? void 0 : out;
+}
+/** Normalized marks of a run, or undefined when empty. */
+function cleanMarks(m) {
+	return m ? normalizeMarks(m) : void 0;
+}
+function blockSpans(blocks) {
+	const out = [];
+	let pos = 0;
+	blocks.forEach((b, index) => {
+		const len = blockText(b).length;
+		out.push({
+			index,
+			start: pos,
+			end: pos + len
+		});
+		pos += len + 1;
+	});
+	return out;
+}
+/** Indices of blocks touched by [start, end] (collapsed range -> its block). */
+function blockIndicesInRange(blocks, start, end) {
+	const out = [];
+	for (const s of blockSpans(blocks)) if (s.end >= start && s.start <= end) {
+		if (end > start && s.start === end && s.start !== start) continue;
+		out.push(s.index);
+	}
+	return out;
+}
+/** Marks that typing at a collapsed offset would inherit. */
+function marksAtOffset(blocks, offset) {
+	for (const s of blockSpans(blocks)) if (offset >= s.start && offset <= s.end) return cleanMarks(marksAt(blocks[s.index].runs, offset - s.start));
+}
+function mapRunsInRange(block, from, to, fn) {
+	const runs = [];
+	let pos = 0;
+	for (const run of block.runs) {
+		const rs = pos;
+		const re = pos + run.t.length;
+		pos = re;
+		const s = Math.max(from, rs);
+		const e = Math.min(to, re);
+		if (s >= e) {
+			runs.push(run);
+			continue;
+		}
+		if (s > rs) runs.push({
+			t: run.t.slice(0, s - rs),
+			m: run.m
+		});
+		runs.push({
+			t: run.t.slice(s - rs, e - rs),
+			m: fn(run.m)
+		});
+		if (e < re) runs.push({
+			t: run.t.slice(e - rs),
+			m: run.m
+		});
+	}
+	return {
+		...block,
+		runs: normalizeRuns(runs)
+	};
+}
+/** Set (or remove with `undefined`) one mark over the global range. */
+function applyMark(blocks, start, end, key, value) {
+	if (start >= end) return blocks;
+	if (key === "lineHeight" && value !== void 0) {
+		const lh = runLineHeight({ lineHeight: value });
+		if (lh === void 0) return blocks;
+		value = lh;
+	}
+	const spans = blockSpans(blocks);
+	return blocks.map((block, i) => {
+		const s = spans[i];
+		if (s.end <= start || s.start >= end) return block;
+		return mapRunsInRange(block, Math.max(start, s.start) - s.start, Math.min(end, s.end) - s.start, (m) => normalizeMarks({
+			...m,
+			[key]: value
+		}));
+	});
+}
+/** Query one mark over a range; collapsed ranges report the caret marks. */
+function queryMark(blocks, start, end, key, stored) {
+	const values = [];
+	if (start >= end) {
+		const v = (stored ?? marksAtOffset(blocks, start))?.[key];
+		return v === void 0 || v === false ? { state: "none" } : {
+			state: "all",
+			value: v
+		};
+	}
+	const spans = blockSpans(blocks);
+	blocks.forEach((block, i) => {
+		const s = spans[i];
+		if (s.end <= start || s.start >= end) return;
+		const from = Math.max(start, s.start) - s.start;
+		const to = Math.min(end, s.end) - s.start;
+		for (const r of sliceRuns(block.runs, from, to)) {
+			const v = r.m?.[key];
+			values.push(v === false ? void 0 : v);
+		}
+	});
+	if (values.length === 0) return { state: "none" };
+	const set = values.filter((v) => v !== void 0);
+	if (set.length === 0) return { state: "none" };
+	if (set.length < values.length) return { state: "some" };
+	return values.every((v) => v === values[0]) ? {
+		state: "all",
+		value: values[0]
+	} : { state: "some" };
+}
+/** Toggle a boolean mark: removes when fully set, sets otherwise. */
+function toggleMark(blocks, start, end, key) {
+	return applyMark(blocks, start, end, key, queryMark(blocks, start, end, key).state === "all" ? void 0 : true);
+}
+function mapBlocks(blocks, indices, fn) {
+	const set = new Set(indices);
+	return blocks.map((b, i) => set.has(i) ? fn(b) : b);
+}
+function stripList(b) {
+	const { kind: _k, depth: _d, start: _s, ...rest } = b;
+	return rest;
+}
+/** Toggle list `kind` on the blocks of a range (all already that kind -> off). */
+function toggleList(blocks, start, end, kind) {
+	const idx = blockIndicesInRange(blocks, start, end);
+	const allSame = idx.every((i) => blocks[i].kind === kind);
+	return mapBlocks(blocks, idx, (b) => allSame ? stripList(b) : {
+		...b,
+		kind
+	});
+}
+/** Set (or clear with `undefined`) the alignment of the blocks in a range. */
+function setBlockAlign(blocks, start, end, align) {
+	return mapBlocks(blocks, blockIndicesInRange(blocks, start, end), (b) => {
+		if (align === void 0) {
+			const { align: _a, ...rest } = b;
+			return rest;
+		}
+		return {
+			...b,
+			align
+		};
+	});
+}
+/** Increase depth of list blocks in the range (non-list blocks untouched). */
+function indentBlocks(blocks, start, end) {
+	return mapBlocks(blocks, blockIndicesInRange(blocks, start, end), (b) => b.kind ? {
+		...b,
+		depth: (b.depth ?? 0) + 1
+	} : b);
+}
+/** Decrease depth; at depth 0 the list marker is removed. */
+function outdentBlocks(blocks, start, end) {
+	return mapBlocks(blocks, blockIndicesInRange(blocks, start, end), (b) => {
+		if (!b.kind) return b;
+		const d = b.depth ?? 0;
+		if (d <= 0) return stripList(b);
+		const next = {
+			...b,
+			depth: d - 1
+		};
+		if (d - 1 === 0) delete next.depth;
+		return next;
+	});
+}
+const BULLETS = [
+	"•",
+	"◦",
+	"▪"
+];
+function alpha(n) {
+	let s = "";
+	let v = n;
+	while (v > 0) {
+		v--;
+		s = String.fromCharCode(97 + v % 26) + s;
+		v = Math.floor(v / 26);
+	}
+	return s;
+}
+function roman(n) {
+	const map = [
+		[1e3, "m"],
+		[900, "cm"],
+		[500, "d"],
+		[400, "cd"],
+		[100, "c"],
+		[90, "xc"],
+		[50, "l"],
+		[40, "xl"],
+		[10, "x"],
+		[9, "ix"],
+		[5, "v"],
+		[4, "iv"],
+		[1, "i"]
+	];
+	let v = n;
+	let s = "";
+	for (const [k, r] of map) while (v >= k) {
+		s += r;
+		v -= k;
+	}
+	return s;
+}
+/**
+* Marker text per block (null for plain paragraphs). Ordered numbering is
+* continuous across consecutive same-depth items and restarts after a
+* non-list block, a shallower item or a kind change; `start` seeds a run.
+* Markers are layout-only: they never enter `text` or offsets.
+*/
+function listMarkers(blocks) {
+	const stack = [];
+	return blocks.map((b) => {
+		if (!b.kind) {
+			stack.length = 0;
+			return null;
+		}
+		const d = Math.max(0, Math.floor(b.depth ?? 0));
+		stack.length = Math.min(stack.length, d + 1);
+		while (stack.length < d) stack.push({
+			kind: b.kind,
+			n: 0
+		});
+		const cur = stack[d];
+		if (!cur || cur.kind !== b.kind) stack[d] = {
+			kind: b.kind,
+			n: b.kind === "ol" ? Math.max(1, b.start ?? 1) : 0
+		};
+		else if (b.kind === "ol") cur.n += 1;
+		if (b.kind === "ul") return BULLETS[d % 3];
+		const n = stack[d].n;
+		const style = d % 3;
+		return `${style === 0 ? n : style === 1 ? alpha(n) : roman(n)}.`;
+	});
+}
+/**
+* Format of the range for toolbars. A collapsed range reports the stored
+* marks (when given) or the marks typing would inherit.
+*/
+function getSelectionFormat(blocks, start, end, baseFontSize, stored) {
+	const q = (key) => queryMark(blocks, start, end, key, stored);
+	const ratios = [];
+	if (start >= end) ratios.push(runRatio(stored ?? marksAtOffset(blocks, start)));
+	else {
+		const spans = blockSpans(blocks);
+		blocks.forEach((block, i) => {
+			const s = spans[i];
+			if (s.end <= start || s.start >= end) return;
+			const from = Math.max(start, s.start) - s.start;
+			const to = Math.min(end, s.end) - s.start;
+			for (const r of sliceRuns(block.runs, from, to)) ratios.push(runRatio(r.m));
+		});
+	}
+	let size;
+	if (ratios.length === 0 || ratios.every((r) => r === ratios[0])) {
+		const r = ratios[0] ?? 1;
+		size = {
+			state: r === 1 ? "none" : "all",
+			value: ratioToSize(r, baseFontSize)
+		};
+	} else size = { state: "some" };
+	const idx = blockIndicesInRange(blocks, start, end);
+	const kinds = new Set(idx.map((i) => blocks[i].kind ?? "none"));
+	let list = { kind: "none" };
+	if (kinds.size === 1) {
+		const kind = [...kinds][0];
+		const depths = new Set(idx.map((i) => blocks[i].depth ?? 0));
+		list = kind === "none" ? { kind } : {
+			kind,
+			...depths.size === 1 ? { depth: [...depths][0] } : {}
+		};
+	} else if (kinds.size > 1) list = { kind: "mixed" };
+	return {
+		bold: q("bold"),
+		italic: q("italic"),
+		underline: q("underline"),
+		strike: q("strike"),
+		color: q("color"),
+		family: q("family"),
+		link: q("link"),
+		lineHeight: q("lineHeight"),
+		align: alignQuery(blocks, start, end),
+		size,
+		list
+	};
+}
+function alignQuery(blocks, start, end) {
+	const vals = blockIndicesInRange(blocks, start, end).map((i) => blocks[i].align);
+	const set = vals.filter((v) => v !== void 0);
+	if (set.length === 0) return { state: "none" };
+	if (set.length < vals.length || set.some((v) => v !== set[0])) return { state: "some" };
+	return {
+		state: "all",
+		value: set[0]
+	};
+}
 //#endregion
 //#region src/nodes/text-v2/layout/engine.ts
+const DEFAULT_INDENT_STEP = 1.5;
 /** Quote multi-word families like `Konva` does so the font shorthand parses. */
 function normalizeFontFamily(fontFamily) {
 	return fontFamily.split(",").map((family) => {
@@ -14535,6 +14922,50 @@ function normalizeFontFamily(fontFamily) {
 function fontString(s) {
 	return `${s.fontStyle} ${s.fontVariant} ${s.fontSize}px ${normalizeFontFamily(s.fontFamily)}`;
 }
+/** Style of a run: node style overridden by the run marks. */
+function runStyle(style, m) {
+	if (!m) return style;
+	let fontStyle = style.fontStyle;
+	if (m.bold || m.italic) {
+		const tokens = new Set(fontStyle.split(/\s+/).filter(Boolean));
+		tokens.delete("normal");
+		if (m.italic) tokens.add("italic");
+		if (m.bold) tokens.add("bold");
+		fontStyle = tokens.size === 0 ? "normal" : Array.from(tokens).join(" ");
+	}
+	return {
+		...style,
+		fontStyle,
+		fontSize: style.fontSize * runRatio(m),
+		fontFamily: typeof m.family === "string" && m.family ? m.family : style.fontFamily
+	};
+}
+/** Pure fallback (same constants as Konva.Text when the browser has none). */
+const approxMetrics = (_font, size) => ({
+	ascent: .91 * size,
+	descent: .21 * size
+});
+const metricsCache = /* @__PURE__ */ new Map();
+/** Ascent/descent used for baseline placement (parity with Konva.Text). */
+function fontMetrics(font, size) {
+	if (Konva.legacyTextRendering) return {
+		ascent: 0,
+		descent: 0
+	};
+	const hit = metricsCache.get(font);
+	if (hit) return hit;
+	const ctx = Konva.Util.createCanvasElement().getContext("2d");
+	ctx.font = font;
+	const m = ctx.measureText("M");
+	const scale = size / 100;
+	const out = {
+		ascent: m.fontBoundingBoxAscent ?? 91 * scale,
+		descent: m.fontBoundingBoxDescent ?? 21 * scale
+	};
+	if (metricsCache.size > 2e3) metricsCache.clear();
+	metricsCache.set(font, out);
+	return out;
+}
 let sharedContext = null;
 /** Default measurer: works on browser, node-canvas and skia-canvas backends. */
 const canvasMeasurer = (font, text) => {
@@ -14582,11 +15013,15 @@ function wordWrapIndex(graphemes, start, matchLen, matchWidth, maxWidth) {
 	const seg = graphemes.slice(start, start + matchLen);
 	return Math.max(seg.lastIndexOf(" "), seg.lastIndexOf("-")) + 1;
 }
-function applyAlign(lines, align, width, padding) {
-	if (align === "left") return;
+function applyAlign(lines, width, padding) {
 	for (const line of lines) {
-		const free = width - line.width - padding * 2;
-		line.offsetX = align === "center" ? free / 2 : free;
+		const align = line.align;
+		if (align === "left") {
+			line.offsetX = line.indent;
+			continue;
+		}
+		const free = width - line.indent - line.width - padding * 2;
+		line.offsetX = line.indent + (align === "center" ? free / 2 : free);
 	}
 }
 var TextLayoutEngine = class {
@@ -14596,8 +15031,10 @@ var TextLayoutEngine = class {
 	/** Entries by signature, so paragraphs that shifted index are reused. */
 	pool = /* @__PURE__ */ new Map();
 	lastParagraphsRelaid = 0;
-	constructor(measurer = canvasMeasurer) {
+	metrics;
+	constructor(measurer = canvasMeasurer, metrics = approxMetrics) {
 		this.measure = measurer;
+		this.metrics = metrics;
 	}
 	/** Number of paragraphs recomputed by the last `layout()` call. */
 	getLastRelaidCount() {
@@ -14608,10 +15045,17 @@ var TextLayoutEngine = class {
 		this.paragraphs = [];
 		this.pool.clear();
 	}
-	paragraphSig(block, style, bounds) {
-		const fixedWidth = bounds.width !== void 0 && !Number.isNaN(bounds.width);
-		const maxWidth = (bounds.width ?? 0) - bounds.padding * 2;
-		return `${fontString(style)}|${style.letterSpacing}|${style.wrap}|${fixedWidth ? maxWidth : "auto"}|${JSON.stringify(block.runs)}`;
+	/** Text indent of a block in px (0 for plain paragraphs). */
+	indentFor(block, style, fixedWidth, maxWidth) {
+		if (!block.kind) return 0;
+		const stepPx = (typeof style.indentStep === "number" && Number.isFinite(style.indentStep) && style.indentStep > 0 ? style.indentStep : DEFAULT_INDENT_STEP) * style.fontSize;
+		const wanted = (Math.max(0, Math.floor(block.depth ?? 0)) + 1) * stepPx;
+		if (!fixedWidth) return wanted;
+		const limit = Math.max(0, maxWidth - 4 * style.fontSize);
+		return Math.min(wanted, limit);
+	}
+	sigFor(block, style, fixedWidth, maxWidth, indent) {
+		return `${fontString(style)}|${style.lineHeight}|${style.letterSpacing}|${style.wrap}|${fixedWidth ? maxWidth - indent : "auto"}|${JSON.stringify(block.runs)}`;
 	}
 	/**
 	* Pre-compute paragraph layouts for `blocks` within a time budget so a
@@ -14619,14 +15063,14 @@ var TextLayoutEngine = class {
 	* Lets callers time-slice very large content (e.g. bulk paste).
 	*/
 	warm(blocks, style, bounds, budgetMs) {
-		const font = fontString(style);
-		const fixedWidth = bounds.width !== void 0 && !Number.isNaN(bounds.width);
+		const fixedWidth = isNum(bounds.width);
 		const maxWidth = (bounds.width ?? 0) - bounds.padding * 2;
 		const deadline = now() + budgetMs;
 		for (const block of blocks) {
-			const sig = this.paragraphSig(block, style, bounds);
+			const indent = this.indentFor(block, style, fixedWidth, maxWidth);
+			const sig = this.sigFor(block, style, fixedWidth, maxWidth, indent);
 			if (this.pool.has(sig)) continue;
-			this.pool.set(sig, this.layoutParagraph(block, sig, font, style, fixedWidth, maxWidth));
+			this.pool.set(sig, this.layoutParagraph(block, sig, style, fixedWidth, maxWidth - indent));
 			if (now() >= deadline) return false;
 		}
 		return true;
@@ -14644,35 +15088,38 @@ var TextLayoutEngine = class {
 		return w + text.length * spacing;
 	}
 	layout(blocks, style, bounds) {
-		const font = fontString(style);
 		const padding = bounds.padding;
 		const fixedWidth = isNum(bounds.width);
 		const fixedHeight = isNum(bounds.height);
 		const maxWidth = (bounds.width ?? 0) - padding * 2;
 		const maxHeightPx = (bounds.height ?? 0) - padding * 2;
 		const lineHeightPx = style.lineHeight * style.fontSize;
-		const sigBase = `${font}|${style.letterSpacing}|${style.wrap}|${fixedWidth ? maxWidth : "auto"}`;
+		const markers = listMarkers(blocks);
 		const prev = this.paragraphs;
 		const next = [];
 		let relaid = 0;
 		const lines = [];
 		let textWidth = 0;
 		let offset = 0;
+		let contentHeight = 0;
 		for (let p = 0; p < blocks.length; p++) {
 			const block = blocks[p];
-			const sig = `${sigBase}|${JSON.stringify(block.runs)}`;
+			const indent = this.indentFor(block, style, fixedWidth, maxWidth);
+			const sig = this.sigFor(block, style, fixedWidth, maxWidth, indent);
 			let entry = prev[p]?.sig === sig ? prev[p] : this.pool.get(sig);
 			if (!entry) {
-				entry = this.layoutParagraph(block, sig, font, style, fixedWidth, maxWidth);
+				entry = this.layoutParagraph(block, sig, style, fixedWidth, maxWidth - indent);
 				relaid++;
 			}
 			next.push(entry);
 			const emitted = this.emitLines(entry, block, p, offset, lines, {
-				font,
 				style,
-				lineHeightPx,
+				indent,
+				marker: markers[p],
+				y: contentHeight,
 				maxHeightPx: fixedHeight ? maxHeightPx : void 0
 			});
+			contentHeight = emitted.y;
 			textWidth = Math.max(textWidth, emitted.maxWidth);
 			if (emitted.stopped) break;
 			offset += blockText(block).length + 1;
@@ -14681,25 +15128,42 @@ var TextLayoutEngine = class {
 		this.pool = new Map(next.map((e) => [e.sig, e]));
 		this.lastParagraphsRelaid = relaid;
 		const width = fixedWidth ? bounds.width : textWidth + padding * 2;
-		const height = fixedHeight ? bounds.height : lines.length * lineHeightPx + padding * 2;
-		applyAlign(lines, style.align, width, padding);
+		const height = fixedHeight ? bounds.height : contentHeight + padding * 2;
+		applyAlign(lines, width, padding);
 		return {
 			lines,
 			textWidth,
 			textHeight: style.fontSize,
 			lineHeightPx,
+			contentHeight,
 			width,
 			height
 		};
 	}
 	/** Append a paragraph's lines to `lines`; stops once a fixed height is full. */
 	emitLines(entry, block, paragraph, offset, lines, opts) {
-		const { font, style, lineHeightPx, maxHeightPx } = opts;
+		const { style, indent, maxHeightPx } = opts;
+		let { y } = opts;
 		let maxWidth = 0;
+		let first = true;
 		for (const pl of entry.lines) {
 			const text = entry.graphemes.slice(pl.startG, pl.endG).join("");
-			const segments = this.buildSegments(entry, block, pl, font, style);
+			const segments = this.buildSegments(entry, block, pl, style);
 			const startChar = entry.graphemes.slice(0, pl.startG).join("").length;
+			let marker;
+			if (first && opts.marker) {
+				const m0 = block.runs[0]?.m;
+				const rs = runStyle(style, m0);
+				const stepPx = Math.min(indent, this.stepPx(style));
+				marker = {
+					text: opts.marker,
+					x: Math.max(0, indent - stepPx),
+					font: fontString(rs),
+					fontSize: rs.fontSize,
+					color: typeof m0?.color === "string" ? m0.color : void 0
+				};
+			}
+			first = false;
 			lines.push({
 				paragraph,
 				start: offset + startChar,
@@ -14707,30 +15171,41 @@ var TextLayoutEngine = class {
 				text,
 				width: segments.reduce((a, s) => a + s.width, 0),
 				measuredWidth: pl.measuredWidth,
-				offsetX: 0,
-				y: lines.length * lineHeightPx,
+				offsetX: indent,
+				y,
+				height: pl.height,
+				baseline: pl.baseline,
+				indent,
+				marker,
+				align: block.align ?? style.align,
 				segments,
 				lastInParagraph: pl.lastInParagraph
 			});
-			maxWidth = Math.max(maxWidth, pl.measuredWidth);
-			if (maxHeightPx !== void 0 && (lines.length + 1) * lineHeightPx > maxHeightPx) return {
+			y += pl.height;
+			maxWidth = Math.max(maxWidth, pl.measuredWidth + indent);
+			if (maxHeightPx !== void 0 && y + pl.height > maxHeightPx) return {
 				stopped: true,
-				maxWidth
+				maxWidth,
+				y
 			};
 		}
 		return {
 			stopped: false,
-			maxWidth
+			maxWidth,
+			y
 		};
 	}
-	rangeWidth(entry, from, to, font, spacing) {
+	stepPx(style) {
+		return (typeof style.indentStep === "number" && Number.isFinite(style.indentStep) && style.indentStep > 0 ? style.indentStep : DEFAULT_INDENT_STEP) * style.fontSize;
+	}
+	rangeWidth(entry, from, to, spacing) {
 		let width = 0;
 		let i = from;
 		while (i < to) {
 			const run = entry.runOf[i];
 			let j = i;
 			while (j < to && entry.runOf[j] === run) j++;
-			width += this.measureChunk(font, entry.graphemes.slice(i, j).join(""), spacing);
+			width += this.measureChunk(entry.fonts[run], entry.graphemes.slice(i, j).join(""), spacing);
 			i = j;
 		}
 		return width;
@@ -14766,17 +15241,58 @@ var TextLayoutEngine = class {
 			matchWidth
 		};
 	}
-	layoutParagraph(block, sig, font, style, fixedWidth, maxWidth) {
+	layoutParagraph(block, sig, style, fixedWidth, maxWidth) {
+		const entry = this.wrapParagraph(block, sig, style, fixedWidth, maxWidth);
+		this.measureLines(entry, style);
+		return entry;
+	}
+	/** Per-line box height and baseline from the runs on each line. */
+	measureLines(entry, style) {
+		const baseFont = fontString(style);
+		for (const line of entry.lines) {
+			let size = 0;
+			let height = 0;
+			let asc = 0;
+			let desc = 0;
+			const seen = /* @__PURE__ */ new Set();
+			for (let g = line.startG; g < line.endG; g++) {
+				const r = entry.runOf[g];
+				if (seen.has(r)) continue;
+				seen.add(r);
+				size = Math.max(size, entry.sizes[r]);
+				height = Math.max(height, entry.lineHeights[r] * entry.sizes[r]);
+				const m = this.metrics(entry.fonts[r], entry.sizes[r]);
+				asc = Math.max(asc, m.ascent);
+				desc = Math.max(desc, m.descent);
+			}
+			if (seen.size === 0) {
+				size = style.fontSize;
+				height = style.lineHeight * size;
+				const m = this.metrics(baseFont, style.fontSize);
+				asc = m.ascent;
+				desc = m.descent;
+			}
+			line.height = height;
+			line.baseline = (asc - desc) / 2 + line.height / 2;
+		}
+	}
+	wrapParagraph(block, sig, style, fixedWidth, maxWidth) {
 		const { graphemes, runOf } = flattenBlock(block);
+		const baseFont = fontString(style);
+		const fonts = block.runs.map((r) => r.m ? fontString(runStyle(style, r.m)) : baseFont);
+		const sizes = block.runs.map((r) => style.fontSize * runRatio(r.m));
 		const entry = {
 			sig,
 			graphemes,
 			runOf,
+			fonts,
+			lineHeights: block.runs.map((r) => runLineHeight(r.m) ?? style.lineHeight),
+			sizes,
 			lines: []
 		};
 		const n = graphemes.length;
 		const spacing = style.letterSpacing;
-		const width = (a, b) => this.rangeWidth(entry, a, b, font, spacing);
+		const width = (a, b) => this.rangeWidth(entry, a, b, spacing);
 		const shouldWrap = style.wrap !== "none";
 		const wrapAtWord = style.wrap !== "char" && shouldWrap;
 		const whole = width(0, n);
@@ -14785,7 +15301,9 @@ var TextLayoutEngine = class {
 				startG: 0,
 				endG: n,
 				measuredWidth: whole,
-				lastInParagraph: true
+				lastInParagraph: true,
+				height: 0,
+				baseline: 0
 			});
 			return entry;
 		}
@@ -14797,7 +15315,9 @@ var TextLayoutEngine = class {
 					startG: start,
 					endG: n,
 					measuredWidth: matchWidth,
-					lastInParagraph: true
+					lastInParagraph: true,
+					height: 0,
+					baseline: 0
 				});
 				return entry;
 			}
@@ -14813,7 +15333,9 @@ var TextLayoutEngine = class {
 				startG: start,
 				endG: trimTrailingSpace(graphemes, start, end),
 				measuredWidth: matchWidth,
-				lastInParagraph: false
+				lastInParagraph: false,
+				height: 0,
+				baseline: 0
 			});
 			start = skipSpace(graphemes, end);
 		}
@@ -14821,7 +15343,7 @@ var TextLayoutEngine = class {
 		if (last) last.lastInParagraph = true;
 		return entry;
 	}
-	buildSegments(entry, block, pl, font, style) {
+	buildSegments(entry, block, pl, style) {
 		const segments = [];
 		let x = 0;
 		let i = pl.startG;
@@ -14830,12 +15352,16 @@ var TextLayoutEngine = class {
 			let j = i;
 			while (j < pl.endG && entry.runOf[j] === run) j++;
 			const t = entry.graphemes.slice(i, j).join("");
+			const font = entry.fonts[run];
 			const width = this.measureChunk(font, t, style.letterSpacing);
 			segments.push({
 				t,
 				m: block.runs[run].m,
+				run,
 				x,
-				width
+				width,
+				font,
+				fontSize: entry.sizes[run]
 			});
 			x += width;
 			i = j;
@@ -14867,12 +15393,18 @@ const LAYOUT_ATTRS = [
 * code written against `Konva.Text` keeps working.
 */
 var WeaveTextV2Shape = class extends Konva.Shape {
-	engine = new TextLayoutEngine();
-	naturalEngine = new TextLayoutEngine();
+	engine = new TextLayoutEngine(canvasMeasurer, fontMetrics);
+	naturalEngine = new TextLayoutEngine(canvasMeasurer, fontMetrics);
 	layoutCache = null;
 	blocksKey = {};
 	blocksCache = [];
 	viewport = null;
+	indentStepValue;
+	linkStyle = {
+		color: "#1155ccff",
+		hoverColor: "#3d7be0ff"
+	};
+	hoveredRun = null;
 	constructor(config) {
 		super(config);
 		this.className = "WeaveTextV2Shape";
@@ -14889,6 +15421,55 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 		this._setAttr("text", value == null ? "" : String(value));
 		return this;
 	}
+	/**
+	* List indent per depth, as a multiple of `fontSize`. Not a node attr: it
+	* comes from the node config and must not be serialized into the document.
+	*/
+	setIndentStep(step) {
+		if (this.indentStepValue !== step) {
+			this.indentStepValue = step;
+			this.layoutCache = null;
+		}
+		return this;
+	}
+	/** Link run colours (from the node config; not serialized). */
+	setLinkStyle(style) {
+		this.linkStyle = style;
+		return this;
+	}
+	/** Run under the pointer (`paragraph:run`), repainted with the hover colour. */
+	setHoveredRun(key) {
+		if (this.hoveredRun !== key) {
+			this.hoveredRun = key;
+			this.getLayer()?.batchDraw();
+		}
+		return this;
+	}
+	getHoveredRun() {
+		return this.hoveredRun;
+	}
+	/**
+	* Link run at a point in node-local coordinates (the legacy node-level
+	* `link` wins: runs are then not links).
+	*/
+	linkAtPoint(point) {
+		if (this.attrs.link) return null;
+		const layout = this.ensureLayout();
+		const o = this.getContentOffset();
+		const x = point.x - o.x;
+		const y = point.y - o.y;
+		for (const line of layout.lines) {
+			if (y < line.y || y >= line.y + line.height) continue;
+			for (const seg of line.segments) {
+				const sx = line.offsetX + seg.x;
+				if (x >= sx && x <= sx + seg.width && isSafeLink(seg.m?.link)) return {
+					key: `${line.paragraph}:${seg.run}`,
+					url: seg.m.link
+				};
+			}
+		}
+		return null;
+	}
 	/** Resolved blocks: stored or lazily synthesized (never written back). */
 	getBlocks() {
 		const k = this.blocksKey;
@@ -14909,6 +15490,10 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 	}
 	/** Replace content with blocks, keeping the `text` mirror in sync. */
 	setBlocks(blocks) {
+		if (!Array.isArray(blocks)) {
+			this._setAttr("blocks", void 0);
+			return this;
+		}
 		this._setAttr("blocks", blocks);
 		this._setAttr("text", blocksToText(blocks));
 		return this;
@@ -14946,6 +15531,16 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 	textDecoration(v) {
 		return this.accessor("textDecoration", "", v);
 	}
+	/**
+	* Always stroke under the node transform. Weave turns `strokeScaleEnabled`
+	* off while a node is transformed; Konva then resets the canvas transform
+	* before stroking, which only works for path shapes. `strokeText` is not a
+	* path, so the outline was painted at local coordinates on the canvas
+	* origin at stage scale 1 (visible over other nodes while resizing).
+	*/
+	getStrokeScaleEnabled() {
+		return true;
+	}
 	accessor(name, fallback, value) {
 		if (value === void 0) return this.attrs[name] ?? fallback;
 		this.setAttr(name, value);
@@ -14980,7 +15575,8 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 			lineHeight: this.lineHeight(),
 			letterSpacing: this.letterSpacing(),
 			wrap: this.wrap(),
-			align: this.align()
+			align: this.align(),
+			indentStep: this.indentStepValue
 		};
 	}
 	/** Lazy, cached layout. Size accessors and painting force it. */
@@ -15010,14 +15606,13 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 		};
 	}
 	/** Rendered width of a string with this shape's font and letter spacing. */
-	measureText(text) {
-		return canvasMeasurer(fontString(this.style()), text) + text.length * this.letterSpacing();
+	measureText(text, font) {
+		return canvasMeasurer(font ?? fontString(this.style()), text) + text.length * this.letterSpacing();
 	}
 	/** Offset of the first line inside the box (padding + vertical align). */
 	getContentOffset() {
 		const padding = this.padding();
-		const layout = this.ensureLayout();
-		const used = layout.lines.length * layout.lineHeightPx + padding * 2;
+		const used = this.ensureLayout().contentHeight + padding * 2;
 		const va = this.verticalAlign();
 		let alignY = 0;
 		if (va === "middle") alignY = (this.getHeight() - used) / 2;
@@ -15040,34 +15635,40 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 	setViewport(range) {
 		this.viewport = range;
 	}
-	visibleRange() {
+	/**
+	* Visible y-range in local coordinates, derived from the context being
+	* painted (current transform + backing canvas size) instead of the stage.
+	* The stage is not the paint target during export (off-screen canvases,
+	* tiles, server-side), so using it culled visible lines. Returns null (paint
+	* everything) when the transform cannot be read.
+	*/
+	visibleRange(ctx) {
 		if (this.viewport) return this.viewport;
-		const stage = this.getStage();
-		if (!stage) return null;
-		const inv = this.getAbsoluteTransform().copy().invert();
-		const w = stage.width();
-		const h = stage.height();
-		const pts = [
-			inv.point({
-				x: 0,
-				y: 0
-			}),
-			inv.point({
-				x: w,
-				y: 0
-			}),
-			inv.point({
-				x: 0,
-				y: h
-			}),
-			inv.point({
-				x: w,
-				y: h
-			})
-		];
+		const native = ctx._context;
+		const m = native.getTransform?.() ?? native.currentTransform;
+		if (!m) return null;
+		const det = m.a * m.d - m.b * m.c;
+		if (!det || !Number.isFinite(det)) return null;
+		const canvas = ctx.getCanvas();
+		const backing = canvas._canvas;
+		const w = backing?.width ?? canvas.getWidth() * canvas.getPixelRatio();
+		const h = backing?.height ?? canvas.getHeight() * canvas.getPixelRatio();
+		if (!(w > 0) || !(h > 0)) return null;
+		let y1 = Infinity;
+		let y2 = -Infinity;
+		for (const [px, py] of [
+			[0, 0],
+			[w, 0],
+			[0, h],
+			[w, h]
+		]) {
+			const y = (m.a * (py - m.f) - m.b * (px - m.e)) / det;
+			if (y < y1) y1 = y;
+			if (y > y2) y2 = y;
+		}
 		return {
-			y1: Math.min(...pts.map((p) => p.y)),
-			y2: Math.max(...pts.map((p) => p.y))
+			y1,
+			y2
 		};
 	}
 	_sceneFunc = (ctx, shape) => {
@@ -15075,30 +15676,22 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 		const layout = self.ensureLayout();
 		if (layout.lines.length === 0) return;
 		const padding = self.padding();
-		const lineHeightPx = layout.lineHeightPx;
 		let baseline = "middle";
-		let translateY = lineHeightPx / 2;
-		if (!Konva.legacyTextRendering) {
-			const m = self.measureMetrics();
-			baseline = "alphabetic";
-			translateY = (m.ascent - m.descent) / 2 + lineHeightPx / 2;
-		}
+		if (!Konva.legacyTextRendering) baseline = "alphabetic";
 		ctx.setAttr("font", fontString(self.style()));
 		ctx.setAttr("textBaseline", baseline);
 		ctx.setAttr("textAlign", "left");
 		const alignY = self.verticalOffset(layout);
+		const range = self.visibleRange(ctx);
 		ctx.translate(padding, alignY + padding);
-		const range = self.visibleRange();
-		const top = alignY + padding;
-		for (let n = 0; n < layout.lines.length; n++) {
-			const lineTop = top + n * lineHeightPx;
-			if (range && (lineTop + lineHeightPx < range.y1 - lineHeightPx || lineTop > range.y2 + lineHeightPx)) continue;
-			self.paintLine(ctx, layout.lines[n], translateY + n * lineHeightPx);
+		for (const line of layout.lines) {
+			if (range && (alignY + padding + line.y + line.height < range.y1 - line.height || alignY + padding + line.y > range.y2 + line.height)) continue;
+			self.paintLine(ctx, line, line.y + line.baseline);
 		}
 	};
 	/** Vertical offset of the text block inside the box (verticalAlign). */
 	verticalOffset(layout) {
-		const used = layout.lines.length * layout.lineHeightPx + this.padding() * 2;
+		const used = layout.contentHeight + this.padding() * 2;
 		const va = this.verticalAlign();
 		if (va === "middle") return (this.getHeight() - used) / 2;
 		if (va === "bottom") return this.getHeight() - used;
@@ -15109,7 +15702,21 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 		const fontSize = this.fontSize();
 		ctx.save();
 		if (decoration.includes("underline")) this.strokeDecoration(ctx, line, y + Math.round(fontSize / 4));
-		for (const seg of line.segments) this.paintSegment(ctx, seg.t, line.offsetX + seg.x, y);
+		if (line.marker) {
+			const mk = line.marker;
+			ctx.setAttr("font", mk.font);
+			this.fillText(ctx, mk.text, mk.x, y, mk.color);
+		}
+		for (const seg of line.segments) {
+			ctx.setAttr("font", seg.font);
+			const x = line.offsetX + seg.x;
+			const isLink = !this.attrs.link && isSafeLink(seg.m?.link);
+			let color = typeof seg.m?.color === "string" ? seg.m.color : void 0;
+			if (isLink) color = this.hoveredRun === `${line.paragraph}:${seg.run}` ? this.linkStyle.hoverColor : this.linkStyle.color;
+			this.paintSegment(ctx, seg, x, y, color);
+			if (seg.m?.underline || isLink) this.strokeSegment(ctx, seg, x, y + Math.round(seg.fontSize / 4), color);
+			if (seg.m?.strike) this.strokeSegment(ctx, seg, x, y - Math.round(seg.fontSize / 4), color);
+		}
 		if (decoration.includes("line-through")) this.strokeDecoration(ctx, line, y - Math.round(fontSize / 4));
 		ctx.restore();
 	}
@@ -15123,24 +15730,44 @@ var WeaveTextV2Shape = class extends Konva.Shape {
 		ctx.stroke();
 		ctx.restore();
 	}
-	paintSegment(ctx, text, x, y) {
+	strokeSegment(ctx, seg, x, y, color) {
+		ctx.save();
+		ctx.beginPath();
+		ctx.moveTo(x, y);
+		ctx.lineTo(x + Math.round(seg.width), y);
+		ctx.lineWidth = seg.fontSize / 15;
+		ctx.strokeStyle = color ?? this.fill();
+		ctx.stroke();
+		ctx.restore();
+	}
+	paintSegment(ctx, seg, x, y, color) {
 		const spacing = this.letterSpacing();
 		if (spacing === 0) {
-			this.fillText(ctx, text, x, y);
+			this.fillText(ctx, seg.t, x, y, color);
 			return;
 		}
 		let cx = x;
-		for (const ch of Array.from(text)) {
-			this.fillText(ctx, ch, cx, y);
-			cx += this.measureSize(ch).width + spacing;
+		for (const ch of Array.from(seg.t)) {
+			this.fillText(ctx, ch, cx, y, color);
+			cx += canvasMeasurer(seg.font, ch) + spacing;
 		}
 	}
-	fillText(ctx, text, x, y) {
+	fillText(ctx, text, x, y, color) {
 		const self = this;
 		self._partialText = text;
 		self._partialTextX = x;
 		self._partialTextY = y;
-		ctx.fillStrokeShape(this);
+		if (color === void 0) {
+			ctx.fillStrokeShape(this);
+			return;
+		}
+		const prev = this.attrs.fill;
+		this.attrs.fill = color;
+		try {
+			ctx.fillStrokeShape(this);
+		} finally {
+			this.attrs.fill = prev;
+		}
 	}
 	_hitFunc = (ctx, shape) => {
 		ctx.beginPath();
@@ -15256,9 +15883,27 @@ function lineIndexAt(layout, offset) {
 	}
 	return fallback;
 }
+/** Width of the first `k` UTF-16 units of a line, run by run. */
+function prefixWidth(line, k, measure) {
+	if (k <= 0) return 0;
+	if (line.segments.length === 0) return measure(line.text.slice(0, k));
+	let width = 0;
+	let pos = 0;
+	for (const seg of line.segments) {
+		const end = pos + seg.t.length;
+		if (k >= end) width += seg.width;
+		else {
+			width += measure(seg.t.slice(0, k - pos), seg.font);
+			break;
+		}
+		pos = end;
+		if (k === end) break;
+	}
+	return width;
+}
 function lineX(line, offset, measure) {
 	const k = Math.max(0, Math.min(offset - line.start, line.text.length));
-	return line.offsetX + (k === 0 ? 0 : measure(line.text.slice(0, k)));
+	return line.offsetX + prefixWidth(line, k, measure);
 }
 /** Caret rectangle in text-local coordinates (before padding/valign offset). */
 function caretRect(layout, offset, measure) {
@@ -15272,16 +15917,22 @@ function caretRect(layout, offset, measure) {
 	};
 	return {
 		x: lineX(line, offset, measure),
-		y: i * layout.lineHeightPx,
-		height: layout.lineHeightPx,
+		y: line.y,
+		height: line.height,
 		line: i
 	};
 }
+/** Index of the line containing a local y (clamped). */
+function lineIndexAtY(layout, y) {
+	const lines = layout.lines;
+	for (let i = 0; i < lines.length; i++) if (y < lines[i].y + lines[i].height) return i;
+	return Math.max(0, lines.length - 1);
+}
 /** Offset closest to a point in text-local coordinates. */
 function offsetFromPoint(layout, point, measure) {
 	const lines = layout.lines;
 	if (lines.length === 0) return 0;
-	return offsetInLine(lines[Math.max(0, Math.min(lines.length - 1, Math.floor(point.y / layout.lineHeightPx)))], point.x, measure);
+	return offsetInLine(lines[lineIndexAtY(layout, point.y)], point.x, measure);
 }
 function offsetInLine(line, x, measure) {
 	const rel = x - line.offsetX;
@@ -15289,7 +15940,7 @@ function offsetInLine(line, x, measure) {
 	const b = boundaries(line.text, graphemeSeg);
 	let prevW = 0;
 	for (let k = 1; k < b.length; k++) {
-		const w = measure(line.text.slice(0, b[k]));
+		const w = prefixWidth(line, b[k], measure);
 		if (rel < (prevW + w) / 2) return line.start + b[k - 1];
 		prevW = w;
 	}
@@ -15313,7 +15964,7 @@ function selectionRects(layout, from, to, measure) {
 	if (from > to) [from, to] = [to, from];
 	if (from === to) return [];
 	const out = [];
-	layout.lines.forEach((line, i) => {
+	layout.lines.forEach((line) => {
 		const hasNewline = line.lastInParagraph;
 		const lineFrom = Math.max(from, line.start);
 		const lineTo = Math.min(to, hasNewline ? line.end + 1 : line.end);
@@ -15324,9 +15975,9 @@ function selectionRects(layout, from, to, measure) {
 		if (x2 <= x1) return;
 		out.push({
 			x: x1,
-			y: i * layout.lineHeightPx,
+			y: line.y,
 			width: x2 - x1,
-			height: layout.lineHeightPx
+			height: line.height
 		});
 	});
 	return out;
@@ -15345,6 +15996,11 @@ var TextEditModel = class {
 	focus = 0;
 	/** x kept while moving vertically; reset by any other move. */
 	desiredX = null;
+	/**
+	* Marks the next typed text takes at a collapsed caret (e.g. bold toggled
+	* with nothing selected). Cleared when the selection moves.
+	*/
+	storedMarks = null;
 	undoStack = [];
 	redoStack = [];
 	lastKind = null;
@@ -15381,12 +16037,14 @@ var TextEditModel = class {
 		const len = this.getText().length;
 		this.anchor = Math.max(0, Math.min(anchor, len));
 		this.focus = Math.max(0, Math.min(focus, len));
+		this.storedMarks = null;
 		this.breakCoalescing();
 	}
 	moveTo(offset, extend = false, keepDesiredX = false) {
 		const len = this.getText().length;
 		const o = Math.max(0, Math.min(offset, len));
 		this.focus = o;
+		this.storedMarks = null;
 		if (!extend) this.anchor = o;
 		if (!keepDesiredX) this.desiredX = null;
 		this.breakCoalescing();
@@ -15394,6 +16052,7 @@ var TextEditModel = class {
 	selectAll() {
 		this.anchor = 0;
 		this.focus = this.getText().length;
+		this.storedMarks = null;
 		this.breakCoalescing();
 	}
 	breakCoalescing() {
@@ -15429,7 +16088,14 @@ var TextEditModel = class {
 		end = Math.max(start, Math.min(end, len));
 		if (start === end && text === "") return false;
 		this.record(kind, start);
-		this.blocks = replaceRange(this.blocks, start, end, text);
+		const carried = this.storedMarks ?? marksAtOffset(this.blocks, start);
+		this.blocks = replaceRange(this.blocks, start, end, text, this.storedMarks ?? void 0);
+		this.storedMarks = null;
+		if (text.endsWith("\n") && carried) {
+			const { link: _link, ...rest } = carried;
+			const next = cleanMarks(rest);
+			if (next && !marksAtOffset(this.blocks, start + text.length)) this.storedMarks = next;
+		}
 		this.anchor = this.focus = start + text.length;
 		this.lastEditEnd = this.focus;
 		this.desiredX = null;
@@ -15469,14 +16135,102 @@ var TextEditModel = class {
 		this.restore(next);
 		return true;
 	}
+	/** Current marks at the caret / selection start (stored marks win). */
+	caretMarks() {
+		return this.storedMarks ?? marksAtOffset(this.blocks, this.getSelection().start);
+	}
+	/** Always one new undo entry, never coalesced. */
+	commitFormat(next) {
+		if (JSON.stringify(next) === JSON.stringify(this.blocks)) return false;
+		this.lastKind = null;
+		this.record("format", -1);
+		this.lastKind = null;
+		this.blocks = next;
+		return true;
+	}
+	/** Set (`undefined` clears) one mark on the selection or the stored marks. */
+	setMark(key, value) {
+		const { start, end } = this.getSelection();
+		if (start === end) {
+			const base = { ...this.caretMarks() ?? {} };
+			if (value === void 0 || value === false) delete base[key];
+			else base[key] = value;
+			this.storedMarks = cleanMarks(base) ?? {};
+			return true;
+		}
+		return this.commitFormat(applyMark(this.blocks, start, end, key, value));
+	}
+	/** Toggle a boolean mark: on unless the whole selection already has it. */
+	toggleMark(key) {
+		const { start, end } = this.getSelection();
+		const q = queryMark(this.blocks, start, end, key, this.storedMarks);
+		return this.setMark(key, q.state === "all" ? void 0 : true);
+	}
+	toggleList(kind) {
+		const { start, end } = this.getSelection();
+		return this.commitFormat(toggleList(this.blocks, start, end, kind));
+	}
+	setAlign(align) {
+		const { start, end } = this.getSelection();
+		return this.commitFormat(setBlockAlign(this.blocks, start, end, align));
+	}
+	indent() {
+		const { start, end } = this.getSelection();
+		return this.commitFormat(indentBlocks(this.blocks, start, end));
+	}
+	outdent() {
+		const { start, end } = this.getSelection();
+		return this.commitFormat(outdentBlocks(this.blocks, start, end));
+	}
+	blockAt(offset) {
+		let pos = 0;
+		for (let i = 0; i < this.blocks.length; i++) {
+			const len = blockText(this.blocks[i]).length;
+			if (offset <= pos + len) return {
+				index: i,
+				start: pos,
+				length: len
+			};
+			pos += len + 1;
+		}
+	}
+	/**
+	* Enter in a list: an empty item exits the list; otherwise the item
+	* continues (the block split carries `kind` and `depth`).
+	*/
+	enter() {
+		const { start, end } = this.getSelection();
+		const b = start === end ? this.blockAt(start) : void 0;
+		if (b && this.blocks[b.index].kind && b.length === 0) return this.commitFormat(outdentToPlain(this.blocks, b.index));
+		return this.replaceRange(start, end, "\n", "other");
+	}
+	/**
+	* Backspace at the start of a list item outdents it, or removes the
+	* marker at depth 0. Returns false when the key is not handled here.
+	*/
+	backspaceInList() {
+		const { start, end } = this.getSelection();
+		if (start !== end) return false;
+		const b = this.blockAt(start);
+		if (!b || b.start !== start || !this.blocks[b.index].kind) return false;
+		return this.commitFormat(outdentBlocks(this.blocks, start, start));
+	}
 	restore(s) {
 		this.blocks = s.blocks;
+		this.storedMarks = null;
 		this.anchor = s.anchor;
 		this.focus = s.focus;
 		this.lastKind = null;
 		this.desiredX = null;
 	}
 };
+function outdentToPlain(blocks, index) {
+	return blocks.map((b, i) => {
+		if (i !== index) return b;
+		const { kind: _k, depth: _d, start: _s, ...rest } = b;
+		return rest;
+	});
+}
 const SLICE_BUDGET_MS = 8;
 const BLINK_MS = 530;
 var TextEditSession = class {
@@ -15534,7 +16288,7 @@ var TextEditSession = class {
 		};
 		if (this.host.selectAllOnStart) this.model.selectAll();
 		this.syncTextarea();
-		ta.focus();
+		ta.focus({ preventScroll: true });
 		this.positionTextarea();
 		this.startBlink();
 		this.repaint();
@@ -15563,7 +16317,7 @@ var TextEditSession = class {
 		if (w.weaveTextEditing) delete w.weaveTextEditing[this.id];
 	}
 	focus() {
-		this.textarea?.focus();
+		this.textarea?.focus({ preventScroll: true });
 	}
 	createTextarea() {
 		const ta = this.host.container.ownerDocument.createElement("textarea");
@@ -15612,8 +16366,12 @@ var TextEditSession = class {
 		if (!ta) return;
 		const c = this.caretStagePoint();
 		const p = this.host.stageToContainer(c);
-		ta.style.left = `${p.x}px`;
-		ta.style.top = `${p.y}px`;
+		this.host.revealCaret?.(p);
+		const box = this.host.container;
+		const maxX = Math.max(0, (box.clientWidth || Infinity) - 2);
+		const maxY = Math.max(0, (box.clientHeight || Infinity) - 20);
+		ta.style.left = `${Math.min(Math.max(p.x, 0), maxX)}px`;
+		ta.style.top = `${Math.min(Math.max(p.y, 0), maxY)}px`;
 	}
 	caretStagePoint() {
 		const r = caretRect(this.target.getLayout(), this.model.focus, this.target.measure);
@@ -15645,10 +16403,41 @@ var TextEditSession = class {
 		if (e.key === "Escape") this.host.onRequestExit("escape");
 		else if (isUndo) this.undo();
 		else if (isRedo) this.redo();
+		else if (this.handleRichKey(e, mod, key)) return true;
 		else if (e.key === "Tab") return true;
 		else return false;
 		return true;
 	}
+	/** Format shortcuts and list key rules; only when rich text is enabled. */
+	handleRichKey(e, mod, key) {
+		if (!this.host.richText) return false;
+		if (mod && !e.shiftKey && !e.altKey) {
+			const marks = {
+				b: "bold",
+				i: "italic",
+				u: "underline"
+			};
+			if (marks[key]) {
+				this.toggleMark(marks[key]);
+				return true;
+			}
+		}
+		if (mod || this.composing) return false;
+		if (e.key === "Tab") {
+			if (e.shiftKey) this.outdent();
+			else this.indent();
+			return true;
+		}
+		if (e.key === "Enter") {
+			if (this.model.enter()) this.afterFormat("command", true);
+			return true;
+		}
+		if (e.key === "Backspace" && this.model.backspaceInList()) {
+			this.afterFormat("command", true);
+			return true;
+		}
+		return false;
+	}
 	handleNavigationKey(e) {
 		if (e.ctrlKey || e.metaKey) return false;
 		if ((e.key === "ArrowUp" || e.key === "ArrowDown") && !e.altKey) {
@@ -15702,7 +16491,15 @@ var TextEditSession = class {
 		while (p < max && oldText[p] === newText[p]) p++;
 		let s = 0;
 		while (s < max - p && oldText[oldText.length - 1 - s] === newText[newText.length - 1 - s]) s++;
-		const inserted = newText.slice(p, newText.length - s);
+		let inserted = newText.slice(p, newText.length - s);
+		if (s + p === oldText.length && inserted !== "") {
+			const q = ta.selectionEnd - inserted.length;
+			if (q >= 0 && q < p && newText.slice(q, q + inserted.length) === inserted && oldText.slice(0, q) + inserted + oldText.slice(q) === newText) {
+				s = oldText.length - q;
+				p = q;
+				inserted = newText.slice(p, newText.length - s);
+			}
+		}
 		const inputType = e.inputType ?? "";
 		const kind = this.editKindFor(inputType);
 		this.model.replaceRange(p, oldText.length - s, inserted, kind);
@@ -15743,6 +16540,7 @@ var TextEditSession = class {
 		if (this.model.undo()) {
 			this.syncTextarea();
 			this.afterContentChange(0, true);
+			this.host.onFormatChange?.("undo");
 		}
 	}
 	redo() {
@@ -15750,8 +16548,42 @@ var TextEditSession = class {
 		if (this.model.redo()) {
 			this.syncTextarea();
 			this.afterContentChange(0, true);
+			this.host.onFormatChange?.("redo");
 		}
 	}
+	afterFormat(reason, content = false) {
+		this.flushPending();
+		this.syncTextarea();
+		if (content) this.afterContentChange(0, true);
+		else this.applyContent();
+		this.afterSelectionChange();
+		this.host.onFormatChange?.(reason);
+	}
+	toggleMark(key) {
+		if (this.model.toggleMark(key)) this.afterFormat("command");
+	}
+	setMark(key, value) {
+		if (this.model.setMark(key, value)) this.afterFormat("command");
+	}
+	toggleList(kind) {
+		if (this.model.toggleList(kind)) this.afterFormat("command");
+	}
+	setAlign(align) {
+		if (this.model.setAlign(align)) this.afterFormat("command");
+	}
+	indent() {
+		if (this.model.indent()) this.afterFormat("command");
+	}
+	outdent() {
+		if (this.model.outdent()) this.afterFormat("command");
+	}
+	getSelection() {
+		return this.model.getSelection();
+	}
+	getFormat() {
+		const { start, end } = this.model.getSelection();
+		return getSelectionFormat(this.model.getBlocks(), start, end, this.target.getFontSize(), this.model.storedMarks);
+	}
 	toLocal(e) {
 		const stagePt = this.host.clientToStage(e.clientX, e.clientY);
 		const p = this.target.getAbsoluteTransform().copy().invert().point(stagePt);
@@ -15766,12 +16598,26 @@ var TextEditSession = class {
 		const { width, height } = this.target.getSize();
 		return local.x + o.x >= 0 && local.y + o.y >= 0 && local.x + o.x <= width && local.y + o.y <= height;
 	}
+	/**
+	* True for pointer targets inside an element the app marked with
+	* `data-weave-text-edit-keep` (e.g. a formatting toolbar): they neither
+	* end the session nor, unless they are form fields, steal focus.
+	*/
+	isKeepTarget(e) {
+		const t = e.target;
+		return typeof Element !== "undefined" && t instanceof Element && !!t.closest("[data-weave-text-edit-keep]");
+	}
 	onMouseDown = (e) => {
+		if (this.isKeepTarget(e)) {
+			if (!e.target.closest("input, textarea, select, [contenteditable=\"true\"]")) e.preventDefault();
+			return;
+		}
 		if (this.isInside(this.toLocal(e))) e.preventDefault();
 	};
 	onPointerDown = (e) => {
 		if (e.button !== 0 && e.pointerType === "mouse") return;
 		if (this.textarea && e.target === this.textarea) return;
+		if (this.isKeepTarget(e)) return;
 		const local = this.toLocal(e);
 		if (!this.isInside(local)) {
 			e.stopPropagation();
@@ -15782,10 +16628,11 @@ var TextEditSession = class {
 		e.preventDefault();
 		const offset = offsetFromPoint(this.target.getLayout(), local, this.target.measure);
 		const text = this.model.getText();
-		if (e.detail >= 3) {
+		const clicks = this.countClicks(e);
+		if (clicks >= 3) {
 			const [s, en] = paragraphRangeAt(text, offset);
 			this.model.setSelection(s, en);
-		} else if (e.detail === 2) {
+		} else if (clicks === 2) {
 			const [s, en] = wordRangeAt(text, offset);
 			this.model.setSelection(s, en);
 		} else {
@@ -15794,8 +16641,31 @@ var TextEditSession = class {
 		}
 		this.syncTextarea();
 		this.afterSelectionChange();
-		this.textarea?.focus();
+		this.textarea?.focus({ preventScroll: true });
 	};
+	lastClick = {
+		t: 0,
+		x: 0,
+		y: 0,
+		n: 0
+	};
+	/**
+	* Browsers report `detail` as 0 on pointerdown, so multi-click is counted
+	* here (same spot, within 500 ms). A real `detail` still wins.
+	*/
+	countClicks(e) {
+		const now = e.timeStamp || Date.now();
+		const l = this.lastClick;
+		const near = now - l.t < 500 && Math.hypot(e.clientX - l.x, e.clientY - l.y) < 5 && l.n > 0;
+		const n = Math.max(e.detail, near ? l.n + 1 : 1);
+		this.lastClick = {
+			t: now,
+			x: e.clientX,
+			y: e.clientY,
+			n: n >= 3 ? 0 : n
+		};
+		return n;
+	}
 	onPointerMove = (e) => {
 		if (!this.dragging) return;
 		const local = this.toLocal(e);
@@ -15807,13 +16677,14 @@ var TextEditSession = class {
 	onPointerUp = () => {
 		if (!this.dragging) return;
 		this.dragging = false;
-		this.textarea?.focus();
+		this.textarea?.focus({ preventScroll: true });
 	};
 	afterSelectionChange() {
 		this.syncTextarea();
 		this.positionTextarea();
 		this.resetBlink();
 		this.repaint();
+		this.host.onSelectionChange?.();
 	}
 	afterContentChange(insertedLength, immediate = false) {
 		this.flushPending();
@@ -15837,6 +16708,7 @@ var TextEditSession = class {
 	applyContent() {
 		this.target.setBlocks(this.model.getBlocks());
 		this.host.onChange?.(this.model.getBlocks());
+		this.host.onSelectionChange?.();
 		this.positionTextarea();
 		this.target.requestRedraw();
 		this.repaint();
@@ -15912,15 +16784,29 @@ function host_signal(signal, abort) {
 //#region src/nodes/text-v2/constants.ts
 /** Default threshold for `onTextSizeWarning` (chars of serialized blocks). */
 const WEAVE_TEXT_V2_SIZE_WARNING_THRESHOLD = 2e5;
+/** Default list indent per depth, as a multiple of the node `fontSize`. */
+const WEAVE_TEXT_V2_DEFAULT_INDENT_STEP = 1.5;
 const WEAVE_TEXT_V2_SELECTION_COLOR = "rgba(66, 133, 244, 0.35)";
 const WEAVE_TEXT_V2_DEFAULT_CONFIG = {
 	...WEAVE_TEXT_NODE_DEFAULT_CONFIG,
-	edition: { outline: {
-		enabled: true,
-		color: "#0074ff",
-		width: 1,
-		padding: 0
-	} },
+	edition: {
+		outline: {
+			enabled: true,
+			color: "#0074ff",
+			width: 1,
+			padding: 0
+		},
+		followPadding: {
+			top: 40,
+			right: 40,
+			bottom: 40,
+			left: 40
+		}
+	},
+	richText: {
+		enabled: false,
+		indentStep: WEAVE_TEXT_V2_DEFAULT_INDENT_STEP
+	},
 	sizeWarning: { threshold: WEAVE_TEXT_V2_SIZE_WARNING_THRESHOLD }
 };
 //#endregion
@@ -15948,6 +16834,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 	editingNodeId = null;
 	session = null;
 	sizeWarned = false;
+	selectionTimer;
 	nodeRenderedAddedRegistered = false;
 	keyPressHandler;
 	constructor(params) {
@@ -16021,6 +16908,11 @@ var WeaveTextV2Node = class extends WeaveNode {
 				linkPreviousTextDecoration
 			}
 		});
+		text.setIndentStep(this.indentStep());
+		text.setLinkStyle({
+			color: this.config.link.defaultColor,
+			hoverColor: this.config.link.hoverColor
+		});
 		this.setupDefaultNodeAugmentation(text);
 		const defaultTransformerProperties = this.defaultGetTransformerProperties(this.config.transform);
 		text.getTransformerProperties = function() {
@@ -16116,7 +17008,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 				this.applySize(shape);
 			},
 			getLayout: () => shape.ensureLayout(),
-			measure: (t) => shape.measureText(t),
+			measure: (t, f) => shape.measureText(t, f),
 			getAbsoluteTransform: () => shape.getAbsoluteTransform(),
 			getContentOffset: () => shape.getContentOffset(),
 			getSize: () => ({
@@ -16167,7 +17059,23 @@ var WeaveTextV2Node = class extends WeaveNode {
 					y: p.y * sy
 				};
 			},
+			revealCaret: (p) => {
+				const box = container;
+				const w = box.clientWidth;
+				const h = box.clientHeight;
+				if (!w || !h) return;
+				const f = this.config.edition.followPadding;
+				const dx = p.x < f.left ? f.left - p.x : p.x > w - f.right ? w - f.right - p.x : 0;
+				const dy = p.y < f.top ? f.top - p.y : p.y > h - f.bottom ? h - f.bottom - p.y : 0;
+				if (!dx && !dy) return;
+				stage.x(stage.x() + dx);
+				stage.y(stage.y() + dy);
+				this.instance.emitEvent("onStageMove");
+			},
 			selectAllOnStart: !create,
+			richText: this.isRich(shape),
+			onSelectionChange: () => this.scheduleSelectionEvent(shape),
+			onFormatChange: (reason) => this.emitFormatChange(shape, reason),
 			caretColor: this.config.cursor.color,
 			selectionColor: WEAVE_TEXT_V2_SELECTION_COLOR,
 			...this.config.edition.outline.enabled && {
@@ -16203,6 +17111,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 	exitEditMode(shape) {
 		const session = this.session;
 		if (!session || !this.editing) return;
+		clearTimeout(this.selectionTimer);
 		const { changed } = session.getResult();
 		session.destroy();
 		this.session = null;
@@ -16265,11 +17174,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 				text.getLayer()?.batchDraw();
 			}
 			const layout = text.getAttrs().layout;
-			if (this.isSelecting() && this.isNodeSelected(text) && (layout !== TEXT_LAYOUT.SMART || !isCorner())) {
-				text.width(text.width() * text.scaleX());
-				resetScale(text);
-				text.fontSize(text.fontSize() * text.scaleY());
-			}
+			if (this.isSelecting() && this.isNodeSelected(text) && (layout !== TEXT_LAYOUT.SMART || !isCorner())) resetScale(text);
 			text.setAttr("shouldUpdateOnTransform", false);
 			text.getLayer()?.batchDraw();
 		});
@@ -16313,6 +17218,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 		};
 		const isLinked = Boolean(nextProps.link);
 		const { linkPreviousFill, linkPreviousTextDecoration } = this.linkOverrides(nextProps);
+		shape.setIndentStep(this.indentStep());
 		shape.setAttrs({
 			...nextProps,
 			...this.outlineProps(),
@@ -16350,7 +17256,7 @@ var WeaveTextV2Node = class extends WeaveNode {
 		delete cleanedAttrs.dragBoundFunc;
 		if (cleanedAttrs.link) {
 			if (typeof cleanedAttrs.linkPreviousFill === "string") cleanedAttrs.fill = cleanedAttrs.linkPreviousFill;
-			if (typeof cleanedAttrs.linkPreviousTextDecoration === "string") cleanedAttrs.textDecoration = cleanedAttrs.linkPreviousTextDecoration;
+			cleanedAttrs.textDecoration = typeof cleanedAttrs.linkPreviousTextDecoration === "string" ? cleanedAttrs.linkPreviousTextDecoration : "";
 		}
 		return {
 			key: attrs.id ?? "",
@@ -16365,18 +17271,85 @@ var WeaveTextV2Node = class extends WeaveNode {
 			}
 		};
 	}
+	linkCtxMenuGuardRegistered = false;
+	linkHoverText = null;
+	linkModifier = false;
+	linkHoverRefresh = null;
+	linkHitAt(text) {
+		const link = text.getAttrs().link;
+		if (link) {
+			const p = this.localPointer(text);
+			return p.x >= 0 && p.y >= 0 && p.x <= text.width() && p.y <= text.height() ? { url: link } : null;
+		}
+		return text.linkAtPoint(this.localPointer(text));
+	}
+	registerLinkContextMenuGuard() {
+		if (this.linkCtxMenuGuardRegistered || this.instance.isServerSide()) return;
+		this.linkCtxMenuGuardRegistered = true;
+		const stage = this.instance.getStage();
+		const signal = this.instance.getEventsController().signal;
+		const syncModifier = (e) => {
+			const next = e.ctrlKey || e.metaKey;
+			if (next === this.linkModifier) return;
+			this.linkModifier = next;
+			this.linkHoverRefresh?.();
+		};
+		window.addEventListener("keydown", syncModifier, { signal });
+		window.addEventListener("keyup", syncModifier, { signal });
+		window.addEventListener("blur", () => {
+			this.linkModifier = false;
+			this.linkHoverRefresh?.();
+		}, { signal });
+		stage.container().addEventListener("contextmenu", (e) => {
+			if (this.editing || !e.ctrlKey) return;
+			const text = this.linkHoverText;
+			if (!text) return;
+			stage.setPointersPositions(e);
+			const hit = this.linkHitAt(text);
+			if (!hit) return;
+			e.preventDefault();
+			e.stopPropagation();
+			this.openUrl(hit.url);
+		}, {
+			capture: true,
+			signal: this.instance.getEventsController().signal
+		});
+	}
 	setupLinkBehavior(text) {
-		text.handleMouseover = () => {
-			if (!text.getAttrs().link) return;
-			text.fill(this.config.link.hoverColor);
-			text.getLayer()?.batchDraw();
+		this.registerLinkContextMenuGuard();
+		const container = () => this.instance.getStage().container();
+		const idleCursor = () => this.isNodeSelected(text) ? "grab" : "pointer";
+		const applyHover = () => {
+			if (this.editing) return;
+			this.linkHoverText = text;
+			const hit = this.linkModifier ? this.linkHitAt(text) : null;
+			if (!text.getAttrs().link) text.setHoveredRun(hit?.key ?? null);
+			else {
+				text.fill(hit ? this.config.link.hoverColor : this.config.link.defaultColor);
+				text.getLayer()?.batchDraw();
+			}
+			container().style.cursor = hit ? "pointer" : idleCursor();
+		};
+		const updateHover = (e) => {
+			if (e?.evt) this.linkModifier = e.evt.ctrlKey || e.evt.metaKey;
+			this.linkHoverRefresh = applyHover;
+			applyHover();
+		};
+		text.handleMouseover = (e) => {
+			updateHover(e);
 		};
 		text.handleMouseout = () => {
+			if (this.linkHoverText === text) {
+				this.linkHoverText = null;
+				this.linkHoverRefresh = null;
+			}
+			text.setHoveredRun(null);
 			if (!text.getAttrs().link) return;
 			text.fill(this.config.link.defaultColor);
 			text.getLayer()?.batchDraw();
 		};
-		text.defineMousePointer = () => text.getAttrs().link ? "pointer" : "default";
+		text.on("pointermove", updateHover);
+		text.defineMousePointer = () => this.linkModifier && text.getAttrs().link ? "pointer" : idleCursor();
 		let linkClickTimeout;
 		const clearLinkClickTimeout = () => {
 			if (linkClickTimeout) {
@@ -16390,27 +17363,41 @@ var WeaveTextV2Node = class extends WeaveNode {
 			previousDblClick();
 		};
 		text.click = ({ wasSelected, ctrlOrMetaPressed }) => {
-			if (!text.getAttrs().link) return;
+			const runLink = text.getAttrs().link ? null : text.linkAtPoint(this.localPointer(text));
+			if (!text.getAttrs().link && !runLink) return;
+			const open = () => runLink ? this.openUrl(runLink.url) : this.openTextLink(text);
 			if (ctrlOrMetaPressed) {
 				clearLinkClickTimeout();
-				this.openTextLink(text);
+				open();
 				return;
 			}
 			if (wasSelected) {
 				clearLinkClickTimeout();
 				linkClickTimeout = setTimeout(() => {
 					linkClickTimeout = void 0;
-					this.openTextLink(text);
+					open();
 				}, Konva.dblClickWindow);
 			}
 		};
 	}
-	openTextLink(textNode) {
+	localPointer(text) {
+		return text.getRelativePointerPosition() ?? {
+			x: -1,
+			y: -1
+		};
+	}
+	lastLinkOpen = 0;
+	openUrl(link) {
 		if (this.instance.isServerSide()) return;
-		const link = textNode.getAttrs().link;
 		if (typeof link !== "string" || !isValidTextLink(link)) return;
+		const now = Date.now();
+		if (now - this.lastLinkOpen < 500) return;
+		this.lastLinkOpen = now;
 		window.open(link, "_blank", "noopener,noreferrer");
 	}
+	openTextLink(textNode) {
+		this.openUrl(textNode.getAttrs().link);
+	}
 	getLink(nodeInstance) {
 		const link = nodeInstance.getAttrs().link;
 		return typeof link === "string" ? link : void 0;
@@ -16430,6 +17417,173 @@ var WeaveTextV2Node = class extends WeaveNode {
 		delete serialized.props.linkPreviousTextDecoration;
 		this.instance.updateNode(serialized);
 	}
+	indentStep() {
+		const step = this.config.richText.indentStep;
+		return Number.isFinite(step) && step > 0 ? step : 1.5;
+	}
+	/**
+	* Rich text is on for a node when its `richText` attribute says so;
+	* nodes without the attribute follow `config.richText.enabled`.
+	*/
+	isRich(nodeInstance) {
+		const own = nodeInstance.getAttrs().richText;
+		return typeof own === "boolean" ? own : this.config.richText.enabled;
+	}
+	isRichTextEnabled(nodeInstance) {
+		return nodeInstance ? this.isRich(nodeInstance) : this.config.richText.enabled;
+	}
+	activeSession(shape) {
+		return this.editing && this.editingNodeId === shape.id() ? this.session : null;
+	}
+	emitFormatChange(shape, reason) {
+		this.instance.emitEvent("onTextFormatChange", {
+			node: shape,
+			format: this.getSelectionFormat(shape),
+			reason
+		});
+	}
+	/** Selection events fire often while dragging: coalesce them. */
+	scheduleSelectionEvent(shape) {
+		if (this.selectionTimer) return;
+		this.selectionTimer = setTimeout(() => {
+			this.selectionTimer = void 0;
+			const session = this.activeSession(shape);
+			if (!session) return;
+			const { start, end } = session.getSelection();
+			this.instance.emitEvent("onTextSelectionChange", {
+				node: shape,
+				start,
+				end,
+				format: session.getFormat()
+			});
+		}, 50);
+	}
+	/**
+	* Format of the active selection while editing, otherwise of `range`
+	* (default: the whole text). Sizes are px.
+	*/
+	getSelectionFormat(nodeInstance, range) {
+		const shape = nodeInstance;
+		const session = this.activeSession(shape);
+		if (session) return session.getFormat();
+		const blocks = shape.getBlocks();
+		const r = range ?? {
+			start: 0,
+			end: blocksToText(blocks).length
+		};
+		return getSelectionFormat(blocks, r.start, r.end, shape.fontSize());
+	}
+	/**
+	* Run a block transform on a non-editing node: one `updateNode`, so one
+	* Weave undo step. Returns false when rich text is disabled.
+	*/
+	commandOnNode(shape, range, fn) {
+		const blocks = shape.getBlocks();
+		const next = fn(blocks, range?.start ?? 0, range?.end ?? blocksToText(blocks).length);
+		if (JSON.stringify(next) === JSON.stringify(blocks)) return false;
+		shape.setBlocks(next);
+		this.applySize(shape);
+		this.instance.updateNode(this.serialize(shape));
+		this.emitFormatChange(shape, "command");
+		return true;
+	}
+	/**
+	* Set a mark (`undefined` clears it). `size` is in px. While the node is
+	* being edited it applies to the editor selection, otherwise to `range`
+	* (default: the whole text).
+	*/
+	applyMark(nodeInstance, key, value, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		let v = value;
+		if (key === "link" && v !== void 0 && !isValidTextLink(String(v))) return false;
+		if (key === "size" && typeof value === "number") v = sizeToRatio(value, shape.fontSize());
+		const session = this.activeSession(shape);
+		if (session) {
+			session.setMark(key, v);
+			return true;
+		}
+		return this.commandOnNode(shape, range, (b, s, e) => applyMark(b, s, e, key, v));
+	}
+	/** Link a range (or the editor selection) to an http(s) URL. */
+	setRunLink(nodeInstance, url, range) {
+		if (typeof url !== "string" || !isValidTextLink(url)) return false;
+		return this.applyMark(nodeInstance, "link", url, range);
+	}
+	removeRunLink(nodeInstance, range) {
+		return this.applyMark(nodeInstance, "link", void 0, range);
+	}
+	toggleMark(nodeInstance, key, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		const session = this.activeSession(shape);
+		if (session) {
+			session.toggleMark(key);
+			return true;
+		}
+		return this.commandOnNode(shape, range, (b, s, e) => toggleMark(b, s, e, key));
+	}
+	toggleList(nodeInstance, kind, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		const session = this.activeSession(shape);
+		if (session) {
+			session.toggleList(kind);
+			return true;
+		}
+		return this.commandOnNode(shape, range, (b, s, e) => toggleList(b, s, e, kind));
+	}
+	/** Align every paragraph touched by the range (default: all). */
+	setAlign(nodeInstance, align, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		if (align !== void 0 && ![
+			"left",
+			"center",
+			"right"
+		].includes(align)) return false;
+		const session = this.activeSession(shape);
+		if (session) {
+			session.setAlign(align);
+			return true;
+		}
+		return this.commandOnNode(shape, range, (b, s, e) => setBlockAlign(b, s, e, align));
+	}
+	indent(nodeInstance, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		const session = this.activeSession(shape);
+		if (session) {
+			session.indent();
+			return true;
+		}
+		return this.commandOnNode(shape, range, indentBlocks);
+	}
+	outdent(nodeInstance, range) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		const session = this.activeSession(shape);
+		if (session) {
+			session.outdent();
+			return true;
+		}
+		return this.commandOnNode(shape, range, outdentBlocks);
+	}
+	/**
+	* Scale the whole text: sets the node `fontSize` (px); size marks are
+	* ratios of it, so every run scales with it.
+	*/
+	setBaseFontSize(nodeInstance, px) {
+		const shape = nodeInstance;
+		if (!this.isRich(shape)) return false;
+		if (!Number.isFinite(px) || px <= 0) return false;
+		if (shape.fontSize() === px) return false;
+		shape.fontSize(px);
+		this.applySize(shape);
+		if (!this.activeSession(shape)) this.instance.updateNode(this.serialize(shape));
+		this.emitFormatChange(shape, "base-size");
+		return true;
+	}
 	resetSmartLayout(textNode) {
 		textNode.setAttr("smartFixedWidth", void 0);
 		textNode.width(Math.max(1, textNode.measureNaturalSize().width * 1.01));
@@ -16448,7 +17602,36 @@ var WeaveTextV2Node = class extends WeaveNode {
 		return next;
 	}
 	static getSchema() {
-		return WeaveTextNode.getSchema();
+		const base = WeaveTextNode.getSchema();
+		const marks = z.object({
+			bold: z.boolean().optional(),
+			italic: z.boolean().optional(),
+			underline: z.boolean().optional(),
+			strike: z.boolean().optional(),
+			color: z.string().optional(),
+			size: z.number().positive().optional().describe("Ratio of the node fontSize (1 is omitted)."),
+			family: z.string().optional(),
+			lineHeight: z.number().positive().optional(),
+			link: z.string().url().refine((value) => isValidTextLink(value), { message: "Link must be an absolute http:// or https:// URL." }).optional()
+		}).passthrough();
+		const block = z.object({
+			runs: z.array(z.object({
+				t: z.string(),
+				m: marks.optional()
+			})),
+			kind: z.enum(["ul", "ol"]).optional(),
+			depth: z.number().int().min(0).optional(),
+			start: z.number().int().min(1).optional(),
+			align: z.enum([
+				"left",
+				"center",
+				"right"
+			]).optional()
+		});
+		return base.extend({ props: base.shape.props.extend({
+			richText: z.boolean().optional().describe("Enables rich text commands for this node."),
+			blocks: z.array(block).optional().describe("Rich content: paragraphs of runs with marks and optional list fields. `text` is the derived plain mirror.")
+		}) });
 	}
 };
 //#endregion
@@ -26970,8 +28153,16 @@ var WeaveTextToolAction = class extends WeaveAction {
 	cancelAction;
 	onPropsChange = void 0;
 	onInit = void 0;
-	constructor() {
+	toolName;
+	initialProps;
+	/**
+	* `name` and `props` let an app register several text tools, e.g. a
+	* plain one and one creating rich text nodes (`props: { richText: true }`).
+	*/
+	constructor(params) {
 		super();
+		this.toolName = params?.name ?? "textTool";
+		this.initialProps = params?.props ?? {};
 		this.initialize();
 	}
 	initialize() {
@@ -26983,7 +28174,7 @@ var WeaveTextToolAction = class extends WeaveAction {
 		this.props = this.initProps();
 	}
 	getName() {
-		return TEXT_TOOL_ACTION_NAME;
+		return this.toolName;
 	}
 	initProps() {
 		return {
@@ -26995,7 +28186,8 @@ var WeaveTextToolAction = class extends WeaveAction {
 			align: "left",
 			lineHeight: 1,
 			verticalAlign: "top",
-			strokeEnabled: false
+			strokeEnabled: false,
+			...this.initialProps
 		};
 	}
 	setupEvents() {