cozyclay 2.1.1 → 3.0.1

package/src/motion/physics-review.js

@@ -0,0 +1,118 @@
+import * as THREE from "three";
+import { createSurfaceSampler } from "./physics-surface.js";
+
+// Contact measurement for motion verification: support sites, inferred
+// contact spans and the floor/slide/float metrics. It never edits a take.
+export const SUPPORT_SITES = [
+	{ id: "leftFoot", label: "Left foot", ko: "왼발", bone: "LeftFoot", chain: "leftFoot", kind: "foot", match: /Left(Foot|Toe)/ },
+	{ id: "rightFoot", label: "Right foot", ko: "오른발", bone: "RightFoot", chain: "rightFoot", kind: "foot", match: /Right(Foot|Toe)/ },
+	{ id: "leftHand", label: "Left hand", ko: "왼손", bone: "LeftHand", chain: "leftHand", kind: "hand", match: /LeftHand/ },
+	{ id: "rightHand", label: "Right hand", ko: "오른손", bone: "RightHand", chain: "rightHand", kind: "hand", match: /RightHand/ },
+	{ id: "leftKnee", label: "Left knee", ko: "왼무릎", bone: "LeftLeg", chain: "leftFoot", kind: "knee", match: /Left(UpLeg|Leg)$/ },
+	{ id: "rightKnee", label: "Right knee", ko: "오른무릎", bone: "RightLeg", chain: "rightFoot", kind: "knee", match: /Right(UpLeg|Leg)$/ },
+];
+export const PHYSICS_LIMITS = Object.freeze({ root: 0.18, pull: 0.10, tilt: Math.PI / 60, floor: 0.005, slide: 0.015, float: 0.025 });
+const quantile = (a, t) => { const s = a.filter(Number.isFinite).sort((x, y) => x - y); return s[Math.floor((s.length - 1) * t)] ?? 0; };
+
+export function copyPhysicsKeys(keys) {
+	return new Map([...keys].map(([f, entries]) => [f, new Map([...entries].map(([id, k]) => [id, {
+		...k, q: k.q?.map((q) => q.clone()) ?? null, p: k.p?.clone() ?? null,
+		...(k.baseQ ? { baseQ: k.baseQ.map((q) => q.clone()) } : {}),
+		...(k.basePos ? { basePos: k.basePos.clone() } : {}),
+		...(k.chainP ? { chainP: k.chainP.map((p) => p.clone()) } : {}),
+		...(k.correctionRange ? { correctionRange: { ...k.correctionRange } } : {}),
+	}]))]));
+}
+export function physicsKeyStamp(keys) {
+	return JSON.stringify([...keys].sort((a, b) => a[0] - b[0]).map(([f, e]) => [f, [...e].sort(([a], [b]) => a.localeCompare(b)).map(([id, k]) => [id, k.p?.toArray(), k.q?.map((q) => q.toArray()), k.basePos?.toArray(), k.baseQ?.map((q) => q.toArray()), k.keepTranslations, k.chainP?.map((p) => p.toArray()), k.correctionRange])]));
+}
+
+/** Measured skin, shared exact transforms; never a cached bind-pose sole. */
+export function createSupportSampler(rig) { return createSurfaceSampler(rig, SUPPORT_SITES); }
+
+function sitePoint(row, site) {
+	return site.kind === "foot" ? (row.toes?.[site.id] ?? row.support[site.id]?.position) : row.support[site.id]?.position;
+}
+
+export function supportIntervals(samples, fps, overrides = [], floorY = 0, groundAt = null) {
+	const spans = [], rejected = [], count = samples.length;
+	const masks = Array.from({ length: count }, () => new Map());
+	for (const site of SUPPORT_SITES) {
+		const floor = quantile(samples.map((r) => r.support[site.id]?.floor), 0.08);
+		const flags = samples.map((r, i) => {
+			const a = samples[Math.max(0, i - 2)].support[site.id], b = samples[Math.min(count - 1, i + 2)].support[site.id], c = r.support[site.id];
+			const pa = sitePoint(samples[Math.max(0, i - 2)], site), pb = sitePoint(samples[Math.min(count - 1, i + 2)], site);
+			if (!a || !b || !c || !pa || !pb) return false;
+			const dt = (Math.min(count - 1, i + 2) - Math.max(0, i - 2)) / fps || 1 / fps;
+			const localGround = r.ground?.[site.id] ?? (groundAt ? groundAt((sitePoint(r, site) ?? c.position).x, (sitePoint(r, site) ?? c.position).z, c.position.y + 0.001) : floorY);
+			return c.floor < localGround + (site.kind === "foot" ? 0.15 : 0.07)
+				&& c.floor < floor + 0.055 && Math.abs(b.position.y - a.position.y) / dt < 0.25
+				&& Math.hypot(pb.x - pa.x, pb.z - pa.z) / dt < 0.16;
+		});
+		const forced = new Set();
+		for (const edit of overrides.filter((o) => o.site === site.id)) {
+			for (let f = Math.max(0, edit.start); f <= Math.min(count - 1, edit.end); f += 1) {
+				flags[f] = edit.mode === "plant";
+				if (flags[f]) forced.add(f); else forced.delete(f);
+			}
+		}
+		let start = -1;
+		for (let f = 0; f <= count; f += 1) {
+			if (flags[f] && start < 0) start = f;
+			if ((f === count || !flags[f]) && start >= 0) {
+				const manual = [...forced].some((i) => i >= start && i < f);
+				if (f - start >= Math.max(3, Math.round(fps * 0.12)) || manual) {
+					const rows = samples.slice(start, f).map((r) => sitePoint(r, site));
+					const anchor = new THREE.Vector3(quantile(rows.map((r) => r.x), 0.5), 0, quantile(rows.map((r) => r.z), 0.5));
+					const wander = Math.max(...rows.map((r) => Math.hypot(r.x - anchor.x, r.z - anchor.z)));
+					if (site.kind === "foot") anchor.y = groundAt ? groundAt(anchor.x, anchor.z, quantile(rows.map((r) => r.y), 0.5) + 0.001) : quantile(rows.map((r) => r.y), 0.5);
+					const span = { id: `${site.id}:${start}`, site: site.id, start, end: f - 1, anchor, manual, wander };
+					if (wander <= PHYSICS_LIMITS.pull || manual) {
+						spans.push(span);
+						for (let i = start; i < f; i += 1) masks[i].set(site.id, span);
+					} else rejected.push({ ...span, reason: "moving-contact" });
+				}
+				start = -1;
+			}
+		}
+	}
+	return { spans, masks, rejected };
+}
+
+export function physicsMetrics(samples, masks, fps, floorY = 0, groundAt = null) {
+	const m = { penetration: 0, penetrationFrame: 0, float: 0, floatFrame: 0, slide: 0, slideFrame: 0, meanSlide: 0, kneeStep: 0, kneeStepFrame: 0, kneeAcceleration: 0, rootAcceleration: 0, count: 0, surfaceMeasured: samples.every((s) => SUPPORT_SITES.slice(0, 2).every((site) => s.support[site.id]?.vertices > 0)) };
+	for (let f = 0; f < samples.length; f += 1) {
+		for (const [id, point] of Object.entries(samples[f].support)) if (point.vertices > 0) { const g = samples[f].ground?.[id] ?? floorY; if (g - point.floor > m.penetration) { m.penetration = g - point.floor; m.penetrationFrame = f; } }
+		for (const site of SUPPORT_SITES) {
+			const r = samples[f].support[site.id]; if (!r) continue;
+			const ground = samples[f].ground?.[site.id] ?? floorY;
+			const depth = Math.max(0, ground - r.floor);
+			if (depth > m.penetration) { m.penetration = depth; m.penetrationFrame = f; }
+			const span = masks[f]?.get(site.id);
+			if (span) {
+				const point = sitePoint(samples[f], site);
+				const slide = Math.hypot(point.x - span.anchor.x, point.z - span.anchor.z);
+				if (slide > m.slide) { m.slide = slide; m.slideFrame = f; }
+				const gap = Math.max(0, r.floor - ground);
+				if (gap > m.float) { m.float = gap; m.floatFrame = f; }
+				m.meanSlide += slide; m.count += 1;
+			}
+		}
+		for (const side of ["leftFoot", "rightFoot"]) {
+			if (f > 0) {
+				const step = Math.abs(samples[f].knees[side] - samples[f - 1].knees[side]);
+				if (step > m.kneeStep) { m.kneeStep = step; m.kneeStepFrame = f; }
+			}
+			if (f > 1) {
+				const a = Math.abs(samples[f].knees[side] - 2 * samples[f - 1].knees[side] + samples[f - 2].knees[side]) * fps * fps;
+				if (a > m.kneeAcceleration) { m.kneeAcceleration = a; m.kneeAccelerationFrame = f; }
+			}
+		}
+		if (f > 1) {
+			const a = samples[f].root.clone().add(samples[f - 2].root).addScaledVector(samples[f - 1].root, -2).length() * fps * fps;
+			if (a > m.rootAcceleration) { m.rootAcceleration = a; m.rootAccelerationFrame = f; }
+		}
+	}
+	m.meanSlide /= m.count || 1;
+	return m;
+}

package/src/{ardy → motion}/physics-support.js

@@ -1,10 +1,9 @@
 import * as THREE from "three";
 import { findBone } from "./ik.js";
-import { SEGMENT_MASSES } from "./auto-physics.js";
+import { SEGMENT_MASSES } from "./center-of-mass.js";
 
 const G = 9.81;
 const V = () => new THREE.Vector3();
-const smooth = (t) => { t = Math.max(0, Math.min(1, t)); return t * t * (3 - 2 * t); };
 const SUPPORT_LIMITS = Object.freeze({ gap: .025, force: .22, moment: .10, maxDrop: .60, friction: .6 });
 
 /** Cached bone lookup and an explicit approximate segmented physical body.
@@ -121,80 +120,6 @@ function patchesAt(row, floorY, shift = 0, overrides = [], frame = 0) {
 		&& !overrides.some((o) => o.site === id && o.mode === "free" && frame >= o.start && frame <= o.end));
 }
 
-/** Joint hypothesis search over vertical body alignment and support patches.
- * The scene plane stays fixed. No action names, pose labels, or forced feet.
- * Flight is a temporal acceleration hypothesis, never 'low velocity'. */
-export function inferSupportAlignment(rows, fps, { floorY = 0, overrides = [], protectedFrames = [], strength = 1 } = {}) {
-	const motion = supportMotion(rows, fps), n = rows.length;
-	const shifts = new Float64Array(n), candidates = [], flight = new Set(), unknown = [];
-	const observed = rows.map((row) => Math.min(...Object.values(row.support).filter((p) => p.vertices > 0).map((p) => p.floor - floorY)));
-	for (let f = 0; f < n; f += 1) {
-		const demand = motion[f], row = rows[f];
-		const baseline = solveSupportForces(row, demand, patchesAt(row, floorY, 0, overrides, f));
-		// Preserve true ballistic motion, including nearby transition frames.
-		let ballistic = 0, tested = 0;
-		for (let i = Math.max(0, f - 2); i <= Math.min(n - 1, f + 2); i += 1) { tested += 1; if (motion[i].force.length() < .28) ballistic += 1; }
-		if (ballistic >= Math.ceil(tested * .6)) { flight.add(f); candidates.push({ frame: f, mode: "flight", shift: 0, ...baseline }); continue; }
-		let shift = 0, selected = baseline, mode = baseline.forceResidual <= SUPPORT_LIMITS.force && baseline.momentResidual <= SUPPORT_LIMITS.moment ? "supported" : "unknown";
-		const gap = observed[f];
-		// Only a sustained support demand is eligible for automatic alignment.
-		// Fast/transient failure is left visible rather than flattened to floor.
-		const stableDemand = demand.force.y > .55 && demand.force.y < 1.5 && Math.hypot(demand.force.x, demand.force.z) < .55;
-		let hints = [];
-		if (mode === "unknown" && stableDemand && gap > -.12 && gap <= SUPPORT_LIMITS.maxDrop) {
-			let best = Infinity;
-			// Body translation and reachable limb contact are hypotheses together.
-			// A low foot may rise via IK while a hand/knee descends. Rigidly
-			// lowering everything to the single lowest vertex cannot solve this.
-			for (const proposed of [...new Set([0, .002 - gap, -.033 - gap, -.068 - gap, -.098 - gap])]) {
-				if (proposed > .12 || proposed < -SUPPORT_LIMITS.maxDrop) continue;
-				const movable = /^(left|right)(Foot|Hand|Knee)$/;
-				const rigid = Object.entries(row.support).filter(([id, p]) => !movable.test(id) && p.vertices > 0);
-				if (rigid.some(([, p]) => p.floor + proposed < floorY - .025)) continue;
-				const patches = []; let correction = 0;
-				for (const [id, p] of Object.entries(row.support)) {
-					if (!p.vertices || overrides.some((o) => o.site === id && o.mode === "free" && f >= o.start && f <= o.end)) continue;
-					const distance = p.floor + proposed - floorY;
-					if (Math.abs(distance) > (movable.test(id) ? .105 : .025)) continue;
-					const dy = floorY + .002 - proposed - p.floor;
-					patches.push([id, { ...p, patch: (p.patch?.length ? p.patch : [p.point ?? p.position]).map((v) => v.clone().add(new THREE.Vector3(0, dy, 0))) }]);
-					correction += Math.abs(dy);
-				}
-				const fit = solveSupportForces(row, demand, patches);
-				const cost = fit.residual + .08 * Math.abs(proposed) + .10 * correction / Math.max(1, patches.length);
-				if (fit.forceResidual < .16 && fit.momentResidual < .075 && fit.residual < baseline.residual * .55 && cost < best) {
-					best = cost; shift = proposed; selected = fit; mode = "align";
-					hints = patches.filter(([id]) => (fit.loads[id] ?? 0) > .03 && movable.test(id)).map(([id]) => id);
-				}
-			}
-		}
-		candidates.push({ frame: f, mode, shift, hints, ...selected });
-	}
-	// A one-frame lucky force solution must not turn into a root jump.
-	const minRun = Math.max(5, Math.ceil(fps * .25));
-	for (let a = 0; a < n;) {
-		if (candidates[a].mode !== "align") { a += 1; continue; }
-		let b = a + 1; while (b < n && candidates[b].mode === "align") b += 1;
-		if (b - a >= minRun) for (let f = a; f < b; f += 1) shifts[f] = candidates[f].shift;
-		else for (let f = a; f < b; f += 1) candidates[f].mode = "unknown";
-		a = b;
-	}
-	const radius = Math.max(3, Math.round(fps * .35)), filtered = new Float64Array(n);
-	for (let f = 0; f < n; f += 1) {
-		if (flight.has(f) || protectedFrames.includes(f)) continue;
-		let sum = 0, weight = 0;
-		for (let i = Math.max(0, f - radius); i <= Math.min(n - 1, f + radius); i += 1) { const w = radius + 1 - Math.abs(f - i); sum += shifts[i] * w; weight += w; }
-		let influence = strength;
-		for (const p of protectedFrames) influence *= smooth(Math.abs(f - p) / (radius + 1));
-		// Never push a lower unrelated surface through the ground.
-		// IK will resolve the limited limb penetration admitted by a candidate;
-		// rigid-body patches were checked above and remain protected.
-		filtered[f] = sum / weight * influence;
-		if (candidates[f].mode === "unknown") unknown.push(f);
-	}
-	return { shifts: filtered, frames: candidates, flight, unknown, motion };
-}
-
 /** Deliberately independent of detected contact masks: 'no contacts' is not a
  * zero-error success when gravity requires support. */
 export function supportDiagnostics(rows, fps, floorY = 0) {

package/src/motion/rig-snapshot.js

@@ -0,0 +1,22 @@
+// Bone transform snapshots for a rig: playback writes bone rotations (and the hips position),
+// so starting or clearing a take captures every bone first and restores the prior pose exactly.
+
+/** Capture the local position and quaternion of every bone in the rig. */
+export function snapshotPlaybackBones(rig) {
+	const out = [];
+	rig.traverse((bone) => {
+		if (!bone.isBone) return;
+		out.push([bone, bone.quaternion.x, bone.quaternion.y, bone.quaternion.z, bone.quaternion.w, bone.position.x, bone.position.y, bone.position.z]);
+	});
+	return out;
+}
+
+/** Restore transforms captured by snapshotPlaybackBones. */
+export function restorePlaybackBones(rig, snapshot) {
+	if (!rig || !snapshot) return;
+	for (const entry of snapshot) {
+		entry[0].quaternion.set(entry[1], entry[2], entry[3], entry[4]);
+		if (entry.length > 5) entry[0].position.set(entry[5], entry[6], entry[7]);
+	}
+	rig.updateMatrixWorld(true);
+}

package/src/motion/take-segments.jsx

@@ -0,0 +1,140 @@
+// The Full-Body strip of the Sequencer as timing segments of the installed take (take-edit.js):
+// Cut at the playhead, drag a segment's amber grip to retime it (wider is slower), drag the
+// outer green grips to trim, right-click a segment to drop it. Each gesture previews here and
+// commits ONE timing command on release (commands/motion-timing.js), so each is one Undo.
+import { useRef, useState } from "react";
+import { isKo, ko } from "../locale.js";
+import { frameFromClientX } from "./timeline-coordinates.js";
+import { createTakeEdit, segmentSpeedForFrames, takeEditLayout, TRIM_MIN_FRAMES } from "../motion3/take-edit.js";
+
+/** The motion prop the Sequencer draws: frames, label and timing segments of the active
+ * character's take, with the timing commands bound to that character. */
+export function timelineTake(motion, characterId, run) {
+	if (!motion) return null;
+	const act = (action, args = {}) => (characterId ? run?.(action, { characterId, ...args }) : null);
+	return {
+		frames: motion.frames, label: motion.prompt || ko("Compiled take", "컴파일된 테이크"),
+		segments: takeEditLayout(motion.edit ?? createTakeEdit(motion.frames)),
+		cut: frame => act("motion.cut", { frame }), speed: (segmentId, speed) => act("motion.setSegmentSpeed", { segmentId, speed }),
+		remove: segmentId => act("motion.removeSegment", { segmentId }), trim: (start, end) => act("motion.trim", { start, end }), reset: () => act("motion.resetTiming"),
+	};
+}
+
+const selectedSegment = (segments, frame) => segments.find(segment => frame >= segment.timelineStart && frame <= segment.timelineEnd) ?? segments[0] ?? null;
+
+function trimRange(edge, frame, preview, max) {
+	return edge === "start"
+		? { ...preview, start: Math.max(0, Math.min(frame, preview.end - TRIM_MIN_FRAMES)) }
+		: { ...preview, end: Math.min(max, Math.max(frame, preview.start + TRIM_MIN_FRAMES)) };
+}
+
+/** While a speed grip is held the dragged segment shows its would-be width and the segments
+ * after it slide by the delta: the same reflow the commit produces. */
+function shownSegments(segments, preview) {
+	if (preview?.kind === "trim") return [{ id: "motion-trim-preview", timelineStart: preview.start, timelineEnd: preview.end, preview: true }];
+	if (preview?.kind !== "speed") return segments;
+	let shift = 0;
+	return segments.map(segment => {
+		if (segment.id !== preview.id) return shift ? { ...segment, timelineStart: segment.timelineStart + shift, timelineEnd: segment.timelineEnd + shift } : segment;
+		const shown = { ...segment, timelineStart: segment.timelineStart + shift, timelineEnd: segment.timelineStart + shift + preview.timelineFrames - 1, previewSpeed: preview.speed };
+		shift += preview.timelineFrames - segment.timelineFrames;
+		return shown;
+	});
+}
+
+export function TakeSegmentClips({ motion, frame, frameCount, displayFrameCount, clipPct, tools }) {
+	const drag = useRef(null);
+	const [preview, setPreview] = useState(null);
+	const segments = motion.segments, selected = selectedSegment(segments, frame), max = motion.frames - 1;
+	function begin(e, state) {
+		if (e.button !== 0) return;
+		e.preventDefault();
+		e.stopPropagation();
+		const rect = e.currentTarget.closest(".tl-lane")?.getBoundingClientRect();
+		if (!rect || rect.width < 2) return;
+		e.currentTarget.setPointerCapture?.(e.pointerId);
+		drag.current = { ...state, rect, displayFrameCount };
+		setPreview(state.preview ?? null);
+	}
+	function move(e) {
+		const active = drag.current;
+		if (!active) return;
+		if (active.preview?.kind === "trim") active.preview = trimRange(active.edge, Math.min(max, frameFromClientX(e.clientX, active.rect.left, active.rect.width, active.displayFrameCount, frameCount)), active.preview, max);
+		else {
+			// a slower segment outgrows the timeline: the grip keeps counting frames past the lane's end
+			const at = ((e.clientX - active.rect.left) / Math.max(1, active.rect.width)) * Math.max(0, active.displayFrameCount - 1);
+			const speed = segmentSpeedForFrames(active.segment, Math.max(1, Math.round(at) - active.segment.timelineStart + 1));
+			const timelineFrames = Math.max(1, Math.round((active.segment.sourceEnd - active.segment.sourceStart + 1) / speed));
+			if (active.preview?.speed === speed) return;
+			active.preview = { kind: "speed", id: active.segment.id, speed, timelineFrames };
+		}
+		setPreview(active.preview);
+	}
+	function end(e) {
+		const active = drag.current;
+		drag.current = null;
+		e.currentTarget.releasePointerCapture?.(e.pointerId);
+		setPreview(null);
+		const next = active?.preview;
+		if (next?.kind === "trim" && (next.start > 0 || next.end < max)) motion.trim(next.start, next.end);
+		if (next?.kind === "speed" && next.speed !== active.segment.speed) motion.speed(active.segment.id, next.speed);
+	}
+	const grip = (className, label, state, extra = {}) => (
+		<button className={`tl-motion-clip-handle ${className}`} type="button" aria-label={label} title={extra.title}
+			onPointerDown={e => begin(e, state)} onPointerMove={move} onPointerUp={end} onPointerCancel={end}
+			onContextMenu={extra.reset ? e => { e.preventDefault(); e.stopPropagation(); motion.reset(); } : undefined} />
+	);
+	const trimState = edge => ({ edge, preview: { kind: "trim", start: 0, end: max } });
+	const shown = shownSegments(segments, preview), single = segments.length === 1;
+	return shown.map((segment, index) => {
+		const speed = segment.previewSpeed ?? segment.speed, grips = tools && (segment.preview || selected?.id === segment.id);
+		const label = segment.preview
+			? `${segment.timelineStart}–${segment.timelineEnd} (${segment.timelineEnd - segment.timelineStart + 1}f)`
+			: single ? `${motion.label}${speed !== 1 ? ` · ${speed}×` : ""}` : `${index + 1} · ${speed}×`;
+		const trimReset = { title: ko("Drag to trim · right-click restores the full take", "드래그로 자르기 · 우클릭으로 전체 테이크 복원"), reset: true };
+		return (
+			<div
+				key={segment.id}
+				className={"tl-motion-clip" + (preview?.kind === "trim" ? " trimming" : "") + (segment.previewSpeed !== undefined ? " retiming" : "") + (!single && selected?.id === segment.id ? " selected" : "")}
+				style={{ "--tl-f-start": clipPct(Math.min(segment.timelineStart, displayFrameCount)), "--tl-f-end": clipPct(Math.min(segment.timelineEnd + 1, displayFrameCount)) }}
+				title={segment.preview ? undefined : isKo
+					? `전신 구간 ${index + 1} — ${segment.speed}× · ${segment.timelineFrames}프레임. 재생 헤드에서 컷 · 주황 그립을 끌어 배속 조절 · 우클릭으로 구간 삭제`
+					: `Full-Body segment ${index + 1} — ${segment.speed}× · ${segment.timelineFrames} frames. Cut at the playhead; drag the amber grip to retime; right-click to delete`}
+				onContextMenu={segment.preview || single ? undefined : e => { e.preventDefault(); e.stopPropagation(); motion.remove(segment.id); }}
+			>
+				{index === 0 && grips && grip("start", ko("Trim take start", "테이크 시작점 자르기"), trimState("start"), trimReset)}
+				<span className="tl-motion-clip-label">{label}</span>
+				{!segment.preview && grips && grip("speed", ko("Retime segment by stretch", "드래그로 구간 배속 조절"), { segment },
+					{ title: ko("Drag — wider is slower, narrower is faster", "드래그 — 늘리면 느리게, 줄이면 빠르게") })}
+				{index === shown.length - 1 && grips && grip("end", ko("Trim take end", "테이크 끝점 자르기"), trimState("end"), trimReset)}
+			</div>
+		);
+	});
+}
+
+/** Sequencer head tools for the take: Cut at the playhead and the selected segment's speed. */
+export function TakeSegmentTools({ motion, frame }) {
+	const selected = selectedSegment(motion.segments, frame), index = motion.segments.indexOf(selected);
+	const [draft, setDraft] = useState(null);
+	const commit = value => {
+		setDraft(null);
+		if (selected && Number.isFinite(value) && value !== selected.speed) motion.speed(selected.id, Math.max(0.1, Math.min(4, value)));
+	};
+	const canCut = Boolean(selected) && frame > selected.timelineStart && frame <= selected.timelineEnd && frame < motion.frames;
+	return (<>
+		<button type="button" className="tl-seq-action cut" data-testid="sequencer-cut" disabled={!canCut}
+			title={ko("Cut the Full-Body clip at the playhead", "재생 헤드에서 전신 클립 자르기")} onClick={() => motion.cut(frame)}>
+			{ko("Cut", "컷")}
+		</button>
+		{selected && (
+			<label className="tl-motion-speed-editor">
+				<span>{ko(`Segment ${index + 1} speed`, `구간 ${index + 1} 배속`)}</span>
+				<input type="range" min="0.1" max="4" step="0.1" value={draft ?? selected.speed} aria-label={ko("Selected Full-Body segment speed", "선택한 전신 구간 배속")}
+					onChange={e => setDraft(e.currentTarget.valueAsNumber)} onPointerUp={e => commit(e.currentTarget.valueAsNumber)} onKeyUp={e => commit(e.currentTarget.valueAsNumber)} />
+				<input type="number" min="0.1" max="4" step="0.1" value={selected.speed} aria-label={ko("Selected Full-Body segment speed value", "선택한 전신 구간 배속 값")}
+					onChange={e => commit(e.currentTarget.valueAsNumber)} />
+				<small>×</small>
+			</label>
+		)}
+	</>);
+}

package/src/{ardy → motion}/timeline-coordinates.js

@@ -8,27 +8,6 @@ export function frameFromClientX(clientX, laneLeft, laneWidth, displayFrameCount
 	return Math.max(0, Math.min(frameCount - 1, displayedFrame));
 }
 
-/** Convert drag delta into a raw prompt-block start frame. Geometry and frame
- * count are captured at pointer-down so extending the timeline cannot feed
- * back into the next pointermove. Scroll cancels out because this uses delta X. */
-export function promptMoveStartFrame(startFrame, startClientX, clientX, laneWidth, displayFrameCount) {
-	const framesPerPixel = Math.max(0, displayFrameCount - 1) / Math.max(1, laneWidth);
-	return startFrame + (clientX - startClientX) * framesPerPixel;
-}
-
-/** Half a second at 24 fps: a shorter take is a pose, not a motion. */
-export const TRIM_MIN_FRAMES = 12;
-
-/** Clamp one trim-handle drag of the loaded take into a legal in/out range.
- * `preview` is the range the gesture currently shows, `frame` the frame under
- * the pointer and `max` the take's last displayed frame. The opposite edge
- * never moves, and the remaining take never drops below `minFrames`. */
-export function motionTrimRange(edge, frame, preview, max, minFrames = TRIM_MIN_FRAMES) {
-	return edge === "start"
-		? { ...preview, start: Math.max(0, Math.min(frame, preview.end - minFrames)) }
-		: { ...preview, end: Math.min(max, Math.max(frame, preview.start + minFrames)) };
-}
-
 /** Optional Shot blocks use their own explicit inclusive range. Gaps remain
  * visible free-camera time instead of being inferred from the next card. */
 export function shotBlockGeometry(shots, index, frameCount, displayFrameCount = frameCount) {

package/src/{ardy → motion}/timeline.css

@@ -433,9 +433,9 @@
 	min-height: 0;
 	height: 100%;
 	display: grid;
+	/* Ruler, then the lanes in TRACKS order: Body group, Root path row, Camera Cuts group. */
 	grid-template-rows:
 		var(--tl-ruler-height, 24px)
-		var(--tl-track-row-height, 38px)
 		var(--tl-track-group-height, 114px)
 		var(--tl-track-row-height, 38px)
 		var(--tl-track-group-height, 114px);
@@ -447,7 +447,6 @@
 .v2-sequencer .tl-surface.empty-shots {
 	grid-template-rows:
 		var(--tl-ruler-height, 24px)
-		var(--tl-track-row-height, 38px)
 		var(--tl-track-group-height, 114px)
 		var(--tl-track-row-height, 38px)
 		var(--tl-track-group-height, 114px);