cozyclay 2.1.0 → 3.0.0

package/src/scenes.js

@@ -4,17 +4,17 @@
 
 import { DEFAULT_SENSOR_FORMAT, SENSOR_FORMATS } from "./shot.js";
 import { normalizeStableItems } from "./stable-items.js";
-import { normalizeMotionCalibration } from "./ardy/motion-calibration.js";
-import { normalizeTrailEdits } from "./motion-trail.js";
+
 import { elementByPath } from "./studio-elements.js";
 import { wrapAngle } from "./scene-objects.js";
+import { normalizeTakeSource } from "./domains/motion/take-source.js";
+import { createKeyLight, normalizeLighting } from "./stage-lighting.js";
 // The timeline clock lives in timeline-fps.js (three-free, so the agent
 // sidecar can import it); re-exported here for every scene-side caller.
 import { LEGACY_FRAME_FPS, TIMELINE_FRAME_FPS, toTimelineFrame } from "./timeline-fps.js";
 
 const CHARACTER_POSITION_LIMITS = elementByPath("character.position");
 const CHARACTER_SCALE_LIMITS = elementByPath("character.scale");
-const KEY_LIGHT_LIMITS = Object.fromEntries(["x", "y", "z", "intensity", "warmth"].map((axis) => [axis, elementByPath(`stage.keyLight.${axis}`)]));
 
 export const SCENES_VERSION = 5;
 export const SCENES_STORAGE_KEY = "cozyclay.scenes.v5";
@@ -71,30 +71,8 @@ const DEFAULT_SCENE_STAGE = Object.freeze({
 	shotAspect: "16:9",
 	cameraPresetId: null,
 	sensorId: DEFAULT_SENSOR_FORMAT,
-	// The key light the user can grab: position of the sun puck, the rig's
-	// master brightness, and a warm/cool colour offset. Values mirror the
-	// tuned StageLights defaults, so a stage saved before the light was
-	// movable renders exactly as it did.
-	keyLight: Object.freeze({ x: 6, y: 9, z: 4, intensity: 1.12, warmth: 0.5 }),
 });
 
-/** Clamp a stored key light back into the stage's usable envelope. */
-export function createKeyLight(value) {
-	const source = plainObject(value) ? value : {};
-	const fallback = DEFAULT_SCENE_STAGE.keyLight;
-	const finite = (entry, base, bounds) => (typeof entry === "number" && Number.isFinite(entry)
-		? Math.max(bounds.min, Math.min(bounds.max, entry))
-		: base);
-	return {
-		x: finite(source.x, fallback.x, KEY_LIGHT_LIMITS.x),
-		y: finite(source.y, fallback.y, KEY_LIGHT_LIMITS.y),
-		z: finite(source.z, fallback.z, KEY_LIGHT_LIMITS.z),
-		intensity: finite(source.intensity, fallback.intensity, KEY_LIGHT_LIMITS.intensity),
-		// 0 = cool daylight, 0.5 = the tuned warm default, 1 = sunset amber
-		warmth: finite(source.warmth, fallback.warmth, KEY_LIGHT_LIMITS.warmth),
-	};
-}
-
 let sceneSequence = 1;
 
 const plainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
@@ -135,28 +113,14 @@ export function normalizeReferenceImage(value) {
 	return typeof value === "string" && value.startsWith("data:image/") ? value : null;
 }
 
-/** Stature band for a cast member. Wider than ardy/npz.js's mocap band
- * (0.6-1.5, a sanity clamp on ESTIMATED statures): the gizmo's scale handles
- * are a deliberate artistic ask, and a previs giant or child is legitimate. */
+/** Stature band for a cast member: the gizmo's scale handles are a deliberate
+ * artistic ask, and a previs giant or child is legitimate. */
 export const CHARACTER_SCALE_MIN = CHARACTER_SCALE_LIMITS.min;
 export const CHARACTER_SCALE_MAX = CHARACTER_SCALE_LIMITS.max;
 const clampScale = (value) => (Number.isFinite(value) && value > 0
 	? Math.max(CHARACTER_SCALE_LIMITS.min, Math.min(CHARACTER_SCALE_LIMITS.max, value))
 	: 1);
 
-/** Where an extra extraction take's performer stands: the filmed offset from
- * person 0, rotated into the ACTIVE character's facing. Pure geometry, so the
- * placement can be proven without a renderer. */
-export function takeAnchor(active, offsetX, offsetZ) {
-	const rad = (finiteOr(active?.rot, 0) * Math.PI) / 180;
-	const dx = finiteOr(offsetX, 0);
-	const dz = finiteOr(offsetZ, 0);
-	return {
-		x: finiteOr(active?.x, 0) + dx * Math.cos(rad) + dz * Math.sin(rad),
-		z: finiteOr(active?.z, 0) - dx * Math.sin(rad) + dz * Math.cos(rad),
-	};
-}
-
 /** One character entry in the stage envelope. `source` may be a v3 entry, a
  * partial (spawn dialog), or null — every field falls back to a sane default
  * and every object is freshly owned by the caller. */
@@ -190,25 +154,17 @@ export function createCharacterEntry(source = null, index = 0) {
 		// take's root travel was authored against it — see the render path.
 		scale: clampScale(s.scale),
 		subject: typeof s.subject === "string" ? s.subject : index === 0 ? DEFAULT_SUBJECT_ONE : DEFAULT_SUBJECT_TWO,
-		// The character's animation layer: its own root path and prompt-block
-		// schedule. The generated clip itself is heavy, so only a lightweight
-		// reference (bridge URL + generation params) is persisted — enough to
-		// re-fetch and decode it on the next session.
+		// The character's animation layer: its own root path.
 		layer: normalizeLayer(s.layer),
-		motionRef: normalizeMotionRef(s.motionRef),
 		// The Pose-mode / IK edits on this character's layer (encoded keys, range
 		// pins and their residuals). The motion domain owns them while the scene
 		// is open; this is what the saved scene carries so a reload keeps them.
 		ikEdits: normalizeIkEdits(s.ikEdits),
+		// A compiled take v3 saves its source; the motion layer compiles it again on load.
+		motionTake: normalizeTakeSource(s.motionTake),
 	};
 }
 
-const MOTION_ID_RE = /^[0-9a-f]{64}$/i;
-
-// A motionRef names its take by content (motionId: SHA-256 of the npz, kept
-// in the project's embedded motions) and/or by location (url: a bridge run,
-// which is what pre-motionId documents carry). Either one alone is a valid
-// ref; the restore path prefers the embedded bytes when both are present.
 function normalizeIkEdits(value) {
 	if (!plainObject(value)) return null;
 	const rows = (list, valid) => (Array.isArray(list) ? list.filter(valid).map((entry) => cloneValue(entry)) : []);
@@ -218,40 +174,10 @@ function normalizeIkEdits(value) {
 	return keys.length || pins.length ? { keys, pins, pinResiduals } : null;
 }
 
-function normalizeMotionRef(ref) {
-	if (!plainObject(ref)) return null;
-	const motionId = typeof ref.motionId === "string" && MOTION_ID_RE.test(ref.motionId) ? ref.motionId.toLowerCase() : null;
-	const url = typeof ref.url === "string" && ref.url ? ref.url : null;
-	if (!motionId && !url) return null;
-	const normalized = {};
-	// Field order matters only for byte-stable serialization; a url-only ref
-	// keeps the exact legacy shape (url first, no motionId key).
-	if (motionId) normalized.motionId = motionId;
-	if (url) normalized.url = url;
-	Object.assign(normalized, {
-		prompt: typeof ref.prompt === "string" ? ref.prompt : "",
-		rotationDeg: Number.isFinite(ref.rotationDeg) ? ref.rotationDeg : 0,
-		anchorX: Number.isFinite(ref.anchorX) ? ref.anchorX : 0,
-		anchorZ: Number.isFinite(ref.anchorZ) ? ref.anchorZ : 0,
-	});
-	// Scene calibration is deliberately metadata on the lightweight motionRef,
-	// never an NPZ member.  Keep it optional so old documents retain their exact
-	// shape, while preserving the calibration produced by the extraction/load
-	// boundary for a later scene reload. cloneValue also strips non-finite values
-	// and recursively owns the object, so a caller cannot mutate the saved stage.
-	if (plainObject(ref.calibration)) normalized.calibration = normalizeMotionCalibration(ref.calibration);
-	if (ref.trailEdits != null) normalized.trailEdits = normalizeTrailEdits(ref.trailEdits);
-	// An agent-installed take keeps the Studio take id its receipts name, so a
-	// reload still reports the same take. Optional, like calibration.
-	if (typeof ref.studioTakeId === "string" && ref.studioTakeId) normalized.studioTakeId = ref.studioTakeId;
-	return normalized;
-}
-
 function normalizeLayer(layer) {
 	const source = plainObject(layer) ? layer : {};
 	return {
 		waypoints: normalizeStableItems(cloneValue(source.waypoints), "waypoint"),
-		promptClips: normalizeStableItems(cloneValue(source.promptClips), "prompt-clip"),
 	};
 }
 
@@ -265,7 +191,6 @@ function normalizeStageLayers(stage) {
 				...character,
 				layer: {
 					waypoints: normalizeStableItems(cloneValue(character.layer?.waypoints), "waypoint", ids),
-					promptClips: normalizeStableItems(cloneValue(character.layer?.promptClips), "prompt-clip", ids),
 				},
 			}))
 			: source.characters,
@@ -273,16 +198,12 @@ function normalizeStageLayers(stage) {
 }
 
 export function createCharacterLayer() {
-	return { waypoints: [], promptClips: [] };
+	return { waypoints: [] };
 }
 
 /** Retime one animation layer from the 20 fps authoring clock onto the 24 fps
- * production clock. Frame numbers only: positions, headings and prompt text
- * are untouched. The mapping is strictly increasing, so ascending order and
- * the gaps between prompt blocks survive it — the guards below re-establish
- * both anyway, because a hand-edited body may never have had them. Prompt
- * ranges are half-open [start, end), matching movePromptClipFrames: touching
- * blocks are legal, overlapping ones are not. */
+ * production clock. Frame numbers only: positions and headings are untouched.
+ * The mapping is strictly increasing, so ascending order survives it. */
 function migrateLayerFrames(layer) {
 	if (!plainObject(layer)) return layer;
 	const next = { ...cloneValue(layer) };
@@ -295,20 +216,6 @@ function migrateLayerFrames(layer) {
 		}
 		next.waypoints = [...byFrame.values()].sort((a, b) => a.frame - b.frame);
 	}
-	if (Array.isArray(layer.promptClips)) {
-		const ordered = layer.promptClips
-			.filter((clip) => plainObject(clip) && Number.isFinite(clip.startFrame) && Number.isFinite(clip.endFrame))
-			.sort((a, b) => a.startFrame - b.startFrame);
-		const clips = [];
-		let floor = 0;
-		for (const clip of ordered) {
-			const startFrame = Math.max(floor, toTimelineFrame(Math.round(clip.startFrame)));
-			const endFrame = Math.max(startFrame, toTimelineFrame(Math.round(clip.endFrame)));
-			clips.push({ ...cloneValue(clip), startFrame, endFrame });
-			floor = endFrame;
-		}
-		next.promptClips = clips;
-	}
 	return next;
 }
 
@@ -337,7 +244,7 @@ function migrateLegacyCast(source) {
 }
 
 const STAGE_ENVELOPE_KEYS = new Set([
-	"characters", "hasCharSheet", "environmentImage", "environment", "style", "hasEnvSheet", "shotAspect", "cameraPresetId", "sensorId", "keyLight",
+	"characters", "hasCharSheet", "environmentImage", "environment", "style", "hasEnvSheet", "shotAspect", "cameraPresetId", "sensorId", "keyLight", "lighting",
 	"charA", "charB", "showB", "poseA", "poseB", "subject", "subject2",
 ]);
 
@@ -376,7 +283,10 @@ export function createSceneStage(stage = null) {
 		sensorId: Object.hasOwn(SENSOR_FORMATS, source.sensorId ?? source.sensorFormat)
 			? (source.sensorId ?? source.sensorFormat)
 			: DEFAULT_SCENE_STAGE.sensorId,
+		// The key light the user grabs (puck position, master brightness, warmth or
+		// colour) and the stage look; a stage saved before either renders as it did.
 		keyLight: createKeyLight(source.keyLight),
+		lighting: normalizeLighting(source.lighting),
 	};
 }
 

package/src/semantic-edit.js

@@ -23,17 +23,14 @@ function equal(a, b) {
 	return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && equal(a[key], b[key]));
 }
 const poseValue = (pose) => ({ bones: pose?.bones ?? {}, rootY: pose?.rootY ?? 0 });
-const blockValues = (blocks) => blocks.map(({ id, ...value }) => value);
+
 const keyValues = (keys = []) => keys.map(({ frame, framing }) => ({ frame, framing }));
 const shotValue = (shot) => ({ ...shot, camera: createCameraBlock(shot.camera), cameraKeys: keyValues(shot.cameraKeys) });
 
 export function semanticEditKind(domain, before, after) {
 	if (before === after) return null;
 	if (domain === "pose") return equal(before, after) ? null : "pose_edit";
-	if (domain === "promptClips") {
-		if (equal(blockValues(before), blockValues(after))) return null;
-		return after.length > before.length ? "prompt_block_add" : "prompt_block_edit";
-	}
+	
 	if (domain === "objects") {
 		const added = after.find((item) => !before.some((previous) => previous.id === item.id));
 		if (added) return added.renderer === "cutout" ? "cutout_insert" : "object_insert";

package/src/set-pieces.jsx

@@ -0,0 +1,183 @@
+/**
+ * The hand-built set pieces: a car, a small plane and a chair, modelled from
+ * primitives in the same clay style as the room and the character tint.
+ * Dimensions are metres against real sizes so the 1.8 m figure keeps honest
+ * scale. Each takes `autoColor` (the viewport's auto-colour mode) and then
+ * tints its primary surfaces flat; glass, tyres and rims keep their own.
+ */
+
+// Blender's solid-view response for auto-colored surfaces. Workbench shades
+// with a neutral studio rig, so the derived hue reaches the eye unmultiplied;
+// under our warm key light a plain standard material turns every hue olive.
+// Full roughness kills the specular sheen and a self-light of the same hue
+// lifts the shadow side the way workbench's studio lighting does.
+export function autoFlat(hex) {
+	return { color: hex, roughness: 1, metalness: 0, emissive: hex, emissiveIntensity: 0.4 };
+}
+
+const CLAY_CAR = "#d98770";
+const CLAY_CAR_TOP = "#e49a84";
+const CLAY_TIRE = "#41484c";
+const CLAY_RIM = "#7c8588";
+const CLAY_GLASS = "#55697a";
+const CLAY_PLANE = "#7896a4";
+const CLAY_PLANE_TRIM = "#e1a849";
+const CLAY_CHAIR = "#b9855d";
+const CLAY_CHAIR_LIGHT = "#cf9d72";
+
+function Wheel({ position }) {
+	return (
+		<group position={position}>
+			<mesh rotation={[0, 0, Math.PI / 2]}>
+				<cylinderGeometry args={[0.33, 0.33, 0.24, 20]} />
+				<meshStandardMaterial color={CLAY_TIRE} roughness={0.95} />
+			</mesh>
+			<mesh rotation={[0, 0, Math.PI / 2]}>
+				<cylinderGeometry args={[0.17, 0.17, 0.26, 16]} />
+				<meshStandardMaterial color={CLAY_RIM} roughness={0.5} metalness={0.35} />
+			</mesh>
+		</group>
+	);
+}
+/**
+ * A generic 5-door-ish sedan silhouette, ~4.5 m long. Origin at the centre
+ * of the footprint, +Z forward.
+ */
+export function Car({ position = [0, 0, 0], rotY = 0, color = CLAY_CAR, topColor = CLAY_CAR_TOP, autoColor = undefined }) {
+	const bodyMaterial = autoColor
+		? { ...autoFlat(autoColor) }
+		: { color, roughness: 0.55, metalness: 0.25 };
+	const topMaterial = autoColor
+		? { ...autoFlat(autoColor) }
+		: { color: topColor, roughness: 0.5, metalness: 0.2 };
+	return (
+		<group position={position} rotation={[0, rotY, 0]}>
+			<mesh position={[0, 0.62, 0]}>
+				<boxGeometry args={[1.78, 0.62, 4.45]} />
+				<meshStandardMaterial {...bodyMaterial} />
+			</mesh>
+			<mesh position={[0, 1.12, -0.15]}>
+				<boxGeometry args={[1.58, 0.5, 2.2]} />
+				<meshStandardMaterial {...topMaterial} />
+			</mesh>
+			<mesh position={[0, 1.14, -0.15]}>
+				<boxGeometry args={[1.62, 0.3, 1.9]} />
+				<meshStandardMaterial color={CLAY_GLASS} roughness={0.15} metalness={0.6} />
+			</mesh>
+			<mesh position={[0, 1.05, 0.95]} rotation={[0.5, 0, 0]}>
+				<boxGeometry args={[1.56, 0.42, 0.08]} />
+				<meshStandardMaterial color={CLAY_GLASS} roughness={0.15} metalness={0.6} />
+			</mesh>
+			<mesh position={[0, 1.05, -1.25]} rotation={[-0.55, 0, 0]}>
+				<boxGeometry args={[1.56, 0.42, 0.08]} />
+				<meshStandardMaterial color={CLAY_GLASS} roughness={0.15} metalness={0.6} />
+			</mesh>
+			<Wheel position={[0.82, 0.33, 1.45]} />
+			<Wheel position={[-0.82, 0.33, 1.45]} />
+			<Wheel position={[0.82, 0.33, -1.45]} />
+			<Wheel position={[-0.82, 0.33, -1.45]} />
+		</group>
+	);
+}
+
+/** Compact single-engine propeller plane, ~3.4 m wingspan and +Z forward. */
+export function SmallPlane({ position = [0, 0, 0], rotY = 0, autoColor = undefined }) {
+	// Auto-color mode tints the PRIMARY surfaces only (fuselage, wings, trim);
+	// glass, tires and rims keep their materials so the silhouette still reads.
+	// Each mesh keeps its own hand-tuned roughness when the mode is off.
+	const mat = (color, roughness, metalness) =>
+		autoColor ? autoFlat(autoColor) : { color, roughness, metalness };
+	return (
+		<group position={position} rotation={[0, rotY, 0]}>
+			<mesh position={[0, 0.76, 0]} rotation={[Math.PI / 2, 0, 0]}>
+				<cylinderGeometry args={[0.23, 0.31, 2.75, 16]} />
+				<meshStandardMaterial {...mat(CLAY_PLANE, 0.58, 0.18)} />
+			</mesh>
+			<mesh position={[0, 0.76, 1.55]} rotation={[Math.PI / 2, 0, 0]}>
+				<coneGeometry args={[0.23, 0.55, 16]} />
+				<meshStandardMaterial {...mat(CLAY_PLANE_TRIM, 0.52, 0.2)} />
+			</mesh>
+
+			<mesh position={[0, 0.73, 0.15]}>
+				<boxGeometry args={[3.4, 0.09, 0.58]} />
+				<meshStandardMaterial {...mat(CLAY_PLANE, 0.62, 0.14)} />
+			</mesh>
+			<mesh position={[0, 0.84, -1.18]}>
+				<boxGeometry args={[1.45, 0.07, 0.38]} />
+				<meshStandardMaterial {...mat(CLAY_PLANE_TRIM, 0.62, 0.12)} />
+			</mesh>
+			<mesh position={[0, 1.08, -1.2]} rotation={[0.22, 0, 0]}>
+				<boxGeometry args={[0.08, 0.62, 0.48]} />
+				<meshStandardMaterial {...mat(CLAY_PLANE, 0.62, 0.12)} />
+			</mesh>
+
+			<mesh position={[0, 1.02, 0.42]} scale={[0.62, 0.46, 0.9]}>
+				<sphereGeometry args={[0.42, 16, 10, 0, Math.PI * 2, 0, Math.PI / 2]} />
+				<meshStandardMaterial color={CLAY_GLASS} roughness={0.16} metalness={0.55} />
+			</mesh>
+
+			<group position={[0, 0.76, 1.86]}>
+				<mesh rotation={[Math.PI / 2, 0, 0]}>
+					<cylinderGeometry args={[0.11, 0.11, 0.2, 12]} />
+					<meshStandardMaterial color={CLAY_RIM} roughness={0.45} metalness={0.4} />
+				</mesh>
+				<mesh position={[0, 0, 0.12]} rotation={[0, 0, 0.28]}>
+					<boxGeometry args={[1.25, 0.08, 0.06]} />
+					<meshStandardMaterial color={CLAY_TIRE} roughness={0.8} />
+				</mesh>
+			</group>
+
+			{[-0.55, 0.55].map((x) => (
+				<group key={x} position={[x, 0.2, 0.15]}>
+					<mesh position={[0, 0.24, 0]} rotation={[0, 0, x < 0 ? -0.35 : 0.35]}>
+						<boxGeometry args={[0.045, 0.55, 0.045]} />
+						<meshStandardMaterial color={CLAY_RIM} roughness={0.65} metalness={0.3} />
+					</mesh>
+					<mesh rotation={[0, 0, Math.PI / 2]}>
+						<cylinderGeometry args={[0.16, 0.16, 0.09, 14]} />
+						<meshStandardMaterial color={CLAY_TIRE} roughness={0.95} />
+					</mesh>
+				</group>
+			))}
+		</group>
+	);
+}
+
+export function Chair({ position = [0, 0, 0], rotY = 0, autoColor = undefined }) {
+	// Auto-color mode tints seat/back and frame together; undefined keeps the
+	// hand-picked clay pair exactly as it ships.
+	const seat = autoColor ? autoFlat(autoColor) : { color: CLAY_CHAIR_LIGHT, roughness: 0.86 };
+	const frame = autoColor ? autoFlat(autoColor) : { color: CLAY_CHAIR, roughness: 0.9 };
+	const legPositions = [
+		[-0.24, 0.23, -0.22],
+		[0.24, 0.23, -0.22],
+		[-0.24, 0.23, 0.22],
+		[0.24, 0.23, 0.22],
+	];
+	return (
+		<group position={position} rotation={[0, rotY, 0]} scale={0.9}>
+			<mesh position={[0, 0.49, 0]} castShadow receiveShadow>
+				<boxGeometry args={[0.6, 0.12, 0.58]} />
+				<meshStandardMaterial {...seat} />
+			</mesh>
+			{legPositions.map((leg, index) => (
+				<mesh key={index} position={leg} castShadow receiveShadow>
+					<boxGeometry args={[0.09, 0.46, 0.09]} />
+					<meshStandardMaterial {...frame} />
+				</mesh>
+			))}
+			<mesh position={[-0.24, 0.92, -0.245]} castShadow receiveShadow>
+				<boxGeometry args={[0.09, 0.86, 0.09]} />
+				<meshStandardMaterial {...frame} />
+			</mesh>
+			<mesh position={[0.24, 0.92, -0.245]} castShadow receiveShadow>
+				<boxGeometry args={[0.09, 0.86, 0.09]} />
+				<meshStandardMaterial {...frame} />
+			</mesh>
+			<mesh position={[0, 1.08, -0.245]} castShadow receiveShadow>
+				<boxGeometry args={[0.52, 0.38, 0.1]} />
+				<meshStandardMaterial {...seat} />
+			</mesh>
+		</group>
+	);
+}

package/src/settings-menu.jsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "react";
 import { ko, localeChosen } from "./locale.js";
 import PreferencesDialog from "./shell/PreferencesDialog.jsx";
 
@@ -14,7 +14,7 @@ const LANGUAGES = [
 	{ id: "ko", label: "한국어", action: "한국어로 전환" },
 ];
 
-export default function SettingsMenu({ motionSetup, motionSetupReveal = 0 }) {
+export default function SettingsMenu() {
 	const [open, setOpen] = useState(false);
 	const triggerRef = useRef(null);
 	const close = useCallback(() => {
@@ -39,13 +39,6 @@ export default function SettingsMenu({ motionSetup, motionSetupReveal = 0 }) {
 		</>
 	);
 
-	// A contextual readiness action can reveal Preferences directly on the
-	// motion connection page without changing the topbar or adding a second
-	// settings surface.
-	useEffect(() => {
-		if (motionSetupReveal) setOpen(true);
-	}, [motionSetupReveal]);
-
 	// First-run cue: the studio starts in English even on a Korean browser, so
 	// the only visible hint that Korean exists used to be the old locale button.
 	// Until a language is stored, a ko-* browser sees the trigger in Korean.
@@ -70,8 +63,7 @@ export default function SettingsMenu({ motionSetup, motionSetupReveal = 0 }) {
 			<PreferencesDialog
 				open={open}
 				onClose={close}
-				motionSetup={motionSetup}
-				initialSection={motionSetupReveal ? "ARDY Connection" : "Appearance"}
+				initialSection="Appearance"
 				cameraTutorial={cameraTutorial}
 			/>
 		</div>

package/src/shell/BottomDock.jsx

@@ -5,9 +5,9 @@ import "./dock.css";
 import LibrarySlot from "./LibrarySlot.jsx";
 import BoardSlot from "./BoardSlot.jsx";
 import { ko } from "../locale.js";
-import Timeline from "../ardy/timeline.jsx";
+import Timeline, { timelineTake } from "../motion/timeline.jsx";
 import { DEFAULT_PLAYBACK_SPEED, SHOT_ASPECT_PRESETS, sceneObjectNameDisplayKo } from "../app-stage.jsx";
-import { motionEditLayout, createMotionEdit } from "../ardy/motion-edit.js";
+
 import { trackFeature } from "../analytics.js";
 import { defaultRailRange } from "../camera-rail-schedule.js";
 import { insertPathMark, pathMarks } from "../object-path.js";
@@ -74,9 +74,8 @@ export default function BottomDock({ tab: requestedTab = "animation", onTabChang
 		tlFrame, motion, waypointMode, craneSelectedIndex,
 		isCameraSelection, addActiveCranePoint, deleteSelectedCranePoint, setCraneSelectedIndex, tlFrameCount,
 		tlFps, characters, activeCharIndex, ghostLayers, pathSpeed,
-		tlPlaying, workflowMode, waypoints, pendingWaypointFrame, promptClips,
-		selectedPromptId, stateBadge, ikMode, ikChains, applyMotionTrim,
-		resetMotionTrim, cutMotionAtPlayhead, changeMotionSegmentSpeed, removeMotionSegmentById, ikFrames,
+		tlPlaying, workflowMode, waypoints, pendingWaypointFrame,
+		stateBadge, ikMode, ikChains, ikFrames,
 		rangePins, rangePinSelection, ikEditTool, rangePinPreview, footSnap,
 		bodyContact, shots, shotAspectKey, activeShotIdx, railDraw,
 		pathDraw, pathTarget, setPathDraw, setRailDraw, setWorkspaceLayout,
@@ -85,13 +84,12 @@ export default function BottomDock({ tab: requestedTab = "animation", onTabChang
 		setBodyContact, setToast, setFootSnap, setTlFrame, advanceFrame,
 		stepFrame, cameraPreviewEndRef, manualCameraOverrideRef, setTlPlaying, toggleWaypointMode,
 		setWaypointMode, selectActiveCharacterInHierarchy, setActiveWaypointId, setPendingWaypointFrame, removeWaypoint,
-		queueRootWaypointFrame, addPromptClip, revealPromptBlocks, setSelectedPromptId, setArdyPrompt,
-		changePromptClip, resizePromptClip, movePromptClip, removePromptClip, setSelectedHierarchyId,
+		queueRootWaypointFrame, setSelectedHierarchyId,
 		selectWorkflowMode, addCameraKeyframe, moveCameraKeyframe, removeCameraKeyframe, syncActiveCameraFraming,
 		activeCamera, activeShotDuration, changeActiveCamera, cameraRail, previewCameraShot,
 		toggleCameraRailDraw, deleteCameraRail, selectTimelineShot, shotsDomain, runStudioAction,
-		clearMotion, subscribeToasts, exportStatus, exportPhaseLabel, ardyRunning, ardyStatus,
-		ardyOutcome, pathPointIndex, setPathPointIndex,
+		clearMotion, subscribeToasts, exportStatus, exportPhaseLabel,
+		pathPointIndex, setPathPointIndex,
 	} = useStudioShell();
 	const dockRef = useRef(null);
 	const [dockHeight, setDockHeight] = useState(readDockHeight);
@@ -160,20 +158,6 @@ export default function BottomDock({ tab: requestedTab = "animation", onTabChang
 	useEffect(() => subscribeToasts((toast) => logStore.push({ kind: "toast", text: toast.uiMessage })),
 		// eslint-disable-next-line react-hooks/exhaustive-deps
 		[]);
-	const generationWasRunning = useRef(false);
-	useEffect(() => {
-		if (ardyRunning && !generationWasRunning.current) logStore.push({ kind: "generation", text: ko("Motion generation started", "모션 생성을 시작했어요") });
-		generationWasRunning.current = ardyRunning;
-	}, [ardyRunning]);
-	useEffect(() => {
-		if (ardyRunning && ardyStatus) logStore.push({ kind: "generation", key: "generation:status", text: ardyStatus });
-	}, [ardyRunning, ardyStatus]);
-	useEffect(() => {
-		if (!ardyOutcome) return;
-		logStore.push({ kind: "generation", text: ardyOutcome.ok
-			? ko("Motion generation finished", "모션 생성을 마쳤어요")
-			: ko(`Motion generation failed — ${ardyOutcome.message}`, `모션 생성 실패 — ${ardyOutcome.message}`) });
-	}, [ardyOutcome]);
 	const exportPhase = exportStatus?.phase, exportLabel = exportStatus?.label, exportMessage = exportStatus?.message;
 	const exportDone = exportStatus?.completedFrames, exportTotal = exportStatus?.frameCount;
 	useEffect(() => {
@@ -238,22 +222,10 @@ export default function BottomDock({ tab: requestedTab = "animation", onTabChang
 			waypointMode={waypointMode}
 			waypoints={waypoints}
 			pendingWaypointFrame={pendingWaypointFrame}
-			previsMode={previsMode}
-			promptClips={promptClips}
-			selectedPromptId={selectedPromptId}
 			badge={stateBadge}
 			ikMode={ikMode}
 			ikDisabled={!ikChains}
-			motion={motion ? {
-				frames: motion.frames,
-				label: motion.prompt || ko("Loaded take", "불러온 테이크"),
-				segments: motionEditLayout(motion.editSegments ?? createMotionEdit(motion.frames)),
-			} : null}
-			onMotionTrim={applyMotionTrim}
-			onMotionTrimReset={resetMotionTrim}
-			onMotionCut={cutMotionAtPlayhead}
-			onMotionSpeedChange={changeMotionSegmentSpeed}
-			onMotionSegmentRemove={removeMotionSegmentById}
+			motion={timelineTake(motion, characters[activeCharIndex]?.id, runStudioAction)}
 			ikFrames={ikFrames}
 			rangePins={rangePins}
 			selectedPinId={rangePinSelection}
@@ -351,21 +323,7 @@ export default function BottomDock({ tab: requestedTab = "animation", onTabChang
 			}}
 			onMarkerRemove={removeWaypoint}
 			onRootKeyframeAdd={queueRootWaypointFrame}
-			onPromptAdd={(frame) => {
-				addPromptClip(frame);
-				selectActiveCharacterInHierarchy();
-				revealPromptBlocks();
-			}}
-			onPromptSelect={(id) => {
-				setSelectedPromptId(id);
-				setArdyPrompt(promptClips.find((clip) => clip.id === id)?.text ?? "");
-				selectActiveCharacterInHierarchy();
-				revealPromptBlocks();
-			}}
-			onPromptChange={changePromptClip}
-			onPromptResize={resizePromptClip}
-			onPromptMove={movePromptClip}
-			onPromptRemove={removePromptClip}
+			
 			onCameraMoveSelect={() => {
 				setSelectedHierarchyId("camera");
 				if (workflowMode !== "camera") selectWorkflowMode("camera");
@@ -482,12 +440,12 @@ function ShotCard() {
 						{ko("Exit", "나가기")}
 						<kbd>Esc</kbd>
 					</button>
-				) : (
+				) : activeShot ? (
 					<button type="button" className="dock-shot-look" aria-pressed="false" onClick={enterShotLook} title={ko("Look through the shot camera (Esc returns)", "샷 카메라 시점으로 보기 (Esc로 복귀)")}>
 						<svg viewBox="0 0 16 16" aria-hidden="true"><path d="M1.75 8S4 3.75 8 3.75 14.25 8 14.25 8 12 12.25 8 12.25 1.75 8 1.75 8z M8 6.25a1.75 1.75 0 1 1 0 3.5 1.75 1.75 0 1 1 0-3.5z" /></svg>
 						{ko("Look through", "샷 시점")}
 					</button>
-				)}
+				) : null}
 			</footer>
 		</section>
 	);

package/src/shell/CompositionGuideButton.jsx

@@ -0,0 +1,20 @@
+import { GUIDE_LABELS, nextGuideMode } from "../shot-guides.js";
+import { ko } from "../locale.js";
+
+export default function CompositionGuideButton({ guideMode, onCycle }) {
+	return (
+		<button
+			type="button"
+			className={"vp-guide-cycle vp-embed-guide" + (guideMode === "off" ? "" : " on")}
+			aria-label={ko("Cycle composition guides", "구도 가이드 전환")}
+			aria-pressed={guideMode !== "off"}
+			title={ko(GUIDE_LABELS[guideMode].en, GUIDE_LABELS[guideMode].ko) + ko(" · click to cycle", " · 클릭으로 전환")}
+			onClick={() => onCycle(nextGuideMode(guideMode))}
+		>
+			<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" aria-hidden="true">
+				<path d="M3 3h18v18H3z" />
+				<path d="M9 3v18M15 3v18M3 9h18M3 15h18" />
+			</svg>
+		</button>
+	);
+}