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

package/dist/lab.js

@@ -0,0 +1,1438 @@
+import Konva from "konva";
+import { WeavePlugin } from "@inditextech/weave-sdk";
+import simplify from "simplify-js";
+//#region src/actions/brush-tool/constants.ts
+/** Name under which the lab plugin registers itself. */
+const BRUSH_LAB_PLUGIN_NAME = "brushLab";
+/**
+* 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
+	}
+};
+//#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);
+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);
+}
+//#endregion
+//#region src/plugins/brush-lab/constants.ts
+const BRUSH_LAB_LAYER_ID = "brushLabLayer";
+const BRUSH_LAB_METRICS_EVENT = "onBrushLabMetrics";
+/** Strokes kept in memory for ghost comparison. */
+const BRUSH_LAB_DEFAULT_MAX_GHOSTS = 5;
+//#endregion
+//#region src/plugins/brush-lab/device-report.ts
+const WINDOW_MS = 2e3;
+/**
+* Collects what pointer events say about the device. It keeps counters and a
+* short window of event times, nothing else.
+*/
+var DeviceReporter = class {
+	pointerType = null;
+	times = [];
+	samples = 0;
+	events = 0;
+	minPressure = Infinity;
+	maxPressure = -Infinity;
+	tilt = false;
+	predicted = false;
+	penAsMouse = false;
+	resolvedProfile = null;
+	zoom = 1;
+	fps = 0;
+	record(e) {
+		this.pointerType = e.pointerType;
+		this.events++;
+		const coalesced = e.getCoalescedEvents?.().length ?? 0;
+		this.samples += Math.max(coalesced, 1);
+		if (typeof e.getPredictedEvents === "function") this.predicted = true;
+		this.times.push(e.timeStamp);
+		const cutoff = e.timeStamp - WINDOW_MS;
+		while (this.times.length > 1 && this.times[0] < cutoff) this.times.shift();
+		if (e.pointerType === "pen" || e.pointerType === "touch") {
+			this.minPressure = Math.min(this.minPressure, e.pressure);
+			this.maxPressure = Math.max(this.maxPressure, e.pressure);
+		}
+		const tilted = Boolean(e.tiltX) || Boolean(e.tiltY);
+		if (e.pointerType === "pen" && tilted) this.tilt = true;
+		if (e.pointerType === "mouse" && (tilted || e.pressure > 0 && e.pressure !== .5)) this.penAsMouse = true;
+	}
+	setResolvedProfile(key) {
+		this.resolvedProfile = key;
+	}
+	setZoom(zoom) {
+		this.zoom = zoom;
+	}
+	setFps(fps) {
+		this.fps = fps;
+	}
+	report() {
+		const first = this.times[0];
+		const span = this.times[this.times.length - 1] - first;
+		const warnings = [];
+		if (this.penAsMouse) warnings.push("penReportsAsMouse");
+		return {
+			pointerType: this.pointerType,
+			resolvedProfile: this.resolvedProfile,
+			sampleRateHz: this.times.length > 1 && span > 0 ? (this.times.length - 1) / span * 1e3 : 0,
+			samplesPerEvent: this.events ? this.samples / this.events : 0,
+			pressure: Number.isFinite(this.minPressure) ? {
+				min: this.minPressure,
+				max: this.maxPressure
+			} : null,
+			tilt: this.tilt,
+			predictedAvailable: this.predicted,
+			zoom: this.zoom,
+			fps: this.fps,
+			warnings
+		};
+	}
+};
+//#endregion
+//#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 = 5;
+const seconds = (now, last) => (now - last > 0 ? now - last : NOMINAL_SAMPLE_INTERVAL_MS) / 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;
+	}
+};
+/** 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;
+	}
+};
+/**
+* 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;
+	}
+	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 {
+			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
+		};
+	}
+};
+/**
+* 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
+			};
+		}
+		return { ...this.tip };
+	}
+};
+/** 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;
+	}
+	reset() {
+		this.tip = null;
+	}
+	seed(point, ctx) {
+		this.tip = { ...point };
+		this.lastTime = ctx.now;
+	}
+	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
+		};
+		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/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/plugins/brush-lab/ghosts.ts
+/**
+* Draws a recorded gesture again through another brush: the same pointer
+* events, captured, stabilized and finished as that brush would have done.
+* Positions only: width, pressure smoothing and the outline are not replayed.
+*/
+function replayRecording(recording, profile, simplifyTolerance) {
+	const coalesced = profile.capture.source === "coalesced";
+	const minMove = profile.capture.minMovePx;
+	const captured = [];
+	for (const event of recording.gesture.events) {
+		const picked = coalesced ? event.samples : event.samples.slice(-1);
+		for (const point of picked) captured.push({
+			time: point.time ?? event.time,
+			point
+		});
+	}
+	if (captured.length === 0) return [];
+	const kept = captured.filter((c, i) => {
+		if (i === 0 || minMove <= 0) return true;
+		const prev = captured[i - 1].point;
+		return Math.hypot(c.point.x - prev.x, c.point.y - prev.y) * recording.zoom >= minMove;
+	});
+	const stabilizer = createStabilizer(profile.stabilizer);
+	stabilizer.reset();
+	const ctx = (time) => ({
+		now: time,
+		zoom: recording.zoom
+	});
+	stabilizer.seed(kept[0].point, ctx(kept[0].time));
+	const points = kept.map((c) => {
+		const p = stabilizer.apply(c.point, ctx(c.time));
+		return {
+			x: p.x,
+			y: p.y,
+			pressure: c.point.pressure
+		};
+	});
+	const cfg = profile.stabilizer;
+	const lastRaw = kept[kept.length - 1].point;
+	const lastOut = points[points.length - 1];
+	if (cfg.type !== "none" && cfg.catchUpOnEnd && (lastRaw.x !== lastOut.x || lastRaw.y !== lastOut.y)) points.push({
+		x: lastRaw.x,
+		y: lastRaw.y,
+		pressure: lastOut.pressure
+	});
+	return finalizePoints(points, profile.finalize, simplifyTolerance, recording.zoom);
+}
+/** The last `max` recordings; the oldest are dropped. Memory only. */
+var RecordingStore = class {
+	max;
+	items = [];
+	constructor(max) {
+		this.max = max;
+	}
+	setMax(max) {
+		this.max = Math.max(1, Math.floor(max));
+		this.trim();
+	}
+	add(recording) {
+		this.items.push(recording);
+		this.trim();
+	}
+	all() {
+		return [...this.items];
+	}
+	last() {
+		return this.items[this.items.length - 1];
+	}
+	clear() {
+		this.items = [];
+	}
+	get size() {
+		return this.items.length;
+	}
+	trim() {
+		while (this.items.length > this.max) this.items.shift();
+	}
+};
+//#endregion
+//#region src/plugins/brush-lab/recorder.ts
+/**
+* Records the pointer events of one gesture, whatever brush is active: every
+* coalesced sample of every event, with its time. The first pointer that goes
+* down owns the gesture; others are ignored.
+*/
+var GestureRecorder = class {
+	pointerId = null;
+	events = [];
+	begin(e) {
+		if (this.pointerId !== null) return;
+		this.pointerId = e.pointerId;
+		this.events = [{
+			time: e.time,
+			samples: e.samples
+		}];
+	}
+	add(e) {
+		if (e.pointerId !== this.pointerId) return;
+		this.events.push({
+			time: e.time,
+			samples: e.samples
+		});
+	}
+	end(pointerId) {
+		if (pointerId === this.pointerId) this.pointerId = null;
+	}
+	/** A copy of the gesture so far. */
+	snapshot() {
+		return { events: this.events.map((ev) => ({
+			time: ev.time,
+			samples: ev.samples.map((s) => ({ ...s }))
+		})) };
+	}
+};
+//#endregion
+//#region src/plugins/brush-lab/metrics.ts
+const dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+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));
+}
+const mean = (values) => values.length ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+/** Measures a finished stroke from what the brush tool reported. */
+function computeStrokeMetrics(input) {
+	const real = input.samples.filter((s) => !s.predicted);
+	let droppedDuplicates = 0;
+	for (let i = 1; i < real.length; i++) if (dist(real[i].raw, real[i - 1].raw) === 0) droppedDuplicates++;
+	const spanMs = real.length > 1 ? real[real.length - 1].time - real[0].time : 0;
+	const effectiveRateHz = spanMs > 0 ? (real.length - 1) / spanMs * 1e3 : 0;
+	const jitters = [];
+	for (let i = 1; i < real.length - 1; i++) jitters.push(distanceToSegment(real[i].raw, real[i - 1].raw, real[i + 1].raw));
+	const lag = mean(real.map((s) => dist(s.raw, s.stabilized)));
+	let movedOnFinish = 0;
+	if (input.finalPoints.length > 0) for (const p of input.beforeFinalize) {
+		let best = Infinity;
+		if (input.finalPoints.length === 1) best = dist(p, input.finalPoints[0]);
+		else for (let i = 1; i < input.finalPoints.length; i++) best = Math.min(best, distanceToSegment(p, input.finalPoints[i - 1], input.finalPoints[i]));
+		movedOnFinish = Math.max(movedOnFinish, best);
+	}
+	const steps = [];
+	for (let i = 1; i < input.finalPoints.length; i++) steps.push(Math.abs(input.finalPoints[i].pressure - input.finalPoints[i - 1].pressure) * input.strokeWidth);
+	return {
+		samples: real.length,
+		points: input.finalPoints.length,
+		droppedDuplicates,
+		effectiveRateHz,
+		jitter: mean(jitters),
+		lag,
+		movedOnFinish,
+		widthRoughness: mean(steps),
+		drawMs: input.drawMs
+	};
+}
+//#endregion
+//#region src/plugins/brush-lab/brush-lab.ts
+/**
+* Lab for tuning the brush on real devices. It listens to the brush tool and
+* draws overlays on a layer of its own. It never changes the document, and it
+* keeps everything it records in memory only: nothing is stored, sent or
+* written anywhere.
+*/
+var WeaveBrushLabPlugin = class extends WeavePlugin {
+	overlays = {
+		raw: false,
+		stabilized: false,
+		final: false,
+		pressure: false
+	};
+	reporter = new DeviceReporter();
+	recordings = new RecordingStore(5);
+	current = null;
+	last = null;
+	lastMetrics = null;
+	compareScenario = null;
+	recorder = new GestureRecorder();
+	listeners = [];
+	frameHandle = null;
+	constructor(params) {
+		super();
+		if (params?.maxGhosts) this.recordings.setMax(params.maxGhosts);
+		this.initialize();
+	}
+	initialize() {
+		this.enabled = true;
+	}
+	getName() {
+		return BRUSH_LAB_PLUGIN_NAME;
+	}
+	getLayerName() {
+		return BRUSH_LAB_LAYER_ID;
+	}
+	getLayer() {
+		return this.instance?.getStage?.()?.findOne?.(`#${this.getLayerName()}`);
+	}
+	onInit() {
+		this.instance.getStage().add(new Konva.Layer({
+			id: this.getLayerName(),
+			draggable: false,
+			listening: false
+		}));
+		if (this.enabled) this.attach();
+	}
+	onRender() {}
+	enable() {
+		this.enabled = true;
+		this.attach();
+		this.getLayer()?.show();
+	}
+	disable() {
+		this.enabled = false;
+		this.detach();
+		this.getLayer()?.hide();
+	}
+	/** Pointer event position in the stage's drawing coordinates. */
+	toStagePoint(e) {
+		const stage = this.instance.getStage();
+		const rect = stage.container().getBoundingClientRect();
+		return stage.getAbsoluteTransform().copy().invert().point({
+			x: e.clientX - rect.left,
+			y: e.clientY - rect.top
+		});
+	}
+	recorderEvent(e) {
+		const sources = typeof e.getCoalescedEvents === "function" && e.getCoalescedEvents().length > 0 ? e.getCoalescedEvents() : [e];
+		return {
+			pointerId: e.pointerId,
+			time: e.timeStamp,
+			samples: sources.map((c) => ({
+				...this.toStagePoint(c),
+				pressure: c.pressure,
+				time: typeof c.timeStamp === "number" && c.timeStamp > 0 ? c.timeStamp : e.timeStamp
+			}))
+		};
+	}
+	attach() {
+		const container = this.instance?.getStage?.()?.container?.();
+		if (container && this.listeners.length === 0) {
+			const inStage = (e) => typeof e.composedPath === "function" ? e.composedPath().includes(container) : true;
+			const add = (type, fn) => {
+				window.addEventListener(type, fn, {
+					passive: true,
+					capture: true
+				});
+				this.listeners.push([
+					type,
+					fn,
+					true
+				]);
+			};
+			add("pointerdown", (e) => {
+				if (inStage(e)) this.recorder.begin(this.recorderEvent(e));
+			});
+			add("pointermove", (e) => {
+				if (inStage(e)) {
+					this.reporter.record(e);
+					this.reporter.setZoom(this.instance.getStage().scaleX());
+				}
+				this.recorder.add(this.recorderEvent(e));
+			});
+			add("pointerup", (e) => this.recorder.end(e.pointerId));
+			add("pointercancel", (e) => this.recorder.end(e.pointerId));
+		}
+		if (this.frameHandle === null && typeof requestAnimationFrame === "function") this.countFrames();
+	}
+	detach() {
+		for (const [type, fn, capture] of this.listeners) window.removeEventListener(type, fn, { capture });
+		this.listeners = [];
+		if (this.frameHandle !== null && typeof cancelAnimationFrame === "function") cancelAnimationFrame(this.frameHandle);
+		this.frameHandle = null;
+	}
+	countFrames() {
+		let frames = 0;
+		let since = performance.now();
+		const tick = (now) => {
+			frames++;
+			if (now - since >= 1e3) {
+				this.reporter.setFps(frames * 1e3 / (now - since));
+				frames = 0;
+				since = now;
+			}
+			this.frameHandle = requestAnimationFrame(tick);
+		};
+		this.frameHandle = requestAnimationFrame(tick);
+	}
+	getDeviceReport() {
+		return this.reporter.report();
+	}
+	getLastMetrics() {
+		return this.lastMetrics;
+	}
+	getOverlays() {
+		return { ...this.overlays };
+	}
+	getRecordingCount() {
+		return this.recordings.size;
+	}
+	setOverlay(name, on) {
+		this.overlays[name] = on;
+		this.redraw();
+	}
+	setMaxGhosts(max) {
+		this.recordings.setMax(max);
+		this.redraw();
+	}
+	/**
+	* Draws the last stroke again through each named brush (every one when none
+	* are given), so the same handwriting can be compared across them.
+	*/
+	compareLast(scenarioId) {
+		if (!BRUSH_SCENARIOS.some((x) => x.id === scenarioId)) return {
+			lines: 0,
+			reason: `Unknown brush "${scenarioId}"`
+		};
+		this.compareScenario = scenarioId;
+		const recording = this.recordings.last();
+		if (!recording) return {
+			lines: 0,
+			reason: "No stroke recorded yet: draw one first"
+		};
+		const events = recording.gesture.events.length;
+		if (events === 0) return {
+			lines: 0,
+			reason: "The stroke has no pointer events (nothing was recorded)"
+		};
+		this.redraw();
+		const lines = this.getLayer()?.find(".lab-ghost").length ?? 0;
+		return lines > 0 ? {
+			lines,
+			events
+		} : {
+			lines: 0,
+			events,
+			reason: "No brush produced a line"
+		};
+	}
+	/** Forgets every kept stroke and removes the ghosts. */
+	clearGhosts() {
+		this.recordings.clear();
+		this.compareScenario = null;
+		this.redraw();
+	}
+	onStrokeStart(info) {
+		this.reporter.setResolvedProfile(info.profile);
+		this.current = {
+			profileKey: info.profile,
+			preset: info.preset,
+			...info.scenario ? { scenario: info.scenario } : {},
+			profile: info.profileConfig,
+			strokeWidth: info.strokeWidth,
+			zoom: info.zoom,
+			samples: [],
+			batchMs: 0
+		};
+		this.getLayer()?.destroyChildren();
+		this.last = null;
+		this.compareScenario = null;
+	}
+	onSample(sample) {
+		if (!this.current) return;
+		this.current.samples.push(sample);
+		if (sample.predicted) return;
+		const layer = this.getLayer();
+		if (!layer) return;
+		const r = this.markerRadius();
+		if (this.overlays.raw) layer.add(new Konva.Circle({
+			x: sample.raw.x,
+			y: sample.raw.y,
+			radius: r,
+			fill: "#ef4444",
+			name: "lab-raw"
+		}));
+		if (this.overlays.stabilized) layer.add(new Konva.Circle({
+			x: sample.stabilized.x,
+			y: sample.stabilized.y,
+			radius: r,
+			fill: "#2563eb",
+			name: "lab-stabilized"
+		}));
+		layer.batchDraw();
+	}
+	onBatch(info) {
+		if (this.current) this.current.batchMs += info.ms;
+	}
+	onStrokeEnd(info) {
+		const current = this.current;
+		this.current = null;
+		if (!current) return;
+		const measured = computeStrokeMetrics({
+			samples: current.samples,
+			beforeFinalize: info.beforeFinalize,
+			finalPoints: info.finalPoints,
+			strokeWidth: info.strokeWidth,
+			drawMs: current.batchMs + info.finalizeMs
+		});
+		const metrics = {
+			profile: current.profileKey,
+			preset: current.preset,
+			...current.scenario ? { scenario: current.scenario } : {},
+			...measured
+		};
+		this.lastMetrics = metrics;
+		this.recordings.add({
+			profileKey: current.profileKey,
+			gesture: this.recorder.snapshot(),
+			strokeWidth: current.strokeWidth,
+			zoom: current.zoom
+		});
+		this.last = {
+			samples: current.samples,
+			finalPoints: info.finalPoints
+		};
+		this.instance.emitEvent(BRUSH_LAB_METRICS_EVENT, metrics);
+		this.redraw();
+	}
+	markerRadius() {
+		const zoom = this.instance.getStage().scaleX();
+		return 2 / (zoom > 0 ? zoom : 1);
+	}
+	redraw() {
+		const layer = this.getLayer();
+		if (!layer) return;
+		layer.destroyChildren();
+		const r = this.markerRadius();
+		const last = this.last;
+		if (last) {
+			const real = last.samples.filter((s) => !s.predicted);
+			if (this.overlays.raw) for (const s of real) layer.add(new Konva.Circle({
+				x: s.raw.x,
+				y: s.raw.y,
+				radius: r,
+				fill: "#ef4444",
+				name: "lab-raw"
+			}));
+			if (this.overlays.stabilized) for (const s of real) layer.add(new Konva.Circle({
+				x: s.stabilized.x,
+				y: s.stabilized.y,
+				radius: r,
+				fill: "#2563eb",
+				name: "lab-stabilized"
+			}));
+			if (this.overlays.final) for (const p of last.finalPoints) layer.add(new Konva.Circle({
+				x: p.x,
+				y: p.y,
+				radius: r * 1.5,
+				stroke: "#16a34a",
+				strokeWidth: r / 2,
+				name: "lab-final"
+			}));
+			if (this.overlays.pressure && last.finalPoints.length > 1) {
+				const bottom = Math.max(...last.finalPoints.map((p) => p.y)) + 30 * r;
+				const flat = [];
+				for (const p of last.finalPoints) flat.push(p.x, bottom - p.pressure * 20 * r);
+				layer.add(new Konva.Line({
+					points: flat,
+					stroke: "#a855f7",
+					strokeWidth: r,
+					name: "lab-pressure"
+				}));
+			}
+		}
+		const recording = this.recordings.last();
+		if (recording && this.compareScenario) {
+			const scenario = BRUSH_SCENARIOS.find((x) => x.id === this.compareScenario);
+			const preset = scenario ? BRUSH_PROFILE_PRESETS[recording.profileKey].find((p) => p.id === scenario.profiles[recording.profileKey]) : void 0;
+			const toFlat = (pts) => pts.flatMap((p) => [p.x, p.y]);
+			if (this.last && this.last.finalPoints.length > 1) layer.add(new Konva.Line({
+				points: toFlat(this.last.finalPoints),
+				stroke: "#111111",
+				strokeWidth: r * 2.5,
+				lineCap: "round",
+				lineJoin: "round",
+				opacity: .9,
+				name: "lab-actual"
+			}));
+			if (scenario && preset) {
+				const points = replayRecording(recording, resolveBrushProfilePatch(preset.patch), 1);
+				if (points.length >= 2) {
+					layer.add(new Konva.Line({
+						points: toFlat(points),
+						stroke: "#e11d48",
+						strokeWidth: r,
+						lineCap: "round",
+						lineJoin: "round",
+						name: "lab-ghost"
+					}));
+					layer.add(new Konva.Text({
+						x: points[0].x,
+						y: points[0].y - 14 * r,
+						text: `${scenario.label.replace(/^[A-Z]: /, "")} (red) vs drawn (black)`,
+						fontSize: 10 * r,
+						fill: "#e11d48",
+						name: "lab-ghost-label"
+					}));
+				}
+			}
+		}
+		layer.moveToTop();
+		layer.batchDraw();
+	}
+};
+//#endregion
+export { BRUSH_LAB_DEFAULT_MAX_GHOSTS, BRUSH_LAB_LAYER_ID, BRUSH_LAB_METRICS_EVENT, BRUSH_LAB_PLUGIN_NAME, WeaveBrushLabPlugin };
+
+//# sourceMappingURL=lab.js.map