From 576e83ca62cf2310f262a3e6799732a57f1ecfc4 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Wed, 7 Oct 2026 04:14:36 +0300
Subject: [PATCH 1/2] [fix] scrub fields: escape reverts typing, rows refresh
 after undo, one undo step per gesture

37 R26 (QUESTIONS-38-lock Q1-Q3):
- DragRow: Escape after TYPING puts the box text back and ignores the blur's
  change event, so the typed value is no longer re-committed (Q1)
- history: undo/redo poke selectedObject, so the Inspector transform rows show
  the restored values at once (Q2)
- history gestures ($lib/historyGesture.js, a leaf): DragRow opens one per scrub
  and per typing session, SliderRow one per range drag; entries recorded in one
  gesture fold into the stack top in place (per-kind merges for transform,
  transformSet, aibatch, props, anim, animspeed, shadergraph; else a 'gesture'
  composite), and a fold that nets to nothing is dropped (Q3)
- Inspector: the debounced transform seal carries its gesture; render order and
  light values (intensity + LIGHT_PARAMS) record props entries; Animation speed
  records an 'animspeed' entry
- new e2e suite scrub-undo (NOT YET RUN at this commit: queued behind e2e slots)

svelte-check 318/47 = baseline.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/components/editors/AnimationWindow.svelte |   2 +-
 src/components/menu/Inspector.svelte          |  65 +++-
 src/components/ui/DragRow.svelte              |  42 ++-
 src/components/ui/SliderRow.svelte            |  11 +-
 src/lib/animationPreview.js                   |  39 +-
 src/lib/history.js                            | 154 ++++++++
 src/lib/historyGesture.js                     |  37 ++
 src/lib/objectActions.js                      |  27 +-
 src/lib/shaderSync.js                         |  12 +-
 tests/e2e/scrub-undo.test.cjs                 | 337 ++++++++++++++++++
 10 files changed, 698 insertions(+), 28 deletions(-)
 create mode 100644 src/lib/historyGesture.js
 create mode 100644 tests/e2e/scrub-undo.test.cjs

diff --git a/src/components/editors/AnimationWindow.svelte b/src/components/editors/AnimationWindow.svelte
index 929e0164..9e80c8f8 100644
--- a/src/components/editors/AnimationWindow.svelte
+++ b/src/components/editors/AnimationWindow.svelte
@@ -1781,7 +1781,7 @@
 						min={0.1}
 						max={8}
 						value={speed}
-						onchange={(/** @type {number} */ v) => target && setSpeed(target.uuid, v || 1)}
+						onchange={(/** @type {number} */ v) => target && setSpeed(target.uuid, v || 1, { record: true })}
 					/>
 				</label>
 				<label
diff --git a/src/components/menu/Inspector.svelte b/src/components/menu/Inspector.svelte
index 9bbb9611..6c044917 100644
--- a/src/components/menu/Inspector.svelte
+++ b/src/components/menu/Inspector.svelte
@@ -40,6 +40,7 @@
 		setObjectsTexture
 	} from '$lib/materialsHandler';
 	import { recordEntry, beginHistoryBatch, endHistoryBatch, recordTransformSet } from '$lib/history';
+	import { currentHistoryGesture, withHistoryGesture } from '$lib/historyGesture';
 	import { deviceOf, deviceSpec, isDeviceObject, setDeviceFor, previewDeviceParams } from '$lib/audioDevices';
 	import { MUSIC_TOOLBOX_ID, musicToolboxPick } from '$lib/musicToolbox';
 	import { openModuleToolbox, moduleToolboxes } from '$lib/moduleToolboxes';
@@ -1097,17 +1098,34 @@
 	// same one a multi-gizmo drag records, so replay + replication come free.
 	// Typed transforms recorded nothing at all before; with a selection they must,
 	// because setting an absolute value collapses the whole set onto one plane.
+	// 37 R26: the seal also carries the field's history GESTURE (one scrub, or one typing
+	// session — $lib/historyGesture). Typing slower than the 500ms seal records twice, and
+	// the second entry folds into the first; a NEW gesture seals the pending one first, so
+	// two gestures never share an entry.
 	/** @type {Map<string, any>|null} */
 	let xformGestureStart = null;
+	/** @type {object|null} */
+	let xformGestureToken = null;
 	/** @type {any} */
 	let xformGestureTimer;
 	function trackTransformGesture() {
+		const token = currentHistoryGesture();
+		if (xformGestureStart != null && token !== xformGestureToken) {
+			clearTimeout(xformGestureTimer);
+			sealTransformGesture();
+		}
 		if (xformGestureStart == null) {
 			xformGestureStart = new Map();
+			xformGestureToken = token;
 			for (const object of insTargets) xformGestureStart.set(object.uuid, poseOf(object));
 		}
 		clearTimeout(xformGestureTimer);
-		xformGestureTimer = setTimeout(() => {
+		xformGestureTimer = setTimeout(sealTransformGesture, 500);
+	}
+	function sealTransformGesture() {
+		const token = xformGestureToken;
+		xformGestureToken = null;
+		withHistoryGesture(token, () => {
 			const keepOrigin = true; // a hand-placed origin survives the re-seat
 			const befores = xformGestureStart;
 			xformGestureStart = null;
@@ -1135,7 +1153,7 @@
 					keepOrigin
 				);
 			else if (items.length === 1 && originTarget && originSet) reseatPivot(); // 24-E3: the single-object pivot too
-		}, 500);
+		});
 	}
 
 	/**
@@ -1195,6 +1213,21 @@
 		$peers.send({ type: 'object', element: $selectedObject.toJSON(), override: true });
 	}
 
+	/**
+	 * 37 R26: a light's own number (intensity, distance, angle…) — the fields recorded no
+	 * undo at all. One step per scrub/typing session; the props kind's `light` key replays it.
+	 * @param {string} key @param {number} value
+	 */
+	function setLightValue(key, value) {
+		const light = $selectedObject;
+		const before = light[key];
+		light[key] = value;
+		selectedObject.update((s) => s);
+		sendLightUpdate();
+		if (before !== value)
+			recordEntry({ kind: 'props', uuid: light.uuid, before: { light: { [key]: before } }, after: { light: { [key]: value } } });
+	}
+
 	/** Object flag → the whole selection. The checkbox/row has already written the
 	 * PRIMARY (bind:checked), so the rest of the set is set to that same value and
 	 * every member replicates its own message. No history kind covers these flags,
@@ -1310,11 +1343,21 @@
 		$peers.send({ type: 'name', name: $selectedObject.name, uuid: $selectedObject.uuid });
 	}
 
-	/** Object-level property (renderOrder/frustumCulled): local apply + replicate (147) @param {string} parameter @param {any} value */
-	function setObjectParam(parameter, value) {
+	/** Object-level property (renderOrder/frustumCulled): local apply + replicate (147) @param {string} parameter @param {any} value @param {boolean} [record] */
+	function setObjectParam(parameter, value, record = false) {
+		// 37 R26: `record` = an undo step per changed object (the props kind replays
+		// `renderOrder`); one batch for a set, and one step per scrub/typing session
+		/** @type {[any, any][]} */
+		const befores = record ? insTargets.map((/** @type {any} */ o) => [o, o[parameter]]) : [];
 		$selectedObject[parameter] = value;
 		selectedObject.update((v) => v);
 		sendParam(parameter); // fans the value + messages over the selection
+		const changed = befores.filter(([o, before]) => o[parameter] !== before);
+		if (!changed.length) return;
+		if (changed.length > 1) beginHistoryBatch();
+		for (const [o, before] of changed)
+			recordEntry({ kind: 'props', uuid: o.uuid, before: { [parameter]: before }, after: { [parameter]: o[parameter] } });
+		if (changed.length > 1) endHistoryBatch(parameter);
 	}
 
 	// ---- move to group (shared by mesh and light targets) -------------------
@@ -3194,7 +3237,7 @@
 								step={0.2}
 								snap={5}
 								ariaLabel="Render order"
-								onchange={(v) => setObjectParam('renderOrder', Math.round(v) || 0)}
+								onchange={(v) => setObjectParam('renderOrder', Math.round(v) || 0, true)}
 							/>
 						</div>
 					</div>
@@ -3437,11 +3480,7 @@
 						<div id="inspector-intensity">
 							<DragRow label="I" accent="text-yellow-300" step={0.02} min={0} snap={0.5}
 								value={$selectedObject.intensity}
-								onchange={(v) => {
-									$selectedObject.intensity = v;
-									selectedObject.update((s) => s);
-									sendLightUpdate();
-								}} />
+								onchange={(v) => setLightValue('intensity', v)} />
 						</div>
 					</div>
 					{#each LIGHT_PARAMS[$selectedObject.type] ?? [] as spec (spec.key)}
@@ -3451,11 +3490,7 @@
 							max={spec.max ?? 10}
 							step={spec.step ?? 0.05}
 							value={Number($selectedObject[spec.key] ?? 0)}
-							onchange={(v) => {
-								$selectedObject[spec.key] = v;
-								selectedObject.update((s) => s);
-								sendLightUpdate();
-							}} />
+							onchange={(v) => setLightValue(spec.key, v)} />
 					{/each}
 
 					{#if aimsByRotation}
diff --git a/src/components/ui/DragRow.svelte b/src/components/ui/DragRow.svelte
index a2e13ede..e7388913 100644
--- a/src/components/ui/DragRow.svelte
+++ b/src/components/ui/DragRow.svelte
@@ -7,6 +7,7 @@
 		displayDecimals,
 		parseValue
 	} from '$lib/units';
+	import { withHistoryGesture } from '$lib/historyGesture';
 
 	// THE numeric field (phase 64.2, rebuilt in 16-Q3). One control everywhere:
 	// transform rows, the boxes beside sliders, and the loose number inputs that
@@ -18,6 +19,10 @@
 	//                      Shift x100; integer fields (decimals 0) step by 1/10/100
 	//   Esc                back to the value you started with, then blur
 	//
+	// 37 R26: each scrub, and each typing session (focus -> Enter / Esc / blur, arrows
+	// included), is ONE history gesture ($lib/historyGesture): whatever the consumer records
+	// while it runs folds into one undo step, and an Esc that lands back where it started
+	// leaves none.
 	// It stays a real <input> the whole time (no button/typing mode swap): the caret
 	// is always available, ids keep working for tests and labels, and touch gets the
 	// numeric keypad via inputmode. type="text" on purpose — the native number
@@ -110,6 +115,11 @@
 	let entryValue = 0;
 	let startValue = 0;
 	let startX = 0;
+	/** the history gesture the next commit belongs to (37 R26); null = none open
+	 * @type {object|null} */
+	let gesture = null;
+	/** true while Esc blurs the field, so the blur's `change` cannot re-commit the typed text */
+	let reverting = false;
 
 	// while typing show exactly what was typed; otherwise render the live value
 	// (or an em-dash when the selection holds several different values)
@@ -118,7 +128,14 @@
 	/** @param {number} next */
 	function commit(next) {
 		if (!Number.isFinite(next)) return;
-		onchange(clamp(next));
+		withHistoryGesture(gesture, () => onchange(clamp(next)));
+	}
+
+	/** `change` fires on blur with the box's text; while Esc reverts that text is stale
+	 * @param {any} event */
+	function onChange(event) {
+		if (reverting) return;
+		onInput(event);
 	}
 
 	/** @param {any} event */
@@ -181,7 +198,17 @@
 		if (event.key === 'Escape') {
 			commit(entryValue);
 			typed = fmt(entryValue);
-			inputEl?.blur();
+			// 37 R26 (Q1): the blur below fires the browser's `change` with the TYPED text still
+			// in the box (the reset of the text lands a render later), and that re-committed
+			// the typed value — so Esc reverted arrow steps and not typing. Put the text back
+			// now and ignore that one `change`.
+			if (inputEl) inputEl.value = typed;
+			reverting = true;
+			try {
+				inputEl?.blur();
+			} finally {
+				reverting = false;
+			}
 			event.preventDefault();
 			event.stopPropagation();
 		} else if (event.key === 'Enter') {
@@ -192,6 +219,7 @@
 	/** @param {any} event */
 	function onFocus(event) {
 		focused = true;
+		gesture = {}; // a typing session
 		entryValue = Number(value) || 0;
 		typed = fmt(value);
 		// select all so typing REPLACES, the usual expectation for a value field
@@ -202,6 +230,7 @@
 	function onBlur() {
 		focused = false;
 		scrubbing = false;
+		gesture = null;
 	}
 
 	/** @param {any} event */
@@ -226,7 +255,8 @@
 			if (Math.abs(dx) < 3) return; // dead zone keeps a click a click
 			scrubbing = true;
 			event.currentTarget.setPointerCapture?.(event.pointerId);
-			onscrubstart();
+			gesture = {}; // a scrub is its own step, even on a field you were typing in
+			withHistoryGesture(gesture, onscrubstart);
 		}
 		// dragging must not smear a text selection across the field
 		document.getSelection?.()?.removeAllRanges?.();
@@ -252,7 +282,9 @@
 		scrubbing = false;
 		if (wasScrubbing) {
 			event.currentTarget.releasePointerCapture?.(event.pointerId);
-			onscrubend();
+			withHistoryGesture(gesture, onscrubend);
+			// typing after a scrub on a focused field is the next step
+			gesture = focused ? {} : null;
 			return;
 		}
 		// a click that did not scrub = "let me type it" (anywhere on the field)
@@ -281,7 +313,7 @@
 		{disabled}
 		use:keys
 		oninput={onInput}
-		onchange={onInput}
+		onchange={onChange}
 		onfocus={onFocus}
 		onblur={onBlur}
 	/>
diff --git a/src/components/ui/SliderRow.svelte b/src/components/ui/SliderRow.svelte
index 0bcd3f7e..2ba630ba 100644
--- a/src/components/ui/SliderRow.svelte
+++ b/src/components/ui/SliderRow.svelte
@@ -8,6 +8,7 @@
 	// ×100). It used to be a plain <input type="number"> that only committed on
 	// Enter/blur, which made its arrows look broken.
 	import DragRow from './DragRow.svelte';
+	import { withHistoryGesture } from '$lib/historyGesture';
 
 	/** @type {{label?: string, value?: number, min?: number, max?: number, step?: number, decimals?: number, id?: string, mixed?: boolean, onchange?: (next: number) => void}} */
 	let {
@@ -24,10 +25,16 @@
 		onchange = () => {}
 	} = $props();
 
+	// 37 R26: a drag of the range is ONE history gesture, like a scrub of the box — whatever
+	// the consumer records per tick folds into one undo step ($lib/historyGesture). It ends
+	// with the range's `change` (the release); a keyboard step has none open, so each is its own.
+	/** @type {object|null} */
+	let rangeGesture = null;
+
 	/** @param {any} raw */
 	function commit(raw) {
 		const next = parseFloat(raw);
-		if (!Number.isNaN(next)) onchange(next);
+		if (!Number.isNaN(next)) withHistoryGesture(rangeGesture, () => onchange(next));
 	}
 </script>
 
@@ -43,7 +50,9 @@
 		{max}
 		{step}
 		{value}
+		onpointerdown={() => (rangeGesture = {})}
 		oninput={(e) => commit(e.currentTarget.value)}
+		onchange={() => (rangeGesture = null)}
 	/>
 	<div class="w-16 shrink-0">
 		<DragRow
diff --git a/src/lib/animationPreview.js b/src/lib/animationPreview.js
index 1cfa2e9d..342f72ce 100644
--- a/src/lib/animationPreview.js
+++ b/src/lib/animationPreview.js
@@ -10,7 +10,7 @@ import {
 	fireAnimFinished as notifyClipFinished,
 	fireAnimMarker as notifyMarker
 } from './flowRuntime';
-import { recordEntry, registerHistoryKind } from './history';
+import { recordEntry, registerHistoryKind, registerHistoryMerge, sameJson } from './history';
 
 // Authored object animation, v2 (17-E). Each object owns a set of named CLIPS;
 // a clip owns TRACKS (one per transform channel) and a track owns KEYS at
@@ -1049,6 +1049,32 @@ registerHistoryKind('anim', (entry, state) => {
 	return true;
 });
 
+// 37 R26: the edits of one scrub/typing gesture (historyGesture.js) are ONE step — length,
+// fps and step write the clip on every change, so without this a 40px scrub was ~10 steps
+registerHistoryMerge('anim', {
+	merge(top, next) {
+		if (top.uuid !== next.uuid) return false;
+		top.afterSet = next.afterSet;
+		return true;
+	},
+	noop: (e) => sameJson(e.beforeSet, e.afterSet)
+});
+
+// 37 R26: the Animation window's speed field is a transport rate, not clip data, so it had
+// no undo at all — every other scrub field in the window does
+registerHistoryKind('animspeed', (entry, state) => {
+	setSpeed(entry.uuid, state.speed);
+	return true;
+});
+registerHistoryMerge('animspeed', {
+	merge(top, next) {
+		if (top.uuid !== next.uuid) return false;
+		top.after = next.after;
+		return true;
+	},
+	noop: (e) => e.before.speed === e.after.speed
+});
+
 // --- authoring ---------------------------------------------------------------
 
 /** Mutate an object's set through normalization, stamping `changedAt`. Records
@@ -2384,12 +2410,17 @@ export function keyTimes(uuid, clipId) {
 	return [...times].sort((a, b) => a - b);
 }
 
-/** @param {string} uuid @param {number} speed */
-export function setSpeed(uuid, speed) {
+/** @param {string} uuid @param {number} speed @param {{record?: boolean}} [opts] */
+export function setSpeed(uuid, speed, opts = {}) {
 	// (transport speed change; rebases the stamp so the pose does not jump)
 	const p = playOf(uuid);
 	const now = syncedNow();
-	setPlay(uuid, { pausedAt: elapsedOf(p, now), at: now, speed: Math.max(0.05, num(speed, 1)) }, true);
+	const next = Math.max(0.05, num(speed, 1));
+	const before = num(p.speed, 1);
+	setPlay(uuid, { pausedAt: elapsedOf(p, now), at: now, speed: next }, true);
+	// 37 R26: an edit from the Animation window is undoable (`record`); playback code is not
+	if (opts.record && before !== next)
+		recordEntry({ kind: 'animspeed', uuid, before: { speed: before }, after: { speed: next } });
 }
 
 /**
diff --git a/src/lib/history.js b/src/lib/history.js
index 26e57bd4..917619e1 100644
--- a/src/lib/history.js
+++ b/src/lib/history.js
@@ -5,6 +5,7 @@ import { peers, showToast, closeSelectionInspector } from '../stores/appStore';
 import { notifyExternalMove } from '$lib/flowRuntime';
 import { parkEditOverlays, stripEditOverlays } from '$lib/editOverlays';
 import { HISTORY_BYTES, entryBytes } from '$lib/meshBudget';
+import { currentHistoryGesture } from '$lib/historyGesture';
 
 // Undo/redo for local edits; remote peers' changes are not recorded, so
 // histories stay per-user.
@@ -26,6 +27,129 @@ export function registerHistoryKind(kind, apply) {
 	kindHandlers[kind] = apply;
 }
 
+// --- 37 R26: one gesture = ONE undo step -------------------------------------
+// An entry recorded while a gesture is current (historyGesture.js — DragRow opens one per
+// scrub and per typing session) is FOLDED into the stack top when the top belongs to the
+// same gesture: a kind that registers a merge makes the top span both (first before, last
+// after); any other pair becomes a 'gesture' composite. The top is mutated IN PLACE so its
+// identity survives (retractEntry and the 38 lock's undo counter both key on identity),
+// and a fold that lands back where the gesture started (Escape after typing) leaves no step.
+
+/** @type {WeakMap<object, object>} entry -> the gesture it was recorded in */
+const gestureOf = new WeakMap();
+
+/**
+ * @typedef {{merge: (top: any, next: any) => boolean, noop?: (entry: any) => boolean}} HistoryMerge
+ * `merge` mutates `top` to span both and returns true, or returns false to keep them
+ * apart; `noop` says when a merged entry changes nothing.
+ */
+/** @type {Record<string, HistoryMerge>} */
+const mergeHandlers = {};
+
+/** @param {string} kind @param {HistoryMerge} handler */
+export function registerHistoryMerge(kind, handler) {
+	mergeHandlers[kind] = handler;
+}
+
+/** @param {string} key @param {any} value */
+const dropStamps = (key, value) => (key === 'changedAt' ? undefined : value);
+/**
+ * Same content? A latest-wins document re-stamps `changedAt` on every write, so a revert
+ * to the starting value still differs by its stamp — compare without them.
+ * @param {any} a @param {any} b
+ */
+export const sameJson = (a, b) => JSON.stringify(a ?? null, dropStamps) === JSON.stringify(b ?? null, dropStamps);
+/** the plain transform entry (no kind) */
+const KIND_TRANSFORM = 'transform';
+/** @param {any} entry */
+const kindOf = (entry) => entry?.kind ?? KIND_TRANSFORM;
+/** what an entry edits, so a composite folds a later edit into the right member @param {any} entry */
+const targetOf = (entry) => entry?.uuid ?? entry?.key ?? null;
+
+/** @param {any} top @param {any} next */
+function mergeSame(top, next) {
+	if (kindOf(top) !== kindOf(next)) return false;
+	const handler = mergeHandlers[kindOf(top)];
+	return !!handler && handler.merge(top, next);
+}
+
+/** @param {any} entry @returns {boolean} */
+function isNoop(entry) {
+	if (entry?.kind === 'gesture') return entry.entries.every(isNoop);
+	return !!mergeHandlers[kindOf(entry)]?.noop?.(entry);
+}
+
+/** Fold `next` into `top` (both of one gesture). Mutates `top`. @param {any} top @param {any} next */
+function foldIntoGesture(top, next) {
+	if (top.kind === 'gesture') {
+		// the newest member editing the same target takes it; a member in between that
+		// edits the same target ends the search (folding past it would reorder the replay)
+		const target = targetOf(next);
+		for (let i = top.entries.length - 1; i >= 0; i--) {
+			const member = top.entries[i];
+			if (mergeSame(member, next)) return;
+			if (target === null || targetOf(member) === target) break;
+		}
+		top.entries.push(next);
+		return;
+	}
+	if (mergeSame(top, next)) return;
+	const first = { ...top };
+	for (const key of Object.keys(top)) delete top[key];
+	Object.assign(top, { kind: 'gesture', label: 'Edit', entries: [first, next], before: 'before', after: 'after' });
+}
+
+/**
+ * Record `entry` into `list` (the undo stack's array or the open batch) as part of the
+ * current gesture. Returns true when it folded into the top, plus whether the top is now
+ * a no-op the caller should drop.
+ * @param {any[]} list @param {any} entry @param {object} gesture
+ */
+function foldIntoTop(list, entry, gesture) {
+	const top = list[list.length - 1];
+	if (!top || gestureOf.get(top) !== gesture) return null;
+	// never reach below a mesh-edit session's barrier
+	if (!batch && sessionBase >= 0 && list.length <= sessionBase) return null;
+	foldIntoGesture(top, entry);
+	return { drop: isNoop(top) };
+}
+
+/** @param {any} top @param {any} next */
+function mergeTransform(top, next) {
+	if (!top.uuid || top.uuid !== next.uuid) return false;
+	top.after = next.after;
+	return true;
+}
+registerHistoryMerge(KIND_TRANSFORM, { merge: mergeTransform, noop: (e) => sameJson(e.before, e.after) });
+
+registerHistoryMerge('transformSet', {
+	merge(top, next) {
+		// per object: the first before, the latest after
+		for (const item of next.items) {
+			const mine = top.items.find((/** @type {any} */ i) => i.uuid === item.uuid);
+			if (mine) mine.after = item.after;
+			else top.items.push({ ...item });
+		}
+		return true;
+	},
+	noop: (e) => e.items.every((/** @type {any} */ i) => sameJson(i.before, i.after))
+});
+
+// a fan over a selection records one batch per change: fold them member by member
+registerHistoryMerge('aibatch', {
+	merge(top, next) {
+		if (top.entries.length !== next.entries.length) return false;
+		/** @type {[any, any][]} */
+		const pairs = top.entries.map((/** @type {any} */ e, /** @type {number} */ i) => [e, next.entries[i]]);
+		if (!pairs.every(([a, b]) => kindOf(a) === kindOf(b) && targetOf(a) === targetOf(b))) return false;
+		// dry run on shallow copies first, so a member that refuses leaves the batch untouched
+		if (!pairs.every(([a, b]) => mergeSame({ ...a }, b))) return false;
+		for (const [a, b] of pairs) mergeSame(a, b);
+		return true;
+	},
+	noop: (e) => e.entries.every(isNoop)
+});
+
 /** @type {import('svelte/store').Writable<any[]>} exported READ-ONLY (tests/debug) */
 export const undoStack = writable([]);
 /** @type {import('svelte/store').Writable<any[]>} */
@@ -64,6 +188,21 @@ export function endHistoryBatch(label = 'AI edit') {
 /** @param {any} entry */
 export function recordEntry(entry) {
 	if (applying) return;
+	const gesture = currentHistoryGesture();
+	if (gesture) {
+		const folded = foldIntoTop(batch ?? get(undoStack), entry, gesture);
+		if (folded) {
+			if (batch) {
+				if (folded.drop) batch.pop();
+				return;
+			}
+			// same identity on top, so notify by hand (or drop a step that changes nothing)
+			undoStack.update((stack) => (folded.drop ? stack.slice(0, -1) : [...stack]));
+			redoStack.set([]);
+			return;
+		}
+		gestureOf.set(entry, gesture);
+	}
 	if (batch) {
 		batch.push(entry);
 		return; // deferred — redoStack stays until the batch commits
@@ -377,6 +516,7 @@ function applyComposite(entry, state) {
 }
 registerHistoryKind('aibatch', applyComposite);
 registerHistoryKind('session', applyComposite); // 15-F mixed-kind seals
+registerHistoryKind('gesture', applyComposite); // 37 R26: one gesture's mixed entries
 
 export function undo() {
 	const stack = get(undoStack);
@@ -391,12 +531,15 @@ export function undo() {
 	}
 	const entry = stack[stack.length - 1];
 	undoStack.update((s) => s.slice(0, -1));
+	// a step that left the stack is sealed: a later edit of its gesture is a new step
+	gestureOf.delete(entry);
 	applying = true;
 	try {
 		if (applyState(entry, entry.before)) redoStack.update((s) => [...s, entry]);
 	} finally {
 		applying = false;
 	}
+	refreshSelection();
 }
 
 export function redo() {
@@ -418,4 +561,15 @@ export function redo() {
 	} finally {
 		applying = false;
 	}
+	refreshSelection();
+}
+
+/**
+ * 37 R26 (Q2): the Inspector's rows read the selected object through `selectedObject`, and
+ * THREE objects are not reactive — an undo rewrote the pose and the rows kept showing the
+ * pre-undo number (a scrub started from it then jumped). Every kind's replay mutates in
+ * place, so poke the selection after any replay rather than in each kind.
+ */
+function refreshSelection() {
+	if (get(selectedObject)?.uuid) selectedObject.update((v) => v);
 }
diff --git a/src/lib/historyGesture.js b/src/lib/historyGesture.js
new file mode 100644
index 00000000..49e171ba
--- /dev/null
+++ b/src/lib/historyGesture.js
@@ -0,0 +1,37 @@
+// 37 R26: "one gesture = ONE undo step" for every scrub field, without each consumer
+// bracketing its own writes. A gesture is a token (any object); history entries recorded
+// while one is current carry it, and history.js folds an entry into the stack top when
+// both share the token (history.js `mergeGestureEntry`). DragRow opens one per scrub and
+// one per typing session (focus -> Enter / Escape / blur), so the arrows, the keystrokes
+// and an Escape revert of one edit are one step — and a revert that lands back where it
+// started leaves no step at all.
+//
+// A LEAF on purpose (imports nothing): DragRow is a UI part that also renders outside the
+// app (the /kit page), and history.js sits in the import-cycle family (CLAUDE.md).
+//
+// Consumers that record LATER than the change (a debounced recorder, like the Inspector's
+// 500 ms transform seal) capture `currentHistoryGesture()` when the change happens and
+// record inside `withHistoryGesture(token, ...)`.
+
+/** @type {object|null} */
+let current = null;
+
+/** The gesture an entry recorded right now belongs to, or null. */
+export function currentHistoryGesture() {
+	return current;
+}
+
+/**
+ * Run `fn` with `token` as the current gesture (null = none). Nests: the outer gesture
+ * comes back afterwards, even when `fn` throws.
+ * @template T @param {object|null} token @param {() => T} fn @returns {T}
+ */
+export function withHistoryGesture(token, fn) {
+	const prev = current;
+	current = token;
+	try {
+		return fn();
+	} finally {
+		current = prev;
+	}
+}
diff --git a/src/lib/objectActions.js b/src/lib/objectActions.js
index ad8a8a5e..c1f22bef 100644
--- a/src/lib/objectActions.js
+++ b/src/lib/objectActions.js
@@ -1,7 +1,7 @@
 import * as THREE from 'three';
 import { get } from 'svelte/store';
 import { dropToSurface } from './snapping';
-import { recordTransform, recordEntry, recordObjectPresence, registerHistoryKind, beginHistoryBatch, endHistoryBatch } from './history';
+import { recordTransform, recordEntry, recordObjectPresence, registerHistoryKind, registerHistoryMerge, sameJson, beginHistoryBatch, endHistoryBatch } from './history';
 import { cascadeJointDeletes } from './joints';
 import { createGroup } from './geometries.svelte';
 import { suspendAnimation, resumeAnimation, parkAnimatedAtBase } from './flowRuntime';
@@ -817,10 +817,35 @@ registerHistoryKind('props', (entry, state) => {
 		if (peer)
 			peer.send({ type: 'objectParameters', parameter: 'origin', uuid: entry.uuid, origin: state.origin });
 	}
+	if ('renderOrder' in state) {
+		// 37 R26: the Inspector's Render order field (it recorded nothing before)
+		object.renderOrder = state.renderOrder;
+		if (peer)
+			peer.send({ type: 'objectParameters', parameter: 'renderOrder', uuid: entry.uuid, renderOrder: state.renderOrder });
+	}
+	if ('light' in state && state.light) {
+		// 37 R26: a light's own numbers (intensity, distance, angle…) — replicated the way the
+		// Inspector sends them, the whole light resent with override
+		Object.assign(object, state.light);
+		if (peer) peer.send({ type: 'object', element: object.toJSON(), override: true });
+	}
 	pokeScene();
 	return true;
 });
 
+/** the keys a props state touches, one level into `light` @param {any} state */
+const propsShape = (state) =>
+	JSON.stringify(Object.keys(state ?? {}).sort().map((k) => (k === 'light' ? [k, Object.keys(state.light ?? {}).sort()] : k)));
+// 37 R26: two edits of one gesture on the same object and the same keys are one step
+registerHistoryMerge('props', {
+	merge(top, next) {
+		if (top.uuid !== next.uuid || propsShape(top.before) !== propsShape(next.before)) return false;
+		top.after = next.after;
+		return true;
+	},
+	noop: (e) => sameJson(e.before, e.after)
+});
+
 // group moves replay through moveObjectToGroup (recordEntry no-ops during replay)
 registerHistoryKind('group', (entry, state) => {
 	const group = get(objectsGroup);
diff --git a/src/lib/shaderSync.js b/src/lib/shaderSync.js
index ace4875c..ccab670c 100644
--- a/src/lib/shaderSync.js
+++ b/src/lib/shaderSync.js
@@ -13,7 +13,7 @@
 import { get } from 'svelte/store';
 import { sessionNow } from './sessionClock'; // 25-E: stamps another peer compares
 import { peers } from '../stores/appStore';
-import { registerHistoryKind, recordEntry } from './history';
+import { registerHistoryKind, registerHistoryMerge, recordEntry, sameJson } from './history';
 import {
 	shaderGraphs,
 	shaderGraphOf,
@@ -127,6 +127,16 @@ export function shaderGestureActive(key) {
 	return gestures.has(key);
 }
 
+// 37 R26: one scrub/typing gesture on a graph field is ONE step (historyGesture.js)
+registerHistoryMerge('shadergraph', {
+	merge(top, next) {
+		if (top.key !== next.key) return false;
+		top.after = next.after;
+		return true;
+	},
+	noop: (e) => sameJson(e.before, e.after)
+});
+
 registerHistoryKind('shadergraph', (/** @type {any} */ entry, /** @type {any} */ state) => {
 	// `state` IS the doc history hands us (applyState passes entry.before or entry.after),
 	// so the direction is an IDENTITY comparison - the idiom every other kind uses. This
diff --git a/tests/e2e/scrub-undo.test.cjs b/tests/e2e/scrub-undo.test.cjs
new file mode 100644
index 00000000..621f379e
--- /dev/null
+++ b/tests/e2e/scrub-undo.test.cjs
@@ -0,0 +1,337 @@
+// 37 R26 — SCRUB FIELDS AND UNDO (the three bugs the 38 behaviour lock found, QUESTIONS-38-lock
+// Q1-Q3). Every scrub field — the Inspector's transforms and values, a shader vector, the
+// Animation window's fields — must:
+//   Q3  record ONE undo step per scrub and ONE per typed edit (focus -> Enter), however many
+//       changes the gesture wrote, and however slowly it was typed;
+//   Q1  put the value back when Escape is pressed after TYPING (it kept the typed value: the
+//       blur's `change` re-committed the text still in the box), and leave no undo step;
+//   Q2  show the restored number the moment Ctrl+Z lands (the transform rows kept the
+//       pre-undo number until something refreshed the selection).
+// Counted as NEW history entries, never the stack length: the history LIMIT evicts one old
+// entry per new one, so a long session hides the count (the lock's own counter).
+const h = require('./helpers.cjs');
+
+const DRAG_WRAP = '.dn-wrap';
+const DRAG_INPUT = '.dn-input';
+
+const near = (/** @type {number} */ a, /** @type {number} */ b, eps = 1e-6) => Math.abs(a - b) <= eps;
+const fmt = (/** @type {any} */ v) => (typeof v === 'number' ? +v.toFixed(5) : v);
+
+/** @param {any} page */
+async function installUndoCounter(page) {
+	await page.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__r26Seen = new WeakSet();
+		w.__r26New = 0;
+		w.__stores.history.undoStack.subscribe((/** @type {any[]} */ stack) => {
+			for (const e of stack)
+				if (e && typeof e === 'object' && !w.__r26Seen.has(e)) {
+					w.__r26Seen.add(e);
+					w.__r26New++;
+				}
+		});
+	});
+}
+/** @param {any} page @returns {Promise<number>} */
+const undoEntries = (page) => page.evaluate(() => /** @type {any} */ (window).__r26New);
+/** @param {any} page */
+const blurAll = async (page) => {
+	await page.evaluate(() => /** @type {any} */ (document.activeElement)?.blur?.());
+	await page.waitForTimeout(60);
+};
+/** @param {any} page @param {string} root @param {number} index */
+const fieldInput = (page, root, index) => page.locator(root + ' ' + DRAG_WRAP).nth(index).locator(DRAG_INPUT);
+
+/** @param {any} page @param {string} root @param {number} index @param {number} dx */
+async function scrub(page, root, index, dx) {
+	const field = page.locator(root + ' ' + DRAG_WRAP).nth(index);
+	await field.evaluate((/** @type {any} */ el) => el.scrollIntoView({ block: 'center' }));
+	await page.waitForTimeout(80);
+	const box = await field.boundingBox();
+	const x = box.x + Math.min(10, box.width / 4);
+	const y = box.y + box.height / 2;
+	await page.mouse.move(x, y);
+	await page.mouse.down();
+	await page.mouse.move(x + dx, y, { steps: 12 });
+	await page.mouse.up();
+}
+
+/** focus the field by a click that does not scrub @param {any} page @param {string} root @param {number} index */
+async function clickToType(page, root, index) {
+	await blurAll(page);
+	await fieldInput(page, root, index).evaluate((/** @type {any} */ el) => el.scrollIntoView({ block: 'center' }));
+	await fieldInput(page, root, index).click();
+	await page.waitForTimeout(120); // DragRow selects the whole value a frame after focus
+}
+
+/**
+ * The R26 contract for one field.
+ * @param {any} page
+ * @param {{ name: string, root: string, index: number, read: () => Promise<number>, typed: string,
+ *   typedValue: number, slowTyped?: [string, string, number], shows?: (v: number) => number, tol?: number }} f
+ */
+async function contract(page, f) {
+	const t = `${f.name}:`;
+	const input = fieldInput(page, f.root, f.index);
+	const tol = f.tol ?? 1e-6;
+	h.check((await input.count()) === 1, `${t} the field is there`);
+
+	// --- Q3: a scrub is ONE step, and one Ctrl+Z undoes all of it ---------------------------
+	await blurAll(page);
+	const v0 = await f.read();
+	let d0 = await undoEntries(page);
+	await scrub(page, f.root, f.index, 40);
+	await page.waitForTimeout(150);
+	await blurAll(page); // a label-wrapped field takes focus on the release
+	await page.waitForTimeout(700); // the Inspector seals a transform gesture 500ms after it
+	const v1 = await f.read();
+	h.check(!near(v1, v0, tol), `${t} (premise) the scrub moved the value: ${fmt(v0)} -> ${fmt(v1)}`);
+	const scrubSteps = (await undoEntries(page)) - d0;
+	h.check(scrubSteps === 1, `${t} a whole scrub is ONE undo step (recorded ${scrubSteps})`);
+	await page.keyboard.press('Control+z');
+	await page.waitForTimeout(80);
+	h.check(near(await f.read(), v0, tol), `${t} one Ctrl+Z puts the scrub back: ${fmt(await f.read())} (was ${fmt(v0)})`);
+	// --- Q2: the field shows the restored number now, with nothing poking the selection -----
+	if (f.shows) {
+		const text = Number(await input.inputValue());
+		h.check(near(text, f.shows(v0), 0.0051), `${t} right after Ctrl+Z the field shows the restored value: ${text} (want ${fmt(f.shows(v0))})`);
+	}
+	await page.keyboard.press('Control+y'); // carry on from the scrubbed value
+	await page.waitForTimeout(150);
+	h.check(near(await f.read(), v1, tol), `${t} and redo brings the scrub back: ${fmt(await f.read())}`);
+
+	// --- Q3: a typed edit (two keystrokes, live) is ONE step -------------------------------
+	const vT = await f.read();
+	d0 = await undoEntries(page);
+	await clickToType(page, f.root, f.index);
+	await page.keyboard.type(f.typed, { delay: 40 });
+	await page.keyboard.press('Enter');
+	await page.waitForTimeout(700);
+	h.check(near(await f.read(), f.typedValue, 1e-3), `${t} (premise) typing "${f.typed}" set ${fmt(await f.read())}`);
+	const typedSteps = (await undoEntries(page)) - d0;
+	h.check(typedSteps === 1, `${t} a typed edit is ONE undo step (recorded ${typedSteps})`);
+	await page.keyboard.press('Control+z');
+	await page.waitForTimeout(80);
+	h.check(near(await f.read(), vT, tol), `${t} one Ctrl+Z undoes the whole typed edit: ${fmt(await f.read())} (was ${fmt(vT)})`);
+	if (f.shows) {
+		const text = Number(await input.inputValue());
+		h.check(near(text, f.shows(vT), 0.0051), `${t} and the field shows it: ${text}`);
+	}
+
+	// typing slower than any debounce in between is still one edit
+	if (f.slowTyped) {
+		const [a, b, want] = f.slowTyped;
+		const vS = await f.read();
+		d0 = await undoEntries(page);
+		await clickToType(page, f.root, f.index);
+		await page.keyboard.type(a);
+		await page.waitForTimeout(800);
+		await page.keyboard.type(b);
+		await page.keyboard.press('Enter');
+		await page.waitForTimeout(700);
+		h.check(near(await f.read(), want, 1e-3), `${t} (premise) slow typing set ${fmt(await f.read())}`);
+		const slowSteps = (await undoEntries(page)) - d0;
+		h.check(slowSteps === 1, `${t} typing with a pause between keys is still ONE step (recorded ${slowSteps})`);
+		await page.keyboard.press('Control+z');
+		await page.waitForTimeout(80);
+		h.check(near(await f.read(), vS, tol), `${t} and one Ctrl+Z undoes it: ${fmt(await f.read())}`);
+	}
+
+	// --- Q1: Escape after TYPING reverts, and leaves no step --------------------------------
+	const vE = await f.read();
+	await markStack(page);
+	await clickToType(page, f.root, f.index);
+	await page.keyboard.type('7', { delay: 30 });
+	await page.waitForTimeout(100);
+	const during = await f.read();
+	h.check(!near(during, vE, tol), `${t} (premise) the typed 7 applied live: ${fmt(during)}`);
+	await page.keyboard.press('Escape');
+	await page.waitForTimeout(700);
+	h.check(near(await f.read(), vE, tol), `${t} Escape after typing reverts to the value before editing: ${fmt(await f.read())} (was ${fmt(vE)})`);
+	h.check((await page.evaluate(() => !!document.activeElement?.closest?.('.dn-wrap'))) === false, `${t} Escape leaves the field`);
+	if (f.shows) {
+		const text = Number(await input.inputValue());
+		h.check(near(text, f.shows(vE), 0.0051), `${t} and the field shows it: ${text}`);
+	}
+	const added = await stackAdded(page);
+	h.check(added === 0, `${t} an edit Escape took back leaves no undo step (${added} new on the stack)`);
+	await blurAll(page);
+}
+
+/** remember which entries are on the undo stack now @param {any} page */
+function markStack(page) {
+	return page.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		w.__stores.history.undoStack.subscribe((/** @type {any[]} */ s) => (w.__r26Mark = new Set(s)))();
+	});
+}
+/** entries on the undo stack that were not there at markStack (eviction-proof) @param {any} page */
+function stackAdded(page) {
+	return page.evaluate(() => {
+		const w = /** @type {any} */ (window);
+		let stack = /** @type {any[]} */ ([]);
+		w.__stores.history.undoStack.subscribe((/** @type {any[]} */ s) => (stack = s))();
+		return stack.filter((e) => !w.__r26Mark.has(e)).length;
+	});
+}
+
+/** the selected object's transform component @param {any} page @param {string} field @param {string} axis */
+const transformReader = (page, field, axis) => () =>
+	page.evaluate(({ field, axis }) => new Promise((r) => window.__stores.selectedObject.subscribe((o) => r(o?.[field]?.[axis]))()), { field, axis });
+
+h.run(async () => {
+	const browser = await h.launch({ args: [...h.GPU_ARGS] });
+	const A = await h.setupPage(browser, 'A', { context: { viewport: { width: 1440, height: 900 } } });
+	const page = A.page;
+	await installUndoCounter(page);
+
+	// ---- the Inspector: transforms ---------------------------------------------------------
+	await page.evaluate(() => window.__stores.commandsHandler.sceneCommand('/create box'));
+	await page.waitForTimeout(1500);
+	const box = await page.evaluate(async () => {
+		const g = await new Promise((r) => window.__stores.objectsGroup.subscribe(r)());
+		const b = g.children.find((c) => c.name === 'Box') ?? g.children[g.children.length - 1];
+		window.__stores.objectActions.selectObject(b.uuid, true);
+		b.position.set(0, 1, 0); // park it: a fresh /create box is dynamic
+		b.rotation.set(0, 0, 0);
+		b.scale.set(1, 1, 1);
+		b.updateMatrix();
+		return b.uuid;
+	});
+	await page.waitForTimeout(800);
+	await page.locator('#inspector-position').waitFor({ state: 'visible', timeout: 10000 });
+	// show the parked pose, so every check starts from what the rows say
+	await page.evaluate(() => window.__stores.selectedObject.update((v) => v));
+	await page.waitForTimeout(150);
+
+	await contract(page, {
+		name: 'position X', root: '#inspector-position', index: 0, read: transformReader(page, 'position', 'x'),
+		typed: '1.37', typedValue: 1.37, slowTyped: ['2', '5', 25], shows: (v) => v
+	});
+	await contract(page, {
+		name: 'rotation Y', root: '#inspector-rotation', index: 1, read: transformReader(page, 'rotation', 'y'),
+		typed: '33', typedValue: (33 * Math.PI) / 180, shows: (v) => (v * 180) / Math.PI, tol: 1e-4
+	});
+	await contract(page, {
+		name: 'scale Z', root: '#inspector-scale', index: 2, read: transformReader(page, 'scale', 'z'),
+		typed: '2.3', typedValue: 2.3, shows: (v) => v
+	});
+
+	// ---- the Inspector: values that recorded no undo at all -------------------------------
+	await contract(page, {
+		name: 'render order', root: '*:has(> .dn-wrap > #inspector-render-order)', index: 0, typed: '12', typedValue: 12,
+		read: () => page.evaluate(() => new Promise((r) => window.__stores.selectedObject.subscribe((o) => r(o?.renderOrder))())),
+		shows: (v) => v
+	});
+
+	await page.evaluate(() => window.__stores.commandsHandler.sceneCommand('/light directional'));
+	await page.waitForTimeout(1200);
+	await page.evaluate(async () => {
+		const g = await new Promise((r) => window.__stores.objectsGroup.subscribe(r)());
+		const l = g.children.find((c) => c.type === 'DirectionalLight');
+		window.__stores.objectActions.selectObject(l.uuid, true);
+	});
+	await page.waitForTimeout(700);
+	await page.locator('#inspector-intensity').waitFor({ state: 'visible', timeout: 10000 });
+	await contract(page, {
+		name: 'light intensity', root: '#inspector-intensity', index: 0, typed: '2.5', typedValue: 2.5,
+		read: () => page.evaluate(() => new Promise((r) => window.__stores.selectedObject.subscribe((o) => r(o?.intensity))())),
+		shows: (v) => v
+	});
+
+	// ---- a light's range slider: one DRAG of the range is one step too --------------------
+	await page.evaluate(() => window.__stores.commandsHandler.sceneCommand('/light point'));
+	await page.waitForTimeout(1200);
+	await page.evaluate(async () => {
+		const g = await new Promise((r) => window.__stores.objectsGroup.subscribe(r)());
+		const l = g.children.find((c) => c.type === 'PointLight');
+		window.__stores.objectActions.selectObject(l.uuid, true);
+	});
+	await page.waitForTimeout(700);
+	const range = page.locator('input[type=range][aria-label="Distance"]').first();
+	await range.waitFor({ state: 'visible', timeout: 10000 });
+	await range.evaluate((/** @type {any} */ el) => el.scrollIntoView({ block: 'center' }));
+	const distance = () => page.evaluate(() => new Promise((r) => window.__stores.selectedObject.subscribe((o) => r(o?.distance))()));
+	const dist0 = await distance();
+	let dr0 = await undoEntries(page);
+	const rb = await range.boundingBox();
+	await page.mouse.move(rb.x + rb.width * 0.1, rb.y + rb.height / 2);
+	await page.mouse.down();
+	await page.mouse.move(rb.x + rb.width * 0.6, rb.y + rb.height / 2, { steps: 10 });
+	await page.mouse.up();
+	await page.waitForTimeout(300);
+	h.check(!near(await distance(), dist0), `light distance slider: (premise) the drag moved it: ${fmt(dist0)} -> ${fmt(await distance())}`);
+	const rangeSteps = (await undoEntries(page)) - dr0;
+	h.check(rangeSteps === 1, `light distance slider: a whole drag of the range is ONE undo step (recorded ${rangeSteps})`);
+	await blurAll(page);
+	await page.keyboard.press('Control+z');
+	await page.waitForTimeout(150);
+	h.check(near(await distance(), dist0), `light distance slider: one Ctrl+Z puts it back: ${fmt(await distance())} (was ${fmt(dist0)})`);
+	await contract(page, {
+		name: 'light distance box', root: '.ui-row:has(> input[type=range][aria-label="Distance"])', index: 0, typed: '12', typedValue: 12,
+		read: distance, shows: (v) => v
+	});
+
+	// ---- a shader vector (it recorded two steps per scrub) --------------------------------
+	await page.evaluate((u) => window.__stores.objectActions.selectObject(u, true), box);
+	await page.waitForTimeout(400);
+	await page.evaluate((u) => {
+		const S = window.__stores;
+		S.shaderGraph.setShaderGraphFor(u, {
+			nodes: [
+				{ id: 'tl', type: 'tilingOffset', position: { x: 70, y: 60 }, data: {} },
+				{ id: 'sf', type: 'surface', position: { x: 380, y: 90 }, data: {} }
+			],
+			edges: [{ id: 'e1', source: 'tl', sourceHandle: 'out', target: 'sf', targetHandle: 'albedo' }]
+		});
+		S.shaderEditorClose?.set?.(false);
+		S.bottomDock.activateDock('shader');
+	}, box);
+	await page.locator('#shader-editor .shader-vec').first().waitFor({ state: 'visible', timeout: 15000 });
+	await contract(page, {
+		name: 'shader vec2 x', root: '#shader-editor .shader-vec', index: 0, typed: '3', typedValue: 3,
+		read: () =>
+			page.evaluate(
+				(u) => new Promise((r) => window.__stores.shaderGraph.shaderGraphs.subscribe((all) => r(Number((all[u]?.nodes ?? []).find((n) => n.type === 'tilingOffset')?.data?.tiling?.[0] ?? 1)))()),
+				box
+			)
+	});
+
+	// ---- the Animation window (length/fps/step: one step PER CHANGE; speed: none) -----------
+	await page.evaluate((u) => {
+		const s = window.__stores;
+		let g;
+		s.objectsGroup.subscribe((x) => (g = x))();
+		const obj = g.getObjectByProperty('uuid', u);
+		s.animationClose.set(false);
+		s.bottomDock.activateDock('animation');
+		const tid = s.animationPreview.addTrack(u, 'pos.y', obj);
+		s.animationPreview.updateTrack(u, tid, { from: 0, to: 4 });
+		s.animationPreview.updateAnim(u, { duration: 2, loop: 'loop' });
+	}, box);
+	await page.locator('#animation-speed').waitFor({ state: 'visible', timeout: 10000 });
+	const anim = (/** @type {string} */ key) => () =>
+		page.evaluate(
+			({ u, key }) => {
+				const s = window.__stores;
+				let set;
+				s.animationPreview.animations.subscribe((v) => (set = v))();
+				const doc = set?.[u];
+				const clip = doc?.clips?.[doc.active];
+				if (key === 'speed') {
+					let pb;
+					s.animationPreview.playback.subscribe((v) => (pb = v))();
+					return Number(pb?.[u]?.speed ?? clip?.speed ?? 1);
+				}
+				const fallback = key === 'fps' ? Number(localStorage.getItem('animationFps')) || 30 : key === 'step' ? 0 : NaN;
+				return Number(clip?.[key] ?? fallback);
+			},
+			{ u: box, key }
+		);
+	await contract(page, { name: 'animation length', root: 'label:has(#animation-length)', index: 0, read: anim('duration'), typed: '3', typedValue: 3 });
+	await contract(page, { name: 'animation speed', root: 'label:has(#animation-speed)', index: 0, read: anim('speed'), typed: '2', typedValue: 2 });
+	await contract(page, { name: 'animation fps', root: 'label:has(#animation-fps)', index: 0, read: anim('fps'), typed: '24', typedValue: 24 });
+	await contract(page, { name: 'animation step', root: 'label:has(#animation-step)', index: 0, read: anim('step'), typed: '2', typedValue: 2 });
+
+	await h.finish(browser);
+});

From 01635c56776442e124037282c988345c0a9f4832 Mon Sep 17 00:00:00 2001
From: AlexZ005 <alexz005.info@gmail.com>
Date: Wed, 7 Oct 2026 08:15:15 +0300
Subject: [PATCH 2/2] [fix] shader editor: node selection stays out of the
 graph document

37 R26 (Q3, the last red of scrub-undo run 1): the click that ends a scrub on
an unselected node SELECTS it, and ShaderEditor wrote xyflow's `selected` into
the replicated graph doc - a second undo step per scrub (Ctrl+Z undid the
selection) and a broadcast of local view state.
- view keys (selected, dragging, measured, resizing) never enter the doc (the
  nodesHandler.serializeNode rule); an older save's copy is ignored
- selection and xyflow's measured size are carried locally across a rebuild

scrub-undo: 156 PASS / 0 FAIL (was 154/2). svelte-check 318/47 = baseline,
vitest 1544 green.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 src/components/editors/ShaderEditor.svelte | 45 +++++++++++++++++++---
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/src/components/editors/ShaderEditor.svelte b/src/components/editors/ShaderEditor.svelte
index a1109d0e..e5a0d955 100644
--- a/src/components/editors/ShaderEditor.svelte
+++ b/src/components/editors/ShaderEditor.svelte
@@ -175,17 +175,49 @@
 	let edges = $state.raw([]);
 	let pushing = false;
 
+	// 37 R26: xyflow's VIEW state (a node's `selected`, `dragging`, `measured`…) is this
+	// screen's, never the document's — the nodesHandler.serializeNode rule. Writing it in made
+	// a click that selects a node a replicated, undoable graph edit: scrubbing a vector on an
+	// unselected node recorded TWO undo steps (the selection, then the scrub), and Ctrl+Z
+	// undid the selection. Selection is kept LOCAL and carried across a document rebuild.
+	const VIEW_KEYS = ['selected', 'dragging', 'measured', 'resizing'];
+	let viewKey = '';
+	/** @param {any} item */
+	function docShape(item) {
+		const out = { ...item };
+		for (const k of VIEW_KEYS) delete out[k];
+		return out;
+	}
+
 	$effect(() => {
 		const next = doc;
 		const key = scope;
 		untrack(() => {
 			pushing = true;
+			// another document: nothing in it is selected yet
+			const sameDoc = viewKey === key;
+			viewKey = key;
+			// this screen's view of each node (selection, xyflow's measured size) survives the
+			// rebuild; the document's copy of those fields (an older save wrote them) does not
+			/** @type {Map<string, any>} */
+			const view = new Map();
+			if (sameDoc)
+				for (const n of nodes) {
+					/** @type {any} */
+					const v = {};
+					for (const k of VIEW_KEYS) if (n[k] !== undefined) v[k] = n[k];
+					view.set(n.id, v);
+				}
+			const wasEdgeSelected = new Set((sameDoc ? edges : []).filter((/** @type {any} */ e) => e.selected).map((/** @type {any} */ e) => e.id));
 			nodes = (next?.nodes ?? []).map((/** @type {any} */ n) => ({
-				...n,
+				...docShape(n),
+				...(view.get(n.id) ?? {}),
 				// the card needs to know which document to write its params into
 				data: { ...(n.data ?? {}), __graphKey: key }
 			}));
-			edges = next?.edges ?? [];
+			edges = (next?.edges ?? []).map((/** @type {any} */ e) =>
+				wasEdgeSelected.has(e.id) ? { ...e, selected: true } : docShape(e)
+			);
 			pushing = false;
 		});
 	});
@@ -197,13 +229,14 @@
 			if (pushing || !doc) return;
 			const stripped = localNodes.map((/** @type {any} */ n) => {
 				const { __graphKey, ...rest } = n.data ?? {};
-				return { ...n, data: rest };
+				return docShape({ ...n, data: rest });
 			});
+			const strippedEdges = localEdges.map(docShape);
 			if (
-				JSON.stringify(stripped) !== JSON.stringify(doc.nodes) ||
-				JSON.stringify(localEdges) !== JSON.stringify(doc.edges)
+				JSON.stringify(stripped) !== JSON.stringify((doc.nodes ?? []).map(docShape)) ||
+				JSON.stringify(strippedEdges) !== JSON.stringify((doc.edges ?? []).map(docShape))
 			)
-				setShaderGraphFor(scope, { nodes: stripped, edges: localEdges });
+				setShaderGraphFor(scope, { nodes: stripped, edges: strippedEdges });
 		});
 	});