@inditextech/weave-sdk 5.7.1 → 5.8.0-SNAPSHOT.613.1

package/dist/types.js

@@ -9579,7 +9579,7 @@ var WeaveRegisterManager = class {
 };
 //#endregion
 //#region package.json
-var version = "5.7.1";
+var version = "5.8.0-SNAPSHOT.613.1";
 //#endregion
 //#region src/managers/setup.ts
 var WeaveSetupManager = class {
@@ -22153,6 +22153,27 @@ var WeaveFrameNode = class extends WeaveNode {
 //#endregion
 //#region src/nodes/stroke/constants.ts
 const WEAVE_STROKE_NODE_TYPE = "stroke";
+/**
+* The look equivalent to the rendering of strokes that have no look: the
+* default of every look setting.
+*/
+const WEAVE_STROKE_LEGACY_LOOK = {
+	version: 1,
+	outline: "legacy",
+	curve: "uniform",
+	pressureInterp: "catmullRom",
+	zoomAware: false,
+	spacingPx: 2,
+	edgePx: 1,
+	caps: "separate",
+	width: {
+		min: 0,
+		max: 1,
+		gamma: 1,
+		taperStart: 0,
+		taperEnd: 0
+	}
+};
 const WEAVE_STROKE_NODE_DEFAULT_CONFIG = {
 	splineResolution: 8,
 	splineTargetEdge: 1,
@@ -22161,9 +22182,380 @@ const WEAVE_STROKE_NODE_DEFAULT_CONFIG = {
 	isEraser: false
 };
 //#endregion
+//#region src/nodes/stroke/render/curve.ts
+const lerp = (a, b, t) => a + (b - a) * t;
+/** Interval between two knots: the square root of the distance (alpha 0.5). */
+const knotStep = (a, b) => Math.max(Math.sqrt(Math.hypot(b.x - a.x, b.y - a.y)), 1e-6);
+/** Barry-Goldman evaluation of the centripetal Catmull-Rom curve at `u` in 0..1 of the middle span. */
+function evaluate(w, u) {
+	const { p, t } = w;
+	const at = lerp(t[1], t[2], u);
+	const blend = (channel) => {
+		const a1 = lerp(p[0][channel], p[1][channel], (at - t[0]) / (t[1] - t[0]));
+		const a2 = lerp(p[1][channel], p[2][channel], (at - t[1]) / (t[2] - t[1]));
+		const a3 = lerp(p[2][channel], p[3][channel], (at - t[2]) / (t[3] - t[2]));
+		const b1 = lerp(a1, a2, (at - t[0]) / (t[2] - t[0]));
+		const b2 = lerp(a2, a3, (at - t[1]) / (t[3] - t[1]));
+		return lerp(b1, b2, (at - t[1]) / (t[2] - t[1]));
+	};
+	return {
+		x: blend("x"),
+		y: blend("y"),
+		pressure: blend("pressure")
+	};
+}
+function distanceToSegment(p, a, b) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const l = dx * dx + dy * dy;
+	const t = l ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / l)) : 0;
+	return Math.hypot(p.x - (a.x + dx * t), p.y - (a.y + dy * t));
+}
+/**
+* Samples a centripetal Catmull-Rom curve through `pts`.
+*
+* The knot intervals follow the distance between points, so the curve does not
+* overshoot or form cusps when the points are unevenly spaced, which the
+* uniform parametrization does. Pressure is interpolated linearly between the
+* two points of a span, or smoothly but never beyond them, so the width of the
+* stroke cannot exceed the widest of its neighbouring widths.
+*/
+function getCentripetalPoints(pts, opts) {
+	if (pts.length < 2) return [...pts];
+	const out = [];
+	for (let i = -1; i < pts.length - 2; i++) {
+		const p0 = pts[Math.max(i, 0)];
+		const p1 = pts[i + 1];
+		const p2 = pts[i + 2];
+		const p3 = pts[Math.min(i + 3, pts.length - 1)];
+		const t1 = knotStep(p0, p1);
+		const t2 = t1 + knotStep(p1, p2);
+		const t3 = t2 + knotStep(p2, p3);
+		const w = {
+			p: [
+				p0,
+				p1,
+				p2,
+				p3
+			],
+			t: [
+				0,
+				t1,
+				t2,
+				t3
+			]
+		};
+		let deviation = 0;
+		for (const probe of [
+			.25,
+			.5,
+			.75
+		]) deviation = Math.max(deviation, distanceToSegment(evaluate(w, probe), p1, p2));
+		const tolerance = Math.max(opts.edge * .1, 1e-6);
+		const steps = deviation < opts.flatness ? 1 : Math.min(Math.max(Math.ceil(Math.sqrt(deviation / tolerance)), opts.minSteps), opts.maxSteps);
+		const lo = Math.min(p1.pressure, p2.pressure);
+		const hi = Math.max(p1.pressure, p2.pressure);
+		for (let s = 0; s < steps; s++) {
+			const u = s / steps;
+			const q = evaluate(w, u);
+			q.pressure = opts.pressure === "linear" ? lerp(p1.pressure, p2.pressure, u) : Math.min(hi, Math.max(lo, q.pressure));
+			out.push(q);
+		}
+	}
+	out.push(pts[pts.length - 1]);
+	return out;
+}
+//#endregion
+//#region src/nodes/stroke/render/look.ts
+const OUTLINES = [
+	"legacy",
+	"round",
+	"freehand"
+];
+const CURVES = [
+	"uniform",
+	"centripetal",
+	"none"
+];
+const PRESSURE_INTERPS = ["catmullRom", "linear"];
+const CAPS = ["separate", "merged"];
+const isObject$2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const pick = (v, allowed, fallback) => typeof v === "string" && allowed.includes(v) ? v : fallback;
+/** A finite number clamped to a range, or the fallback. */
+const num = (v, min, max, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : fallback;
+/**
+* Reads the look saved on a stroke. Returns `null` when the stroke has none or
+* its look is of a version this release does not understand, so the stroke is
+* drawn as in releases that did not know looks. Missing or invalid fields fall
+* back to the legacy values and out-of-range numbers are clamped, so a stored
+* look can never make the renderer misbehave.
+*/
+function readStrokeLook(raw) {
+	if (!isObject$2(raw) || raw["version"] !== WEAVE_STROKE_LEGACY_LOOK.version) return null;
+	const base = WEAVE_STROKE_LEGACY_LOOK;
+	const width = isObject$2(raw["width"]) ? raw["width"] : {};
+	return {
+		version: 1,
+		outline: pick(raw["outline"], OUTLINES, base.outline),
+		curve: pick(raw["curve"], CURVES, base.curve),
+		pressureInterp: pick(raw["pressureInterp"], PRESSURE_INTERPS, base.pressureInterp),
+		zoomAware: typeof raw["zoomAware"] === "boolean" ? raw["zoomAware"] : base.zoomAware,
+		spacingPx: num(raw["spacingPx"], .5, 10, base.spacingPx),
+		edgePx: num(raw["edgePx"], .25, 5, base.edgePx),
+		caps: pick(raw["caps"], CAPS, base.caps),
+		width: {
+			min: num(width["min"], 0, 1, base.width.min),
+			max: num(width["max"], 0, 1, base.width.max),
+			gamma: num(width["gamma"], .2, 3, base.width.gamma),
+			taperStart: num(width["taperStart"], 0, 200, base.width.taperStart),
+			taperEnd: num(width["taperEnd"], 0, 200, base.width.taperEnd)
+		}
+	};
+}
+/** Quadratic ease-out: 0 at the tip, 1 once the taper distance is covered. */
+const easeOut = (t) => t * (2 - t);
+/** Lowest half-width drawn, in canvas units, so a stroke never vanishes. */
+const MIN_HALF_WIDTH = .5;
+/**
+* Half of the drawn width at a point, in canvas units.
+*
+* The width is the stroke width times `min + (max - min) * pressure^gamma`,
+* narrowed by the start and end tapers. With the default width rule this is
+* `strokeWidth * pressure / 2`, the legacy width. `distanceFromStart` and
+* `distanceToEnd` are along the stroke, in the unit of the tapers.
+*/
+function halfWidthAt(look, strokeWidth, pressure, distanceFromStart, distanceToEnd) {
+	const { min, max, gamma, taperStart, taperEnd } = look.width;
+	const p = Math.min(1, Math.max(0, Number.isFinite(pressure) ? pressure : .5));
+	let fraction = min + (max - min) * Math.pow(p, gamma);
+	if (taperStart > 0 && distanceFromStart < taperStart) fraction *= easeOut(Math.max(0, distanceFromStart) / taperStart);
+	if (taperEnd > 0 && distanceToEnd < taperEnd) fraction *= easeOut(Math.max(0, distanceToEnd) / taperEnd);
+	return Math.max(strokeWidth * fraction / 2, MIN_HALF_WIDTH);
+}
+//#endregion
+//#region src/nodes/stroke/render/round-outline.ts
+/**
+* Drops points that the quads between their neighbours already cover. A point
+* is skipped only while every point skipped since the last kept one stays
+* within a hundredth of the radius of the chord that replaces them, in position
+* and in radius, so a vertex, a turn or a change of width is always kept. A gap
+* is also never wider than two radii. The first and last points are kept.
+*/
+function thinRoundPoints(pts) {
+	if (pts.length <= 2) return pts;
+	const out = [pts[0]];
+	let anchor = 0;
+	for (let i = 2; i < pts.length; i++) {
+		const a = pts[anchor];
+		const b = pts[i];
+		const dx = b.x - a.x;
+		const dy = b.y - a.y;
+		const chord = Math.hypot(dx, dy);
+		let keepPrevious = chord > 2 * Math.min(a.r, b.r) || i - anchor > 24;
+		for (let j = anchor + 1; j < i && !keepPrevious; j++) {
+			const p = pts[j];
+			const t = chord > 0 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / (chord * chord))) : 0;
+			const off = Math.hypot(p.x - (a.x + dx * t), p.y - (a.y + dy * t));
+			const tolerance = .01 * Math.min(a.r, b.r, p.r);
+			if (off > tolerance || Math.abs(p.r - (a.r + (b.r - a.r) * t)) > tolerance) keepPrevious = true;
+		}
+		if (keepPrevious) {
+			out.push(pts[i - 1]);
+			anchor = i - 1;
+		}
+	}
+	out.push(pts[pts.length - 1]);
+	return out;
+}
+/** Largest gap, in screen pixels, a skipped disc may leave on the outer side of a bend. */
+const MAX_WEDGE_PX = .1;
+const angleDiff = (a, b) => {
+	let d = Math.abs(a - b);
+	if (d > Math.PI) d = 2 * Math.PI - d;
+	return d;
+};
+/**
+* Which points need their disc. Between two neighbours the tangent quad covers
+* the stroke exactly; a disc only matters where the outline turns, to fill the
+* wedge on the outside of the bend. Where the turn is so slight that the
+* wedge would be thinner than a tenth of a screen pixel the disc is skipped,
+* which removes most arcs of a smooth stroke and makes it far cheaper to fill.
+*/
+function pointsNeedingDisc(pts, scale) {
+	const need = new Array(pts.length).fill(false);
+	if (pts.length === 0) return need;
+	need[0] = true;
+	need[pts.length - 1] = true;
+	const dir = [0];
+	const lean = [0];
+	const valid = [false];
+	for (let i = 1; i < pts.length; i++) {
+		const p = pts[i];
+		const q = pts[i - 1];
+		const dx = p.x - q.x;
+		const dy = p.y - q.y;
+		const l = Math.hypot(dx, dy);
+		const ok = l > Math.abs(p.r - q.r) && l >= 1e-9;
+		valid.push(ok);
+		dir.push(Math.atan2(dy, dx));
+		lean.push(ok ? Math.asin(Math.max(-1, Math.min(1, (q.r - p.r) / l))) : 0);
+		if (!ok) {
+			need[i] = true;
+			need[i - 1] = true;
+		}
+	}
+	for (let i = 1; i < pts.length - 1; i++) {
+		if (need[i]) continue;
+		if (!valid[i] || !valid[i + 1]) {
+			need[i] = true;
+			continue;
+		}
+		const turn = angleDiff(dir[i], dir[i + 1]) + Math.abs(lean[i + 1] - lean[i]);
+		const radiusPx = Math.max(pts[i].r * scale, 1e-6);
+		if (turn > Math.sqrt(8 * MAX_WEDGE_PX / radiusPx)) need[i] = true;
+	}
+	return need;
+}
+/**
+* Appends the outline of a variable-width stroke to the current path: a disc at
+* every point and, between neighbours, the quad bounded by their two external
+* tangents. Every sub-path has the same winding, so a single non-zero fill is
+* the exact union: turns, reversals and ends are round by construction.
+*/
+function appendRoundPath(ctx, points, scale = 1) {
+	const pts = thinRoundPoints(points);
+	const need = pointsNeedingDisc(pts, scale);
+	const polygon = (v) => {
+		let area = 0;
+		for (let k = 0; k < v.length; k++) {
+			const [x1, y1] = v[k];
+			const [x2, y2] = v[(k + 1) % v.length];
+			area += x1 * y2 - x2 * y1;
+		}
+		const w = area < 0 ? [...v].reverse() : v;
+		ctx.moveTo(w[0][0], w[0][1]);
+		for (let k = 1; k < w.length; k++) ctx.lineTo(w[k][0], w[k][1]);
+		ctx.closePath();
+	};
+	const tangents = (i) => {
+		const p = pts[i];
+		const q = pts[i - 1];
+		const dx = p.x - q.x;
+		const dy = p.y - q.y;
+		const l = Math.hypot(dx, dy);
+		if (l <= Math.abs(p.r - q.r) || l < 1e-9) return null;
+		const ux = dx / l;
+		const uy = dy / l;
+		const k = (q.r - p.r) / l;
+		const s = Math.sqrt(Math.max(0, 1 - k * k));
+		return {
+			a: [k * ux - s * uy, k * uy + s * ux],
+			b: [k * ux + s * uy, k * uy - s * ux]
+		};
+	};
+	let left = [];
+	let right = [];
+	let prev = null;
+	const flush = () => {
+		if (left.length >= 2) polygon([...left, ...right.reverse()]);
+		left = [];
+		right = [];
+		prev = null;
+	};
+	for (let i = 1; i < pts.length; i++) {
+		const p = pts[i];
+		const q = pts[i - 1];
+		const t = tangents(i);
+		if (!t) {
+			flush();
+			continue;
+		}
+		if (!prev) {
+			left = [[q.x + q.r * t.a[0], q.y + q.r * t.a[1]]];
+			right = [[q.x + q.r * t.b[0], q.y + q.r * t.b[1]]];
+		} else {
+			const mitre = (u, v) => {
+				const sx = u[0] + v[0];
+				const sy = u[1] + v[1];
+				const d = (sx * sx + sy * sy) / 2;
+				return [sx / d * q.r, sy / d * q.r];
+			};
+			const ml = mitre(prev.a, t.a);
+			const mr = mitre(prev.b, t.b);
+			left.push([q.x + ml[0], q.y + ml[1]]);
+			right.push([q.x + mr[0], q.y + mr[1]]);
+		}
+		prev = t;
+		const last = i === pts.length - 1;
+		const next = last ? null : tangents(i + 1);
+		if (last || need[i] || !next) {
+			left.push([p.x + p.r * t.a[0], p.y + p.r * t.a[1]]);
+			right.push([p.x + p.r * t.b[0], p.y + p.r * t.b[1]]);
+			flush();
+		}
+	}
+	flush();
+	for (let i = 0; i < pts.length; i++) {
+		if (!need[i]) continue;
+		const p = pts[i];
+		ctx.moveTo(p.x + p.r, p.y);
+		ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2, false);
+	}
+}
+/** Splits a centerline into the runs the dash pattern draws. */
+function splitRoundRuns(pts, dash) {
+	if (!dash.length || dash.every((d) => !(d > 0))) return [pts];
+	const runs = [];
+	let index = 0;
+	let on = true;
+	let remaining = dash[0];
+	let current = on ? [pts[0]] : [];
+	for (let i = 1; i < pts.length; i++) {
+		let a = pts[i - 1];
+		const b = pts[i];
+		let segment = Math.hypot(b.x - a.x, b.y - a.y);
+		while (segment > remaining) {
+			const t = remaining / segment;
+			const cut = {
+				x: a.x + (b.x - a.x) * t,
+				y: a.y + (b.y - a.y) * t,
+				r: a.r + (b.r - a.r) * t
+			};
+			if (on) {
+				current.push(cut);
+				runs.push(current);
+				current = [];
+			} else current = [cut];
+			on = !on;
+			index = (index + 1) % dash.length;
+			segment -= remaining;
+			remaining = dash[index];
+			a = cut;
+			if (!(remaining > 0)) remaining = Number.EPSILON;
+		}
+		remaining -= segment;
+		if (on) current.push(b);
+	}
+	if (on && current.length > 0) runs.push(current);
+	return runs.filter((r) => r.length > 0);
+}
+/**
+* Fills a round outline, once per dash run, so overlaps inside a run never
+* blend twice and a translucent colour stays uniform.
+*/
+function drawRoundOutline(ctx, points, color, dash = [], scale = 1) {
+	for (const run of splitRoundRuns(points, dash)) {
+		ctx.beginPath();
+		ctx.fillStyle = color;
+		appendRoundPath(ctx, run, scale);
+		ctx.fill();
+	}
+}
+//#endregion
 //#region src/nodes/stroke/stroke.ts
 var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 	config;
+	previewLook = null;
 	nodeType = WEAVE_STROKE_NODE_TYPE;
 	initialize = void 0;
 	/**
@@ -22236,10 +22628,11 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 	* emitted as a single edge - subdividing a straight line adds vertices
 	* without changing a pixel.
 	*/
-	getSplinePoints(pts, resolution = this.config.splineResolution) {
+	getSplinePoints(pts, resolution = this.config.splineResolution, opts) {
 		if (pts.length < 2) return [...pts];
-		const targetEdge = this.config.splineTargetEdge;
-		const maxSteps = this.config.splineMaxSteps;
+		const targetEdge = opts?.targetEdge ?? this.config.splineTargetEdge;
+		const maxSteps = opts?.maxSteps ?? this.config.splineMaxSteps;
+		const flatness = opts?.flatness ?? WeaveStrokeNode.SPLINE_FLATNESS_EPSILON;
 		const result = [];
 		for (let i = -1; i < pts.length - 2; i++) {
 			const p0 = pts[Math.max(i, 0)];
@@ -22256,8 +22649,12 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 				const at = this.catmullRomAt(p0, p1, p2, p3, probe);
 				deviation = Math.max(deviation, this.distanceToSegment(at, p1, p2));
 			}
-			const steps = deviation < WeaveStrokeNode.SPLINE_FLATNESS_EPSILON ? 1 : Math.min(Math.max(Math.ceil(chord / targetEdge), resolution), maxSteps);
-			for (let s = 0; s < steps; s++) result.push(this.catmullRomAt(p0, p1, p2, p3, s / steps));
+			const steps = deviation < flatness ? 1 : Math.min(Math.max(Math.ceil(chord / targetEdge), resolution), maxSteps);
+			for (let s = 0; s < steps; s++) {
+				const q = this.catmullRomAt(p0, p1, p2, p3, s / steps);
+				if (opts?.pressure === "linear") q.pressure = p1.pressure + (p2.pressure - p1.pressure) * (s / steps);
+				result.push(q);
+			}
 		}
 		result.push(pts[pts.length - 1]);
 		return result;
@@ -22284,7 +22681,7 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 	* result by well under a pixel (95th-percentile outline edge 1.72px vs
 	* 1.76px; byte-identical on long, gently-curved strokes).
 	*/
-	drawDashPolygon(ctx, leftSide, rightSide, color) {
+	drawDashPolygon(ctx, leftSide, rightSide, color, mergeCaps = false) {
 		const capStartL = leftSide[0];
 		const capStartR = rightSide[0];
 		const capEndL = leftSide.at(-1);
@@ -22296,6 +22693,24 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 		for (const p of leftSide) ctx.lineTo(p.x, p.y);
 		for (const p of outlineRight) ctx.lineTo(p.x, p.y);
 		ctx.closePath();
+		if (mergeCaps) {
+			const outline = [...leftSide, ...outlineRight];
+			let area = 0;
+			for (let i = 0; i < outline.length; i++) {
+				const a = outline[i];
+				const b = outline[(i + 1) % outline.length];
+				area += a.x * b.y - b.x * a.y;
+			}
+			for (const [a, b] of [[capStartL, capStartR], [capEndL, capEndR]]) {
+				const cx = (a.x + b.x) / 2;
+				const cy = (a.y + b.y) / 2;
+				const r = Math.hypot(a.x - b.x, a.y - b.y) / 2;
+				ctx.moveTo(cx + r, cy);
+				ctx.arc(cx, cy, r, 0, Math.PI * 2, area < 0);
+			}
+			ctx.fill();
+			return;
+		}
 		ctx.fill();
 		this.drawRoundCap(ctx, capStartL, capStartR, color);
 		this.drawRoundCap(ctx, capEndL, capEndR, color);
@@ -22313,6 +22728,13 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 		}
 		const filtered = this.resamplePoints(pts, this.config.resamplingSpacing);
 		const centerline = this.getSplinePoints(filtered, this.config.splineResolution);
+		this.drawCenterlineRibbon(ctx, centerline, (_i, p) => Math.max(baseW * p.pressure / 2, .5), color, dash, false);
+	}
+	/**
+	* Draws the offset-outline ribbon along an already prepared centerline.
+	* `halfWidth` gives the half-width at each centerline point.
+	*/
+	drawCenterlineRibbon(ctx, centerline, halfWidth, color, dash, mergeCaps) {
 		let dashIndex = 0;
 		let dashOn = true;
 		let dashRemaining = dash.length ? dash[0] : Infinity;
@@ -22326,7 +22748,7 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 				leftSide.push(pendingEndLeft);
 				rightSide.push(pendingEndRight);
 			}
-			this.drawDashPolygon(ctx, leftSide, rightSide, color);
+			this.drawDashPolygon(ctx, leftSide, rightSide, color, mergeCaps);
 		};
 		for (let i = 0; i < centerline.length - 1; i++) {
 			const p0 = centerline[i];
@@ -22336,8 +22758,8 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 			const segLen = Math.hypot(dx, dy) || 1;
 			const nx = -dy / segLen;
 			const ny = dx / segLen;
-			const w0 = Math.max(baseW * p0.pressure / 2, .5);
-			const w1 = Math.max(baseW * p1.pressure / 2, .5);
+			const w0 = halfWidth(i, p0);
+			const w1 = halfWidth(i + 1, p1);
 			let traveled = 0;
 			while (traveled < segLen) {
 				const step = Math.min(dashRemaining, segLen - traveled);
@@ -22387,12 +22809,107 @@ var WeaveStrokeNode = class WeaveStrokeNode extends WeaveNode {
 		}
 		flushRun();
 	}
+	/**
+	* The look a stroke is drawn with: the viewer-side preview if one is on,
+	* otherwise the look saved with the stroke. `null` draws the legacy ribbon.
+	*/
+	resolveLook(shape) {
+		return this.previewLook ?? readStrokeLook(shape.getAttrs().look);
+	}
+	/**
+	* Draws every stroke of this screen with `look`, without changing any saved
+	* stroke and without other users seeing it. `null` turns the preview off.
+	*/
+	setLookPreview(look) {
+		this.previewLook = look === null ? null : readStrokeLook(look);
+		this.redrawStrokes();
+	}
+	getLookPreview() {
+		return this.previewLook;
+	}
+	redrawStrokes() {
+		const stage = this.instance?.getStage?.();
+		if (!stage || typeof stage.find !== "function") return;
+		const layers = /* @__PURE__ */ new Set();
+		for (const node of stage.find(".node")) if (node.getAttrs().nodeType === "stroke") layers.add(node.getLayer());
+		for (const layer of layers) layer?.batchDraw();
+	}
+	/** Screen pixels per canvas unit at a shape. */
+	screenScale(shape) {
+		const scale = shape.getAbsoluteScale?.().x;
+		return typeof scale === "number" && Number.isFinite(scale) && scale > 0 ? scale : 1;
+	}
+	/**
+	* The centerline of a stroke with a look: the points resampled and joined by
+	* the look's curve. Spacing and detail are in screen pixels when the look
+	* follows the zoom, in canvas units otherwise; `scale` is screen pixels per
+	* canvas unit.
+	*/
+	buildLookCenterline(look, scale, pts) {
+		const toCanvas = (px) => look.zoomAware ? px / scale : px;
+		const edge = toCanvas(look.edgePx);
+		const flatness = toCanvas(WeaveStrokeNode.SPLINE_FLATNESS_EPSILON);
+		const maxSteps = look.zoomAware ? Math.max(this.config.splineMaxSteps, 256) : this.config.splineMaxSteps;
+		const filtered = this.resamplePoints(pts, toCanvas(look.spacingPx));
+		if (look.curve === "centripetal") return getCentripetalPoints(filtered, {
+			edge,
+			minSteps: 2,
+			maxSteps,
+			flatness,
+			pressure: look.pressureInterp
+		});
+		if (look.curve === "none") return filtered;
+		return this.getSplinePoints(filtered, this.config.splineResolution, {
+			targetEdge: edge,
+			maxSteps,
+			flatness,
+			pressure: look.pressureInterp
+		});
+	}
+	/**
+	* Draws a stroke that has a look: the centerline is built with the look's
+	* curve, spacing and detail, widths follow its width rule, and the outline is
+	* the legacy ribbon or the round one.
+	*/
+	drawRibbonWithLook(ctx, shape, look, pts, baseW, color, dash) {
+		if (!pts) return;
+		if (pts.length < 2) {
+			const pt = pts[0];
+			const r = halfWidthAt(look, baseW, pt.pressure, Infinity, Infinity);
+			ctx.beginPath();
+			ctx.fillStyle = color;
+			ctx.arc(pt.x, pt.y, r, 0, Math.PI * 2);
+			ctx.fill();
+			return;
+		}
+		const scale = this.screenScale(shape);
+		const centerline = this.buildLookCenterline(look, scale, pts);
+		const unit = look.zoomAware ? scale : 1;
+		const along = [0];
+		for (let i = 1; i < centerline.length; i++) along.push(along[i - 1] + Math.hypot(centerline[i].x - centerline[i - 1].x, centerline[i].y - centerline[i - 1].y) * unit);
+		const total = along[along.length - 1];
+		const halfWidth = (i, p) => halfWidthAt(look, baseW, p.pressure, along[i], total - along[i]);
+		if (look.outline === "legacy") {
+			this.drawCenterlineRibbon(ctx, centerline, halfWidth, color, dash, look.caps === "merged");
+			return;
+		}
+		drawRoundOutline(ctx, centerline.map((p, i) => ({
+			x: p.x,
+			y: p.y,
+			r: halfWidth(i, p)
+		})), color, dash, scale);
+	}
 	drawShape(ctx, shape) {
 		const strokeElements = shape.getAttrs().strokeElements;
 		if (strokeElements?.length === 0) return;
 		const color = shape.getAttrs().stroke ?? "black";
 		const strokeWidth = shape.getAttrs().strokeWidth ?? 1;
 		const dash = shape.getAttrs().dash ?? [];
+		const look = this.resolveLook(shape);
+		if (look) {
+			this.drawRibbonWithLook(ctx, shape, look, strokeElements, strokeWidth, color, dash);
+			return;
+		}
 		this.drawRibbonWithDash(ctx, strokeElements, strokeWidth, color, dash);
 	}
 	onRender(props) {
@@ -28446,6 +28963,8 @@ var WeaveLineToolAction = class extends WeaveAction {
 //#endregion
 //#region src/actions/brush-tool/constants.ts
 const BRUSH_TOOL_ACTION_NAME = "brushTool";
+/** Name under which the lab plugin registers itself. */
+const BRUSH_LAB_PLUGIN_NAME = "brushLab";
 const BRUSH_TOOL_STATE = {
 	["INACTIVE"]: "inactive",
 	["IDLE"]: "idle",
@@ -28463,207 +28982,2369 @@ const PREVIEW_ID_SUFFIX = "--preview";
 * Bounds the handover so a preview can never be orphaned on screen.
 */
 const PREVIEW_HANDOVER_MAX_FRAMES = 30;
+const BRUSH_INPUT_PROFILE_KEYS = [
+	"mouse",
+	"touch",
+	"pen.applePencil",
+	"pen.desktop"
+];
+/**
+* The legacy input profile: reproduces, point for point, what the brush tool
+* recorded before profiles existed. Every profile starts from it.
+*/
+const BRUSH_LEGACY_INPUT_PROFILE = {
+	capture: {
+		source: "legacy",
+		clock: "now",
+		minMovePx: 0,
+		predicted: "tail",
+		event: "pointermove"
+	},
+	pressure: {
+		zero: "legacy",
+		filter: "legacy",
+		timeConstantMs: 40,
+		oneEuro: {
+			minCutoff: 1,
+			beta: .01
+		},
+		floor: .15,
+		start: "backfill",
+		startSamples: 3,
+		end: "backfill"
+	},
+	stabilizer: {
+		type: "none",
+		minCutoff: 3,
+		beta: .01,
+		radiusPx: 4,
+		amount: .3,
+		zoomAware: false,
+		catchUpOnEnd: true
+	},
+	finalize: {
+		mode: "dp",
+		toleranceUnit: "canvas",
+		pressureWeight: 20,
+		resampleSpacingPx: 2
+	},
+	touchGuard: {
+		waitMs: 0,
+		movePx: 0,
+		cancelOnSecondTouch: false,
+		ignoreAfterPen: false
+	}
+};
 const BRUSH_TOOL_DEFAULT_CONFIG = {
+	input: {
+		forceProfile: null,
+		profiles: {
+			mouse: BRUSH_LEGACY_INPUT_PROFILE,
+			touch: BRUSH_LEGACY_INPUT_PROFILE,
+			"pen.applePencil": BRUSH_LEGACY_INPUT_PROFILE,
+			"pen.desktop": BRUSH_LEGACY_INPUT_PROFILE
+		}
+	},
 	interpolationSteps: 10,
 	simplifyTolerance: .5
 };
 //#endregion
-//#region src/actions/brush-tool/brush-tool.ts
-var WeaveBrushToolAction = class extends WeaveAction {
-	config;
-	initialized = false;
-	state;
-	clickPoint;
-	strokeId;
-	isSpacePressed = false;
-	isEraser;
-	container;
-	measureContainer;
-	cancelAction;
-	prevTouchAction;
-	penActive = false;
-	lastSmoothedPressure = .5;
-	hasPressureSample = false;
-	lastPointerPos = null;
-	lastPointerTime = 0;
-	predictedCount = 0;
-	onPropsChange = void 0;
-	onInit = void 0;
-	constructor(params) {
-		super();
-		this.config = mergeExceptArrays(BRUSH_TOOL_DEFAULT_CONFIG, params?.config ?? {});
-		this.initialize();
+//#region src/actions/brush-tool/stages/stabilizer.ts
+/** Time assumed between two samples whose times do not advance, in ms. */
+const NOMINAL_SAMPLE_INTERVAL_MS$1 = 5;
+const seconds = (now, last) => (now - last > 0 ? now - last : NOMINAL_SAMPLE_INTERVAL_MS$1) / 1e3;
+/**
+* Scale between canvas units and the units distances are configured in: screen
+* pixels when the stabilizer is zoom-aware, canvas units otherwise.
+*/
+const unitScale = (cfg, ctx) => cfg.zoomAware && ctx.zoom > 0 && Number.isFinite(ctx.zoom) ? ctx.zoom : 1;
+var NoStabilizer = class {
+	reset() {}
+	seed() {}
+	apply(point) {
+		return point;
 	}
-	initialize() {
-		this.initialized = false;
-		this.state = BRUSH_TOOL_STATE.INACTIVE;
-		this.strokeId = null;
-		this.clickPoint = null;
-		this.container = void 0;
-		this.isEraser = false;
-		this.measureContainer = void 0;
-		this.props = this.initProps();
-		this.isSpacePressed = false;
+};
+/** One Euro low-pass filter on one axis. */
+var OneEuroAxis = class {
+	last = 0;
+	derivative = 0;
+	lastTime = 0;
+	seeded = false;
+	reset() {
+		this.seeded = false;
+		this.derivative = 0;
+	}
+	seed(value, time) {
+		this.last = value;
+		this.lastTime = time;
+		this.derivative = 0;
+		this.seeded = true;
+	}
+	filter(value, time, minCutoff, beta) {
+		if (!this.seeded) {
+			this.seed(value, time);
+			return value;
+		}
+		const dt = seconds(time, this.lastTime);
+		const factor = (cutoff) => {
+			const r = 2 * Math.PI * cutoff * dt;
+			return r / (r + 1);
+		};
+		const a = factor(1);
+		this.derivative = a * ((value - this.last) / dt) + (1 - a) * this.derivative;
+		const alpha = factor(minCutoff + beta * Math.abs(this.derivative));
+		const filtered = alpha * value + (1 - alpha) * this.last;
+		this.last = Number.isFinite(filtered) ? filtered : value;
+		this.lastTime = time;
+		return this.last;
 	}
-	getName() {
-		return BRUSH_TOOL_ACTION_NAME;
+};
+/**
+* One Euro filter (Casiez, Roussel, Vogel 2012) on the pen position: slow
+* movement is smoothed, fast movement is followed closely.
+*/
+var OneEuroStabilizer = class {
+	cfg;
+	x = new OneEuroAxis();
+	y = new OneEuroAxis();
+	constructor(cfg) {
+		this.cfg = cfg;
 	}
-	initProps() {
+	reset() {
+		this.x.reset();
+		this.y.reset();
+	}
+	seed(point, ctx) {
+		const s = unitScale(this.cfg, ctx);
+		this.x.seed(point.x * s, ctx.now);
+		this.y.seed(point.y * s, ctx.now);
+	}
+	apply(point, ctx) {
+		const s = unitScale(this.cfg, ctx);
 		return {
-			stroke: "#000000ff",
-			strokeWidth: 1,
-			opacity: 1
+			x: this.x.filter(point.x * s, ctx.now, this.cfg.minCutoff, this.cfg.beta) / s,
+			y: this.y.filter(point.y * s, ctx.now, this.cfg.minCutoff, this.cfg.beta) / s
 		};
 	}
-	/**
-	* Velocity-adaptive exponential smoothing of a single raw pressure sample.
-	*
-	* This is the one place pressure smoothing happens. Every sample that
-	* becomes a stroke point must go through it - including the
-	* high-frequency coalesced samples a stylus reports (see
-	* `handlePointerMove`), which previously bypassed it entirely and so
-	* landed in the stroke with their raw value, no pressure floor, and
-	* without advancing the smoothing state for later samples.
-	*
-	* Timing intentionally uses `performance.now()` (not the event's own
-	* `timeStamp`), matching the original behaviour: the two are not
-	* guaranteed to share a time origin, and mixing them corrupts the
-	* velocity term that drives `alpha`.
-	*
-	* The first sample of a stroke SEEDS the filter with its own value
-	* rather than being blended toward the neutral 0.5 baseline. Blending
-	* from a constant gives every stroke a warm-up transient: the filter
-	* starts at 0.5 and converges toward the pressure actually being
-	* applied, so a stroke drawn lighter than 0.5 renders visibly fatter at
-	* its start (and heavier than 0.5, thinner) until the filter catches
-	* up. Seeding removes that transient entirely - smoothing then only
-	* ever acts between real samples, which is its actual purpose.
-	*/
-	smoothPressureSample(raw, clientX, clientY) {
-		const now = performance.now();
-		let velocity = 0;
-		const hasPosition = Number.isFinite(clientX) && Number.isFinite(clientY);
-		if (hasPosition && this.lastPointerPos && now - this.lastPointerTime > 0) {
-			const dx = clientX - this.lastPointerPos.x;
-			const dy = clientY - this.lastPointerPos.y;
-			velocity = Math.hypot(dx, dy) / (now - this.lastPointerTime) * 1e3;
-		}
-		if (hasPosition) this.lastPointerPos = {
-			x: clientX,
-			y: clientY
-		};
-		this.lastPointerTime = now;
-		const safeRaw = Number.isFinite(raw) ? raw : .5;
-		if (!this.hasPressureSample) {
-			this.hasPressureSample = true;
-			this.lastSmoothedPressure = safeRaw;
-			return Math.max(this.lastSmoothedPressure, .15);
+};
+/**
+* Pulled string: the recorded point is held back on a leash of fixed length
+* and only moves when the pen pulls it taut, so movement inside the leash
+* leaves no mark and tight curves are rounded.
+*/
+var PulledStringStabilizer = class {
+	cfg;
+	tip = null;
+	constructor(cfg) {
+		this.cfg = cfg;
+	}
+	reset() {
+		this.tip = null;
+	}
+	seed(point) {
+		this.tip = { ...point };
+	}
+	apply(point, ctx) {
+		if (!this.tip) {
+			this.tip = { ...point };
+			return point;
+		}
+		const leash = this.cfg.radiusPx / unitScale(this.cfg, ctx);
+		const dx = point.x - this.tip.x;
+		const dy = point.y - this.tip.y;
+		const distance = Math.hypot(dx, dy);
+		if (distance > leash && distance > 0) {
+			const pull = (distance - leash) / distance;
+			this.tip = {
+				x: this.tip.x + dx * pull,
+				y: this.tip.y + dy * pull
+			};
 		}
-		const alpha = Math.min(Math.max(velocity / 1500, .15), .6);
-		const smoothed = alpha * safeRaw + (1 - alpha) * this.lastSmoothedPressure;
-		this.lastSmoothedPressure = Number.isFinite(smoothed) ? smoothed : safeRaw;
-		return Math.max(this.lastSmoothedPressure, .15);
+		return { ...this.tip };
 	}
-	/**
-	* Raw pressure a pointer sample reports: the device's own reading for a
-	* pen, a neutral constant for devices that do not sense pressure.
-	*/
-	getRawPressure(pointerType, pressure) {
-		if (pointerType === "pen") return (typeof pressure === "number" ? pressure : 0) || .5;
-		return .5;
+};
+/** Longest time constant of the streamline stabilizer, at amount 1, in ms. */
+const STREAMLINE_MAX_TAU_MS = 80;
+/**
+* Streamline: the recorded point eases towards the pen with a time constant
+* proportional to `amount`, so the result does not depend on how often samples
+* arrive. Amount 0 follows the pen exactly.
+*/
+var StreamlineStabilizer = class {
+	cfg;
+	tip = null;
+	lastTime = 0;
+	constructor(cfg) {
+		this.cfg = cfg;
 	}
-	getEventPressure(e) {
-		return this.smoothPressureSample(this.getRawPressure(e.evt.pointerType, e.evt.pressure), e.evt.clientX, e.evt.clientY);
+	reset() {
+		this.tip = null;
 	}
-	/**
-	* Resets the pressure-smoothing state (smoothed pressure, last known pointer
-	* position/time, and predicted-point bookkeeping) to a neutral baseline.
-	*
-	* This state is scoped to a single stroke: it must be reset before the
-	* first pressure sample of a new stroke is computed (in `handlePointerDown`,
-	* ahead of the `getEventPressure` call for point 0), not only afterwards -
-	* otherwise that first sample can inherit smoothing state left behind by
-	* the previous stroke (its ending pressure, pointer position and time),
-	* inflating the very first point's pressure.
-	*/
-	resetPressureSmoothingState() {
-		this.lastSmoothedPressure = .5;
-		this.hasPressureSample = false;
-		this.lastPointerPos = null;
-		this.lastPointerTime = 0;
-		this.predictedCount = 0;
+	seed(point, ctx) {
+		this.tip = { ...point };
+		this.lastTime = ctx.now;
 	}
-	setupEvents() {
-		const stage = this.instance.getStage();
-		this.prevTouchAction = stage.container().style.touchAction;
-		stage.container().style.touchAction = "none";
-		window.addEventListener("keyup", (e) => {
-			if (e.code === "Space" && this.instance.getActiveAction() === "brushTool") this.isSpacePressed = false;
-		}, { signal: this.instance.getEventsController().signal });
-		window.addEventListener("keydown", (e) => {
-			if (e.code === "Enter" && this.instance.getActiveAction() === "brushTool") {
-				e.stopPropagation();
-				this.cancelAction();
-				return;
-			}
-			if (e.code === "Space" && this.instance.getActiveAction() === "brushTool") {
-				e.stopPropagation();
-				this.isSpacePressed = true;
-				return;
-			}
-			if (e.code === "Escape" && this.instance.getActiveAction() === "brushTool") {
-				e.stopPropagation();
-				this.cancelAction();
-			}
-		}, { signal: this.instance.getEventsController().signal });
-		const handlePointerDown = (e) => {
-			if (this.state === BRUSH_TOOL_STATE.INACTIVE) return;
-			if (this.state !== BRUSH_TOOL_STATE.IDLE) return;
-			if (this.getZoomPlugin()?.isPinching()) return;
-			if (this.isSpacePressed) return;
-			if (e?.evt?.button !== 0) return;
-			if (e.evt.pointerType === "touch" && this.penActive) return;
-			if (e.evt.pointerType === "pen") this.penActive = true;
-			this.resetPressureSmoothingState();
-			const pointPressure = this.getEventPressure(e);
-			this.handleStartStroke(pointPressure);
-			e.evt.stopPropagation();
-		};
-		stage.on("pointerdown", handlePointerDown);
-		const handlePointerMove = (e) => {
-			if (this.state === BRUSH_TOOL_STATE.INACTIVE) return;
-			this.setCursor();
-			if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
-			if (this.getZoomPlugin()?.isPinching()) return;
-			const coalescedEvents = e.evt.getCoalescedEvents ? e.evt.getCoalescedEvents() : [];
-			if (coalescedEvents.length > 1) {
-				const samples = coalescedEvents.map((ce) => ({
-					pressure: this.smoothPressureSample(this.getRawPressure(ce.pointerType, ce.pressure), ce.clientX, ce.clientY),
-					isPredicted: false
-				}));
-				const predictedEvents = e.evt.getPredictedEvents ? e.evt.getPredictedEvents() : [];
-				if (predictedEvents.length > 0) {
-					const last = predictedEvents[predictedEvents.length - 1];
-					const predPressure = Math.max(.15 * this.getRawPressure(last.pointerType, last.pressure) + .85 * this.lastSmoothedPressure, .15);
-					samples.push({
-						pressure: predPressure,
-						sourceEvent: last,
-						isPredicted: true
-					});
-				}
-				this.applyMovementSamples(samples);
-			} else {
-				const pointPressure = this.getEventPressure(e);
-				this.handleMovement(pointPressure, void 0, false);
-			}
-			e.evt.stopPropagation();
+	apply(point, ctx) {
+		const tau = this.cfg.amount * STREAMLINE_MAX_TAU_MS;
+		if (!this.tip || tau <= 0) {
+			this.tip = { ...point };
+			this.lastTime = ctx.now;
+			return point;
+		}
+		const dt = seconds(ctx.now, this.lastTime) * 1e3;
+		const alpha = 1 - Math.exp(-dt / tau);
+		this.tip = {
+			x: this.tip.x + (point.x - this.tip.x) * alpha,
+			y: this.tip.y + (point.y - this.tip.y) * alpha
 		};
-		stage.on("pointermove", handlePointerMove);
-		const handlePointerUp = (e) => {
-			this.penActive = false;
+		this.lastTime = ctx.now;
+		return { ...this.tip };
+	}
+};
+/** Creates the stabilizer selected by a profile. */
+function createStabilizer(cfg) {
+	switch (cfg.type) {
+		case "oneEuro": return new OneEuroStabilizer(cfg);
+		case "pulledString": return new PulledStringStabilizer(cfg);
+		case "streamline": return new StreamlineStabilizer(cfg);
+		default: return new NoStabilizer();
+	}
+}
+//#endregion
+//#region src/actions/brush-tool/stages/pressure.ts
+/** Time assumed between two samples whose times do not advance, in ms. */
+const NOMINAL_SAMPLE_INTERVAL_MS = 5;
+function resetPressureState(state) {
+	state.lastSmoothedPressure = .5;
+	state.hasPressureSample = false;
+	state.lastPointerPos = null;
+	state.lastPointerTime = 0;
+	state.predictedCount = 0;
+	state.lastDerivative = 0;
+	state.lastNonZeroPressure = null;
+}
+/**
+* Raw pressure a pointer sample reports: the device's own reading for a pen, a
+* neutral constant for devices that do not sense pressure.
+*
+* `zero` decides what a reported pressure of 0 means for a pen: `legacy`
+* replaces it with 0.5, `keep` records it (the pressure floor still applies),
+* `holdLast` repeats the last non-zero reading. `commit: false` reads without
+* remembering the value, for speculative samples.
+*/
+function getRawPressure(pointerType, pressure, zero = "legacy", state, commit = true) {
+	if (pointerType !== "pen") return .5;
+	const value = typeof pressure === "number" && Number.isFinite(pressure) ? pressure : 0;
+	switch (zero) {
+		case "keep": return typeof pressure === "number" && Number.isFinite(pressure) ? pressure : .5;
+		case "holdLast":
+			if (value > 0) {
+				if (commit && state) state.lastNonZeroPressure = value;
+				return value;
+			}
+			return state?.lastNonZeroPressure ?? .5;
+		default: return value || .5;
+	}
+}
+/**
+* Legacy velocity-adaptive exponential smoothing of one raw pressure sample.
+*
+* The first sample of a stroke seeds the filter with its own value. Fast
+* movement gives a higher alpha (more responsive), slow movement a lower one.
+*/
+function smoothLegacy(state, cfg, raw, clientX, clientY, now) {
+	let velocity = 0;
+	const hasPosition = Number.isFinite(clientX) && Number.isFinite(clientY);
+	if (hasPosition && state.lastPointerPos && now - state.lastPointerTime > 0) {
+		const dx = clientX - state.lastPointerPos.x;
+		const dy = clientY - state.lastPointerPos.y;
+		velocity = Math.hypot(dx, dy) / (now - state.lastPointerTime) * 1e3;
+	}
+	if (hasPosition) state.lastPointerPos = {
+		x: clientX,
+		y: clientY
+	};
+	state.lastPointerTime = now;
+	const safeRaw = Number.isFinite(raw) ? raw : .5;
+	if (!state.hasPressureSample) {
+		state.hasPressureSample = true;
+		state.lastSmoothedPressure = safeRaw;
+		return Math.max(state.lastSmoothedPressure, cfg.floor);
+	}
+	const alpha = Math.min(Math.max(velocity / 1500, .15), .6);
+	const smoothed = alpha * safeRaw + (1 - alpha) * state.lastSmoothedPressure;
+	state.lastSmoothedPressure = Number.isFinite(smoothed) ? smoothed : safeRaw;
+	return Math.max(state.lastSmoothedPressure, cfg.floor);
+}
+/** Seconds between two samples; a non-advancing clock assumes a nominal rate. */
+function elapsedSeconds(state, now) {
+	const dt = now - state.lastPointerTime;
+	return (dt > 0 ? dt : NOMINAL_SAMPLE_INTERVAL_MS) / 1e3;
+}
+/** Seeds a filter with its first sample. */
+function seed(state, value, now) {
+	state.hasPressureSample = true;
+	state.lastSmoothedPressure = value;
+	state.lastPointerTime = now;
+	state.lastDerivative = 0;
+}
+/** Exponential smoothing with a time constant, independent of the report rate. */
+function smoothTimeEma(state, cfg, safeRaw, now) {
+	if (!state.hasPressureSample) {
+		seed(state, safeRaw, now);
+		return Math.max(safeRaw, cfg.floor);
+	}
+	const dt = elapsedSeconds(state, now) * 1e3;
+	const alpha = 1 - Math.exp(-dt / Math.max(cfg.timeConstantMs, 1e-6));
+	const smoothed = alpha * safeRaw + (1 - alpha) * state.lastSmoothedPressure;
+	state.lastSmoothedPressure = Number.isFinite(smoothed) ? smoothed : safeRaw;
+	state.lastPointerTime = now;
+	return Math.max(state.lastSmoothedPressure, cfg.floor);
+}
+const smoothingFactor = (dt, cutoff) => {
+	const r = 2 * Math.PI * cutoff * dt;
+	return r / (r + 1);
+};
+/**
+* One Euro filter (Casiez, Roussel, Vogel 2012): a low-pass filter whose cutoff
+* rises with speed, so slow changes are smoothed and fast ones follow closely.
+*/
+function smoothOneEuro(state, cfg, safeRaw, now) {
+	if (!state.hasPressureSample) {
+		seed(state, safeRaw, now);
+		return Math.max(safeRaw, cfg.floor);
+	}
+	const dt = elapsedSeconds(state, now);
+	const derivative = (safeRaw - state.lastSmoothedPressure) / dt;
+	const a = smoothingFactor(dt, 1);
+	state.lastDerivative = a * derivative + (1 - a) * state.lastDerivative;
+	const cutoff = cfg.oneEuro.minCutoff + cfg.oneEuro.beta * Math.abs(state.lastDerivative);
+	const alpha = smoothingFactor(dt, cutoff);
+	const smoothed = alpha * safeRaw + (1 - alpha) * state.lastSmoothedPressure;
+	state.lastSmoothedPressure = Number.isFinite(smoothed) ? smoothed : safeRaw;
+	state.lastPointerTime = now;
+	return Math.max(state.lastSmoothedPressure, cfg.floor);
+}
+/** Smooths one raw pressure sample with the filter selected by the profile. */
+function smoothPressure(state, cfg, raw, clientX, clientY, now) {
+	const safeRaw = Number.isFinite(raw) ? raw : .5;
+	switch (cfg.filter) {
+		case "timeEma": return smoothTimeEma(state, cfg, safeRaw, now);
+		case "oneEuro": return smoothOneEuro(state, cfg, safeRaw, now);
+		case "none":
+			state.hasPressureSample = true;
+			state.lastSmoothedPressure = safeRaw;
+			state.lastPointerTime = now;
+			return Math.max(safeRaw, cfg.floor);
+		default: return smoothLegacy(state, cfg, raw, clientX, clientY, now);
+	}
+}
+/**
+* Pressure of a predicted (speculative) sample. It blends against the current
+* state read-only, because predicted samples are rolled back and must not
+* advance the state real samples depend on.
+*/
+function peekPredictedPressure(state, cfg, raw) {
+	return Math.max(.15 * raw + .85 * state.lastSmoothedPressure, cfg.floor);
+}
+/**
+* Start policy for the first point's pressure. A stroke's pointer-down reading
+* is frequently an unreliable contact spike.
+*
+* - `backfill`: the first real movement sample replaces it once it exists.
+* - `average`: it becomes the mean of the first `startSamples` real movement
+*   readings, refined as each one arrives, so it never keeps the contact value.
+* - `none`: it is left as reported.
+*
+* Predicted samples never change it.
+*/
+function applyStartPolicy(elements, incoming, isPredicted, cfg) {
+	if (isPredicted || elements.length === 0) return;
+	if (cfg.start === "backfill" && elements.length === 1) elements[0] = {
+		...elements[0],
+		pressure: incoming.pressure
+	};
+	else if (cfg.start === "average" && elements.length <= cfg.startSamples) {
+		const readings = [...elements.slice(1), incoming];
+		elements[0] = {
+			...elements[0],
+			pressure: readings.reduce((sum, p) => sum + p.pressure, 0) / readings.length
+		};
+	}
+}
+/**
+* End policy. A lift-off reading can be as unreliable as the contact spike;
+* under `backfill` the last point takes the second-to-last point's pressure.
+*/
+function applyEndPolicy(elements, cfg) {
+	if (cfg.end === "backfill" && elements.length >= 2) {
+		const result = [...elements];
+		const lastIndex = result.length - 1;
+		result[lastIndex] = {
+			...result[lastIndex],
+			pressure: result[lastIndex - 1].pressure
+		};
+		return result;
+	}
+	return elements;
+}
+//#endregion
+//#region src/actions/brush-tool/stages/capture.ts
+const createCaptureState = () => ({ lastClient: null });
+/**
+* Legacy capture of a pointer move that carries batched (coalesced) samples.
+*
+* Every real sample is smoothed through the same path as any other sample but
+* deliberately carries no `sourceEvent`: coalesced samples keep using the
+* event's already-resolved pointer position. The last predicted sample, if
+* any, is appended as a provisional point.
+*
+* Returns `null` when the event has at most one sample, so the caller takes
+* the single-event path.
+*/
+function captureLegacySamples(evt, deps) {
+	const coalescedEvents = evt.getCoalescedEvents ? evt.getCoalescedEvents() : [];
+	if (coalescedEvents.length <= 1) return null;
+	const samples = coalescedEvents.map((ce) => ({
+		pressure: deps.smooth(deps.rawPressure(ce.pointerType, ce.pressure), ce.clientX, ce.clientY, ce.timeStamp),
+		isPredicted: false
+	}));
+	const predictedEvents = evt.getPredictedEvents ? evt.getPredictedEvents() : [];
+	if (predictedEvents.length > 0) {
+		const last = predictedEvents[predictedEvents.length - 1];
+		samples.push({
+			pressure: deps.predictedPressure(deps.rawPressure(last.pointerType, last.pressure, false)),
+			sourceEvent: last,
+			isPredicted: true
+		});
+	}
+	return samples;
+}
+/**
+* Captures every sample a pointer move carries: each batched (coalesced) sample
+* becomes a point at its own position, pressure and time, in the order the
+* browser reported them. An event without a batch is one sample.
+*
+* Positions are computed from each sample's client coordinates, so no shared
+* stage state is changed. Samples closer than `minMovePx` (screen px) to the
+* last recorded one are skipped. The browser's predicted tail is appended as a
+* provisional point when enabled and at least one real sample was kept.
+*/
+function captureCoalescedSamples(evt, deps, cfg, state) {
+	const batch = evt.getCoalescedEvents ? evt.getCoalescedEvents() : [];
+	const source = batch.length > 0 ? batch : [evt];
+	const samples = [];
+	for (const ce of source) {
+		if (cfg.minMovePx > 0 && state.lastClient && Math.hypot(ce.clientX - state.lastClient.x, ce.clientY - state.lastClient.y) < cfg.minMovePx) continue;
+		state.lastClient = {
+			x: ce.clientX,
+			y: ce.clientY
+		};
+		samples.push({
+			pressure: deps.smooth(deps.rawPressure(ce.pointerType, ce.pressure), ce.clientX, ce.clientY, ce.timeStamp),
+			point: deps.toContainerPoint(ce.clientX, ce.clientY),
+			time: ce.timeStamp,
+			isPredicted: false
+		});
+	}
+	if (samples.length > 0 && cfg.predicted === "tail") {
+		const predictedEvents = evt.getPredictedEvents ? evt.getPredictedEvents() : [];
+		if (predictedEvents.length > 0) {
+			const last = predictedEvents[predictedEvents.length - 1];
+			samples.push({
+				pressure: deps.predictedPressure(deps.rawPressure(last.pointerType, last.pressure, false)),
+				point: deps.toContainerPoint(last.clientX, last.clientY),
+				time: last.timeStamp,
+				isPredicted: true
+			});
+		}
+	}
+	return samples;
+}
+//#endregion
+//#region src/actions/brush-tool/stages/bezier-fit.ts
+const sub = (a, b) => ({
+	x: a.x - b.x,
+	y: a.y - b.y
+});
+const add = (a, b) => ({
+	x: a.x + b.x,
+	y: a.y + b.y
+});
+const scale = (a, s) => ({
+	x: a.x * s,
+	y: a.y * s
+});
+const dot = (a, b) => a.x * b.x + a.y * b.y;
+const length = (a) => Math.hypot(a.x, a.y);
+const normalize = (a) => {
+	const l = length(a);
+	return l > 0 ? {
+		x: a.x / l,
+		y: a.y / l
+	} : {
+		x: 0,
+		y: 0
+	};
+};
+const B0 = (u) => (1 - u) ** 3;
+const B1 = (u) => 3 * u * (1 - u) ** 2;
+const B2 = (u) => 3 * u * u * (1 - u);
+const B3 = (u) => u ** 3;
+/** Point on a cubic Bézier curve. */
+function bezierPoint(b, t) {
+	return {
+		x: B0(t) * b[0].x + B1(t) * b[1].x + B2(t) * b[2].x + B3(t) * b[3].x,
+		y: B0(t) * b[0].y + B1(t) * b[1].y + B2(t) * b[2].y + B3(t) * b[3].y
+	};
+}
+function derivative(b, t) {
+	const q = [
+		sub(b[1], b[0]),
+		sub(b[2], b[1]),
+		sub(b[3], b[2])
+	].map((v) => scale(v, 3));
+	const s = 1 - t;
+	return {
+		x: s * s * q[0].x + 2 * s * t * q[1].x + t * t * q[2].x,
+		y: s * s * q[0].y + 2 * s * t * q[1].y + t * t * q[2].y
+	};
+}
+function secondDerivative(b, t) {
+	const q = [add(sub(b[2], scale(b[1], 2)), b[0]), add(sub(b[3], scale(b[2], 2)), b[1])].map((v) => scale(v, 6));
+	return {
+		x: (1 - t) * q[0].x + t * q[1].x,
+		y: (1 - t) * q[0].y + t * q[1].y
+	};
+}
+/**
+* Direction of the curve at `index`, estimated over a window at least
+* `window` long on each side (but inside `first..last`), so that noise in the
+* nearest samples does not tilt it. With `before` false only the following
+* points are used (a start tangent); with `after` false only the preceding
+* ones (an end tangent). The vector points forward along the stroke.
+*/
+function windowTangent(pts, index, first, last, window, before, after) {
+	let back = index;
+	if (before) while (back > first && length(sub(pts[index], pts[back])) < window) back--;
+	let ahead = index;
+	if (after) while (ahead < last && length(sub(pts[ahead], pts[index])) < window) ahead++;
+	return normalize(sub(pts[ahead], pts[back]));
+}
+function chordLengthParameterize(pts, first, last) {
+	const u = [0];
+	for (let i = first + 1; i <= last; i++) u.push(u[u.length - 1] + length(sub(pts[i], pts[i - 1])));
+	const total = u[u.length - 1] || 1;
+	return u.map((v) => v / total);
+}
+function generateBezier(pts, first, last, u, tHat1, tHat2) {
+	const p0 = pts[first];
+	const p3 = pts[last];
+	let c00 = 0, c01 = 0, c11 = 0, x0 = 0, x1 = 0;
+	for (let i = 0; i < u.length; i++) {
+		const a0 = scale(tHat1, B1(u[i]));
+		const a1 = scale(tHat2, B2(u[i]));
+		c00 += dot(a0, a0);
+		c01 += dot(a0, a1);
+		c11 += dot(a1, a1);
+		const tmp = sub(pts[first + i], add(scale(p0, B0(u[i]) + B1(u[i])), scale(p3, B2(u[i]) + B3(u[i]))));
+		x0 += dot(a0, tmp);
+		x1 += dot(a1, tmp);
+	}
+	const det = c00 * c11 - c01 * c01;
+	const alphaL = det === 0 ? 0 : (x0 * c11 - x1 * c01) / det;
+	const alphaR = det === 0 ? 0 : (c00 * x1 - c01 * x0) / det;
+	const segLength = length(sub(p3, p0));
+	const epsilon = 1e-6 * segLength;
+	if (alphaL < epsilon || alphaR < epsilon) {
+		const d = segLength / 3;
+		return [
+			p0,
+			add(p0, scale(tHat1, d)),
+			add(p3, scale(tHat2, d)),
+			p3
+		];
+	}
+	return [
+		p0,
+		add(p0, scale(tHat1, alphaL)),
+		add(p3, scale(tHat2, alphaR)),
+		p3
+	];
+}
+function newtonRaphson(b, p, u) {
+	const d = sub(bezierPoint(b, u), p);
+	const d1 = derivative(b, u);
+	const d2 = secondDerivative(b, u);
+	const numerator = dot(d, d1);
+	const denominator = dot(d1, d1) + dot(d, d2);
+	return denominator === 0 ? u : u - numerator / denominator;
+}
+function maxError(pts, first, last, b, u) {
+	let split = Math.floor((last - first + 1) / 2) + first;
+	let max = 0;
+	for (let i = first + 1; i < last; i++) {
+		const d = sub(bezierPoint(b, u[i - first]), pts[i]);
+		const e = dot(d, d);
+		if (e >= max) {
+			max = e;
+			split = i;
+		}
+	}
+	return {
+		error: max,
+		split
+	};
+}
+function fitCubic(pts, first, last, tHat1, tHat2, errorSq, window, out) {
+	if (last - first === 1) {
+		const d = length(sub(pts[last], pts[first])) / 3;
+		out.push({
+			bez: [
+				pts[first],
+				add(pts[first], scale(tHat1, d)),
+				add(pts[last], scale(tHat2, d)),
+				pts[last]
+			],
+			first,
+			last,
+			u: [0, 1]
+		});
+		return;
+	}
+	let u = chordLengthParameterize(pts, first, last);
+	let bez = generateBezier(pts, first, last, u, tHat1, tHat2);
+	let { error, split } = maxError(pts, first, last, bez, u);
+	if (error < errorSq) {
+		out.push({
+			bez,
+			first,
+			last,
+			u
+		});
+		return;
+	}
+	if (error < errorSq * 4) for (let i = 0; i < 4; i++) {
+		const prime = u.map((v, k) => {
+			const p = newtonRaphson(bez, pts[first + k], v);
+			return Number.isFinite(p) ? Math.min(Math.max(p, 0), 1) : v;
+		});
+		bez = generateBezier(pts, first, last, prime, tHat1, tHat2);
+		({error, split} = maxError(pts, first, last, bez, prime));
+		u = prime;
+		if (error < errorSq) {
+			out.push({
+				bez,
+				first,
+				last,
+				u
+			});
+			return;
+		}
+	}
+	const center = windowTangent(pts, split, first, last, window, true, true);
+	const back = scale(center, -1);
+	fitCubic(pts, first, split, tHat1, back, errorSq, window, out);
+	fitCubic(pts, split, last, center, tHat2, errorSq, window, out);
+}
+/**
+* Fits cubic Bézier segments to a polyline so that no input point is farther
+* than `tolerance` from the curve. Needs at least two points, none repeated
+* consecutively.
+*/
+function fitCurve(points, tolerance) {
+	if (points.length < 2) return [];
+	const out = [];
+	const last = points.length - 1;
+	const window = tolerance * 3;
+	fitCubic(points, 0, last, windowTangent(points, 0, 0, last, window, false, true), scale(windowTangent(points, last, 0, last, window, true, false), -1), tolerance * tolerance, window, out);
+	return out;
+}
+//#endregion
+//#region src/actions/brush-tool/stages/finalize.ts
+/** Size of one screen pixel in canvas units at a zoom level. */
+const pixelSize = (zoom) => zoom > 0 && Number.isFinite(zoom) ? 1 / zoom : 1;
+/**
+* Tolerance applied when a stroke is finished, in canvas units. The legacy
+* value is the tool-level tolerance in canvas units; with the `screen` unit the
+* configured pixels are converted with the zoom in force when the stroke ends,
+* so the same setting gives the same on-screen fidelity at any zoom.
+*/
+function resolveFinalizeTolerance(cfg, toolTolerance, zoom = 1) {
+	const tolerance = cfg.tolerance ?? toolTolerance;
+	return cfg.toleranceUnit === "screen" ? tolerance * pixelSize(zoom) : tolerance;
+}
+/** Distance from `p` to the segment, and where along it the closest point is. */
+function toSegment(p, { a, b }) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const lengthSq = dx * dx + dy * dy;
+	const t = lengthSq ? Math.min(1, Math.max(0, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSq)) : 0;
+	return {
+		distance: Math.hypot(p.x - (a.x + dx * t), p.y - (a.y + dy * t)),
+		t
+	};
+}
+/**
+* Douglas-Peucker simplification that also keeps pressure detail: a point is
+* kept when it is off the straight path by more than `tolerance`, or when its
+* pressure differs from the pressure interpolated along that path by more than
+* `tolerance / pressureWeight`.
+*/
+function simplifyWithPressure(points, tolerance, pressureWeight) {
+	if (points.length <= 2) return points;
+	const keep = new Uint8Array(points.length);
+	keep[0] = keep[points.length - 1] = 1;
+	const stack = [[0, points.length - 1]];
+	while (stack.length > 0) {
+		const [first, last] = stack.pop();
+		let worst = 0;
+		let index = -1;
+		for (let i = first + 1; i < last; i++) {
+			const { distance, t } = toSegment(points[i], {
+				a: points[first],
+				b: points[last]
+			});
+			const expected = points[first].pressure + (points[last].pressure - points[first].pressure) * t;
+			const error = Math.max(distance, Math.abs(points[i].pressure - expected) * pressureWeight);
+			if (error > worst) {
+				worst = error;
+				index = i;
+			}
+		}
+		if (worst > tolerance && index !== -1) {
+			keep[index] = 1;
+			stack.push([first, index], [index, last]);
+		}
+	}
+	return points.filter((_, i) => keep[i] === 1);
+}
+/** Pressure at curve parameter `t` of a segment, interpolated between input points. */
+function pressureAt(seg, points, t) {
+	let prev = seg.u[0];
+	for (let k = 1; k < seg.u.length; k++) {
+		const next = Math.max(seg.u[k], prev);
+		if (t <= next || k === seg.u.length - 1) {
+			const span = next - prev;
+			const f = span > 0 ? Math.min(1, Math.max(0, (t - prev) / span)) : 0;
+			const p0 = points[seg.first + k - 1].pressure;
+			return p0 + (points[seg.first + k].pressure - p0) * f;
+		}
+		prev = next;
+	}
+	return points[seg.last].pressure;
+}
+/**
+* Fits a smooth curve through the stroke and samples it back to points, so the
+* saved format stays `{x, y, pressure}`. `tolerance` is the largest distance
+* between the curve and an input point; `spacing` is the distance between
+* sampled points. Both are in canvas units. The first and last points are kept
+* exactly.
+*/
+function fitAndResample(points, tolerance, spacing) {
+	if (points.length < 3 || !(tolerance > 0)) return points;
+	const distinct = points.filter((p, i) => i === 0 || p.x !== points[i - 1].x || p.y !== points[i - 1].y);
+	if (distinct.length < 3) return points;
+	const segments = fitCurve(distinct, tolerance);
+	if (segments.length === 0) return points;
+	const out = [];
+	for (const seg of segments) {
+		let arc = 0;
+		let prev = seg.bez[0];
+		for (let k = 1; k <= 16; k++) {
+			const q = bezierPoint(seg.bez, k / 16);
+			arc += Math.hypot(q.x - prev.x, q.y - prev.y);
+			prev = q;
+		}
+		const steps = Math.max(1, Math.ceil(arc / Math.max(spacing, 1e-6)));
+		for (let k = 0; k < steps; k++) {
+			const t = k / steps;
+			const q = k === 0 ? seg.bez[0] : bezierPoint(seg.bez, t);
+			out.push({
+				x: q.x,
+				y: q.y,
+				pressure: pressureAt(seg, distinct, t)
+			});
+		}
+	}
+	const end = distinct[distinct.length - 1];
+	out.push({
+		x: end.x,
+		y: end.y,
+		pressure: end.pressure
+	});
+	return out;
+}
+/** Reduces a finished stroke's points as selected by the profile. */
+function finalizePoints(points, cfg, toolTolerance, zoom = 1) {
+	const tolerance = resolveFinalizeTolerance(cfg, toolTolerance, zoom);
+	switch (cfg.mode) {
+		case "none": return points;
+		case "dpPressure": return simplifyWithPressure(points, tolerance, cfg.toleranceUnit === "screen" ? cfg.pressureWeight * pixelSize(zoom) : cfg.pressureWeight);
+		case "bezierFit": return fitAndResample(points, tolerance, cfg.resampleSpacingPx * pixelSize(zoom));
+		default: return simplify(points, tolerance, true);
+	}
+}
+//#endregion
+//#region src/actions/brush-tool/profiles.ts
+/**
+* Coarse platform of the running browser: `ipad`, `ios`, `mac`, `windows`,
+* `android`, `linux` or `unknown`. iPadOS reports a desktop Mac user agent, so
+* a Mac with multi-touch is an iPad.
+*/
+function detectBrushPlatform(nav) {
+	const source = nav === void 0 ? typeof navigator === "undefined" ? null : navigator : nav;
+	if (!source) return "unknown";
+	const ua = source.userAgent ?? "";
+	const platform = source.platform ?? "";
+	if (/iPad/i.test(ua)) return "ipad";
+	if (/iPhone|iPod/i.test(ua)) return "ios";
+	if (/Mac/i.test(platform) && (source.maxTouchPoints ?? 0) > 1) return "ipad";
+	if (/Android/i.test(ua)) return "android";
+	if (/Win/i.test(platform) || /Windows/i.test(ua)) return "windows";
+	if (/Mac/i.test(platform) || /Macintosh/i.test(ua)) return "mac";
+	if (/Linux|X11/i.test(platform) || /Linux|X11/i.test(ua)) return "linux";
+	return "unknown";
+}
+const isProfileKey = (key) => BRUSH_INPUT_PROFILE_KEYS.includes(key);
+/**
+* Profile chosen from the pointer type and platform. A pen on an iPad is an
+* Apple Pencil; any other pen is a desktop pen. Unknown pointer types behave
+* like a mouse.
+*/
+function automaticBrushProfileKey(info) {
+	switch (info.pointerType) {
+		case "pen": return info.platform === "ipad" ? "pen.applePencil" : "pen.desktop";
+		case "touch": return "touch";
+		default: return "mouse";
+	}
+}
+/**
+* Resolves the input profile for a stroke. A forced profile wins, then the
+* application's resolver, then the automatic choice. A resolver that throws or
+* returns an unknown key is ignored.
+*/
+function resolveBrushInputProfileKey(info, cfg) {
+	if (isProfileKey(cfg.forceProfile)) return cfg.forceProfile;
+	if (cfg.resolveProfile) try {
+		const key = cfg.resolveProfile(info);
+		if (isProfileKey(key)) return key;
+	} catch {}
+	return automaticBrushProfileKey(info);
+}
+//#endregion
+//#region src/actions/brush-tool/tunables/descriptors.ts
+const profile = (key, spec) => ({
+	key,
+	scope: "profile",
+	path: key.split("."),
+	...spec
+});
+const look = (key, spec) => ({
+	key,
+	scope: "look",
+	path: key.split("."),
+	...spec
+});
+/** Every setting accepted by an input profile. */
+const BRUSH_PROFILE_TUNABLES = [
+	profile("capture.source", {
+		stage: "capture",
+		group: "Capture",
+		kind: "capture",
+		type: "enum",
+		default: "legacy",
+		options: ["legacy", "coalesced"],
+		help: "legacy keeps one position per event; coalesced keeps every batched pen sample with its own position."
+	}),
+	profile("capture.clock", {
+		stage: "capture",
+		group: "Capture",
+		kind: "capture",
+		type: "enum",
+		default: "now",
+		options: ["now", "event"],
+		help: "Time base of time-dependent filters: processing time or the time reported by each sample."
+	}),
+	profile("capture.minMovePx", {
+		stage: "capture",
+		group: "Capture",
+		kind: "capture",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 3,
+		step: .1,
+		unit: "px",
+		help: "Samples closer than this to the last recorded one are skipped."
+	}),
+	profile("capture.predicted", {
+		stage: "capture",
+		group: "Capture",
+		kind: "capture",
+		type: "enum",
+		default: "tail",
+		options: ["off", "tail"],
+		help: "Draw the browser-predicted tail ahead of the pen to hide latency."
+	}),
+	profile("capture.event", {
+		stage: "capture",
+		group: "Capture",
+		kind: "capture",
+		type: "enum",
+		default: "pointermove",
+		options: ["pointermove", "pointerrawupdate"],
+		help: "Event that delivers samples. pointerrawupdate lowers latency where supported.",
+		advanced: true
+	}),
+	profile("pressure.zero", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "enum",
+		default: "legacy",
+		options: [
+			"legacy",
+			"keep",
+			"holdLast"
+		],
+		help: "How a pen pressure of 0 is treated: legacy replaces it with 0.5, keep records it, holdLast repeats the last non-zero value."
+	}),
+	profile("pressure.filter", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "enum",
+		default: "legacy",
+		options: [
+			"legacy",
+			"timeEma",
+			"oneEuro",
+			"none"
+		],
+		help: "Pressure smoothing: the legacy velocity-adaptive filter, a time-based one, the One Euro filter, or none."
+	}),
+	profile("pressure.timeConstantMs", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "number",
+		default: 40,
+		min: 1,
+		max: 500,
+		step: 1,
+		unit: "ms",
+		help: "Time constant of the timeEma filter; larger is smoother and slower."
+	}),
+	profile("pressure.oneEuro.minCutoff", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "number",
+		default: 1,
+		min: .01,
+		max: 10,
+		step: .01,
+		unit: "Hz",
+		help: "One Euro minimum cutoff: lower removes more jitter at slow speed.",
+		advanced: true
+	}),
+	profile("pressure.oneEuro.beta", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "number",
+		default: .01,
+		min: 0,
+		max: 1,
+		step: .001,
+		help: "One Euro speed coefficient: higher removes more lag at high speed.",
+		advanced: true
+	}),
+	profile("pressure.floor", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "number",
+		default: .15,
+		min: 0,
+		max: .5,
+		step: .01,
+		unit: "fraction",
+		help: "Lowest pressure that is recorded; prevents invisible strokes."
+	}),
+	profile("pressure.start", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "enum",
+		default: "backfill",
+		options: [
+			"backfill",
+			"average",
+			"none"
+		],
+		help: "First point: backfill takes the next real sample, average takes the mean of the first movement readings, none keeps the contact reading."
+	}),
+	profile("pressure.startSamples", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "number",
+		default: 3,
+		min: 1,
+		max: 10,
+		step: 1,
+		integer: true,
+		unit: "count",
+		help: "Number of readings averaged by the average start policy.",
+		advanced: true
+	}),
+	profile("pressure.end", {
+		stage: "pressure",
+		group: "Pressure",
+		kind: "capture",
+		type: "enum",
+		default: "backfill",
+		options: ["backfill", "none"],
+		help: "Last point: backfill takes the second-to-last pressure, none keeps the lift-off reading."
+	}),
+	profile("stabilizer.type", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "enum",
+		default: "none",
+		options: [
+			"none",
+			"oneEuro",
+			"pulledString",
+			"streamline"
+		],
+		help: "Smooths the pen position while drawing."
+	}),
+	profile("stabilizer.minCutoff", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "number",
+		default: 3,
+		min: .1,
+		max: 20,
+		step: .1,
+		unit: "Hz",
+		help: "One Euro minimum cutoff: lower removes more jitter at slow speed."
+	}),
+	profile("stabilizer.beta", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "number",
+		default: .01,
+		min: 0,
+		max: 1,
+		step: .001,
+		help: "One Euro speed coefficient: higher removes more lag at high speed."
+	}),
+	profile("stabilizer.radiusPx", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "number",
+		default: 4,
+		min: 0,
+		max: 40,
+		step: .5,
+		unit: "px",
+		help: "Pulled string leash length: the pen must move this far before the line follows."
+	}),
+	profile("stabilizer.amount", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "number",
+		default: .3,
+		min: 0,
+		max: 1,
+		step: .01,
+		unit: "fraction",
+		help: "Streamline strength: 0 follows the pen exactly, 1 is the strongest smoothing."
+	}),
+	profile("stabilizer.zoomAware", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "boolean",
+		default: false,
+		help: "Interpret the distances in screen pixels, so the effect on screen is the same at every zoom level. Off: canvas units."
+	}),
+	profile("stabilizer.catchUpOnEnd", {
+		stage: "stabilizer",
+		group: "Stabilizer",
+		kind: "capture",
+		type: "boolean",
+		default: true,
+		help: "Complete the stroke at the position where the pen was lifted."
+	}),
+	profile("finalize.mode", {
+		stage: "finalize",
+		group: "Finish",
+		kind: "capture",
+		type: "enum",
+		default: "dp",
+		options: [
+			"dp",
+			"dpPressure",
+			"bezierFit",
+			"none"
+		],
+		help: "How points are reduced when the stroke ends: simplification, simplification keeping pressure detail, curve fitting, or nothing."
+	}),
+	profile("finalize.tolerance", {
+		stage: "finalize",
+		group: "Finish",
+		kind: "capture",
+		type: "number",
+		default: null,
+		nullable: true,
+		min: 0,
+		max: 20,
+		step: .05,
+		help: "Tolerance of the finishing step. Empty uses the tool-level tolerance."
+	}),
+	profile("finalize.toleranceUnit", {
+		stage: "finalize",
+		group: "Finish",
+		kind: "capture",
+		type: "enum",
+		default: "canvas",
+		options: ["canvas", "screen"],
+		help: "canvas: tolerance in canvas units. screen: in pixels, converted with the zoom when the stroke ends."
+	}),
+	profile("finalize.pressureWeight", {
+		stage: "finalize",
+		group: "Finish",
+		kind: "capture",
+		type: "number",
+		default: 20,
+		min: 0,
+		max: 200,
+		step: 1,
+		help: "Distance units per pressure unit when simplification keeps pressure detail.",
+		advanced: true
+	}),
+	profile("finalize.resampleSpacingPx", {
+		stage: "finalize",
+		group: "Finish",
+		kind: "capture",
+		type: "number",
+		default: 2,
+		min: .5,
+		max: 20,
+		step: .5,
+		unit: "px",
+		help: "Spacing of the points a fitted curve is resampled to.",
+		advanced: true
+	}),
+	profile("touchGuard.waitMs", {
+		stage: "touch",
+		group: "Finger",
+		kind: "capture",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 500,
+		step: 10,
+		unit: "ms",
+		help: "Wait before a finger stroke is committed, so a second finger can cancel it."
+	}),
+	profile("touchGuard.movePx", {
+		stage: "touch",
+		group: "Finger",
+		kind: "capture",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 40,
+		step: 1,
+		unit: "px",
+		help: "Movement that commits the stroke before the wait ends."
+	}),
+	profile("touchGuard.cancelOnSecondTouch", {
+		stage: "touch",
+		group: "Finger",
+		kind: "capture",
+		type: "boolean",
+		default: false,
+		help: "Cancel the stroke when a second finger lands during the wait."
+	}),
+	profile("touchGuard.ignoreAfterPen", {
+		stage: "touch",
+		group: "Finger",
+		kind: "capture",
+		type: "boolean",
+		default: false,
+		help: "Finger input does not draw once a pen has been used."
+	})
+];
+/** Every setting accepted by a stroke look. */
+const BRUSH_LOOK_TUNABLES = [
+	look("outline", {
+		stage: "outline",
+		group: "Outline",
+		kind: "draw",
+		type: "enum",
+		default: "legacy",
+		options: [
+			"legacy",
+			"round",
+			"freehand"
+		],
+		help: "Shape of the stroke: legacy ribbon, round (discs and segments, no spikes) or freehand."
+	}),
+	look("curve", {
+		stage: "curve",
+		group: "Curve",
+		kind: "draw",
+		type: "enum",
+		default: "uniform",
+		options: [
+			"uniform",
+			"centripetal",
+			"none"
+		],
+		help: "Curve through the points. centripetal does not overshoot when points are unevenly spaced."
+	}),
+	look("pressureInterp", {
+		stage: "curve",
+		group: "Curve",
+		kind: "draw",
+		type: "enum",
+		default: "catmullRom",
+		options: ["catmullRom", "linear"],
+		help: "How pressure is interpolated between points. linear never bulges."
+	}),
+	look("zoomAware", {
+		stage: "detail",
+		group: "Detail",
+		kind: "draw",
+		type: "boolean",
+		default: false,
+		help: "Choose spacing and subdivision in screen pixels so smoothness does not depend on zoom."
+	}),
+	look("spacingPx", {
+		stage: "detail",
+		group: "Detail",
+		kind: "draw",
+		type: "number",
+		default: 2,
+		min: .5,
+		max: 10,
+		step: .5,
+		unit: "px",
+		help: "Minimum spacing between control points.",
+		advanced: true
+	}),
+	look("edgePx", {
+		stage: "detail",
+		group: "Detail",
+		kind: "draw",
+		type: "number",
+		default: 1,
+		min: .25,
+		max: 5,
+		step: .25,
+		unit: "px",
+		help: "Detail of the curve. The centripetal curve keeps every edge within a tenth of this of the true curve; the uniform curve uses it as the target length of an edge.",
+		advanced: true
+	}),
+	look("caps", {
+		stage: "ends",
+		group: "Ends",
+		kind: "draw",
+		type: "enum",
+		default: "separate",
+		options: ["separate", "merged"],
+		help: "merged draws the round ends inside the same fill, so translucent colours stay uniform."
+	}),
+	look("width.min", {
+		stage: "width",
+		group: "Width",
+		kind: "draw",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 1,
+		step: .01,
+		unit: "fraction",
+		help: "Width at pressure 0, as a fraction of the stroke width."
+	}),
+	look("width.max", {
+		stage: "width",
+		group: "Width",
+		kind: "draw",
+		type: "number",
+		default: 1,
+		min: 0,
+		max: 1,
+		step: .01,
+		unit: "fraction",
+		help: "Width at pressure 1, as a fraction of the stroke width."
+	}),
+	look("width.gamma", {
+		stage: "width",
+		group: "Width",
+		kind: "draw",
+		type: "number",
+		default: 1,
+		min: .2,
+		max: 3,
+		step: .05,
+		help: "Response curve: below 1 reacts faster to light pressure, above 1 needs a firmer press."
+	}),
+	look("width.taperStart", {
+		stage: "width",
+		group: "Width",
+		kind: "draw",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 200,
+		step: 1,
+		unit: "px",
+		help: "Distance over which the start narrows; 0 for none."
+	}),
+	look("width.taperEnd", {
+		stage: "width",
+		group: "Width",
+		kind: "draw",
+		type: "number",
+		default: 0,
+		min: 0,
+		max: 200,
+		step: 1,
+		unit: "px",
+		help: "Distance over which the end narrows; 0 for none."
+	})
+];
+/** Every tunable setting. */
+const BRUSH_TUNABLES = [...BRUSH_PROFILE_TUNABLES, ...BRUSH_LOOK_TUNABLES];
+/** Finds a tunable by scope and key. */
+function getBrushTunable(scope, key) {
+	return BRUSH_TUNABLES.find((t) => t.scope === scope && t.key === key);
+}
+//#endregion
+//#region src/actions/brush-tool/tunables/validate.ts
+/**
+* Checks a value against a descriptor. Returns a message when the value is
+* invalid, or `null` when it is accepted.
+*/
+function validateBrushTunableValue(tunable, value) {
+	const name = `${tunable.scope} setting "${tunable.key}"`;
+	if (value === null || value === void 0) return tunable.nullable ? null : `${name} cannot be empty`;
+	switch (tunable.type) {
+		case "boolean": return typeof value === "boolean" ? null : `${name} must be true or false`;
+		case "enum": return typeof value === "string" && tunable.options?.includes(value) ? null : `${name} must be one of: ${tunable.options?.join(", ")}`;
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) return `${name} must be a finite number`;
+			if (tunable.integer && !Number.isInteger(value)) return `${name} must be a whole number`;
+			if (tunable.min !== void 0 && value < tunable.min) return `${name} must be at least ${tunable.min}`;
+			if (tunable.max !== void 0 && value > tunable.max) return `${name} must be at most ${tunable.max}`;
+			return null;
+	}
+}
+function collectLeaves(obj, prefix = []) {
+	return Object.entries(obj).flatMap(([k, v]) => v !== null && typeof v === "object" && !Array.isArray(v) ? collectLeaves(v, [...prefix, k]) : [{
+		key: [...prefix, k].join("."),
+		value: v
+	}]);
+}
+/**
+* Validates a partial profile or look against the descriptors. Every leaf must
+* name a known setting and hold an accepted value. Returns the messages of all
+* problems found; an empty list means the patch is valid.
+*/
+function validateBrushTunablePatch(scope, patch) {
+	if (patch === null || typeof patch !== "object" || Array.isArray(patch)) return [`A ${scope} change must be an object`];
+	const errors = [];
+	for (const { key, value } of collectLeaves(patch)) {
+		const tunable = getBrushTunable(scope, key);
+		if (!tunable) {
+			errors.push(`Unknown ${scope} setting "${key}"`);
+			continue;
+		}
+		const error = validateBrushTunableValue(tunable, value);
+		if (error) errors.push(error);
+	}
+	return errors;
+}
+//#endregion
+//#region src/actions/brush-tool/tunables/merge.ts
+const isPlain = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** Deep clone of plain data. */
+function cloneData(value) {
+	if (Array.isArray(value)) return value.map(cloneData);
+	if (isPlain(value)) return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneData(v)]));
+	return value;
+}
+/** Returns a new object: `base` with every defined value of `patch` merged in. */
+function mergeData(base, patch) {
+	const result = cloneData(base);
+	if (!isPlain(patch)) return result;
+	for (const [k, v] of Object.entries(patch)) {
+		if (v === void 0) continue;
+		result[k] = isPlain(v) && isPlain(result[k]) ? mergeData(result[k], v) : cloneData(v);
+	}
+	return result;
+}
+/** Freezes plain data recursively. */
+function deepFreeze(value) {
+	if (isPlain(value) || Array.isArray(value)) {
+		for (const v of Object.values(value)) deepFreeze(v);
+		Object.freeze(value);
+	}
+	return value;
+}
+//#endregion
+//#region src/actions/brush-tool/tunables/presets.ts
+const FIXES = {
+	capture: {
+		source: "coalesced",
+		clock: "event"
+	},
+	pressure: { zero: "keep" }
+};
+const withFixes = (patch) => mergeData(FIXES, patch);
+const PEN_SMOOTH = withFixes({
+	pressure: {
+		filter: "oneEuro",
+		oneEuro: {
+			minCutoff: 1.5,
+			beta: .02
+		},
+		start: "average"
+	},
+	stabilizer: {
+		type: "oneEuro",
+		minCutoff: 6,
+		beta: .05,
+		zoomAware: true
+	},
+	finalize: {
+		mode: "bezierFit",
+		toleranceUnit: "screen",
+		tolerance: 2,
+		resampleSpacingPx: 8
+	}
+});
+const PEN_ILLUSTRATOR = withFixes({
+	pressure: {
+		filter: "timeEma",
+		timeConstantMs: 30,
+		start: "average"
+	},
+	stabilizer: {
+		type: "streamline",
+		amount: .25,
+		zoomAware: true
+	},
+	finalize: {
+		mode: "bezierFit",
+		toleranceUnit: "screen",
+		tolerance: 2,
+		resampleSpacingPx: 8
+	}
+});
+const TOUCH_GUARD = withFixes({ touchGuard: {
+	waitMs: 100,
+	movePx: 6,
+	cancelOnSecondTouch: true
+} });
+const legacy = () => ({
+	id: "legacy",
+	label: "Legacy",
+	description: "Behaviour of earlier releases, point for point.",
+	patch: {}
+});
+const fixed = () => ({
+	id: "fixed",
+	label: "Fixed",
+	description: "Keeps every pen sample, uses event time, keeps zero pressure.",
+	patch: FIXES
+});
+const penPresets = () => [
+	legacy(),
+	fixed(),
+	{
+		id: "smooth",
+		label: "Smooth",
+		description: "Fixed, plus One Euro smoothing of pressure and position and a Bézier-fitted finish.",
+		patch: PEN_SMOOTH
+	},
+	{
+		id: "illustrator",
+		label: "Illustrator-like",
+		description: "Fixed, plus streamline stabilizing and a Bézier-fitted finish in screen pixels.",
+		patch: PEN_ILLUSTRATOR
+	}
+];
+const RAW_PROFILE_PRESETS = {
+	mouse: [
+		legacy(),
+		fixed(),
+		{
+			id: "stabilized",
+			label: "Stabilized",
+			description: "Fixed, plus One Euro position smoothing that follows the zoom and a Bézier-fitted finish.",
+			patch: withFixes({
+				stabilizer: {
+					type: "oneEuro",
+					minCutoff: 2,
+					beta: .01,
+					zoomAware: true
+				},
+				finalize: {
+					mode: "bezierFit",
+					toleranceUnit: "screen",
+					tolerance: 2,
+					resampleSpacingPx: 8
+				}
+			})
+		},
+		{
+			id: "pulledString",
+			label: "Pulled string",
+			description: "Fixed, plus a pulled-string stabilizer.",
+			patch: withFixes({ stabilizer: {
+				type: "pulledString",
+				radiusPx: 6,
+				zoomAware: true
+			} })
+		}
+	],
+	touch: [
+		legacy(),
+		fixed(),
+		{
+			id: "guarded",
+			label: "Guarded",
+			description: "Fixed, plus a short wait that a second finger can cancel.",
+			patch: TOUCH_GUARD
+		},
+		{
+			id: "smooth",
+			label: "Smooth",
+			description: "Guarded, plus One Euro position smoothing and a Bézier-fitted finish.",
+			patch: mergeData(TOUCH_GUARD, {
+				stabilizer: {
+					type: "oneEuro",
+					minCutoff: 3,
+					beta: .02,
+					zoomAware: true
+				},
+				finalize: {
+					mode: "bezierFit",
+					toleranceUnit: "screen",
+					tolerance: 2,
+					resampleSpacingPx: 8
+				}
+			})
+		}
+	],
+	"pen.applePencil": penPresets(),
+	"pen.desktop": penPresets()
+};
+const WIDTH_CURVE = { width: {
+	min: .2,
+	gamma: .8
+} };
+const ROUND = {
+	...WIDTH_CURVE,
+	outline: "round",
+	caps: "merged",
+	curve: "centripetal",
+	pressureInterp: "linear",
+	zoomAware: true
+};
+const RAW_LOOK_PRESETS = [
+	{
+		id: "legacy",
+		label: "Legacy",
+		description: "No look is stored: strokes are drawn as in earlier releases.",
+		patch: null
+	},
+	{
+		id: "widthCurve",
+		label: "Width curve",
+		description: "Legacy outline with a minimum width and a pressure curve.",
+		patch: WIDTH_CURVE
+	},
+	{
+		id: "round",
+		label: "Round",
+		description: "Round outline: no spikes at turns, uniform translucent colour.",
+		patch: ROUND
+	},
+	{
+		id: "freehand",
+		label: "Freehand",
+		description: "Freehand outline.",
+		patch: {
+			...WIDTH_CURVE,
+			outline: "freehand",
+			caps: "merged",
+			zoomAware: true
+		}
+	},
+	{
+		id: "illustrator",
+		label: "Illustrator-like",
+		description: "Round outline with a Size ± Variation style width range.",
+		patch: {
+			...ROUND,
+			width: {
+				min: .4,
+				max: 1,
+				gamma: 1
+			}
+		}
+	}
+];
+const RAW_SCENARIOS = [
+	{
+		id: "A",
+		label: "A: legacy",
+		description: "Today's behaviour, identical point for point.",
+		profiles: {
+			mouse: "legacy",
+			touch: "legacy",
+			"pen.applePencil": "legacy",
+			"pen.desktop": "legacy"
+		},
+		look: "legacy"
+	},
+	{
+		id: "B",
+		label: "B: fixes",
+		description: "Every pen sample, event time and zero pressure kept.",
+		profiles: {
+			mouse: "fixed",
+			touch: "fixed",
+			"pen.applePencil": "fixed",
+			"pen.desktop": "fixed"
+		},
+		look: "legacy"
+	},
+	{
+		id: "C",
+		label: "C: smooth",
+		description: "B plus smoothing and a pressure curve.",
+		profiles: {
+			mouse: "stabilized",
+			touch: "smooth",
+			"pen.applePencil": "smooth",
+			"pen.desktop": "smooth"
+		},
+		look: "widthCurve"
+	},
+	{
+		id: "D",
+		label: "D: round",
+		description: "C plus the round outline.",
+		profiles: {
+			mouse: "stabilized",
+			touch: "smooth",
+			"pen.applePencil": "smooth",
+			"pen.desktop": "smooth"
+		},
+		look: "round"
+	},
+	{
+		id: "E",
+		label: "E: freehand",
+		description: "B plus the freehand outline.",
+		profiles: {
+			mouse: "fixed",
+			touch: "fixed",
+			"pen.applePencil": "fixed",
+			"pen.desktop": "fixed"
+		},
+		look: "freehand"
+	},
+	{
+		id: "F",
+		label: "F: Illustrator-like",
+		description: "Bézier-fitted finish, streamline stabilizing and a Size ± Variation width.",
+		profiles: {
+			mouse: "stabilized",
+			touch: "smooth",
+			"pen.applePencil": "illustrator",
+			"pen.desktop": "illustrator"
+		},
+		look: "illustrator"
+	}
+];
+/** Factory profile presets per profile. Read-only. */
+const BRUSH_PROFILE_PRESETS = deepFreeze(RAW_PROFILE_PRESETS);
+/** Factory look presets. Read-only. */
+const BRUSH_LOOK_PRESETS = deepFreeze(RAW_LOOK_PRESETS);
+/** Factory scenarios. Read-only. */
+const BRUSH_SCENARIOS = deepFreeze(RAW_SCENARIOS);
+/** Full profile configuration of a preset: the legacy profile with its patch. */
+function resolveBrushProfilePatch(patch) {
+	return mergeData(BRUSH_LEGACY_INPUT_PROFILE, patch);
+}
+/** Full look of a preset, or `null` when the preset stores no look. */
+function resolveBrushLookPatch(patch) {
+	return patch === null ? null : mergeData(WEAVE_STROKE_LEGACY_LOOK, patch);
+}
+function getBrushScenario(id) {
+	return BRUSH_SCENARIOS.find((s) => s.id === id);
+}
+/**
+* Registry of profile and look presets: the read-only factory presets plus
+* custom ones. Factory presets cannot be changed or removed; a copy under a
+* new name can be made and edited. Custom presets live in memory; the
+* application decides whether to keep them.
+*/
+var WeaveBrushPresetRegistry = class WeaveBrushPresetRegistry {
+	customProfiles = /* @__PURE__ */ new Map();
+	customLooks = /* @__PURE__ */ new Map();
+	static profileKey(key, id) {
+		return `${key}/${id}`;
+	}
+	listProfilePresets(key) {
+		const custom = [...this.customProfiles.entries()].filter(([k]) => k.startsWith(`${key}/`)).map(([, v]) => v);
+		return [...BRUSH_PROFILE_PRESETS[key], ...custom];
+	}
+	getProfilePreset(key, id) {
+		return this.listProfilePresets(key).find((p) => p.id === id);
+	}
+	isFactoryProfilePreset(key, id) {
+		return BRUSH_PROFILE_PRESETS[key].some((p) => p.id === id);
+	}
+	/** Changes a custom profile preset; a factory preset is rejected. */
+	setProfilePreset(key, id, patch) {
+		if (this.isFactoryProfilePreset(key, id)) return {
+			ok: false,
+			error: `"${id}" is a factory preset and cannot be changed; copy it first`
+		};
+		const existing = this.customProfiles.get(WeaveBrushPresetRegistry.profileKey(key, id));
+		if (!existing) return {
+			ok: false,
+			error: `Unknown preset "${id}"`
+		};
+		this.customProfiles.set(WeaveBrushPresetRegistry.profileKey(key, id), {
+			...existing,
+			patch: mergeData(existing.patch, patch)
+		});
+		return { ok: true };
+	}
+	/** Copies a preset under a new id. */
+	copyProfilePreset(key, fromId, newId, label = newId) {
+		const from = this.getProfilePreset(key, fromId);
+		if (!from) return {
+			ok: false,
+			error: `Unknown preset "${fromId}"`
+		};
+		if (this.getProfilePreset(key, newId)) return {
+			ok: false,
+			error: `A preset "${newId}" already exists`
+		};
+		this.customProfiles.set(WeaveBrushPresetRegistry.profileKey(key, newId), {
+			id: newId,
+			label,
+			description: `Copy of ${from.label}`,
+			patch: mergeData(from.patch, {})
+		});
+		return { ok: true };
+	}
+	removeProfilePreset(key, id) {
+		if (this.isFactoryProfilePreset(key, id)) return {
+			ok: false,
+			error: `"${id}" is a factory preset and cannot be removed`
+		};
+		return this.customProfiles.delete(WeaveBrushPresetRegistry.profileKey(key, id)) ? { ok: true } : {
+			ok: false,
+			error: `Unknown preset "${id}"`
+		};
+	}
+	listLookPresets() {
+		return [...BRUSH_LOOK_PRESETS, ...this.customLooks.values()];
+	}
+	getLookPreset(id) {
+		return this.listLookPresets().find((p) => p.id === id);
+	}
+	isFactoryLookPreset(id) {
+		return BRUSH_LOOK_PRESETS.some((p) => p.id === id);
+	}
+	/** Changes a custom look preset; a factory preset is rejected. */
+	setLookPreset(id, patch) {
+		if (this.isFactoryLookPreset(id)) return {
+			ok: false,
+			error: `"${id}" is a factory preset and cannot be changed; copy it first`
+		};
+		const existing = this.customLooks.get(id);
+		if (!existing) return {
+			ok: false,
+			error: `Unknown preset "${id}"`
+		};
+		this.customLooks.set(id, {
+			...existing,
+			patch: mergeData(existing.patch ?? {}, patch)
+		});
+		return { ok: true };
+	}
+	copyLookPreset(fromId, newId, label = newId) {
+		const from = this.getLookPreset(fromId);
+		if (!from) return {
+			ok: false,
+			error: `Unknown preset "${fromId}"`
+		};
+		if (this.getLookPreset(newId)) return {
+			ok: false,
+			error: `A preset "${newId}" already exists`
+		};
+		this.customLooks.set(newId, {
+			id: newId,
+			label,
+			description: `Copy of ${from.label}`,
+			patch: from.patch === null ? null : mergeData(from.patch, {})
+		});
+		return { ok: true };
+	}
+	removeLookPreset(id) {
+		if (this.isFactoryLookPreset(id)) return {
+			ok: false,
+			error: `"${id}" is a factory preset and cannot be removed`
+		};
+		return this.customLooks.delete(id) ? { ok: true } : {
+			ok: false,
+			error: `Unknown preset "${id}"`
+		};
+	}
+};
+//#endregion
+//#region src/actions/brush-tool/tunables/config-io.ts
+/** Version of the exported configuration document. */
+const BRUSH_CONFIG_DOCUMENT_VERSION = 1;
+const isObject$1 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/**
+* Reads and validates a configuration document, given as an object or as JSON
+* text. Nothing is applied: the result holds fully resolved values, or every
+* problem found.
+*/
+function parseBrushConfigDocument(input) {
+	let doc = input;
+	if (typeof input === "string") try {
+		doc = JSON.parse(input);
+	} catch {
+		return {
+			ok: false,
+			errors: ["The document is not valid JSON"]
+		};
+	}
+	if (!isObject$1(doc)) return {
+		ok: false,
+		errors: ["The document must be an object"]
+	};
+	if (doc["version"] !== 1) return {
+		ok: false,
+		errors: [`Unsupported document version "${String(doc["version"])}"; expected 1`]
+	};
+	const errors = [];
+	const profiles = {};
+	if (doc["profiles"] !== void 0) {
+		if (!isObject$1(doc["profiles"])) errors.push("\"profiles\" must be an object");
+		else for (const [key, value] of Object.entries(doc["profiles"])) {
+			if (!BRUSH_INPUT_PROFILE_KEYS.includes(key)) {
+				errors.push(`Unknown profile "${key}"`);
+				continue;
+			}
+			const problems = validateBrushTunablePatch("profile", value);
+			if (problems.length > 0) errors.push(...problems.map((p) => `${key}: ${p}`));
+			else profiles[key] = resolveBrushProfilePatch(value);
+		}
+	}
+	let look;
+	if (doc["look"] !== void 0) {
+		if (doc["look"] === null) look = null;
+		else if (!isObject$1(doc["look"])) errors.push("\"look\" must be an object or null");
+		else {
+			const { version, ...settings } = doc["look"];
+			if (version !== WEAVE_STROKE_LEGACY_LOOK.version) errors.push(`Unsupported look version "${String(version)}"`);
+			else {
+				const problems = validateBrushTunablePatch("look", settings);
+				if (problems.length > 0) errors.push(...problems.map((p) => `look: ${p}`));
+				else look = mergeData(WEAVE_STROKE_LEGACY_LOOK, settings);
+			}
+		}
+	}
+	return errors.length > 0 ? {
+		ok: false,
+		errors
+	} : {
+		ok: true,
+		profiles,
+		look
+	};
+}
+//#endregion
+//#region src/actions/brush-tool/brush-tool.ts
+var WeaveBrushToolAction = class extends WeaveAction {
+	config;
+	initialized = false;
+	state;
+	clickPoint;
+	strokeId;
+	isSpacePressed = false;
+	isEraser;
+	container;
+	measureContainer;
+	cancelAction;
+	prevTouchAction;
+	penActive = false;
+	lastSmoothedPressure = .5;
+	hasPressureSample = false;
+	lastPointerPos = null;
+	lastPointerTime = 0;
+	predictedCount = 0;
+	activeProfile;
+	activeProfileKey = "mouse";
+	look = null;
+	captureState = createCaptureState();
+	pendingTouch = null;
+	/** Preset each profile currently holds: a preset id, `custom` or `imported`. */
+	presetIds = {
+		mouse: "legacy",
+		touch: "legacy",
+		"pen.applePencil": "legacy",
+		"pen.desktop": "legacy"
+	};
+	/** Scenario applied last, until a profile is changed on its own. */
+	scenarioId = null;
+	/** Pointer that is drawing the stroke in progress. */
+	strokePointerId = null;
+	/** A pen has been used since the tool was activated. */
+	penSeen = false;
+	/** Last position the pen reported, before any stabilizing. */
+	lastRawPoint = null;
+	stabilizer;
+	pressureStateView;
+	onPropsChange = void 0;
+	onInit = void 0;
+	constructor(params) {
+		super();
+		this.config = mergeExceptArrays(BRUSH_TOOL_DEFAULT_CONFIG, params?.config ?? {});
+		for (const key of Object.keys(params?.config?.input?.profiles ?? {})) this.presetIds[key] = "custom";
+		this.initialize();
+	}
+	initialize() {
+		this.initialized = false;
+		this.state = BRUSH_TOOL_STATE.INACTIVE;
+		this.strokeId = null;
+		this.clickPoint = null;
+		this.container = void 0;
+		this.isEraser = false;
+		this.measureContainer = void 0;
+		this.props = this.initProps();
+		this.isSpacePressed = false;
+		this.setActiveProfile("mouse");
+	}
+	setActiveProfile(key) {
+		this.activeProfileKey = key;
+		this.activeProfile = this.config.input.profiles[key];
+		this.stabilizer = createStabilizer(this.activeProfile.stabilizer);
+	}
+	/** Key of the profile used by the stroke in progress, or the last one. */
+	getActiveProfileKey() {
+		return this.activeProfileKey;
+	}
+	/** Preset a profile currently holds: a preset id, `custom` or `imported`. */
+	getPresetId(key) {
+		return this.presetIds[key];
+	}
+	/** Scenario applied last, or `null` once a profile was changed on its own. */
+	getScenarioId() {
+		return this.scenarioId;
+	}
+	/**
+	* How a stroke was drawn, recorded on it only while the lab plugin is
+	* active, so ordinary documents carry no such data.
+	*/
+	getInputMeta() {
+		const lab = this.instance.getPlugin(BRUSH_LAB_PLUGIN_NAME);
+		if (!lab || lab.isEnabled?.() === false) return void 0;
+		return {
+			profile: this.activeProfileKey,
+			preset: this.presetIds[this.activeProfileKey],
+			...this.scenarioId ? { scenario: this.scenarioId } : {}
+		};
+	}
+	/** The lab plugin, when it is registered and on; it only listens. */
+	getTraceSink() {
+		const lab = this.instance.getPlugin(BRUSH_LAB_PLUGIN_NAME);
+		if (!lab || lab.isEnabled?.() === false) return null;
+		return typeof lab.onSample === "function" ? lab : null;
+	}
+	/** Current configuration of a profile (a copy). */
+	getInputProfile(key) {
+		return mergeExceptArrays(this.config.input.profiles[key], {});
+	}
+	/**
+	* Changes a profile's configuration. The change applies from the next
+	* stroke: the profile object is replaced, never mutated, so a stroke in
+	* progress keeps the configuration it started with.
+	*/
+	setInputProfile(key, patch) {
+		if (!(key in this.config.input.profiles)) return {
+			applied: false,
+			errors: [`Unknown profile "${key}"`]
+		};
+		const errors = validateBrushTunablePatch("profile", patch);
+		if (errors.length > 0) return {
+			applied: false,
+			errors
+		};
+		this.config.input.profiles[key] = mergeExceptArrays(this.config.input.profiles[key], patch);
+		this.presetIds[key] = "custom";
+		this.scenarioId = null;
+		return {
+			applied: true,
+			errors: []
+		};
+	}
+	/** The profiles and the look as a portable, versioned document. */
+	exportConfig() {
+		return {
+			version: 1,
+			profiles: {
+				mouse: this.getInputProfile("mouse"),
+				touch: this.getInputProfile("touch"),
+				"pen.applePencil": this.getInputProfile("pen.applePencil"),
+				"pen.desktop": this.getInputProfile("pen.desktop")
+			},
+			look: this.getLook()
+		};
+	}
+	/** The configuration as JSON text. */
+	exportConfigJson() {
+		return JSON.stringify(this.exportConfig(), null, 2);
+	}
+	/**
+	* Restores a configuration exported with `exportConfig`, given as an object
+	* or JSON text. A document with an unsupported version or invalid values is
+	* rejected as a whole and nothing changes.
+	*/
+	importConfig(input) {
+		const parsed = parseBrushConfigDocument(input);
+		if (!parsed.ok) return {
+			applied: false,
+			errors: parsed.errors
+		};
+		Object.assign(this.config.input.profiles, parsed.profiles);
+		for (const key of Object.keys(parsed.profiles)) this.presetIds[key] = "imported";
+		this.scenarioId = null;
+		if (parsed.look !== void 0) this.look = parsed.look;
+		return {
+			applied: true,
+			errors: []
+		};
+	}
+	/** Look saved on every new stroke, or `null` when none is saved. */
+	getLook() {
+		return this.look ? mergeData(this.look, {}) : null;
+	}
+	/**
+	* Changes the look saved on new strokes, or clears it with `null` so new
+	* strokes carry no look and are drawn as in earlier releases. Strokes
+	* already drawn keep the look they were saved with.
+	*/
+	setLook(patch) {
+		if (patch === null) {
+			this.look = null;
+			return {
+				applied: true,
+				errors: []
+			};
+		}
+		const errors = validateBrushTunablePatch("look", patch);
+		if (errors.length > 0) return {
+			applied: false,
+			errors
+		};
+		this.look = mergeData(this.look ?? WEAVE_STROKE_LEGACY_LOOK, patch);
+		return {
+			applied: true,
+			errors: []
+		};
+	}
+	/**
+	* Applies a scenario: one preset for each profile and one look preset.
+	* Custom presets are looked up in `registry` when given.
+	*/
+	applyScenario(scenario, registry = new WeaveBrushPresetRegistry()) {
+		const resolved = typeof scenario === "string" ? getBrushScenario(scenario) : scenario;
+		if (!resolved) return {
+			applied: false,
+			errors: [`Unknown scenario "${scenario}"`]
+		};
+		const errors = [];
+		const profiles = {};
+		for (const key of Object.keys(this.config.input.profiles)) {
+			const preset = registry.getProfilePreset(key, resolved.profiles[key]);
+			if (!preset) {
+				errors.push(`Unknown preset "${resolved.profiles[key]}" for profile "${key}"`);
+				continue;
+			}
+			profiles[key] = resolveBrushProfilePatch(preset.patch);
+		}
+		const lookPreset = registry.getLookPreset(resolved.look);
+		if (!lookPreset) errors.push(`Unknown look preset "${resolved.look}"`);
+		if (errors.length > 0 || !lookPreset) return {
+			applied: false,
+			errors
+		};
+		Object.assign(this.config.input.profiles, profiles);
+		this.presetIds = { ...resolved.profiles };
+		this.scenarioId = resolved.id;
+		this.look = resolveBrushLookPatch(lookPreset.patch);
+		return {
+			applied: true,
+			errors: []
+		};
+	}
+	/** Forces a profile for every stroke, or `null` to resolve automatically. */
+	setForcedProfile(key) {
+		this.config.input.forceProfile = key;
+	}
+	/** Replaces the automatic profile resolution; `undefined` restores it. */
+	setProfileResolver(resolver) {
+		this.config.input.resolveProfile = resolver;
+	}
+	/**
+	* The pressure-smoothing state, as a view over this action's own fields so
+	* the stage functions mutate the same state the action exposes.
+	*/
+	get pressureState() {
+		if (!this.pressureStateView) {
+			const self = this;
+			this.pressureStateView = {
+				get lastSmoothedPressure() {
+					return self.lastSmoothedPressure;
+				},
+				set lastSmoothedPressure(v) {
+					self.lastSmoothedPressure = v;
+				},
+				get hasPressureSample() {
+					return self.hasPressureSample;
+				},
+				set hasPressureSample(v) {
+					self.hasPressureSample = v;
+				},
+				get lastPointerPos() {
+					return self.lastPointerPos;
+				},
+				set lastPointerPos(v) {
+					self.lastPointerPos = v;
+				},
+				get lastPointerTime() {
+					return self.lastPointerTime;
+				},
+				set lastPointerTime(v) {
+					self.lastPointerTime = v;
+				},
+				get predictedCount() {
+					return self.predictedCount;
+				},
+				set predictedCount(v) {
+					self.predictedCount = v;
+				},
+				lastDerivative: 0,
+				lastNonZeroPressure: null
+			};
+		}
+		return this.pressureStateView;
+	}
+	getName() {
+		return BRUSH_TOOL_ACTION_NAME;
+	}
+	initProps() {
+		return {
+			stroke: "#000000ff",
+			strokeWidth: 1,
+			opacity: 1
+		};
+	}
+	/**
+	* Smooths one raw pressure sample with the filter of the active profile.
+	*
+	* This is the one place pressure smoothing happens: every sample that
+	* becomes a stroke point, including the high-frequency coalesced samples a
+	* stylus reports, goes through it so the smoothing state advances for later
+	* samples.
+	*/
+	smoothPressureSample(raw, clientX, clientY, time) {
+		return smoothPressure(this.pressureState, this.activeProfile.pressure, raw, clientX, clientY, this.sampleTime(time));
+	}
+	/**
+	* Time of a sample, in ms. With the `event` clock it is the time the sample's
+	* own event reported, so processing a batch in one step does not change the
+	* time between its samples; otherwise (or when the event reports no usable
+	* time) it is the time of processing.
+	*/
+	sampleTime(eventTime) {
+		if (this.activeProfile.capture.clock === "event" && typeof eventTime === "number" && Number.isFinite(eventTime)) return eventTime;
+		return performance.now();
+	}
+	/**
+	* Raw pressure a pointer sample reports: the device's own reading for a
+	* pen, a neutral constant for devices that do not sense pressure.
+	*/
+	getRawPressure(pointerType, pressure, commit = true) {
+		return getRawPressure(pointerType, pressure, this.activeProfile.pressure.zero, this.pressureState, commit);
+	}
+	getEventPressure(e) {
+		return this.smoothPressureSample(this.getRawPressure(e.evt.pointerType, e.evt.pressure), e.evt.clientX, e.evt.clientY, e.evt.timeStamp);
+	}
+	/**
+	* Resets the stroke-scoped state (pressure smoothing, predicted-point
+	* bookkeeping and the position stabilizer) to a neutral baseline.
+	*
+	* This state belongs to a single stroke: it must be reset before the first
+	* pressure sample of a new stroke is computed (in `handlePointerDown`, ahead
+	* of the `getEventPressure` call for point 0), not only afterwards -
+	* otherwise that first sample can inherit state left behind by the previous
+	* stroke, inflating the very first point's pressure.
+	*/
+	resetPressureSmoothingState() {
+		resetPressureState(this.pressureState);
+		this.captureState = createCaptureState();
+		this.lastRawPoint = null;
+		this.stabilizer.reset();
+	}
+	/**
+	* Maps a client position to the stroke container the same way the stage maps
+	* its own pointer position (content rectangle, then the inverse of the
+	* container's absolute transform), without changing any stage state.
+	*/
+	clientToContainer(clientX, clientY) {
+		const content = this.instance.getStage().getContent();
+		const rect = content.getBoundingClientRect();
+		const scaleX = rect.width / content.clientWidth || 1;
+		const scaleY = rect.height / content.clientHeight || 1;
+		const transform = this.measureContainer.getAbsoluteTransform().copy();
+		transform.invert();
+		return transform.point({
+			x: (clientX - rect.left) / scaleX,
+			y: (clientY - rect.top) / scaleY
+		});
+	}
+	/** Captures the samples of one pointer move into the stroke in progress. */
+	handleMoveEvent(e) {
+		const deps = {
+			smooth: (raw, clientX, clientY, time) => this.smoothPressureSample(raw, clientX, clientY, time),
+			rawPressure: (pointerType, pressure, commit) => this.getRawPressure(pointerType, pressure, commit),
+			predictedPressure: (raw) => peekPredictedPressure(this.pressureState, this.activeProfile.pressure, raw)
+		};
+		if (this.activeProfile.capture.source === "coalesced") this.applyMovementSamples(captureCoalescedSamples(e.evt, {
+			...deps,
+			toContainerPoint: (clientX, clientY) => this.clientToContainer(clientX, clientY)
+		}, this.activeProfile.capture, this.captureState));
+		else {
+			const samples = captureLegacySamples(e.evt, deps);
+			if (samples) this.applyMovementSamples(samples);
+			else {
+				const pointPressure = this.getEventPressure(e);
+				this.handleMovement(pointPressure, void 0, false);
+			}
+		}
+	}
+	setupEvents() {
+		const stage = this.instance.getStage();
+		this.prevTouchAction = stage.container().style.touchAction;
+		stage.container().style.touchAction = "none";
+		window.addEventListener("keyup", (e) => {
+			if (e.code === "Space" && this.instance.getActiveAction() === "brushTool") this.isSpacePressed = false;
+		}, { signal: this.instance.getEventsController().signal });
+		window.addEventListener("keydown", (e) => {
+			if (e.code === "Enter" && this.instance.getActiveAction() === "brushTool") {
+				e.stopPropagation();
+				this.cancelAction();
+				return;
+			}
+			if (e.code === "Space" && this.instance.getActiveAction() === "brushTool") {
+				e.stopPropagation();
+				this.isSpacePressed = true;
+				return;
+			}
+			if (e.code === "Escape" && this.instance.getActiveAction() === "brushTool") {
+				e.stopPropagation();
+				this.cancelAction();
+			}
+		}, { signal: this.instance.getEventsController().signal });
+		const handlePointerDown = (e) => {
+			if (this.state === BRUSH_TOOL_STATE.INACTIVE) return;
+			if (this.pendingTouch && e.evt.pointerType === "touch" && e.evt.pointerId !== this.pendingTouch.pointerId) {
+				if (this.activeProfile.touchGuard.cancelOnSecondTouch) this.cancelPendingTouch();
+				return;
+			}
+			if (this.state !== BRUSH_TOOL_STATE.IDLE) return;
+			if (this.getZoomPlugin()?.isPinching()) return;
+			if (this.isSpacePressed) return;
+			if (e?.evt?.button !== 0) return;
+			if (e.evt.pointerType === "touch" && this.penActive) return;
+			if (e.evt.pointerType === "pen") {
+				this.penActive = true;
+				this.penSeen = true;
+			}
+			this.setActiveProfile(resolveBrushInputProfileKey({
+				pointerType: e.evt.pointerType,
+				platform: detectBrushPlatform(),
+				persistentDeviceId: e.evt.persistentDeviceId
+			}, this.config.input));
+			const guard = this.activeProfile.touchGuard;
+			if (e.evt.pointerType === "touch" && guard.ignoreAfterPen && this.penSeen) return;
+			this.resetPressureSmoothingState();
+			const pointPressure = this.getEventPressure(e);
+			this.strokePointerId = typeof e.evt.pointerId === "number" ? e.evt.pointerId : null;
+			if (e.evt.pointerType === "touch" && (guard.waitMs > 0 || guard.movePx > 0)) {
+				this.startPendingTouch(e, pointPressure);
+				e.evt.stopPropagation();
+				return;
+			}
+			this.handleStartStroke(pointPressure, e.evt.timeStamp);
+			this.captureState.lastClient = {
+				x: e.evt.clientX,
+				y: e.evt.clientY
+			};
+			e.evt.stopPropagation();
+		};
+		stage.on("pointerdown", handlePointerDown);
+		const handlePointerMove = (e) => {
+			if (this.state === BRUSH_TOOL_STATE.INACTIVE) return;
+			this.setCursor();
+			if (this.pendingTouch && this.state === BRUSH_TOOL_STATE.IDLE) {
+				this.handlePendingTouchMove(e);
+				return;
+			}
 			if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
 			if (this.getZoomPlugin()?.isPinching()) return;
+			this.handleMoveEvent(e);
+			e.evt.stopPropagation();
+		};
+		stage.on("pointermove", handlePointerMove);
+		const handlePointerUp = (e) => {
+			this.penActive = false;
+			if (this.pendingTouch && this.state === BRUSH_TOOL_STATE.IDLE) {
+				if (e.evt.pointerId !== this.pendingTouch.pointerId) return;
+				this.commitPendingTouch();
+			}
+			if (this.state !== BRUSH_TOOL_STATE.DEFINE_STROKE) return;
+			if (this.strokePointerId !== null && typeof e.evt.pointerId === "number" && e.evt.pointerId !== this.strokePointerId) return;
 			this.handleEndStroke();
+			this.strokePointerId = null;
 			e.evt.stopPropagation();
 		};
 		stage.on("pointerup", handlePointerUp);
@@ -28696,9 +31377,101 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			height: maxY - minY
 		};
 	}
-	handleStartStroke(pressure) {
+	/** Puts a finger stroke on hold until it is clear it is not a gesture. */
+	startPendingTouch(e, pressure) {
+		const guard = this.activeProfile.touchGuard;
+		const pending = {
+			pointerId: e.evt.pointerId,
+			startClient: {
+				x: e.evt.clientX,
+				y: e.evt.clientY
+			},
+			pressure,
+			time: e.evt.timeStamp,
+			start: this.instance.getMousePointer(),
+			samples: [],
+			timer: null
+		};
+		if (guard.waitMs > 0) pending.timer = setTimeout(() => this.commitPendingTouch(), guard.waitMs);
+		this.pendingTouch = pending;
+	}
+	/** Drops a waiting finger stroke without leaving a mark. */
+	cancelPendingTouch() {
+		if (this.pendingTouch?.timer) clearTimeout(this.pendingTouch.timer);
+		this.pendingTouch = null;
+		this.strokePointerId = null;
+	}
+	/**
+	* Starts the stroke of a waiting finger at the point where it touched down,
+	* then replays the moves that were held back, so the path is not lost.
+	*/
+	commitPendingTouch() {
+		const pending = this.pendingTouch;
+		if (!pending) return;
+		if (pending.timer) clearTimeout(pending.timer);
+		this.pendingTouch = null;
+		if (this.state !== BRUSH_TOOL_STATE.IDLE) return;
+		this.handleStartStroke(pending.pressure, pending.time, pending.start);
+		this.captureState.lastClient = pending.startClient;
+		if (this.activeProfile.capture.source === "coalesced") for (const move of pending.samples) this.handleMoveEvent({ evt: {
+			pointerId: move.pointerId,
+			pointerType: move.pointerType,
+			clientX: move.clientX,
+			clientY: move.clientY,
+			pressure: move.pressure,
+			timeStamp: move.timeStamp,
+			getCoalescedEvents: () => move.coalesced,
+			getPredictedEvents: () => [],
+			stopPropagation: () => void 0
+		} });
+	}
+	/** Holds a move of the waiting finger, and commits once it has moved enough. */
+	handlePendingTouchMove(e) {
+		const pending = this.pendingTouch;
+		if (!pending || e.evt.pointerId !== pending.pointerId) return;
+		const guard = this.activeProfile.touchGuard;
+		if (this.getZoomPlugin()?.isPinching()) {
+			if (guard.cancelOnSecondTouch) this.cancelPendingTouch();
+			return;
+		}
+		const batch = e.evt.getCoalescedEvents ? e.evt.getCoalescedEvents() : [];
+		const source = batch.length > 0 ? batch : [e.evt];
+		pending.samples.push({
+			pointerId: e.evt.pointerId,
+			pointerType: e.evt.pointerType,
+			clientX: e.evt.clientX,
+			clientY: e.evt.clientY,
+			pressure: e.evt.pressure,
+			timeStamp: e.evt.timeStamp,
+			coalesced: source.map((c) => ({
+				pointerType: c.pointerType,
+				pressure: c.pressure,
+				clientX: c.clientX,
+				clientY: c.clientY,
+				timeStamp: c.timeStamp
+			}))
+		});
+		if (guard.movePx > 0 && Math.hypot(e.evt.clientX - pending.startClient.x, e.evt.clientY - pending.startClient.y) >= guard.movePx) this.commitPendingTouch();
+		e.evt.stopPropagation();
+	}
+	handleStartStroke(pressure, time, start) {
 		this.resetPressureSmoothingState();
-		const { mousePoint, container, measureContainer } = this.instance.getMousePointer();
+		const { mousePoint, container, measureContainer } = start ?? this.instance.getMousePointer();
+		if (mousePoint) {
+			const self = this;
+			this.stabilizer.seed(mousePoint, {
+				get now() {
+					return self.sampleTime(time);
+				},
+				get zoom() {
+					return self.instance.getStage().scaleX();
+				}
+			});
+			this.lastRawPoint = {
+				x: mousePoint.x,
+				y: mousePoint.y
+			};
+		}
 		this.clickPoint = mousePoint;
 		this.container = container;
 		this.measureContainer = measureContainer;
@@ -28711,8 +31484,11 @@ var WeaveBrushToolAction = class extends WeaveAction {
 				y: mousePoint.y,
 				pressure
 			});
+			const inputMeta = this.getInputMeta();
 			const node = nodeHandler.create(this.strokeId, {
 				...this.props,
+				...this.look ? { look: this.look } : {},
+				...inputMeta ? { inputMeta } : {},
 				isEraser: this.isEraser,
 				strokeScaleEnabled: true,
 				x: 0,
@@ -28724,6 +31500,14 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			const nodeInstance = nodeHandler.onRender(node.props);
 			this.measureContainer?.add(nodeInstance);
 		}
+		this.getTraceSink()?.onStrokeStart({
+			profile: this.activeProfileKey,
+			preset: this.presetIds[this.activeProfileKey],
+			...this.scenarioId ? { scenario: this.scenarioId } : {},
+			profileConfig: this.activeProfile,
+			strokeWidth: this.props.strokeWidth ?? 1,
+			zoom: this.instance.getStage().scaleX()
+		});
 		this.setState(BRUSH_TOOL_STATE.DEFINE_STROKE);
 	}
 	/**
@@ -28743,23 +31527,50 @@ var WeaveBrushToolAction = class extends WeaveAction {
 		const stage = this.instance.getStage();
 		const tempStroke = stage.findOne(`#${this.strokeId}`);
 		if (!this.measureContainer || !tempStroke) return;
+		const sink = this.getTraceSink();
+		const batchStart = sink ? performance.now() : 0;
 		let newStrokeElements = [...tempStroke.getAttrs().strokeElements];
+		const skipPredicted = this.activeProfile.stabilizer.type !== "none";
 		for (const sample of samples) {
+			if (sample.isPredicted && skipPredicted) continue;
 			if (sample.sourceEvent) stage.setPointersPositions(sample.sourceEvent);
-			const { mousePoint } = this.instance.getMousePointerRelativeToContainer(this.measureContainer);
+			const mousePoint = sample.point ?? this.instance.getMousePointerRelativeToContainer(this.measureContainer).mousePoint;
+			if (!sample.isPredicted) this.lastRawPoint = {
+				x: mousePoint.x,
+				y: mousePoint.y
+			};
+			const sampleTime = () => this.sampleTime(sample.time);
+			const stabilized = this.stabilizer.apply(mousePoint, {
+				get now() {
+					return sampleTime();
+				},
+				get zoom() {
+					return stage.scaleX();
+				}
+			});
+			sink?.onSample({
+				raw: {
+					x: mousePoint.x,
+					y: mousePoint.y
+				},
+				stabilized: {
+					x: stabilized.x,
+					y: stabilized.y
+				},
+				pressure: sample.pressure,
+				time: sampleTime(),
+				predicted: sample.isPredicted
+			});
 			const currentPoint = {
-				x: mousePoint.x - tempStroke.x(),
-				y: mousePoint.y - tempStroke.y(),
+				x: stabilized.x - tempStroke.x(),
+				y: stabilized.y - tempStroke.y(),
 				pressure: sample.pressure
 			};
 			if (!sample.isPredicted && this.predictedCount > 0) {
 				newStrokeElements = newStrokeElements.slice(0, -1 * this.predictedCount);
 				this.predictedCount = 0;
 			}
-			if (!sample.isPredicted && newStrokeElements.length === 1) newStrokeElements[0] = {
-				...newStrokeElements[0],
-				pressure: currentPoint.pressure
-			};
+			applyStartPolicy(newStrokeElements, currentPoint, sample.isPredicted, this.activeProfile.pressure);
 			newStrokeElements.push(currentPoint);
 			if (sample.isPredicted) this.predictedCount++;
 		}
@@ -28773,6 +31584,10 @@ var WeaveBrushToolAction = class extends WeaveAction {
 		});
 		const nodeHandler = this.instance.getNodeHandler("stroke");
 		if (nodeHandler) nodeHandler.onUpdate(tempStroke, tempStroke.getAttrs());
+		sink?.onBatch({
+			ms: performance.now() - batchStart,
+			samples: samples.length
+		});
 	}
 	handleMovement(pressure, predictedEvent, isPredicted = false) {
 		this.applyMovementSamples([{
@@ -28781,26 +31596,60 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			isPredicted
 		}]);
 	}
+	/**
+	* The point that completes a stabilized stroke at the pen's last position,
+	* or `null` when the stroke already ends there or has no stabilizer.
+	*/
+	getStrokeCompletion(elements, tempStroke) {
+		const cfg = this.activeProfile.stabilizer;
+		if (cfg.type === "none" || !cfg.catchUpOnEnd) return null;
+		if (!this.lastRawPoint || elements.length === 0) return null;
+		const last = elements[elements.length - 1];
+		const x = this.lastRawPoint.x - tempStroke.x();
+		const y = this.lastRawPoint.y - tempStroke.y();
+		if (x === last.x && y === last.y) return null;
+		return {
+			x,
+			y,
+			pressure: last.pressure
+		};
+	}
 	finalizeStroke(tempStroke, nodeHandler) {
-		const box = this.getBoundingBox(tempStroke.getAttrs().strokeElements);
+		let box = this.getBoundingBox(tempStroke.getAttrs().strokeElements);
 		let newStrokeElements = [...tempStroke.getAttrs().strokeElements];
 		if (this.predictedCount > 0) {
 			newStrokeElements = newStrokeElements.slice(0, -1 * this.predictedCount);
 			this.predictedCount = 0;
 		}
-		if (newStrokeElements.length >= 2) {
-			const lastIndex = newStrokeElements.length - 1;
-			newStrokeElements[lastIndex] = {
-				...newStrokeElements[lastIndex],
-				pressure: newStrokeElements[lastIndex - 1].pressure
-			};
+		const completion = this.getStrokeCompletion(newStrokeElements, tempStroke);
+		if (completion) {
+			newStrokeElements = [...newStrokeElements, completion];
+			box = this.getBoundingBox([...tempStroke.getAttrs().strokeElements, completion]);
 		}
+		newStrokeElements = applyEndPolicy(newStrokeElements, this.activeProfile.pressure);
 		newStrokeElements = newStrokeElements.map((point) => ({
 			...point,
 			x: point.x - box.x,
 			y: point.y - box.y
 		}));
-		const compressedPoints = simplify(newStrokeElements, this.config.simplifyTolerance, true);
+		const finalize = this.activeProfile.finalize;
+		const zoom = finalize.toleranceUnit === "screen" || finalize.mode === "bezierFit" || finalize.mode === "dpPressure" ? this.instance.getStage().scaleX() : 1;
+		const finalizeStart = performance.now();
+		const compressedPoints = finalizePoints(newStrokeElements, finalize, this.config.simplifyTolerance, zoom);
+		this.getTraceSink()?.onStrokeEnd({
+			beforeFinalize: newStrokeElements.map((p) => ({
+				x: p.x + box.x,
+				y: p.y + box.y,
+				pressure: p.pressure
+			})),
+			finalPoints: compressedPoints.map((p) => ({
+				x: p.x + box.x,
+				y: p.y + box.y,
+				pressure: p.pressure
+			})),
+			strokeWidth: tempStroke.getAttrs().strokeWidth ?? 1,
+			finalizeMs: performance.now() - finalizeStart
+		});
 		const sw = tempStroke.getAttrs().strokeWidth ?? 1;
 		const finalWidth = Math.max(box.width, sw);
 		const finalHeight = Math.max(box.height, sw);
@@ -28873,6 +31722,8 @@ var WeaveBrushToolAction = class extends WeaveAction {
 		stage.container().focus();
 		this.cancelAction = cancel;
 		if (selectionPlugin) selectionPlugin.setSelectedNodes([]);
+		this.cancelPendingTouch();
+		this.penSeen = false;
 		this.props = this.initProps();
 		this.setState(BRUSH_TOOL_STATE.IDLE);
 		this.instance.emitEvent("onAddingBrush");
@@ -28893,6 +31744,7 @@ var WeaveBrushToolAction = class extends WeaveAction {
 			if (node) selectionPlugin.setSelectedNodes([node]);
 			this.instance.triggerAction(SELECTION_TOOL_ACTION_NAME);
 		}
+		this.cancelPendingTouch();
 		this.clickPoint = null;
 		this.setState(BRUSH_TOOL_STATE.INACTIVE);
 	}
@@ -37544,6 +40396,6 @@ var WeaveNodesSnappingPlugin = class extends WeavePlugin {
 	}
 };
 //#endregion
-export { ALIGN_NODES_ALIGN_TO, ALIGN_NODES_TOOL_ACTION_NAME, ALIGN_NODES_TOOL_STATE, BRUSH_TOOL_ACTION_NAME, BRUSH_TOOL_DEFAULT_CONFIG, BRUSH_TOOL_STATE, CONNECTOR_TOOL_ACTION_NAME, CONNECTOR_TOOL_DEFAULT_CONFIG, CONNECTOR_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, DEFAULT_GUIDE_TOOL_ACTION_CONFIG, DEFAULT_SNAPPING_MANAGER_CONFIG, ELLIPSE_TOOL_ACTION_NAME, ELLIPSE_TOOL_STATE, ERASER_TOOL_ACTION_NAME, ERASER_TOOL_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_DISTANCE_NAME, GUIDE_DISTANCE_ORIGIN, GUIDE_KIND, GUIDE_NAME, GUIDE_ORIENTATION, GUIDE_STATE, GUIDE_TOOL_ACTION_NAME, GUIDE_TOOL_STATE, LINE_TOOL_ACTION_NAME, LINE_TOOL_DEFAULT_CONFIG, LINE_TOOL_STATE, MEASURE_TOOL_ACTION_NAME, MEASURE_TOOL_STATE, MOVE_ORIENTATION, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, PEN_TOOL_ACTION_NAME, PEN_TOOL_STATE, POLYGON_TOOL_ACTION_NAME, POLYGON_TOOL_STATE, PREVIEW_HANDOVER_MAX_FRAMES, PREVIEW_ID_SUFFIX, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, REGULAR_POLYGON_TOOL_ACTION_NAME, REGULAR_POLYGON_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, STAGE_MINIMAP_DEFAULT_CONFIG, STAR_TOOL_ACTION_NAME, STAR_TOOL_STATE, TEXT_LAYOUT, TEXT_TOOL_ACTION_NAME, TEXT_TOOL_STATE, TextLayoutEngine, VIDEO_TOOL_ACTION_NAME, VIDEO_TOOL_STATE, WEAVE_ARROW_NODE_TYPE, WEAVE_ARROW_TOOL_ACTION_NAME, WEAVE_ARROW_TOOL_STATE, WEAVE_COMMENTS_RENDERER_KEY, WEAVE_COMMENTS_TOOL_LAYER_ID, WEAVE_COMMENT_CREATE_ACTION, WEAVE_COMMENT_NODE_ACTION, WEAVE_COMMENT_NODE_DEFAULTS, WEAVE_COMMENT_NODE_TYPE, WEAVE_COMMENT_STATUS, WEAVE_COMMENT_TOOL_ACTION_NAME, WEAVE_COMMENT_TOOL_DEFAULT_CONFIG, WEAVE_COMMENT_TOOL_STATE, WEAVE_COMMENT_VIEW_ACTION, WEAVE_CONNECTOR_NODE_ANCHOR_ORIGIN, WEAVE_CONNECTOR_NODE_DECORATOR_TYPE, WEAVE_CONNECTOR_NODE_DEFAULT_CONFIG, WEAVE_CONNECTOR_NODE_LINE_ORIGIN, WEAVE_CONNECTOR_NODE_LINE_TYPE, WEAVE_CONNECTOR_NODE_TYPE, WEAVE_COPY_PASTE_CONFIG_DEFAULT, WEAVE_COPY_PASTE_NODES_KEY, WEAVE_COPY_PASTE_PASTE_CATCHER_ID, WEAVE_COPY_PASTE_PASTE_MODES, WEAVE_DEFAULT_USER_INFO_FUNCTION, WEAVE_ELLIPSE_NODE_TYPE, WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR, WEAVE_FRAME_NODE_DEFAULT_CONFIG, WEAVE_FRAME_NODE_DEFAULT_PROPS, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_CONFIG, WEAVE_GRID_DOT_TYPES, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_GROUP_NODE_TYPE, WEAVE_IMAGES_TOOL_ACTION_NAME, WEAVE_IMAGES_TOOL_DEFAULT_CONFIG, WEAVE_IMAGES_TOOL_STATE, WEAVE_IMAGES_TOOL_UPLOAD_TYPE, WEAVE_IMAGE_CROP_ANCHOR_POSITION, WEAVE_IMAGE_CROP_END_TYPE, WEAVE_IMAGE_DEFAULT_CONFIG, WEAVE_IMAGE_NODE_TYPE, WEAVE_IMAGE_TOOL_ACTION_NAME, WEAVE_IMAGE_TOOL_CONFIG_DEFAULT, WEAVE_IMAGE_TOOL_STATE, WEAVE_IMAGE_TOOL_UPLOAD_TYPE, WEAVE_LAYER_NODE_TYPE, WEAVE_LINE_NODE_DEFAULT_CONFIG, WEAVE_LINE_NODE_TYPE, WEAVE_MEASURE_NODE_DEFAULT_CONFIG, WEAVE_MEASURE_NODE_TYPE, WEAVE_MEASURE_TOOL_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_KEY, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_LAYER_ID, WEAVE_NODES_SELECTION_DEFAULT_CONFIG, WEAVE_NODES_SELECTION_KEY, WEAVE_NODES_SELECTION_LAYER_ID, WEAVE_NODES_SNAPPING_PLUGIN_KEY, WEAVE_POLYGON_NODE_TYPE, WEAVE_POLYGON_PRESETS, WEAVE_RECTANGLE_NODE_TYPE, WEAVE_REGULAR_POLYGON_NODE_TYPE, WEAVE_SHAPE_LABEL_DEFAULTS, WEAVE_STAGE_DEFAULT_MODE, WEAVE_STAGE_DROP_AREA_KEY, WEAVE_STAGE_GRID_PLUGIN_KEY, WEAVE_STAGE_IMAGE_CROPPING_MODE, WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG, WEAVE_STAGE_KEYBOARD_MOVE_KEY, WEAVE_STAGE_KEYBOARD_MOVE_ORIENTATION, WEAVE_STAGE_MINIMAP_KEY, WEAVE_STAGE_NODE_TYPE, WEAVE_STAGE_PANNING_DEFAULT_CONFIG, WEAVE_STAGE_PANNING_KEY, WEAVE_STAGE_PANNING_THROTTLE_MS, WEAVE_STAGE_SHAPE_LABEL_EDITION_MODE, WEAVE_STAGE_TEXT_EDITION_MODE, WEAVE_STAGE_ZOOM_DEFAULT_CONFIG, WEAVE_STAGE_ZOOM_KEY, WEAVE_STAGE_ZOOM_TYPE, WEAVE_STAR_NODE_TYPE, WEAVE_STROKE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_NODE_TYPE, WEAVE_STROKE_SINGLE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_SINGLE_NODE_TIP_SIDE, WEAVE_STROKE_SINGLE_NODE_TIP_TYPE, WEAVE_STROKE_SINGLE_NODE_TYPE, WEAVE_STROKE_TOOL_ACTION_NAME, WEAVE_STROKE_TOOL_ACTION_NAME_ALIASES, WEAVE_STROKE_TOOL_DEFAULT_CONFIG, WEAVE_STROKE_TOOL_STATE, WEAVE_TEXT_LINK_ALLOWED_PROTOCOLS, WEAVE_TEXT_NODE_DEFAULT_CONFIG, WEAVE_TEXT_NODE_TYPE, WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS, WEAVE_USERS_POINTERS_KEY, WEAVE_USERS_PRESENCE_CONFIG_DEFAULT_PROPS, WEAVE_USERS_PRESENCE_PLUGIN_KEY, WEAVE_USERS_SELECTION_KEY, WEAVE_USER_POINTER_KEY, WEAVE_USER_PRESENCE_KEY, WEAVE_USER_SELECTION_KEY, WEAVE_VIDEO_DEFAULT_CONFIG, WEAVE_VIDEO_NODE_TYPE, Weave, WeaveAction, WeaveAlignNodesToolAction, WeaveArrowNode, WeaveArrowToolAction, WeaveBrushToolAction, WeaveCommentNode, WeaveCommentToolAction, WeaveCommentsRendererPlugin, WeaveConnectedUsersPlugin, WeaveConnectorNode, WeaveConnectorToolAction, WeaveContextMenuPlugin, WeaveCopyPasteNodesPlugin, WeaveEllipseNode, WeaveEllipseToolAction, WeaveEraserToolAction, WeaveExportNodesToolAction, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToSelectionToolAction, WeaveFrameNode, WeaveFrameToolAction, WeaveGroupNode, WeaveGuideToolAction, WeaveImageNode, WeaveImageToolAction, WeaveImagesToolAction, WeaveLayerNode, WeaveLineNode, WeaveLineToolAction, WeaveMeasureNode, WeaveMeasureToolAction, WeaveMoveToolAction, WeaveNode, WeaveNodesMultiSelectionFeedbackPlugin, WeaveNodesSelectionPlugin, WeaveNodesSnappingPlugin, WeavePenToolAction, WeavePlugin, WeavePolygonNode, WeavePolygonToolAction, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRegularPolygonNode, WeaveRegularPolygonToolAction, WeaveRenderer, WeaveSelectionToolAction, WeaveStageDropAreaPlugin, WeaveStageGridPlugin, WeaveStageKeyboardMovePlugin, WeaveStageMinimapPlugin, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomPlugin, WeaveStarNode, WeaveStarToolAction, WeaveStateManipulation, WeaveStore, WeaveStrokeNode, WeaveStrokeSingleNode, WeaveStrokeToolAction, WeaveTextNode, WeaveTextToolAction, WeaveTextV2Node, WeaveTextV2Shape, WeaveUsersPointersPlugin, WeaveUsersPresencePlugin, WeaveUsersSelectionPlugin, WeaveVideoNode, WeaveVideoToolAction, WeaveZoomInToolAction, WeaveZoomOutToolAction, applyLabelBlocksState, buildAncestorGroupIds, canComposite, clearContainerTargets, computeEllipseLabelMinSize, computePolygonLabelMinSize, computeRectangleLabelMinSize, containerOverCursor, containsNodeDeep, defaultInitialState, downscaleImageFile, downscaleImageFromURL, getBoundingBox, getDownscaleRatio, getExportBoundingBox, getImageSizeFromFile, getJSONFromYjsBinary, getSelectedNodesMetadata, getShapeLabelSchemaFields, getStageClickPoint, getTargetAndSkipNodes, getTargetedNode, getTopmostShadowHost, getVisibleNodes, getVisibleNodesInViewport, hasFrames, hasImages, instantiatePreset, intersectArrays, isArray, isIOS, isInShadowDOM, isNodeInSelection, isNumber, isObject, isServer, labelId, loadImageSource, mapJsonToYjsArray, mapJsonToYjsElements, mapJsonToYjsMap, memoize, mergeExceptArrays, moveNodeToContainer, moveNodeToContainerNT, resetScale, resolveLabelBlocks, setupCanvasBackend, setupSkiaBackend, sleep, spreadLabelProps, weavejsToYjsBinary };
+export { ALIGN_NODES_ALIGN_TO, ALIGN_NODES_TOOL_ACTION_NAME, ALIGN_NODES_TOOL_STATE, BRUSH_CONFIG_DOCUMENT_VERSION, BRUSH_INPUT_PROFILE_KEYS, BRUSH_LAB_PLUGIN_NAME, BRUSH_LEGACY_INPUT_PROFILE, BRUSH_LOOK_PRESETS, BRUSH_LOOK_TUNABLES, BRUSH_PROFILE_PRESETS, BRUSH_PROFILE_TUNABLES, BRUSH_SCENARIOS, BRUSH_TOOL_ACTION_NAME, BRUSH_TOOL_DEFAULT_CONFIG, BRUSH_TOOL_STATE, BRUSH_TUNABLES, CONNECTOR_TOOL_ACTION_NAME, CONNECTOR_TOOL_DEFAULT_CONFIG, CONNECTOR_TOOL_STATE, COPY_PASTE_NODES_PLUGIN_STATE, DEFAULT_GUIDE_TOOL_ACTION_CONFIG, DEFAULT_SNAPPING_MANAGER_CONFIG, ELLIPSE_TOOL_ACTION_NAME, ELLIPSE_TOOL_STATE, ERASER_TOOL_ACTION_NAME, ERASER_TOOL_STATE, FRAME_TOOL_ACTION_NAME, FRAME_TOOL_STATE, GUIDE_DISTANCE_NAME, GUIDE_DISTANCE_ORIGIN, GUIDE_KIND, GUIDE_NAME, GUIDE_ORIENTATION, GUIDE_STATE, GUIDE_TOOL_ACTION_NAME, GUIDE_TOOL_STATE, LINE_TOOL_ACTION_NAME, LINE_TOOL_DEFAULT_CONFIG, LINE_TOOL_STATE, MEASURE_TOOL_ACTION_NAME, MEASURE_TOOL_STATE, MOVE_ORIENTATION, MOVE_TOOL_ACTION_NAME, MOVE_TOOL_STATE, PEN_TOOL_ACTION_NAME, PEN_TOOL_STATE, POLYGON_TOOL_ACTION_NAME, POLYGON_TOOL_STATE, PREVIEW_HANDOVER_MAX_FRAMES, PREVIEW_ID_SUFFIX, RECTANGLE_TOOL_ACTION_NAME, RECTANGLE_TOOL_STATE, REGULAR_POLYGON_TOOL_ACTION_NAME, REGULAR_POLYGON_TOOL_STATE, SELECTION_TOOL_ACTION_NAME, SELECTION_TOOL_STATE, STAGE_MINIMAP_DEFAULT_CONFIG, STAR_TOOL_ACTION_NAME, STAR_TOOL_STATE, TEXT_LAYOUT, TEXT_TOOL_ACTION_NAME, TEXT_TOOL_STATE, TextLayoutEngine, VIDEO_TOOL_ACTION_NAME, VIDEO_TOOL_STATE, WEAVE_ARROW_NODE_TYPE, WEAVE_ARROW_TOOL_ACTION_NAME, WEAVE_ARROW_TOOL_STATE, WEAVE_COMMENTS_RENDERER_KEY, WEAVE_COMMENTS_TOOL_LAYER_ID, WEAVE_COMMENT_CREATE_ACTION, WEAVE_COMMENT_NODE_ACTION, WEAVE_COMMENT_NODE_DEFAULTS, WEAVE_COMMENT_NODE_TYPE, WEAVE_COMMENT_STATUS, WEAVE_COMMENT_TOOL_ACTION_NAME, WEAVE_COMMENT_TOOL_DEFAULT_CONFIG, WEAVE_COMMENT_TOOL_STATE, WEAVE_COMMENT_VIEW_ACTION, WEAVE_CONNECTOR_NODE_ANCHOR_ORIGIN, WEAVE_CONNECTOR_NODE_DECORATOR_TYPE, WEAVE_CONNECTOR_NODE_DEFAULT_CONFIG, WEAVE_CONNECTOR_NODE_LINE_ORIGIN, WEAVE_CONNECTOR_NODE_LINE_TYPE, WEAVE_CONNECTOR_NODE_TYPE, WEAVE_COPY_PASTE_CONFIG_DEFAULT, WEAVE_COPY_PASTE_NODES_KEY, WEAVE_COPY_PASTE_PASTE_CATCHER_ID, WEAVE_COPY_PASTE_PASTE_MODES, WEAVE_DEFAULT_USER_INFO_FUNCTION, WEAVE_ELLIPSE_NODE_TYPE, WEAVE_FRAME_DEFAULT_BACKGROUND_COLOR, WEAVE_FRAME_NODE_DEFAULT_CONFIG, WEAVE_FRAME_NODE_DEFAULT_PROPS, WEAVE_FRAME_NODE_TYPE, WEAVE_GRID_DEFAULT_CONFIG, WEAVE_GRID_DOT_TYPES, WEAVE_GRID_LAYER_ID, WEAVE_GRID_TYPES, WEAVE_GROUP_NODE_TYPE, WEAVE_IMAGES_TOOL_ACTION_NAME, WEAVE_IMAGES_TOOL_DEFAULT_CONFIG, WEAVE_IMAGES_TOOL_STATE, WEAVE_IMAGES_TOOL_UPLOAD_TYPE, WEAVE_IMAGE_CROP_ANCHOR_POSITION, WEAVE_IMAGE_CROP_END_TYPE, WEAVE_IMAGE_DEFAULT_CONFIG, WEAVE_IMAGE_NODE_TYPE, WEAVE_IMAGE_TOOL_ACTION_NAME, WEAVE_IMAGE_TOOL_CONFIG_DEFAULT, WEAVE_IMAGE_TOOL_STATE, WEAVE_IMAGE_TOOL_UPLOAD_TYPE, WEAVE_LAYER_NODE_TYPE, WEAVE_LINE_NODE_DEFAULT_CONFIG, WEAVE_LINE_NODE_TYPE, WEAVE_MEASURE_NODE_DEFAULT_CONFIG, WEAVE_MEASURE_NODE_TYPE, WEAVE_MEASURE_TOOL_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_DEFAULT_CONFIG, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_KEY, WEAVE_NODES_MULTI_SELECTION_FEEDBACK_PLUGIN_LAYER_ID, WEAVE_NODES_SELECTION_DEFAULT_CONFIG, WEAVE_NODES_SELECTION_KEY, WEAVE_NODES_SELECTION_LAYER_ID, WEAVE_NODES_SNAPPING_PLUGIN_KEY, WEAVE_POLYGON_NODE_TYPE, WEAVE_POLYGON_PRESETS, WEAVE_RECTANGLE_NODE_TYPE, WEAVE_REGULAR_POLYGON_NODE_TYPE, WEAVE_SHAPE_LABEL_DEFAULTS, WEAVE_STAGE_DEFAULT_MODE, WEAVE_STAGE_DROP_AREA_KEY, WEAVE_STAGE_GRID_PLUGIN_KEY, WEAVE_STAGE_IMAGE_CROPPING_MODE, WEAVE_STAGE_KEYBOARD_MOVE_DEFAULT_CONFIG, WEAVE_STAGE_KEYBOARD_MOVE_KEY, WEAVE_STAGE_KEYBOARD_MOVE_ORIENTATION, WEAVE_STAGE_MINIMAP_KEY, WEAVE_STAGE_NODE_TYPE, WEAVE_STAGE_PANNING_DEFAULT_CONFIG, WEAVE_STAGE_PANNING_KEY, WEAVE_STAGE_PANNING_THROTTLE_MS, WEAVE_STAGE_SHAPE_LABEL_EDITION_MODE, WEAVE_STAGE_TEXT_EDITION_MODE, WEAVE_STAGE_ZOOM_DEFAULT_CONFIG, WEAVE_STAGE_ZOOM_KEY, WEAVE_STAGE_ZOOM_TYPE, WEAVE_STAR_NODE_TYPE, WEAVE_STROKE_LEGACY_LOOK, WEAVE_STROKE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_NODE_TYPE, WEAVE_STROKE_SINGLE_NODE_DEFAULT_CONFIG, WEAVE_STROKE_SINGLE_NODE_TIP_SIDE, WEAVE_STROKE_SINGLE_NODE_TIP_TYPE, WEAVE_STROKE_SINGLE_NODE_TYPE, WEAVE_STROKE_TOOL_ACTION_NAME, WEAVE_STROKE_TOOL_ACTION_NAME_ALIASES, WEAVE_STROKE_TOOL_DEFAULT_CONFIG, WEAVE_STROKE_TOOL_STATE, WEAVE_TEXT_LINK_ALLOWED_PROTOCOLS, WEAVE_TEXT_NODE_DEFAULT_CONFIG, WEAVE_TEXT_NODE_TYPE, WEAVE_USERS_POINTERS_CONFIG_DEFAULT_PROPS, WEAVE_USERS_POINTERS_KEY, WEAVE_USERS_PRESENCE_CONFIG_DEFAULT_PROPS, WEAVE_USERS_PRESENCE_PLUGIN_KEY, WEAVE_USERS_SELECTION_KEY, WEAVE_USER_POINTER_KEY, WEAVE_USER_PRESENCE_KEY, WEAVE_USER_SELECTION_KEY, WEAVE_VIDEO_DEFAULT_CONFIG, WEAVE_VIDEO_NODE_TYPE, Weave, WeaveAction, WeaveAlignNodesToolAction, WeaveArrowNode, WeaveArrowToolAction, WeaveBrushPresetRegistry, WeaveBrushToolAction, WeaveCommentNode, WeaveCommentToolAction, WeaveCommentsRendererPlugin, WeaveConnectedUsersPlugin, WeaveConnectorNode, WeaveConnectorToolAction, WeaveContextMenuPlugin, WeaveCopyPasteNodesPlugin, WeaveEllipseNode, WeaveEllipseToolAction, WeaveEraserToolAction, WeaveExportNodesToolAction, WeaveExportStageToolAction, WeaveFitToScreenToolAction, WeaveFitToSelectionToolAction, WeaveFrameNode, WeaveFrameToolAction, WeaveGroupNode, WeaveGuideToolAction, WeaveImageNode, WeaveImageToolAction, WeaveImagesToolAction, WeaveLayerNode, WeaveLineNode, WeaveLineToolAction, WeaveMeasureNode, WeaveMeasureToolAction, WeaveMoveToolAction, WeaveNode, WeaveNodesMultiSelectionFeedbackPlugin, WeaveNodesSelectionPlugin, WeaveNodesSnappingPlugin, WeavePenToolAction, WeavePlugin, WeavePolygonNode, WeavePolygonToolAction, WeaveRectangleNode, WeaveRectangleToolAction, WeaveRegularPolygonNode, WeaveRegularPolygonToolAction, WeaveRenderer, WeaveSelectionToolAction, WeaveStageDropAreaPlugin, WeaveStageGridPlugin, WeaveStageKeyboardMovePlugin, WeaveStageMinimapPlugin, WeaveStageNode, WeaveStagePanningPlugin, WeaveStageResizePlugin, WeaveStageZoomPlugin, WeaveStarNode, WeaveStarToolAction, WeaveStateManipulation, WeaveStore, WeaveStrokeNode, WeaveStrokeSingleNode, WeaveStrokeToolAction, WeaveTextNode, WeaveTextToolAction, WeaveTextV2Node, WeaveTextV2Shape, WeaveUsersPointersPlugin, WeaveUsersPresencePlugin, WeaveUsersSelectionPlugin, WeaveVideoNode, WeaveVideoToolAction, WeaveZoomInToolAction, WeaveZoomOutToolAction, applyLabelBlocksState, automaticBrushProfileKey, buildAncestorGroupIds, canComposite, clearContainerTargets, computeEllipseLabelMinSize, computePolygonLabelMinSize, computeRectangleLabelMinSize, containerOverCursor, containsNodeDeep, defaultInitialState, detectBrushPlatform, downscaleImageFile, downscaleImageFromURL, getBoundingBox, getBrushScenario, getBrushTunable, getDownscaleRatio, getExportBoundingBox, getImageSizeFromFile, getJSONFromYjsBinary, getSelectedNodesMetadata, getShapeLabelSchemaFields, getStageClickPoint, getTargetAndSkipNodes, getTargetedNode, getTopmostShadowHost, getVisibleNodes, getVisibleNodesInViewport, hasFrames, hasImages, instantiatePreset, intersectArrays, isArray, isIOS, isInShadowDOM, isNodeInSelection, isNumber, isObject, isServer, labelId, loadImageSource, mapJsonToYjsArray, mapJsonToYjsElements, mapJsonToYjsMap, memoize, mergeExceptArrays, moveNodeToContainer, moveNodeToContainerNT, parseBrushConfigDocument, resetScale, resolveBrushInputProfileKey, resolveBrushLookPatch, resolveBrushProfilePatch, resolveLabelBlocks, setupCanvasBackend, setupSkiaBackend, sleep, spreadLabelProps, validateBrushTunablePatch, validateBrushTunableValue, weavejsToYjsBinary };
 
 //# sourceMappingURL=types.js.map