cozyclay 2.0.2 → 2.1.1

package/src/domains/motion.js

@@ -1,7 +1,3 @@
-import {
-	I2V_MOTION_STILL_OUTPUT, I2V_MOTION_SHOT_ASPECT, I2V_MOTION_MIN_DURATION,
-	waitForMotionJob, submitMotionJob, buildH3MotionPrompt,
-} from "../i2v-motion-client.js";
 import { useState, useEffect, useSyncExternalStore, useContext, useRef, useMemo } from "react";
 import { AppContext } from '../app-context.js';
 import { createDocumentStore } from '../document-store.js';
@@ -11,14 +7,11 @@ import {
 	TIMELINE_FPS,
 	hierarchyIdForIkFocus,
 	ARDY_PRESERVE_DEFAULT,
-	MULTIMODEL_REASONS,
-	nextCharacterId,
 	REST_BONES,
 	ARDY_SEED_MAX,
 	lineTrackLabel,
 	ARDY_DURATION_MIN,
 	buildPromptSchedule,
-	toArdyFrameEntries,
 	posePlacementFrame,
 	toArdySegments,
 	ARDY_FPS,
@@ -51,22 +44,15 @@ import * as THREE from "three";
 import { StudioProtocolError } from "../studio-agent-protocol.js";
 import { restorePlaybackBones, snapshotPlaybackBones, applyMotionFrame, captureArdyRoot } from "../ardy/playback.js";
 import { isKo, ko } from "../locale.js";
-import {
-	isPlatformPageUrl,
-	normalizeSourceUrl,
-	sourceLabel,
-	requestBridgeFootage,
-	fetchFootageBlob,
-	probeFootage,
-	requestBridgeExtract,
-} from "../multimodel-ingest.js";
 import { characterScaleFor, loadMotionFromUrl } from "../ardy/npz.js";
 import { supportHeightForObject, OBJECT_LIBRARY } from "../scene-objects.js";
 import { applySupportRise, autoRoofDrop, applyAutoFall, applyRootDrop, normalizeRootDrop } from "../ardy/root-drop.js";
-import { takeAnchor, createCharacterEntry } from "../scenes.js";
+import { isProxyFigure } from "../scenes.js";
+import { characterCapabilities, kindRefusal, refuseRigOnly } from "../character-kind.js";
 import { retimeMotion } from "../ardy/retime.js";
 import {
 	createMotionEdit,
+	motionEditLayout,
 	renderMotionEdit,
 	remapFrameKeyMap,
 	remapTimelineFrame,
@@ -92,8 +78,8 @@ import {
 } from "../take-recipe.js";
 import { buildGenerationRequest, generationRefusal } from '../motion/generation.js';
 import { planPosePin } from '../ardy/pose-pin.js';
-import { applyTrailFalloffDelta, restoreTrailEdits, trailEditRange, worldDeltaToTrailClip } from "../motion-trail.js";
-import { bakeIkDragKey, chainsChangedBy, ikDragRecord, ikDragTouch } from "../ardy/ik-drag.js";
+import { TRAIL_TRACKS, applyTrailFalloffDelta, restoreTrailEdits, trailEditRange, worldDeltaToTrailClip } from "../motion-trail.js";
+import { bakeIkDragKey, bakeIkDragRange, chainsChangedBy, ikDragRecord, ikDragTouch } from "../ardy/ik-drag.js";
 import { ikKeyJson, ikTrackKeyFromJson } from "../ardy/ik-key-json.js";
 import { findAbsoluteIkKeyConflicts } from "../trail-key-conflicts.js";
 import { chooseIkEntryPose } from "../ik-camera.js";
@@ -103,52 +89,10 @@ import { openMotionDb, getMotion, putMotion } from "../motion-store.js";
 import { resolveMotionSource, decodeMotionResource, encodeMotionResource, sha256Hex } from "../motion-resources.js";
 import { applyRangePin, captureRangePinTarget, normalizeRangePin, rangePinTargetWorld, rangePinTracks, removeRangePinKeys } from "../ardy/range-pin.js";
 import { rangePinObjectMatrixAt } from "../range-pin-object-transform.js";
+import { createMotionVideoCapture } from "./motion/motion-video-capture.js";
+import { ensureRangePinState, overlappingRangePin, rangePinConflictFrames, rangePinOverlapMessage } from "./motion/motion-range-pin-rules.js";
 
-const sameMotionIntent = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-const emptyMotionLayer = id => ({ id, take: null, fullTake: null, ikKeys: [], ikPins: [], ikPinResiduals: [], committedIkEdits: [], takeRecipe: null, takeVersions: [] });
-const keyVector = p => ({ x: p.x, y: p.y, z: p.z });
-const keyQuaternion = q => ({ ...keyVector(q), w: q.w });
-function encodeMotionKeys(keys) {
-	return [...keys].sort(([a], [b]) => a - b).map(([frame, tracks]) => ({ frame, tracks: Object.fromEntries([...tracks].map(([track, key]) => [track, {
-		...(key.q ? { q: key.q.map(keyQuaternion) } : {}), ...(key.p ? { p: keyVector(key.p) } : {}),
-		...(key.baseQ ? { baseQ: key.baseQ.map(keyQuaternion) } : {}), ...(key.basePos ? { basePos: keyVector(key.basePos) } : {}),
-		...(key.chainP ? { chainP: key.chainP.map(keyVector) } : {}), ...(key.keepTranslations ? { keepTranslations: true } : {}),
-		...(key.blend != null ? { blend: key.blend } : {}),
-		...(key.pin ? { pin: key.pin } : {}),
-	}])) }));
-}
-function decodeMotionKeys(rows) {
-	const q = value => new THREE.Quaternion(value.x, value.y, value.z, value.w).normalize();
-	const p = value => new THREE.Vector3(value.x, value.y, value.z);
-	return new Map(rows.map(row => [row.frame, new Map(Object.entries(row.tracks).map(([track, key]) => [track, {
-		q: key.q?.map(q) ?? null, p: key.p ? p(key.p) : null,
-		...(key.baseQ ? { baseQ: key.baseQ.map(q) } : {}), ...(key.basePos ? { basePos: p(key.basePos) } : {}),
-		...(key.chainP ? { chainP: key.chainP.map(p) } : {}), ...(key.keepTranslations ? { keepTranslations: true } : {}),
-		...(key.blend != null ? { blend: key.blend } : {}),
-		...(key.pin ? { pin: key.pin } : {}),
-	}]))]));
-}
-function cloneRangePin(pin) {
-	return {
-		...pin,
-		target: pin.target.space === "world"
-			? { space: "world", position: [...pin.target.position] }
-			: { space: "object", objectId: pin.target.objectId, local: [...pin.target.local] },
-	};
-}
-function encodeRangePins(pins) {
-	return [...(pins instanceof Map ? pins.values() : pins ?? [])].map(cloneRangePin);
-}
-function decodeRangePins(rows) {
-	return new Map((rows ?? []).map((pin) => [pin.id, cloneRangePin(pin)]));
-}
-function encodeRangePinResiduals(values) {
-	return [...(values instanceof Map ? values.entries() : values ?? [])].map(([id, entries]) => [id, (entries ?? []).map((entry) => ({ ...entry }))]);
-}
-function decodeRangePinResiduals(rows) {
-	return new Map((rows ?? []).map(([id, entries]) => [id, (entries ?? []).map((entry) => ({ ...entry }))]));
-}
-
+import { sameMotionIntent, emptyMotionLayer, encodeMotionKeys, decodeMotionKeys, cloneRangePin, encodeRangePins, decodeRangePins, encodeRangePinResiduals, decodeRangePinResiduals } from "./motion/motion-intent-codec.js";
 // Plain intent owns take identities and JSON keys. Decoded buffers and rig
 // preimages are copy-on-record runtime resources, never mutable store values.
 export function createMotionDomain(appContext, characters) {
@@ -158,7 +102,10 @@ export function createMotionDomain(appContext, characters) {
 		const ref = entry.motionRef;
 		const take = ref ? { resourceId: `restore:${entry.id}:${ref.motionId ?? ref.url}`, url: ref.url ?? null, anchorX: ref.anchorX, anchorZ: ref.anchorZ,
 			rotationDeg: ref.rotationDeg, prompt: ref.prompt ?? '', ...(ref.trailEdits ? { trailEdits: ref.trailEdits } : {}), ...(ref.studioTakeId ? { studioTakeId: ref.studioTakeId } : {}) } : null;
-		return { id: entry.id, take, fullTake: take, takeVersions: ref?.url ? [{ motionUrl: ref.url, recipe: null, savedAt: Date.now(), label: ko('Loaded', '불러옴') }] : [] };
+		// The saved Pose-mode / IK edits come back with the scene (scenes.js ikEdits).
+		const edits = entry.ikEdits;
+		return { id: entry.id, take, fullTake: take, takeVersions: ref?.url ? [{ motionUrl: ref.url, recipe: null, savedAt: Date.now(), label: ko('Loaded', '불러옴') }] : [],
+			ikKeys: edits?.keys ?? [], ikPins: edits?.pins ?? [], ikPinResiduals: edits?.pinResiduals ?? [] };
 	});
 	function snapshotTake(take) {
 		if (!take) return null;
@@ -192,6 +139,8 @@ export function createMotionDomain(appContext, characters) {
 	const visibleMotion = id => previews.get(id) ?? motionFor(id);
 	const frame = () => appContext.live.state?.timeline.currentFrame ?? 0;
 	const rigFor = id => appContext.shared.rigs[id];
+	// Rig-only tools refuse a capsule figure by name before looking for its rig.
+	const rigOnly = (id, feature) => refuseRigOnly(appContext.storeDomain('cast')?.read().find(row => row.id === id), feature);
 	function rigSnapshots() {
 		return new Map(Object.entries(appContext.shared.rigs).map(([id, rig]) => [id, appContext.shared.snapshotExportRig(rig)]));
 	}
@@ -245,8 +194,10 @@ export function createMotionDomain(appContext, characters) {
 			.flatMap(rows => rows.flatMap(row => [row.take?.resourceId, row.fullTake?.resourceId])).filter(Boolean));
 		for (const id of takes.keys()) if (!ids.has(id)) takes.delete(id);
 	}
-	function beginAction() {
-		rigImages.set(read(), gesture?.rigs ?? rigSnapshots());
+	function beginAction(preimages = null) {
+		// The bus passes a target id; an explicit preview commit can override
+		// only its rig's preimage without retaining the preview in Undo.
+		rigImages.set(read(), new Map([...(gesture?.rigs ?? rigSnapshots()), ...(preimages instanceof Map ? preimages : [])]));
 		const session = documentStore.beginAction('motion');
 		return { ...session,
 			run(fn) { return session.run(() => { running++; try { return fn(); } finally { running--; } }); },
@@ -267,6 +218,7 @@ export function createMotionDomain(appContext, characters) {
 		setRangePinState(id, state);
 	}
 	function bakeRangePin(id, spec, replaceExisting = false, projectionOnly = false) {
+		rigOnly(id, 'ik');
 		const motion = motionFor(id), rig = rigFor(id), resolved = rig && resolveIkRig(rig);
 		if (!motion || !resolved) throw new StudioProtocolError('TARGET_NOT_READY', 'Load a take and rig for this character first.');
 		const pin = normalizeRangePin(spec, { clipFrames: motion.frames }), state = rangePinState(id);
@@ -331,7 +283,8 @@ export function createMotionDomain(appContext, characters) {
 	function clear(id) {
 		previews.delete(id);
 		writeLayer(id, { take: null, fullTake: null, ikKeys: [], ikPins: [], ikPinResiduals: [], committedIkEdits: [], takeRecipe: null });
-		castWrite(rows => rows.map(row => row.id === id ? { ...row, scale: 1, motionRef: null } : row));
+		castWrite(rows => rows.map(row => row.id === id ? { ...row, scale: 1, motionRef: null,
+			layer: { ...row.layer, promptClips: [] } } : row));
 		synchronizeTimeline();
 	}
 	function editSegments(id, segments) {
@@ -351,6 +304,7 @@ export function createMotionDomain(appContext, characters) {
 		synchronizeTimeline();
 	}
 	function fix(id, scope = 'frame') {
+		rigOnly(id, 'collision');
 		const rig = rigFor(id), resolved = rig && resolveIkRig(rig);
 		if (!resolved) throw new StudioProtocolError('TARGET_NOT_READY', 'The character rig is not loaded.');
 		const state = appContext.shared.ikStatesRef.current.get(id) ?? { ...createIkState(), ...resolved };
@@ -362,7 +316,7 @@ export function createMotionDomain(appContext, characters) {
 			try {
 				fixCollisionsRange({ rig, ...resolved, ikState: state, startFrame: 0, endFrame: take.frames - 1,
 					applyFrame(at) { applyMotionFrame(rig, take, at); ikEvaluate(resolved.chains, state, at, resolved.fkJoints, 6); },
-					blockersAt(at) { for (const row of read()) if (row.id !== id) appContext.shared.poseMemberAtFrame(rigFor(row.id), motionFor(row.id), appContext.shared.ikStatesRef.current.get(row.id), at, 6); return blockers(at); } });
+					blockersAt(at) { for (const row of read()) if (row.id !== id && rigFor(row.id)) appContext.shared.poseMemberAtFrame(rigFor(row.id), motionFor(row.id), appContext.shared.ikStatesRef.current.get(row.id), at, 6); return blockers(at); } });
 			} finally { for (const snapshot of originals.values()) appContext.shared.restoreExportRig(snapshot); }
 		} else {
 			const result = fixCollisions(rig, resolved.chains, { ikState: state, fkJoints: resolved.fkJoints, blockers: blockers(frame()) });
@@ -388,6 +342,7 @@ export function createMotionDomain(appContext, characters) {
 		return keyed ? run('ik.setKey', { characterId: id, frame: at, tracks: keyed.tracks }) : null;
 	}
 	function keyPose(id, at, pose) {
+		rigOnly(id, 'pose');
 		const rig = rigFor(id), resolved = rig && resolveIkRig(rig);
 		if (!resolved) throw new StudioProtocolError('TARGET_NOT_READY', 'The character rig is not loaded.');
 		restoreBindPositions(rig); applyPose(rig, { ...REST_BONES, ...pose.bones }); applyHipsOffset(rig, pose.rootY ?? 0);
@@ -397,6 +352,7 @@ export function createMotionDomain(appContext, characters) {
 		});
 	}
 	function editTrail(id, { track = "hips", grabFrame, radiusFrames, delta }) {
+		rigOnly(id, 'trails');
 		const take = motionFor(id), character = appContext.storeDomain('cast').read().find(row => row.id === id);
 		if (!take) throw new StudioProtocolError('TARGET_NOT_READY', 'Load a take first.');
 		const scale = character.scale ?? 1;
@@ -410,12 +366,14 @@ export function createMotionDomain(appContext, characters) {
 	let physicsJob = 0;
 	const physicsStamp = id => JSON.stringify([layer(id), appContext.storeDomain('cast').read().find(row => row.id === id)]);
 	function applyPhysics(id) {
+		rigOnly(id, 'physics');
 		const preview = physicsReviews.get(id);
 		if (!preview || preview.stamp !== physicsStamp(id)) throw new StudioProtocolError('STALE_TARGET', 'Analyse this take again before applying corrections.');
 		setKeys(id, preview.result.candidate.keys);
 		domain.onPhysicsPreview?.(null);
 	}
 	async function autoPhysics(id, options, context) {
+		rigOnly(id, 'physics');
 		const rig = rigFor(id), resolved = rig && resolveIkRig(rig), take = motionFor(id);
 		if (!resolved || !take) throw new StudioProtocolError('TARGET_NOT_READY', 'Load a take and character rig first.');
 		const job = ++physicsJob, stamp = physicsStamp(id), original = appContext.shared.snapshotExportRig(rig);
@@ -541,7 +499,6 @@ export function useMotion(appContext) {
 		return () => { window.removeEventListener('pointerdown', start, true); domain.finishGesture(true); };
 	}, [domain, appContext.shared.activeChar.id]);
 	const [i2vMotion, setI2vMotion] = useState({ a: null, b: null, job: null, status: "idle", error: "", instruction: "", dailyRemaining: null });
-	/* ------------------------------ IK layer ------------------------------ */
 	// IK posing for Subject 1: dragging a wrist/ankle handle FOCUSES that
 	// joint and solves its chain backward (two-bone analytic IK) on top of
 	// the current pose; joints never dragged stay purely on the FK pose.
@@ -554,6 +511,8 @@ export function useMotion(appContext) {
 	// outside React renders so pointer moves stay cheap and the drag-end bake
 	// can create a delta key over the raw clip.
 	const ikDragRef = useRef(null);
+	const ikPreDragRef = useRef(null);
+	const pendingIkEditRef = useRef(null);
 	const ikCameraMemoryRef = useRef(new Map());
 
 	const [ikChains, setIkChains] = useState(null);
@@ -561,6 +520,7 @@ export function useMotion(appContext) {
 	const [ikFkJoints, setIkFkJoints] = useState(null);
 
 	const [ikFocus, setIkFocus] = useState(null);
+	const [pendingIkEdit, setPendingIkEdit] = useState(null);
 
 	// Foot snap (ground plant): while ON, body (hips) drags keep the feet at
 	// the positions captured when the drag started — the knees bend instead
@@ -600,8 +560,7 @@ export function useMotion(appContext) {
 	const setCommittedIkEdits = update => domain.writeLayer(appContext.shared.activeChar.id, { committedIkEdits: typeof update === 'function' ? update(domain.layer(appContext.shared.activeChar.id).committedIkEdits) : update });
 	domain.onProject = () => setIkTick(value => value + 1);
 
-	/* --------------------- IK-mode motion trail editing ---------------------
-	 * Grabbing the viewport trajectory line deforms the loaded take with a
+	/* Grabbing the viewport trajectory line deforms the loaded take with a
 	 * smoothstep falloff around the grab frame (pure local preview). The last
 	 * finished drag stays pending so "Regenerate from trail edit" can send the
 	 * auto-derived window through the existing motionEdit pipeline. */
@@ -612,6 +571,7 @@ export function useMotion(appContext) {
 	const [ikEditTool, setIkEditTool] = useState("ik");
 
 	const [trailEdit, setTrailEdit] = useState(null);
+	const [trailTrackFocus, setTrailTrackFocus] = useState("hips");
 	const [rangePinSelection, setRangePinSelection] = useState(null);
 	const [rangePinPartPick, setRangePinPartPick] = useState(null);
 	const [rangePinPreview, setRangePinPreview] = useState(null);
@@ -629,12 +589,89 @@ export function useMotion(appContext) {
 		}
 	}
 
-	function ensureRangePinState(state) {
-		if (!state) return state;
-		if (!(state.pins instanceof Map)) state.pins = new Map();
-		if (!(state.pinResiduals instanceof Map)) state.pinResiduals = new Map();
-		return state;
+	function selectedIkRange(frame = appContext.shared.tlFrame) {
+		const count = Math.max(1, motion?.frames ?? appContext.shared.tlFrameCount ?? 1);
+		if (!motion) return { startFrame: 0, endFrame: count - 1 };
+		const edit = motion.editSegments ?? createMotionEdit(count);
+		const layout = motionEditLayout(edit);
+		const at = Math.max(0, Math.min(count - 1, Math.round(frame) || 0));
+		const selected = layout.find((segment) => at >= segment.timelineStart && at <= segment.timelineEnd) ?? layout[0];
+		return {
+			startFrame: Math.max(0, selected?.timelineStart ?? 0),
+			endFrame: Math.min(count - 1, selected?.timelineEnd ?? count - 1),
+		};
+	}
+
+	function setPendingIkEditValue(value) {
+		pendingIkEditRef.current = value;
+		setPendingIkEdit(value);
 	}
+
+	function restorePendingIkState(pending) {
+		// A replaced take or another authored edit owns the newer state.
+		if (domain.layer(pending.characterId) !== pending.sourceLayer) return;
+		const state = pending.state;
+		state.keys = copyPhysicsKeys(pending.beforeKeys);
+		state.tracked = new Set(pending.beforeTracked);
+		state.targets = new Map([...pending.beforeTargets].map(([id, target]) => [id, target.clone()]));
+		state.plants = new Map([...pending.beforePlants].map(([id, target]) => [id, target.clone()]));
+		if (pending.rig) {
+			if (pending.beforeFrame === appContext.shared.tlFrame) appContext.shared.restoreExportRig(pending.beforeRig);
+			else appContext.shared.poseMemberAtFrame(pending.rig, pending.motion, state, appContext.shared.tlFrame, IK_CORRECTION_BLEND_FRAMES);
+			if (state.chains) ikSeedTargets(state.chains, state);
+		}
+	}
+
+	function cancelPendingIkEdit() {
+		const pending = pendingIkEditRef.current;
+		if (!pending) return false;
+		restorePendingIkState(pending);
+		setPendingIkEditValue(null);
+		ikDragRef.current = null;
+		ikPreDragRef.current = null;
+		setIkTick((value) => value + 1);
+		return true;
+	}
+
+	function applyPendingIkEdit() {
+		const pending = pendingIkEditRef.current;
+		if (!pending) return false;
+		if (pending.characterId !== appContext.shared.activeChar.id || domain.layer(pending.characterId) !== pending.sourceLayer) {
+			cancelPendingIkEdit();
+			return false;
+		}
+		const session = domain.beginAction(new Map([[pending.characterId, pending.beforeRig]]));
+		try {
+			session.run(() => domain.setKeys(pending.characterId, pending.candidate.keys));
+			session.commit();
+		} catch (error) {
+			session.cancel();
+			throw error;
+		}
+		setPendingIkEditValue(null);
+		ikDragRef.current = null;
+		ikPreDragRef.current = null;
+		if (pending.rig) appContext.shared.poseMemberAtFrame(pending.rig, motion, pending.state, appContext.shared.tlFrame, IK_CORRECTION_BLEND_FRAMES);
+		setIkTick((value) => value + 1);
+		appContext.notify(isKo
+			? `IK 보정을 ${pending.startFrame}–${pending.endFrame}프레임에 적용했어요`
+			: `Applied IK correction across frames ${pending.startFrame}–${pending.endFrame}`);
+		return true;
+	}
+
+	function clearTrailTrackFocus() {
+		setTrailTrackFocus(null);
+		setIkFocus(null);
+	}
+	function selectTrailTrack(track) {
+		setTrailTrackFocus(track);
+		focusIkHandle(track);
+	}
+
+	useEffect(() => {
+		if (!ikMode || ikEditTool !== "trail") setTrailTrackFocus(TRAIL_TRACKS.some(track => track.id === ikFocus) ? ikFocus : "hips");
+	}, [ikMode, ikEditTool, ikFocus]);
+
 	function rangePinObjectWorldMatrix(objectId, frame) {
 		const object = appContext.shared.sceneObjects.find((entry) => entry.id === objectId);
 		if (!object) return null;
@@ -649,20 +686,6 @@ export function useMotion(appContext) {
 		appContext.shared.poseMemberAtFrame(appContext.shared.activeRig, motion, null, frame);
 		if (ikChains && state.keys.size > 0) ikEvaluate(ikChains, state, frame, ikFkJoints, IK_CORRECTION_BLEND_FRAMES);
 	}
-	function rangePinConflictFrames(draft, state = appContext.shared.ikStateRef.current) {
-		if (!Number.isInteger(draft?.startFrame) || !Number.isInteger(draft?.endFrame) || draft.endFrame < draft.startFrame) return [];
-		const tracks = rangePinTracks(draft), conflicts = [];
-		for (let frame = draft.startFrame; frame <= draft.endFrame; frame += 1) {
-			if (tracks.some((track) => { const key = state.keys.get(frame)?.get(track); return key && key.pin !== draft.id; })) conflicts.push(frame);
-		}
-		return conflicts;
-	}
-	function overlappingRangePin(draft, state = appContext.shared.ikStateRef.current) {
-		return [...ensureRangePinState(state).pins.values()].find((pin) => pin.id !== draft.id && rangePinTracks(pin).some((track) => rangePinTracks(draft).includes(track)) && Math.max(pin.startFrame, draft.startFrame) <= Math.min(pin.endFrame, draft.endFrame));
-	}
-	function rangePinOverlapMessage(pin) {
-		return pin ? ko(`A required body or limb track already has an overlapping pin (${pin.startFrame}–${pin.endFrame}).`, `필요한 몸통 또는 팔다리 파츠에 겹치는 고정이 있어요 (${pin.startFrame}–${pin.endFrame}).`) : "";
-	}
 	function captureRangePinTargetForDraft(draft) {
 		if (!motion || !appContext.shared.activeRig || !ikChains) return null;
 		const objectWorldMatrix = draft.targetKind === "object" ? (objectId, frame) => rangePinObjectWorldMatrix(objectId, frame) : null;
@@ -758,7 +781,7 @@ export function useMotion(appContext) {
 	/** Write one key from its JSON form (studio-actions.js character.setIkKey):
 	 * each named track replaces its key at `frame` and joins the tracked set. */
 	function setCharacterIkKey(characterId, frame, tracks) {
-		appContext.shared.castMemberOf(characterId);
+		refuseRigOnly(appContext.shared.castMemberOf(characterId), 'ik');
 		if (appContext.storeDomain('motion')) return appContext.storeDomain('motion').setKey(characterId, frame, tracks);
 		editCharacterIkKeys(characterId, (state) => {
 			let entry = state.keys.get(frame);
@@ -794,11 +817,6 @@ export function useMotion(appContext) {
 		return count;
 	}
 
-	/** A baked key entry in the JSON form character.setIkKey takes. */
-	function ikKeyJson(entry) {
-		return ikKeyJson(entry);
-	}
-
 	const [bridge, setBridge] = useState(null);
 
 	const [bridgeChecking, setBridgeChecking] = useState(false);
@@ -833,8 +851,7 @@ export function useMotion(appContext) {
 	// operator scrubbed to — the box takes any destination frame.
 	const [ardyPosePlacement, setArdyPosePlacement] = useState("start");
 
-	/* ------------------- take recipes and versions (C9/C12) -------------------
-	 * The recipe of the take that is loaded RIGHT NOW: seed + prompt blocks +
+	/* The recipe of the take that is loaded RIGHT NOW: seed + prompt blocks +
 	 * the line edits pulled on top of it. It is written in exactly one place
 	 * (commitTakeRecipe, on a successful run) and read in two: the request
 	 * assembly, which attaches it as C10 `replay`, and the version strip, which
@@ -873,9 +890,6 @@ export function useMotion(appContext) {
 
 	const [ardyOutcome, setArdyOutcome] = useState(null);
 
-	// Timeline frames for the configured duration: [0, duration*TIMELINE_FPS-1].
-	const maxDst = Math.max(0, Math.round(ardyDuration) * TIMELINE_FPS - 1);
-
 	// Wave-2 gate: the bridge only routes lineEdit once M4's routing lands.
 	// Until the /ardy/health payload says so, the request is never sent —
 	// today's bridge ignores unknown fields, so an ungated POST would quietly
@@ -884,6 +898,13 @@ export function useMotion(appContext) {
 
 	// Loaded motion: decoded arrays plus the world anchor captured at load.
 	const motion = domain.visibleMotion(appContext.shared.activeChar.id);
+	useEffect(() => {
+		const pending = pendingIkEditRef.current;
+		if (pending && (pending.characterId !== appContext.shared.activeChar.id
+			|| pending.rig !== appContext.shared.activeRig || pending.motion !== motion
+			|| pending.sourceLayer !== domain.layer(pending.characterId)
+			|| !ikMode || ikEditTool !== "ik")) cancelPendingIkEdit();
+	}, [appContext.shared.activeChar.id, appContext.shared.activeRig, motion, pinLayer, ikMode, ikEditTool]);
 	const rangePinRebuildRef = useRef(null);
 	const rangePinSourceStamp = JSON.stringify([pinLayer.take, appContext.shared.activeChar.id]);
 	// A fit is invalidated by a different take, trim or preview, not by key
@@ -924,7 +945,6 @@ export function useMotion(appContext) {
 
 	const [motionError, setMotionError] = useState("");
 
-	/* ------------------------- video capture (ingest) ---------------------- */
 	const [multiModelUrl, setMultiModelUrl] = useState("");
 
 	const [multiModelSource, setMultiModelSource] = useState(null);
@@ -965,8 +985,8 @@ export function useMotion(appContext) {
 		appContext.shared.setTlFrame((f) => Math.max(0, Math.min(f + delta, appContext.shared.frameCountRef.current - 1)));
 	}
 
-	/* --------------------------- motion playback ---------------------------- */
 	function leaveIkMode() {
+		cancelPendingIkEdit();
 		const poserCam = appContext.shared.poserCamRef?.current;
 		if (ikMode && poserCam && appContext.shared.activeChar?.id) {
 			const look = appContext.shared.poserLook?.current ?? {};
@@ -995,257 +1015,6 @@ export function useMotion(appContext) {
 		appContext.shared.restoreRef.current = { rig, bones: snapshotPlaybackBones(rig) };
 	}
 
-	/* ---------------------------- video capture ----------------------------
-	 * Footage in, takes out. The ingest downloads and decodes a source so the
-	 * timeline is sized by what was actually read; extraction then turns it
-	 * into one take per tracked performer. Take 0 belongs to the ACTIVE
-	 * character's layer, the rest are landed on their own cast members. */
-	// A picked file is already local bytes: no download stage, straight to the
-	// probe that produces the timeline numbers.
-	function chooseMultiModelFile(event) {
-		const file = event.target.files?.[0] ?? null;
-		if (!file) return;
-		setMultiModelUrl("");
-		ingestFootage({ kind: "file", name: file.name, blob: file, bytes: file.size });
-	}
-
-	async function pasteMultiModelUrl() {
-		try {
-			const text = await navigator.clipboard.readText();
-			if (!text.trim()) return;
-			setMultiModelUrl(text.trim());
-			setMultiModelStatus("idle");
-		} catch {
-			appContext.notify(isKo ? "클립보드를 읽지 못했어요 — 직접 붙여넣어 주세요" : "Clipboard is unavailable — paste into the field directly");
-		}
-	}
-
-	function useMultiModelUrl() {
-		const raw = multiModelUrl.trim();
-		// A platform page (YouTube, Vimeo, …) is never browser-fetchable, but
-		// the dev bridge can fetch it server-side. With the bridge up the
-		// address goes there; without it the named refusal below stands.
-		if (isPlatformPageUrl(raw) && bridge?.ok) {
-			ingestPlatformFootage(raw);
-			return;
-		}
-		const normalized = normalizeSourceUrl(raw);
-		if (!normalized.ok) {
-			setMultiModelStatus("error");
-			setMultiModelStage("error");
-			setMultiModelError(MULTIMODEL_REASONS[normalized.reason]?.[isKo ? 1 : 0] ?? normalized.reason);
-			return;
-		}
-		ingestFootage({ kind: "url", name: sourceLabel(normalized.url), url: normalized.url });
-	}
-
-	/** Platform page → bridge download (yt-dlp + normalize) → the local
-	 *  /ardy/footage/… address rides the ordinary ingest unchanged. */
-	async function ingestPlatformFootage(pageUrl) {
-		const run = appContext.shared.multiModelRunRef.current + 1;
-		appContext.shared.multiModelRunRef.current = run;
-		const live = () => appContext.shared.multiModelRunRef.current === run;
-		setMultiModelSource({ kind: "url", name: sourceLabel(pageUrl), url: pageUrl });
-		setMultiModelFootage(null);
-		setMultiModelError("");
-		setMultiModelStatus("busy");
-		setMultiModelStage("fetching");
-		setMultiModelProgress(null);
-		setMultiModelTake(null);
-		setMultiModelExtract("idle");
-		setMultiModelExtractProgress(null);
-		setMultiModelExtractError("");
-		try {
-			const footage = await requestBridgeFootage(pageUrl, {
-				onProgress: ({ ratio }) => {
-					if (live()) setMultiModelProgress(Number.isFinite(ratio) ? ratio : null);
-				},
-			});
-			if (!live()) return;
-			ingestFootage({ kind: "url", name: footage.title || sourceLabel(pageUrl), url: footage.url, fps: footage.fps, bridgeId: footage.footage ?? null });
-		} catch (error) {
-			if (!live()) return;
-			const code = error?.message ?? String(error);
-			setMultiModelStage("error");
-			setMultiModelStatus("error");
-			setMultiModelProgress(null);
-			setMultiModelError(MULTIMODEL_REASONS[code]?.[isKo ? 1 : 0] ?? code);
-		}
-	}
-
-	/** Download (when remote), decode, measure, then size the timeline from what
-	 *  was actually read. Each run carries a token so a slow first source can
-	 *  never land its numbers after a second one replaced it. */
-	async function ingestFootage(source, commandContext = null) {
-		const run = appContext.shared.multiModelRunRef.current + 1;
-		appContext.shared.multiModelRunRef.current = run;
-		const live = () => appContext.shared.multiModelRunRef.current === run;
-		setMultiModelSource(source);
-		setMultiModelFootage(null);
-		setMultiModelError("");
-		setMultiModelStatus("busy");
-		setMultiModelProgress(null);
-		// A take baked from the PREVIOUS clip must not read as this one's
-		// result, so the extraction state resets with the source.
-		setMultiModelTake(null);
-		setMultiModelExtract("idle");
-		setMultiModelExtractProgress(null);
-		setMultiModelExtractError("");
-		try {
-			let blob = source.blob ?? null;
-			let bytes = source.bytes ?? 0;
-			if (!blob) {
-				setMultiModelStage("fetching");
-				const downloaded = await fetchFootageBlob(source.url, {
-					onProgress: ({ ratio }) => {
-						if (live()) setMultiModelProgress(ratio);
-					},
-				});
-				if (!live()) return;
-				blob = downloaded.blob;
-				bytes = downloaded.bytes;
-			}
-			setMultiModelStage("probing");
-			if (appContext.shared.multiModelObjectUrlRef.current) URL.revokeObjectURL(appContext.shared.multiModelObjectUrlRef.current);
-			const objectUrl = URL.createObjectURL(blob);
-			appContext.shared.multiModelObjectUrlRef.current = objectUrl;
-			const probed = await probeFootage(objectUrl, {
-				createVideo: () => document.createElement("video"),
-				// The bridge normalized the clip and DECLARED its rate; a probe
-				// that re-guesses it would overrule a measurement with a guess.
-				knownFps: Number.isFinite(source.fps) ? source.fps : null,
-			});
-			if (!live()) return;
-			commandContext?.check();
-			const footage = { ...probed, bytes, objectUrl, blob, bridgeId: source.bridgeId ?? null };
-			setMultiModelFootage(footage);
-			setMultiModelStage("ready");
-			setMultiModelStatus("ready");
-			setMultiModelProgress(1);
-			// The timeline is the point: the playhead now spans the footage that
-			// was actually decoded, at the rate that was actually measured.
-			appContext.shared.setTlFps(footage.fps);
-			appContext.shared.setTlFrameCount(footage.frames);
-			appContext.shared.setTlFrame(0);
-			appContext.shared.setTlPlaying(false);
-			appContext.notify((isKo, ko) => isKo
-				? `${source.name} 인제스트됨 — ${footage.frames}프레임 @ ${footage.fps} fps`
-				: `Ingested ${source.name} — ${footage.frames} frames @ ${footage.fps} fps`);
-			return footage;
-		} catch (error) {
-			if (commandContext && (commandContext.signal.aborted || error.code === "STALE_TARGET")) throw error;
-			if (!live()) return;
-			const code = error?.message ?? String(error);
-			setMultiModelStage("error");
-			setMultiModelStatus("error");
-			setMultiModelProgress(null);
-			setMultiModelError(MULTIMODEL_REASONS[code]?.[isKo ? 1 : 0] ?? code);
-		}
-	}
-
-	/** Extract motion from the ingested footage. With the bridge up this goes
-	 *  to the GPU box (GVHMR: whole-clip temporal context, real 3D body
-	 *  prior — previs-grade). If the bridge is unavailable or is configured for
-	 *  another backend, extraction stops with a named error. */
-	async function extractMultiModelMotion() {
-		if (!bridge?.ok) {
-			setMultiModelExtract("error");
-			setMultiModelExtractError(MULTIMODEL_REASONS["extract-bridge-required"]?.[isKo ? 1 : 0] ?? "extract-bridge-required");
-			return;
-		}
-		if (bridge.extractionBackend !== "gvhmr") {
-			setMultiModelExtract("error");
-			setMultiModelExtractError(MULTIMODEL_REASONS["extract-backend-unsupported"]?.[isKo ? 1 : 0] ?? "extract-backend-unsupported");
-			return;
-		}
-		return extractMultiModelMotionGpu();
-	}
-
-	async function extractMultiModelMotionGpu() {
-		const footage = multiModelFootage;
-		if (!footage || multiModelExtract === "running") return;
-		const run = appContext.shared.multiModelRunRef.current;
-		const live = () => appContext.shared.multiModelRunRef.current === run;
-		setMultiModelExtract("running");
-		setMultiModelExtractProgress(null);
-		setMultiModelExtractError("");
-		setMultiModelTake(null);
-		try {
-			const done = await requestBridgeExtract(
-				footage.bridgeId ? { footage: footage.bridgeId } : footage.blob,
-				{
-					onProgress: ({ ratio }) => {
-						if (live()) setMultiModelExtractProgress(Number.isFinite(ratio) ? ratio : null);
-					},
-				}
-			);
-			if (!live()) return;
-			if (done.quality && done.quality.pass === false) {
-				const failed = Array.isArray(done.quality.checks)
-					? done.quality.checks.filter((check) => check && check.pass === false).map((check) => check.name).join(", ")
-					: "quality";
-				appContext.notify(isKo
-					? `모캡 품질 경고: ${failed || "검증 실패"} — 결과는 로드하지만 보정이 필요합니다`
-					: `Mocap quality warning: ${failed || "validation failed"} — loaded for review, correction required`);
-			}
-			// One take per tracked performer. An older bridge sends a single
-			// motionUrl and no list; that is the same thing with one entry.
-			const takes = Array.isArray(done.takes) && done.takes.length
-				? done.takes
-				: [{ motionUrl: done.motionUrl, personScale: done.personScale, offsetX: 0, offsetZ: 0 }];
-			const label = multiModelSource?.name ?? "extracted take";
-			// The cast can change while the GPU works, so the destination is read
-			// now, once, and every take is placed against THIS character.
-			const active = appContext.live.characters.find((entry) => entry.id === appContext.shared.activeChar.id) ?? appContext.shared.activeChar;
-			// Take 0 arrives as an ordinary motion npz; loadMotion decodes,
-			// retimes to the 24 fps timeline, snapshots the rig baseline and
-			// applies the stature stored in the take itself — the body matches
-			// the FILMED person because the file carries the measurement, not
-			// because this handler remembered to re-apply it afterwards.
-			const fallbackScale = Number.isFinite(takes[0].personScale) ? takes[0].personScale : done.personScale;
-			let personScale = await loadMotion(takes[0].motionUrl ?? done.motionUrl, label, active.rot, null, active.id, null, { personScaleFallback: fallbackScale });
-			if (!live()) return;
-			// loadMotion reports the stature it applied — 1 for a take that
-			// stores none, nothing at all if the load failed. A failed load is
-			// not a finished extraction: say so with the named reason instead
-			// of a receipt for a take nobody can play.
-			if (!Number.isFinite(personScale)) throw new Error("extract-convert-failed");
-			// Only a take that stores NO stature gets the fallback for an npz
-			// that predates person_scale (or an older bridge): the response
-			// still carries the estimate, clamped the same way, because a bad
-			// leg estimate must never produce a giant or a gnome.
-			const declared = Number.isFinite(takes[0].personScale) ? takes[0].personScale : done.personScale;
-			if (personScale === 1 && Number.isFinite(declared)) {
-				personScale = characterScaleFor(null, declared);
-			}
-			// The clip itself is session-only; this reference is what a save
-			// keeps and restoreMotionRefs re-fetches on the next session.
-			const leadRef = {
-				url: takes[0].motionUrl ?? done.motionUrl,
-				prompt: label,
-				rotationDeg: active.rot,
-				anchorX: active.x,
-				anchorZ: active.z,
-			};
-			if (!appContext.storeDomain('motion')) appContext.shared.publishStudioCharacters((list) => list.map((entry) => entry.id === active.id
-				? { ...entry, scale: personScale, motionRef: leadRef }
-				: entry));
-			const placed = await deliverExtraTakes(takes.slice(1), active, label);
-			if (!live()) return;
-			const persons = 1 + placed;
-			setMultiModelTake({ frames: done.frames, fps: done.fps, gpu: true, personScale, persons, trajectory: done.performance?.trajectory, segmentation: done.segmentation ?? done.performance?.segmentation ?? takes[0]?.segmentation ?? null, quality: done.quality ?? takes[0]?.quality ?? null });
-			setMultiModelExtract("done");
-			appContext.notify(isKo
-				? `GPU 모션 추출됨 — ${done.frames}프레임 @ ${done.fps} fps${persons > 1 ? ` · ${persons}명` : ""} · 인물 스케일 ×${personScale.toFixed(2)}`
-				: `GPU motion extracted — ${done.frames} frames @ ${done.fps} fps${persons > 1 ? ` · ${persons} performers` : ""} · person scale ×${personScale.toFixed(2)}`);
-		} catch (error) {
-			if (!live()) return;
-			const code = error?.message ?? String(error);
-			setMultiModelExtract("error");
-			setMultiModelExtractError(MULTIMODEL_REASONS[code]?.[isKo ? 1 : 0] ?? code);
-		}
-	}
-
 	/** Land takes 1..N-1 on the rest of the cast. Each extra take is its OWN
 	 *  layer: it goes to that entry's sessionMotion, NOT through the editing
 	 *  buffer, which holds the active character's clip alone. Returns how many
@@ -1268,104 +1037,6 @@ export function useMotion(appContext) {
 		worldScale,
 	});
 
-	async function deliverExtraTakes(extras, active, label) {
-		const decoded = await Promise.all(extras.map(async (take, index) => {
-			if (typeof take?.motionUrl !== "string" || !take.motionUrl) return null;
-			try {
-				// Inbound boundary, exactly like every other clip: decode, then
-				// retime onto the production clock before anything counts frames.
-				const anchor = takeAnchor(active, take.offsetX, take.offsetZ);
-				const clip = retimeMotion(await loadMotionFromUrl(take.motionUrl), TIMELINE_FPS);
-				const scale = characterScaleFor(clip, take.personScale);
-				const raised = applyAuthoredSupportRise(clip, { ...anchor, y: active.y ?? 0 }, active.rot, scale);
-				const staging = autoRoofDrop(
-					raised,
-					{ x: anchor.x, z: anchor.z, y: active.y ?? 0, rotationDeg: active.rot },
-					authoredSupportDescriptors(),
-					{ worldScale: scale },
-				);
-				const stagedClip = staging ? applyAutoFall(raised, staging, { worldScale: scale }) : raised;
-				return {
-					url: take.motionUrl,
-					prompt: `${label} · ${index + 2}`,
-					rotationDeg: active.rot,
-					anchor,
-					// A second performer is a DIFFERENT body: their take carries
-					// their own stature, and the response estimate is only the
-					// fallback for an npz that stores none.
-					scale: characterScaleFor(clip, take.personScale),
-					clip: stagedClip,
-				};
-			} catch {
-				return null; // one unreadable take never voids the others
-			}
-		}));
-		const usable = decoded.filter(Boolean);
-		if (!usable.length) return 0;
-		const owned = appContext.storeDomain('motion');
-		// Plan against the cast as it stands, so ids are decided once and the
-		// full-take map can be seeded with them.
-		const list = appContext.live.characters;
-		const taken = new Set([active.id]);
-		let idPool = list;
-		const assignments = usable.map((take) => {
-			// Reuse a visible cast member with no clip of its own before adding
-			// another body to the set.
-			const reuse = list.find((entry) => !entry.hidden && !taken.has(entry.id) && !entry.sessionMotion && !entry.motionRef);
-			const id = reuse ? reuse.id : nextCharacterId(idPool);
-			if (!reuse) idPool = [...idPool, { id }];
-			taken.add(id);
-			return {
-				id,
-				spawn: !reuse,
-				patch: {
-					hidden: false,
-					x: take.anchor.x,
-					z: take.anchor.z,
-					rot: take.rotationDeg,
-					scale: take.scale,
-					motionRef: {
-						url: take.url,
-						prompt: take.prompt,
-						rotationDeg: take.rotationDeg,
-						anchorX: take.anchor.x,
-						anchorZ: take.anchor.z,
-					},
-					sessionMotion: {
-						...take.clip,
-						url: take.url,
-						prompt: take.prompt,
-						anchorX: take.anchor.x,
-						anchorZ: take.anchor.z,
-						anchorFrame: 0,
-						rotationDeg: take.rotationDeg,
-						editSegments: createMotionEdit(take.clip.frames),
-					},
-				},
-			};
-		});
-		const place = current => {
-			let next = current;
-			for (const { id, spawn, patch } of assignments) {
-				next = spawn && !next.some((entry) => entry.id === id)
-					? [...next, { ...createCharacterEntry({ id, model: active.model, pose: DEFAULT_POSE, subject: "a person" }, next.length), ...patch }]
-					: next.map((entry) => (entry.id === id ? { ...entry, ...patch } : entry));
-			}
-			return next;
-		};
-		if (owned) owned.runPrepared(active.id, () => {
-			owned.castWrite(place);
-			for (const { id, patch } of assignments) { owned.replace(id, patch.sessionMotion); owned.persistTake(patch.sessionMotion, patch.motionRef); }
-			return { affectedIds: assignments.map(row => row.id) };
-		});
-		else {
-			appContext.shared.publishStudioCharacters(place);
-			// Their takes are trimmable the moment they become the active layer.
-			for (const { id, patch } of assignments) appContext.shared.motionFullRef.current.set(id, patch.sessionMotion);
-		}
-		return assignments.length;
-	}
-
 	function commitLoadedTake(characterId, take, { recipe = null, job = null, promptClips = null, scale = characterScaleFor(take) } = {}) {
 		const owned = appContext.storeDomain('motion');
 		const previous = owned.layer(characterId);
@@ -1406,6 +1077,7 @@ export function useMotion(appContext) {
 		setMotionBusy(true);
 		setMotionError("");
 		try {
+			refuseRigOnly(appContext.live.characters.find((entry) => entry.id === targetCharacterId), "take");
 			// Inbound boundary: an ARDY take (20 fps) or a filmed one (30/60)
 			// becomes a production-clock clip here, once, before anything on
 			// the timeline counts its frames. Same-rate input rides through.
@@ -1512,8 +1184,8 @@ export function useMotion(appContext) {
 		}
 	}
 
-	/** Drop the ACTIVE character's take, its IK corrections and the stature the
-	 * take imposed. One Ctrl+Z entry brings all three back; nothing to clear
+	/** Drop the ACTIVE character's take, its IK corrections, prompt blocks and
+	 * the stature the take imposed. One Ctrl+Z entry brings all four back; nothing to clear
 	 * records nothing, so the shortcut never becomes a dead press.
 	 *
 	 * The pose flows (studio Apply/Reset, pose tiles, photo pose) call this
@@ -1559,7 +1231,7 @@ export function useMotion(appContext) {
 	// volume on every other frame of the walk.
 	const poseOtherCastMembers = (frame) => {
 		for (const entry of appContext.shared.characters) {
-			if (entry.id === appContext.shared.activeChar.id) continue;
+			if (entry.id === appContext.shared.activeChar.id || isProxyFigure(entry)) continue;
 			appContext.shared.poseMemberAtFrame(appContext.shared.rigs[entry.id], entry.sessionMotion, appContext.shared.ikStatesRef.current.get(entry.id), frame, IK_CORRECTION_BLEND_FRAMES);
 		}
 	};
@@ -1612,7 +1284,7 @@ export function useMotion(appContext) {
 			}
 			setIkMode(true);
 			appContext.notify(motion
-				? ko("Pose mode — correct the motion; drag end keys the fix at this frame", "포즈 모드 — 모션을 보정합니다. 드래그를 끝내면 이 프레임에 보정 키가 찍혀요")
+				? ko("Pose mode — preview the correction, then apply it to the selected motion block", "포즈 모드 — 보정을 미리 본 뒤 선택한 모션 구간에 적용하세요")
 				: ko("Pose mode — drag handles in the main view; the shot camera stays frozen in the inset", "포즈 모드 — 메인 뷰에서 핸들을 드래그하세요. 샷 카메라는 인셋에 고정됩니다"));
 			return;
 		}
@@ -1627,8 +1299,26 @@ export function useMotion(appContext) {
 	// Drag solve, routed by handle kind: chain targets solve the two-bone
 	// chain toward the target; mid joints reposition the elbow/knee with both
 	// ends pinned (the handle snaps to the clamped position); FK joints swing
-	// toward the pointer. Keys are baked on drag END — see ikDragEnd.
+	// toward the pointer. The solved pose stays a preview until Apply.
 	function ikSolve(kind, trackId, targetWorld) {
+		const state = appContext.shared.ikStateRef.current;
+		const ikChains = state.chains;
+		const ikFkJoints = state.fkJoints;
+		if (!ikDragRef.current) {
+			const pending = pendingIkEditRef.current;
+			ikPreDragRef.current = pending ?? {
+				characterId: appContext.shared.activeChar.id,
+				beforeFrame: appContext.shared.tlFrame,
+				sourceLayer: domain.layer(appContext.shared.activeChar.id),
+				state, rig: appContext.shared.activeRig, motion,
+				beforeRig: appContext.shared.snapshotExportRig(appContext.shared.activeRig),
+				beforeKeys: snapshotIkKeys(state),
+				beforeTracked: new Set(state.tracked),
+				beforeTargets: new Map([...state.targets].map(([id, target]) => [id, target.clone()])),
+				beforePlants: new Map([...state.plants].map(([id, target]) => [id, target.clone()])),
+			};
+			ikDragRef.current = { frame: appContext.shared.tlFrame, ids: new Set(pending?.ids ?? []) };
+		}
 		ikDragRef.current = ikDragRecord(ikDragRef.current, appContext.shared.tlFrame);
 		const touch = (id) => ikDragTouch(appContext.shared.ikStateRef.current, ikDragRef.current, id);
 		if (kind === "chain") {
@@ -1696,18 +1386,47 @@ export function useMotion(appContext) {
 		solveSwingAngle(joint, targetWorld.axis, targetWorld.angle, targetWorld.startQuat, targetWorld.startParentQuat);
 	}
 
-	// Drag end: key the dragged part's local rotations at the playhead, so a
-	// scrub away and back restores the dragged pose exactly (slerp).
+	// Drag end: retain the solved pose as a preview. Apply creates keys at both
+	// boundaries of the selected timeline motion segment.
 	function ikDragEnd() {
 		appContext.shared.ikBodyDragRef.current = false;
 		const drag = ikDragRef.current;
 		ikDragRef.current = null;
-		// One entry per drag: the pointermoves only moved bones, the keys map is
-		// untouched until this bake — the key it sets records the pre-drag keys.
-		if (appContext.storeDomain('motion') || ikChains) keyIkPoseAtPlayhead(
-			motion ? (drag ? drag.ids : null) : null,
-		);
-		setIkTick((n) => n + 1);
+		if (!motion) {
+			keyIkPoseAtPlayhead();
+			ikPreDragRef.current = null;
+			setIkTick((n) => n + 1);
+			return;
+		}
+		if (!drag?.ids?.size) {
+			ikPreDragRef.current = null;
+			return;
+		}
+		const state = appContext.shared.ikStateRef.current;
+		const raw = (rawRig, at) => appContext.shared.poseMemberAtFrame(rawRig, motion, null, at);
+		const keyed = bakeIkDragKey(state.chains, state.fkJoints, drag.frame, drag.ids, raw);
+		if (!keyed) {
+			ikPreDragRef.current = null;
+			return;
+		}
+		const before = ikPreDragRef.current;
+		const range = pendingIkEditRef.current ?? selectedIkRange(drag.frame);
+		const next = copyPhysicsKeys(before.beforeKeys);
+		const boundaries = bakeIkDragRange(state.chains, state.fkJoints, keyed, range.startFrame, range.endFrame, drag.ids, raw);
+		for (const [at, entry] of boundaries) {
+			if (!entry) continue;
+			let frameEntry = next.get(at);
+			if (!frameEntry) next.set(at, (frameEntry = new Map()));
+			for (const [track, key] of entry) frameEntry.set(track, { ...key, blend: IK_CORRECTION_BLEND_FRAMES });
+		}
+		setPendingIkEditValue({
+			...before,
+			frame: drag.frame,
+			startFrame: range.startFrame,
+			endFrame: range.endFrame,
+			ids: [...drag.ids],
+			candidate: { ...state, keys: next, tracked: new Set([...state.tracked, ...drag.ids]) },
+		});
 	}
 
 	/** Bake the current tracked rotations at the playhead into a scratch layer
@@ -2046,35 +1765,6 @@ export function useMotion(appContext) {
 		return true;
 	}
 
-	function downloadArdyPose() {
-		const rig = appContext.shared.posedRig();
-		if (!rig) {
-			appContext.notify(ko("Character not loaded yet", "캐릭터가 아직 로드되지 않았어요"));
-			return;
-		}
-		trackFeature("export_pose");
-		const pose = buildArdyPose({
-			rig,
-			camRef: appContext.shared.shotCamRef,
-			look: appContext.shared.look,
-			fovDeg: appContext.shared.fovDeg,
-			slate: slateLine(appContext.shared.shot),
-			// rigName follows the posed character's actual model below
-			rigName: appContext.shared.posingChar?.model ?? appContext.shared.charA.model,
-			root: captureArdyRoot(rig),
-		});
-		const blob = new Blob([JSON.stringify(pose, null, 2)], { type: "application/json" });
-		const url = URL.createObjectURL(blob);
-		const a = document.createElement("a");
-		a.href = url;
-		a.download = "cozyclay-pose.json";
-		document.body.appendChild(a);
-		a.click();
-		a.remove();
-		URL.revokeObjectURL(url);
-		appContext.notify(ko("Pose exported", "포즈 내보내기 완료"));
-	}
-
 	function recheckMotionHealth() {
 		setBridgeChecking(true);
 		return appContext.shared.bridgeRefreshRef.current().finally(() => setBridgeChecking(false));
@@ -2128,6 +1818,10 @@ export function useMotion(appContext) {
 	 * buys the full step count. */
 	function runLineEdit() {
 		if (appContext.shared.generationPendingRef.current || appContext.shared.genRunningRef.current || ardyRunning) return;
+		if (isProxyFigure(appContext.shared.activeChar)) {
+			appContext.notify(kindRefusal("lineEdit", isKo));
+			return;
+		}
 		const generationRequest = requestMotionGeneration("line_edit", "edit", { lineEdit: true });
 		if (!appContext.shared.takeSourceUrl) {
 			appContext.notify(ko("The current take has no bridge source — generate it once before editing a path", "현재 테이크에 브리지 원본이 없어요 — 궤적을 편집하기 전에 한 번 생성하세요"));
@@ -2214,6 +1908,7 @@ export function useMotion(appContext) {
 		if (appContext.shared.generationPendingRef.current || appContext.shared.genRunningRef.current || ardyRunning) throw generationRefusal('TARGET_BUSY', 'A motion generation is already running.');
 		if (appContext.shared.linePreviewUrl) throw generationRefusal('TARGET_NOT_READY', previewBlockingReason(en => en), previewBlockingReason(ko));
 		const character = appContext.storeDomain('cast').read().find(row => row.id === args.characterId);
+		refuseRigOnly(character, 'motion');
 		const active = character.id === appContext.shared.loadedLayerCharRef.current;
 		const posing = active && appContext.shared.posing;
 		const rig = posing ? appContext.shared.posedRig() : appContext.shared.rigs[character.id];
@@ -2257,9 +1952,12 @@ export function useMotion(appContext) {
 		});
 	}
 
-	/* --------------------- trail drag -> preview -> regen -------------------- */
-	function onTrailDragStart({ grabFrame } = {}) {
+	function onTrailDragStart({ track, grabFrame } = {}) {
 		if (!motion) return;
+		if (track) {
+			setTrailTrackFocus(track);
+			focusIkHandle(track);
+		}
 		const frame = Math.round(grabFrame ?? appContext.shared.tlFrame);
 		appContext.shared.setTlFrame(frame);
 		// The pre-drag take is both the deformation base (repeated moves re-derive
@@ -2329,6 +2027,10 @@ export function useMotion(appContext) {
 	 * deformed line contributes the grab-frame pose as a root guide. */
 	function runTrailRegeneration() {
 		if (appContext.shared.generationPendingRef.current || appContext.shared.genRunningRef.current || ardyRunning) return;
+		if (isProxyFigure(appContext.shared.activeChar)) {
+			appContext.notify(kindRefusal("trails", isKo));
+			return;
+		}
 		const request = requestMotionGeneration("trail", "edit", { motionEdit: true });
 		if (!trailEdit) return;
 		// Same rule as runArdy: motionEdit rewrites a span of THE take, and a
@@ -2419,8 +2121,7 @@ export function useMotion(appContext) {
 		setTrailEdit(null);
 	}
 
-	/* ------------------------- motion job queue ---------------------------
-	 * One box, one job at a time: explicit entry points suppress duplicate
+	/* One box, one job at a time: explicit entry points suppress duplicate
 	 * requests through queueing and execution. The
 	 * payload is frozen at enqueue time; completion delivers the clip to the
 	 * REQUESTING character's layer, not whoever happens to be selected then. */
@@ -2533,8 +2234,7 @@ export function useMotion(appContext) {
 		}
 	}
 
-	/* ------------------- recipe + version bookkeeping (C9/C12) ----------------
-	 * ONE writer for both. Every take that reaches the app came out of a job,
+	/* ONE writer for both. Every take that reaches the app came out of a job,
 	 * so a job's completion is the only place where "what is this take made of"
 	 * can be answered honestly, and the answer is checkpointed next to the
 	 * motionUrl in the same breath. Nothing else may write takeRecipeRef except
@@ -2652,8 +2352,7 @@ export function useMotion(appContext) {
 		}
 	}
 
-	/* ---------------------- the two edit entries (C12) ------------------------
-	 * Scene blocks the shot with Kimodo; Refine pulls one joint's path with
+	/* Scene blocks the shot with Kimodo; Refine pulls one joint's path with
 	 * ProjFlow. Everything else the pipeline can do is one of those two said
 	 * more precisely, and both are reachable from the take itself instead of
 	 * from a foldout the artist has to remember to open.
@@ -2707,12 +2406,16 @@ export function useMotion(appContext) {
 	}
 
 	function refineDisabledReason() {
+		if (!characterCapabilities(appContext.shared.activeChar).lineEdit) return kindRefusal("lineEdit", isKo);
 		if (!motion) return ko("No take yet — block a scene first", "아직 테이크가 없어요 — 먼저 장면을 만들어 주세요");
 		if (!motion.url) return ko("This take has no bridge source — generate it once before refining", "이 테이크에는 브리지 원본이 없어요 — 한 번 생성해야 다듬을 수 있어요");
 		return "";
 	}
 
 	function sceneDisabledReason() {
+		// A standing capability, so it outranks the bridge probe: a capsule figure
+		// cannot generate whatever the backend says.
+		if (!characterCapabilities(appContext.shared.activeChar).motion) return kindRefusal("motion", isKo);
 		if (bridge === null || bridgeChecking) return motionReadinessMessage("loading");
 		if (generationBusy) return ko("A generation is already running", "이미 생성이 돌고 있어요");
 		// NOT a line-edit preview, deliberately. Every other reason here is a
@@ -2914,244 +2617,51 @@ export function useMotion(appContext) {
 	function cancelArdy() {
 		appContext.shared.ardyAbortRef.current?.abort();
 	}
-	function captureI2vStill() {
-		// H3 480P renders 832x480. The still is captured at exactly that canvas
-		// (x2) regardless of the Studio's shot ratio; markI2vPose also switches
-		// the viewport to the matching ratio so what the user framed is what
-		// gets sent.
-		const captured = appContext.shared.captureLiveFraming({ output: I2V_MOTION_STILL_OUTPUT });
-		if (!captured?.dataUrl?.startsWith("data:image/")) throw new Error(ko("The shot renderer is not ready.", "렌더러가 준비되지 않았어요."));
-		if (captured.width !== I2V_MOTION_STILL_OUTPUT.width || captured.height !== I2V_MOTION_STILL_OUTPUT.height) {
-			throw new Error(ko(`The H3 480P reference must be captured at ${I2V_MOTION_STILL_OUTPUT.width}×${I2V_MOTION_STILL_OUTPUT.height}.`, `H3 480P 참조 캡처는 ${I2V_MOTION_STILL_OUTPUT.width}×${I2V_MOTION_STILL_OUTPUT.height}이어야 해요.`));
-		}
-		// H3 must see the same complete subject in both endpoints. A clipped
-		// foot or head makes the model invent the missing geometry during the
-		// transition, which is exactly the bad motion this flow is meant to avoid.
-		const rig = appContext.live.state.rigs?.[appContext.shared.activeChar.id];
-		const cam = appContext.shared.shotCamRef.current;
-		if (!rig || !cam) throw new Error(ko("The full-body frame is not ready yet. Wait a moment and try the reference capture again.", "전신 프레임을 확인할 수 없어 참조를 캡처할 수 없어요. 잠시 후 다시 시도하세요."));
-		rig.updateWorldMatrix(true, true);
-		cam.updateMatrixWorld(true);
-		const bounds = new THREE.Box3().setFromObject(rig);
-		const corners = [
-			new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.min.z),
-			new THREE.Vector3(bounds.min.x, bounds.min.y, bounds.max.z),
-			new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.min.z),
-			new THREE.Vector3(bounds.min.x, bounds.max.y, bounds.max.z),
-			new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.min.z),
-			new THREE.Vector3(bounds.max.x, bounds.min.y, bounds.max.z),
-			new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.min.z),
-			new THREE.Vector3(bounds.max.x, bounds.max.y, bounds.max.z),
-		].map((corner) => corner.project(cam));
-		const margin = 0.94;
-		const clipped = corners.some((corner) =>
-			corner.z < -1 || corner.z > 1 || Math.abs(corner.x) > margin || Math.abs(corner.y) > margin
-		);
-		if (clipped) {
-			throw new Error(ko(
-				"The full character is not inside the A/B reference. In the shot view, pull the camera back until the head and both feet are visible, then capture again.",
-				"A/B 참조에 캐릭터 전신이 다 안 들어왔어요. 샷 시점에서 머리와 양발이 화면 안에 들어오도록 카메라를 뒤로 빼고 다시 캡처하세요."
-			));
-		}
-		if (!appContext.shared.i2vMotionSegmentationReady || !Array.isArray(captured.partColours) || captured.partColours.length === 0) {
-			throw new Error(ko("Enable View → Body part colours → Shaded before capturing an A/B reference.", "A/B 참조는 View에서 부위 색상 → 음영을 켜야 캡처할 수 있어요."));
-		}
-		return { ...captured, framing: appContext.shared.captureCurrentFraming() };
-	}
-	/** Put the viewport on the Fal canvas and hand the fly controls to the
-	 * shot camera, so the user composes the A/B reference on exactly the
-	 * 832x480 frame the clip will have. Idempotent; capture does not need it. */
-	function enterI2vFraming() {
-		appContext.shared.runStudioAction("stage.setFilmback", { shotAspect: I2V_MOTION_SHOT_ASPECT });
-		if (!appContext.shared.lookThroughShot) appContext.shared.enterShotLook();
-	}
-	function markI2vPose(slot) {
-		try {
-			if (slot === "b" && i2vMotion.a && framingDistance(i2vMotion.a.framing, appContext.shared.captureCurrentFraming()) > 0.001) {
-				throw new Error(ko("The camera moved between A and B. Capture both refs with the same camera framing.", "A와 B 사이에서 카메라가 이동했어요. 같은 카메라 프레이밍으로 다시 캡처하세요."));
-			}
-			const still = captureI2vStill();
-			// The capture is already on the Fal canvas; make the viewport agree so
-			// the user sees the frame that was just sent.
-			appContext.shared.runStudioAction("stage.setFilmback", { shotAspect: I2V_MOTION_SHOT_ASPECT });
-			setI2vMotion((current) => ({ ...current, [slot]: still, status: "idle", error: "" }));
-			if (slot === "a") appContext.shared.setI2vMotionCameraUnlocked(false);
-			appContext.notify(isKo ? `포즈 ${slot.toUpperCase()} 캡처됨 · ${still.width}×${still.height}` : `Pose ${slot.toUpperCase()} captured · ${still.width}×${still.height}`);
-		} catch (error) {
-			setI2vMotion((current) => ({ ...current, error: error.message, status: "error" }));
-		}
-	}
-	function clearI2vPose(slot) {
-		setI2vMotion((current) => ({ ...current, [slot]: null, status: "idle", error: "", job: null }));
-		if (slot === "a") appContext.shared.setI2vMotionCameraUnlocked(false);
-	}
-	function clearI2vMotion() {
-		setI2vMotion({ a: null, b: null, job: null, status: "idle", error: "", instruction: "", promptOverride: "", duration: I2V_MOTION_MIN_DURATION, dailyRemaining: null });
-		appContext.shared.setI2vMotionCameraUnlocked(false);
-	}
-	function restoreI2vCamera() {
-		const framing = i2vMotion.a?.framing;
-		const camera = appContext.shared.shotCamRef.current;
-		if (!framing || !camera) return;
-		camera.position.set(framing.pos.x, framing.pos.y, framing.pos.z);
-		camera.rotation.order = "YXZ";
-		camera.rotation.set(framing.pitch, framing.yaw, 0);
-		camera.fov = framing.fovDeg;
-		camera.updateProjectionMatrix();
-		appContext.shared.look.current.yaw = framing.yaw;
-		appContext.shared.look.current.pitch = framing.pitch;
-		appContext.shared.shotCameraPosRef.current = { ...framing.pos };
-		appContext.shared.setCameraPos({ ...framing.pos });
-		appContext.shared.setFovDeg(framing.fovDeg);
-		appContext.shared.setI2vMotionCameraUnlocked(false);
-		setI2vMotion((current) => ({ ...current, error: "", status: "idle" }));
-		appContext.notify(isKo ? "A 캡처 카메라로 복원했어요." : "Restored the camera used for A.");
-	}
-	function framingDistance(a, b) {
-		if (!a || !b) return Infinity;
-		return Math.max(
-			Math.abs(a.pos.x - b.pos.x), Math.abs(a.pos.y - b.pos.y), Math.abs(a.pos.z - b.pos.z),
-			Math.abs(a.yaw - b.yaw), Math.abs(a.pitch - b.pitch), Math.abs(a.fovDeg - b.fovDeg),
-		);
-	}
-	/** The AI motion card's lock line: AI video motion is not enabled for this account. */
-	function showI2vMotionLock() {
-		setI2vMotion((current) => ({ ...current, error: ko("AI motion generation is locked during QA.", "AI 모션 생성은 QA 중 잠겨 있어요."), status: "error" }));
-	}
-	/** The AI motion card shows every failure itself. For motion.generateFromVideo the
-	 * answer says what happened: `{ failed }` with the reason in English, or the
-	 * finished job, the footage it was ingested as (null when ingest failed) and
-	 * the account's daily generations left. */
-	async function generateI2vMotion(kind = "interpolate", instructionOverride = null, commandContext = null) {
-		// One explicit request on the motion:* contract (#466). While the route is
-		// gated, the lock itself is the demand signal. Telemetry never decides.
-		const motionRequest = startMotionRequest({
-			surface: !commandContext ? "fal_card" : commandContext.origin === "mcp" || commandContext.origin === "live" ? "mcp" : "agent",
-			input_mode: kind === "interpolate" ? "a_to_b" : "still",
-		});
-		if (!appContext.shared.i2vMotionEnabled) {
-			motionRequest.block("locked");
-			showI2vMotionLock();
-			return { failed: "AI video motion (Fal) is not enabled for this account." };
-		}
-		let source = i2vMotion;
-		if (kind === "act" && !source.a) {
-			try { source = { ...source, a: captureI2vStill() }; setI2vMotion((current) => ({ ...current, a: source.a })); }
-			catch (error) {
-				motionRequest.block("missing_input");
-				setI2vMotion((current) => ({ ...current, error: error.message, status: "error" }));
-				return { failed: "Could not capture the character's pose frame: the full body must be inside the shot frame, shaded part colours must be on (view.setPartColours { mode: \"shaded\" }), and the renderer and rig must be ready." };
-			}
-		}
-		if (kind === "interpolate" && (!source.a || !source.b)) {
-			motionRequest.block("missing_input");
-			setI2vMotion((current) => ({ ...current, error: ko("Capture both A and B poses first.", "A와 B 포즈를 먼저 캡처하세요."), status: "error" }));
-			return { failed: "Capture both A and B poses first." };
-		}
-		if (!source.a?.partColours || (kind === "interpolate" && !source.b?.partColours)) {
-			motionRequest.block("missing_input");
-			setI2vMotion((current) => ({ ...current, error: ko("Recapture A/B refs with shaded body-part segmentation enabled.", "색 세그멘테이션이 포함된 음영 A/B 참조를 다시 캡처하세요."), status: "error" }));
-			return { failed: "The captured pose frame has no shaded body-part segmentation; the user must recapture it in the Fal card with shaded part colours on." };
-		}
-		if (kind === "interpolate" && framingDistance(source.a.framing, source.b.framing) > 0.001) {
-			motionRequest.block("missing_input");
-			setI2vMotion((current) => ({ ...current, error: ko("The camera changed between A and B. Capture both poses with the same camera.", "A와 B 사이에서 카메라가 바뀌었어요. 같은 카메라로 다시 캡처하세요."), status: "error" }));
-			return { failed: "The camera changed between poses A and B; capture both with the same camera." };
-		}
-		// A hand-edited prompt wins verbatim; otherwise build from the description.
-		// Interpolate now honours the description too (#380): the bare pose
-		// difference lets the model invent the transition and produces junk.
-		const description = instructionOverride || source.instruction || "";
-		const prompt = source.promptOverride?.trim()
-			? source.promptOverride.trim()
-			: buildH3MotionPrompt(description || (kind === "interpolate" ? "" : "Make the character perform the requested action."), { interpolate: kind === "interpolate" });
-		setI2vMotion((current) => ({ ...current, status: "submitting", error: "", job: null }));
-		motionRequest.pass("fal");
-		motionRequest.start();
-		try {
-			const fetchImpl = commandContext ? (url, options) => fetch(url, { ...options, signal: commandContext.signal }) : undefined;
-			const submitted = await submitMotionJob({
-				kind,
-				stillA: source.a?.dataUrl,
-				stillB: source.b?.dataUrl,
-				still: source.a?.dataUrl,
-				prompt,
-				duration: source.duration ?? I2V_MOTION_MIN_DURATION,
-			}, fetchImpl);
-			const id = submitted?.job?.id;
-			if (!id) throw Object.assign(new Error(ko("The server did not return a motion job ID.", "생성 작업 ID를 받지 못했어요.")), { reason: "The motion server did not return a job id." });
-			setI2vMotion((current) => ({ ...current, status: "queued", job: submitted.job, dailyRemaining: submitted.dailyRemaining }));
-			const finished = await waitForMotionJob(id, {
-				fetchImpl,
-				onUpdate: (job) => setI2vMotion((current) => ({ ...current, job, status: job?.status ?? current.status })),
-			});
-			commandContext?.check();
-			const job = finished?.job;
-			if (job?.status !== "done") throw Object.assign(new Error(job?.error || ko("AI motion generation failed.", "AI 모션 생성에 실패했어요.")), job?.error ? {} : { reason: "The AI video generation failed." });
-			motionRequest.succeed();
-			setI2vMotion((current) => ({ ...current, job, status: "done", dailyRemaining: finished.dailyRemaining }));
-			let footage = null;
-			if (job.video?.url) {
-				const motionSource = { kind: "url", url: job.video.url, name: `Fal H3 Max Turbo · ${job.resolution}` };
-				setMultiModelSource(motionSource);
-				// Put the completed clip through the same probe/ingest path as a
-				// manually supplied URL so GVHMR sees measured fps, duration and
-				// a ready extraction card without another generation request.
-				footage = (await ingestFootage(motionSource, commandContext)) ?? null;
-				appContext.shared.setResult({
-					mode: "video",
-					modelLabel: "Fal H3 Max Turbo",
-					prompt,
-					frame: source.a?.dataUrl ?? null,
-					videoUrl: job.video.url,
-					motion: {
-						videoUrl: job.video.url,
-						resolution: job.resolution,
-						width: job.width,
-						height: job.height,
-						fps: job.fps,
-						duration: job.resultDuration ?? job.duration,
-						cost: job.cost,
-					},
-				});
-				appContext.shared.setResultOpen(true);
-				// Applied = the clip is in the Studio, ready for GVHMR extraction.
-				motionRequest.apply();
-				// The result modal and the studio modal are both z-30; never stack them.
-				appContext.shared.setI2vMotionStudioOpen(false);
-				appContext.notify((isKo, ko) => isKo ? "AI 영상이 준비됐어요 · 추출 패널에서 GVHMR을 실행하세요" : "AI video is ready · run GVHMR from the extraction panel");
-			}
-			return { job, footage, dailyRemaining: finished.dailyRemaining ?? null };
-		} catch (error) {
-			const cancelled = Boolean(commandContext && (commandContext.signal.aborted || error?.code === "STALE_TARGET"));
-			// 429 is the account's daily cap (workers/api daily_cap).
-			motionRequest.fail(error, cancelled ? "aborted" : error?.status === 429 ? "quota" : "generation_failed");
-			if (cancelled) throw error;
-			setI2vMotion((current) => ({ ...current, status: "error", error: error.message || String(error) }));
-			return { failed: error.reason ?? `The AI video generation failed: ${error.message || error}` };
-		}
-	}
-	/** Why the chip cannot start an AI video motion now, as the user reads it:
-	 * one already running, or none left today. The lock has its own AI motion card line. */
-	function i2vMotionUnavailable() {
-		if (!["idle", "done", "error", "failed"].includes(i2vMotion.status)) return ko("A generation is already running", "이미 생성이 돌고 있어요");
-		if (i2vMotion.dailyRemaining === 0) return ko("No AI video motion generations left today", "오늘 남은 AI 영상 모션 생성이 없어요");
-		return null;
-	}
-	function generateI2vMotionFromUi(instruction) {
-		if (!appContext.shared.i2vMotionEnabled) {
-			// Locked, the action's availability check refuses before
-			// generateI2vMotion runs, so the chip records its own lock (#466).
-			startMotionRequest({ surface: "agent", input_mode: "still" }).block("locked");
-			showI2vMotionLock();
-		} else {
-			// The chip clears the typed instruction when clicked, so a refusal says why.
-			const reason = i2vMotionUnavailable();
-			if (reason) { appContext.notify(reason); return null; }
-		}
-		return appContext.shared.runStudioAction("motion.generateFromVideo", { instruction });
-	}
-	function updateI2vMotionQuota(dailyRemaining) { setI2vMotion((current) => ({ ...current, dailyRemaining })); }
+	const {
+		chooseMultiModelFile,
+		pasteMultiModelUrl,
+		useMultiModelUrl,
+		ingestPlatformFootage,
+		ingestFootage,
+		extractMultiModelMotion,
+		extractMultiModelMotionGpu,
+		deliverExtraTakes,
+		captureI2vStill,
+		enterI2vFraming,
+		markI2vPose,
+		clearI2vPose,
+		clearI2vMotion,
+		restoreI2vCamera,
+		framingDistance,
+		showI2vMotionLock,
+		generateI2vMotion,
+		i2vMotionUnavailable,
+		generateI2vMotionFromUi,
+		updateI2vMotionQuota,
+	} = createMotionVideoCapture({
+		appContext,
+		bridge,
+		i2vMotion,
+		setI2vMotion,
+		multiModelUrl,
+		multiModelSource,
+		multiModelFootage,
+		multiModelExtract,
+		setMultiModelUrl,
+		setMultiModelSource,
+		setMultiModelStatus,
+		setMultiModelStage,
+		setMultiModelProgress,
+		setMultiModelFootage,
+		setMultiModelError,
+		setMultiModelTake,
+		setMultiModelExtract,
+		setMultiModelExtractProgress,
+		setMultiModelExtractError,
+		loadMotion,
+		authoredSupportDescriptors,
+		applyAuthoredSupportRise,
+	});
 	domain.setVideoDraft = patch => setI2vMotion(current => ({ ...current, ...patch }));
 	domain.requestLineEdit = runLineEdit;
 	domain.requestTrailRegeneration = runTrailRegeneration;
@@ -3189,7 +2699,8 @@ export function useMotion(appContext) {
 		bodyContact, setBodyContact, IK_CORRECTION_BLEND_FRAMES, autoPhysicsRunning, setAutoPhysicsRunning,
 		physicsPreview, setPhysicsPreview, physicsShow, physicsProgress, physicsOptions, setPhysicsOptions,
 		ikTick, setIkTick, committedIkEdits, setCommittedIkEdits, trailFalloffS, setTrailFalloffS, showTrails,
-		setShowTrails, ikEditTool, setIkEditTool, trailEdit, trailFalloffFrames, focusIkHandle, snapshotIkKeys,
+		setShowTrails, ikEditTool, setIkEditTool, trailEdit, trailTrackFocus, selectTrailTrack, clearTrailTrackFocus, trailFalloffFrames, focusIkHandle, snapshotIkKeys,
+		pendingIkEdit, applyPendingIkEdit, cancelPendingIkEdit,
 		rangePinApplySpec: (pin) => {
 			domain.run('motion.rangePin.apply', { characterId: appContext.shared.activeChar.id, pin });
 			return { residuals: decodeRangePinResiduals(domain.layer(appContext.shared.activeChar.id).ikPinResiduals).get(pin.id) };