cozyclay 1.9.0 → 2.0.0

package/src/{fal-motion-client.js → i2v-motion-client.js}

@@ -1,16 +1,16 @@
-export const FAL_MOTION_MODEL = "minimax/h3-max-turbo/image-to-video";
-export const FAL_MOTION_RESOLUTION = "480P";
-export const FAL_MOTION_MIN_DURATION = 5;
-export const FAL_MOTION_MAX_DURATION = 15;
-// The durations the Fal card offers. 15 s (362 frames) is the measured upper
+export const I2V_MOTION_MODEL = "minimax/h3-max-turbo/image-to-video";
+export const I2V_MOTION_RESOLUTION = "480P";
+export const I2V_MOTION_MIN_DURATION = 5;
+export const I2V_MOTION_MAX_DURATION = 15;
+// The durations the AI motion card offers. 15 s (362 frames) is the measured upper
 // end the H3 endpoint accepts and the extractor handles (#380 sit-to-bench).
-export const FAL_MOTION_DURATIONS = Object.freeze([5, 10, 15]);
+export const I2V_MOTION_DURATIONS = Object.freeze([5, 10, 15]);
 // H3's 480P output is 832x480. The reference still is captured at exactly
 // twice that canvas, and the Studio switches its viewport to the matching
 // "fal 480P" ratio when A is captured, so the user composes the shot on the
 // canvas the clip will have.
-export const FAL_MOTION_STILL_OUTPUT = Object.freeze({ width: 1664, height: 960 });
-export const FAL_MOTION_SHOT_ASPECT = "fal 480P";
+export const I2V_MOTION_STILL_OUTPUT = Object.freeze({ width: 1664, height: 960 });
+export const I2V_MOTION_SHOT_ASPECT = "fal 480P";
 
 export function motionApiOrigin(location = globalThis.location) {
   const configured = globalThis.__COZYCLAY_MOTION_API__;
@@ -51,24 +51,24 @@ async function request(path, body, fetchImpl = fetch) {
   return payload;
 }
 
-export function submitFalMotion(input, fetchImpl = fetch) {
+export function submitMotionJob(input, fetchImpl = fetch) {
   const kind = input?.kind === "interpolate" ? "interpolate" : "act";
   const body = {
     ...(kind === "interpolate" ? { stillA: input.stillA, stillB: input.stillB } : { still: input.still }),
     prompt: input.prompt,
-    duration: Number(input.duration ?? FAL_MOTION_MIN_DURATION),
+    duration: Number(input.duration ?? I2V_MOTION_MIN_DURATION),
   };
   return request(`/v1/motion/${kind}`, body, fetchImpl);
 }
 
-export function getFalMotionJob(id, fetchImpl = fetch) {
+export function getMotionJob(id, fetchImpl = fetch) {
   return request(`/v1/motion/jobs/${encodeURIComponent(id)}`, undefined, fetchImpl);
 }
 
-export async function waitForFalMotionJob(id, { intervalMs = 500, timeoutMs = 120_000, fetchImpl = fetch, onUpdate } = {}) {
+export async function waitForMotionJob(id, { intervalMs = 500, timeoutMs = 120_000, fetchImpl = fetch, onUpdate } = {}) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    const payload = await getFalMotionJob(id, fetchImpl);
+    const payload = await getMotionJob(id, fetchImpl);
     const job = payload?.job ?? null;
     onUpdate?.(job, payload);
     if (job?.status === "done" || job?.status === "failed") return payload;

package/src/i2v-motion-studio.jsx

@@ -0,0 +1,180 @@
+import { ko, isKo } from "./locale.js";
+import { buildH3MotionPrompt, I2V_MOTION_DURATIONS, I2V_MOTION_MIN_DURATION } from "./i2v-motion-client.js";
+
+// The AI motion workflow split by what needs the viewport (#407 UX). The
+// card stays in the Pose foldout and holds only the steps that operate on the
+// 3D scene (framing, shaded mode, A/B capture, camera lock). The modal takes
+// the text-heavy authoring (mode, description, duration, prompt, generate)
+// onto a wide surface. A blocking overlay would hide the viewport, so capture
+// never lives in the modal.
+//
+// App builds one `model` (state + derived booleans) and one `actions` object
+// (handlers) and passes both to each surface, so the two cannot drift.
+
+function Stepper({ step }) {
+	return (
+		<div className="i2v-motion-stepper" aria-label={ko("AI motion steps", "AI 모션 진행 단계")}>
+			{[
+				[1, ko("Shaded", "음영")],
+				[2, "A"],
+				[3, "B"],
+				[4, ko("Generate", "생성")],
+			].map(([n, label]) => <span key={n} className={step === n ? "active" : step > n ? "done" : ""}><b>{n}</b>{label}</span>)}
+		</div>
+	);
+}
+
+function CameraStatus({ model, actions }) {
+	const { hasA, hasB, cameraMatch, cameraUnlocked, currentCameraMatch } = model;
+	return (
+		<>
+			<p className={"i2v-motion-camera-status" + (cameraMatch ? " ready" : "")} data-testid="i2v-motion-camera-status">
+				{hasA
+					? cameraUnlocked
+						? ko("Camera unlocked · recapture A to save a new reference.", "카메라 잠금 해제됨 · A를 다시 캡처하면 새 기준을 저장합니다.")
+						: currentCameraMatch
+							? cameraMatch ? ko("✓ A/B camera framing matched · camera locked", "✓ A/B 카메라 프레이밍 일치 확인 · 카메라 잠금") : ko("✓ A camera saved · camera locked", "✓ A 카메라 기준 저장 · 카메라 잠금")
+							: ko("The camera changed after A. Restore the A camera.", "A 이후 카메라가 바뀌었어요. A 카메라로 복원하세요.")
+					: ko("Capture A first to save the camera reference.", "A를 먼저 캡처하면 카메라 기준을 저장합니다.")}
+			</p>
+			{hasA && <div className="i2v-motion-camera-actions">
+				<button type="button" className="btn ghost" onClick={actions.toggleCameraLock}>{cameraUnlocked ? ko("Lock camera", "카메라 잠그기") : ko("Unlock camera", "카메라 잠금 해제")}</button>
+				{!currentCameraMatch && <button type="button" className="btn ghost" onClick={actions.restoreCamera}>{ko("Restore A camera", "A 카메라로 복원")}</button>}
+			</div>}
+		</>
+	);
+}
+
+function Thumbs({ model }) {
+	const { i2vMotion } = model;
+	if (!i2vMotion.a && !i2vMotion.b) return null;
+	return (
+		<div className="i2v-motion-thumbs" aria-label={ko("AI motion reference poses", "AI motion reference poses")}>
+			{i2vMotion.a && <figure><img src={i2vMotion.a.dataUrl} alt="Pose A" /><figcaption>A · {i2vMotion.a.width}×{i2vMotion.a.height}</figcaption></figure>}
+			{i2vMotion.b && <figure><img src={i2vMotion.b.dataUrl} alt="Pose B" /><figcaption>B · {i2vMotion.b.width}×{i2vMotion.b.height}</figcaption></figure>}
+		</div>
+	);
+}
+
+/** The viewport-side strip in the Pose foldout. Capture and framing only. */
+export function I2vMotionCaptureCard({ model, actions, onOpen }) {
+	const { i2vMotion, mode, enabled, segmentationReady, step, hasA, hasB, cameraUnlocked, framingActive } = model;
+	return (
+		<section className="i2v-motion-card" data-testid="i2v-motion-studio" data-motion-enabled={enabled ? "true" : "false"}>
+			<div className="i2v-motion-head">
+				<strong>{ko("AI motion", "AI 모션 생성")}</strong>
+				<span>{!enabled ? ko("QA lock", "QA 잠금") : i2vMotion.job?.status === "done" ? ko("Done", "완료") : i2vMotion.status === "error" ? ko("Needs attention", "확인 필요") : "H3 Max Turbo · 480P"}</span>
+			</div>
+			<Stepper step={step} />
+			<div className="i2v-motion-segmentation-row">
+				<p className="inspector-hint i2v-motion-ratio">{ko("Frame the shot at the H3 ratio (832×480) in the shot view.", "샷 시점을 H3 비율(832×480)로 맞추고 구도를 잡으세요.")}</p>
+				<button type="button" className="btn i2v-motion-flat-cta" data-testid="i2v-motion-frame-shot" onClick={actions.enterFraming} disabled={framingActive}>{ko("480P shot view", "480P 비율로 샷 시점")}</button>
+			</div>
+			<div className={"i2v-motion-segmentation-row" + (segmentationReady ? " ready" : "")}>
+				<p className="inspector-hint i2v-motion-segmentation">{segmentationReady ? ko("Shaded body-part segmentation ON · A/B capture ready", "색 세그멘테이션 음영 모드 ON · A/B 캡처 가능") : ko("Shaded body-part colours are required for A/B refs.", "A/B 참조에는 부위 색상 음영 모드가 필요합니다.")}</p>
+				{!segmentationReady && <button type="button" className="btn i2v-motion-flat-cta" onClick={actions.enableShaded}>{ko("Enable Shaded", "음영 모드 켜기")}</button>}
+			</div>
+			<div className="i2v-motion-capture-status" aria-live="polite" data-testid="i2v-motion-capture-status">
+				<div className={"i2v-motion-capture-slot" + (hasA ? " captured" : "")} data-testid="i2v-motion-ref-a-status">
+					<strong>A · {hasA ? ko("Captured", "캡처 완료") : ko("Not captured", "미캡처")}</strong>
+					<span>{hasA ? `${i2vMotion.a.width}×${i2vMotion.a.height} · Shaded ${i2vMotion.a.partColours.length}개` : ko("Press Capture A on the current frame", "현재 프레임에서 A 캡처를 누르세요")}</span>
+				</div>
+				<div className={"i2v-motion-capture-slot" + (hasB ? " captured" : "")} data-testid="i2v-motion-ref-b-status">
+					<strong>B · {hasB ? ko("Captured", "캡처 완료") : ko("Not captured", "미캡처")}</strong>
+					<span>{hasB ? `${i2vMotion.b.width}×${i2vMotion.b.height} · Shaded ${i2vMotion.b.partColours.length}개` : ko("Set the B pose, keep the camera still, then press Capture B", "B 포즈를 만든 뒤 카메라를 움직이지 말고 B 캡처를 누르세요")}</span>
+					{hasB && <button type="button" className="i2v-motion-slot-action" onClick={() => actions.clearPose("b")}>{ko("Remove B", "B 제거")}</button>}
+				</div>
+			</div>
+			<CameraStatus model={model} actions={actions} />
+			<div className="i2v-motion-pose-row">
+				<button type="button" className={i2vMotion.a ? "btn active" : "btn"} disabled={!segmentationReady} onClick={() => actions.markPose("a")}>{i2vMotion.a ? ko("Recapture A", "A 재캡처") : ko("Capture A", "A 캡처")}</button>
+				{mode === "interpolate" && <button type="button" className={i2vMotion.b ? "btn active" : "btn"} disabled={!segmentationReady || cameraUnlocked} onClick={() => actions.markPose("b")}>{i2vMotion.b ? ko("Recapture B", "B 재캡처") : ko("Capture B", "B 캡처")}</button>}
+				{(i2vMotion.a || i2vMotion.b) && <button type="button" className="btn ghost" onClick={actions.clear}>{ko("Clear", "초기화")}</button>}
+			</div>
+			<Thumbs model={model} />
+			<div className="i2v-motion-open-row">
+				<button type="button" className="btn primary i2v-motion-open" data-testid="i2v-motion-open" onClick={onOpen}>{ko("Describe & generate", "동작 설명 · 생성")}</button>
+			</div>
+		</section>
+	);
+}
+
+/** The wide authoring surface: description, duration, prompt, generate. */
+export function I2vMotionModal({ model, actions, onClose }) {
+	const { i2vMotion, mode, enabled, hasA, hasB, step } = model;
+	const interpolate = mode === "interpolate";
+	const generateDisabled = interpolate
+		? (!enabled || i2vMotion.status === "submitting" || i2vMotion.status === "queued" || !hasA || !hasB)
+		: (!enabled || i2vMotion.status === "submitting" || i2vMotion.status === "queued" || !hasA || !!i2vMotion.b || !i2vMotion.instruction.trim());
+	const generateTitle = !enabled
+		? ko("Locked until owner testing is complete.", "소유자 테스트가 끝날 때까지 잠겨 있습니다.")
+		: interpolate && !hasB
+			? ko("Capture B before generating.", "B 포즈를 먼저 캡처하세요.")
+			: !interpolate && !!i2vMotion.b
+				? ko("Remove B for A-only action mode.", "A만 동작 모드에서는 B를 제거하세요.")
+				: !interpolate && !i2vMotion.instruction.trim()
+					? ko("Enter an action description.", "동작 설명을 입력하세요.")
+					: "";
+	const busy = i2vMotion.status === "submitting" || i2vMotion.status === "queued";
+	return (
+		<div className="modal-overlay" onClick={onClose}>
+			<div className="modal i2v-motion-modal" role="dialog" aria-modal="true" aria-labelledby="i2v-motion-title" onClick={(event) => event.stopPropagation()}>
+				<div className="modal-head">
+					<h3 id="i2v-motion-title">{ko("AI motion", "AI 모션 생성")}</h3>
+					<button type="button" className="x" onClick={onClose} aria-label={ko("Close", "닫기")}>✕</button>
+				</div>
+				<div className="i2v-motion-modal-body">
+					<div className="i2v-motion-modal-left">
+						<Stepper step={step} />
+						<Thumbs model={model} />
+						{step < 4 && <p className="inspector-hint">{ko("Capture A/B in the viewport — close this and use the card.", "A/B 캡처는 뷰포트에서 합니다. 닫고 카드에서 캡처하세요.")}</p>}
+						{i2vMotion.job?.status === "done" && i2vMotion.job.video?.url && <video className="i2v-motion-video" src={i2vMotion.job.video.url} controls playsInline preload="metadata" />}
+					</div>
+					<div className="i2v-motion-modal-right">
+						<div className="i2v-motion-mode-tabs" role="tablist" aria-label={ko("AI motion mode", "AI 모션 방식")}>
+							<button type="button" role="tab" aria-selected={interpolate} className={interpolate ? "active" : ""} onClick={() => actions.setMode("interpolate")}>{ko("A→B interpolate", "A→B 보간")}</button>
+							<button type="button" role="tab" aria-selected={!interpolate} className={!interpolate ? "active" : ""} onClick={() => actions.setMode("act")}>{ko("A-only action", "A만 동작")}</button>
+						</div>
+						<p className="inspector-hint i2v-motion-mode-hint">
+							{interpolate
+								? ko("Describe how the character moves from A to B.", "A와 B 사이를 어떻게 움직일지 설명과 함께 만듭니다.")
+								: ko("Creates motion from one A pose and an action description.", "A 포즈 하나와 동작 설명으로 움직임을 만듭니다.")}
+						</p>
+						<textarea
+							className="i2v-motion-instruction"
+							value={i2vMotion.instruction}
+							placeholder={interpolate
+								? ko("Describe the motion from A to B. Example: walk to the bench, turn, and sit", "A에서 B로 어떻게 움직이는지 적으세요. 예: 벤치로 걸어가 돌아서 앉는다")
+								: ko("With A only, describe the action. Example: swing the sword overhead and step forward", "A만 캡처한 뒤 동작을 적으세요. 예: 검을 머리 위로 휘두르고 한 걸음 전진")}
+							onChange={(event) => actions.setI2vMotion((current) => ({ ...current, instruction: event.target.value }))}
+						/>
+						<div className="i2v-motion-duration-row">
+							<span className="inspector-hint">{ko("Length", "길이")}</span>
+							{I2V_MOTION_DURATIONS.map((seconds) => (
+								<button key={seconds} type="button" className={"btn small" + ((i2vMotion.duration ?? I2V_MOTION_MIN_DURATION) === seconds ? " active" : "")} onClick={() => actions.setI2vMotion((current) => ({ ...current, duration: seconds }))}>{seconds}{ko("s", "초")}</button>
+							))}
+						</div>
+						<details className="i2v-motion-prompt-edit">
+							<summary>{ko("Prompt to send", "보낼 프롬프트")}</summary>
+							<textarea
+								className="i2v-motion-instruction i2v-motion-prompt-override"
+								value={i2vMotion.promptOverride ?? ""}
+								placeholder={buildH3MotionPrompt(i2vMotion.instruction, { interpolate })}
+								onChange={(event) => actions.setI2vMotion((current) => ({ ...current, promptOverride: event.target.value }))}
+							/>
+							<p className="inspector-hint">{ko("Left blank, this is built from the description above. Edit it and your text is sent verbatim.", "비워 두면 위 설명으로 자동 생성됩니다. 직접 고치면 그대로 전송됩니다.")}</p>
+						</details>
+						{i2vMotion.status === "error" && <p className="studio-hint error i2v-motion-inline-error" role="alert">{i2vMotion.error}</p>}
+						<div className="i2v-motion-actions">
+							<button type="button" className="btn primary" title={generateTitle} disabled={generateDisabled} onClick={() => actions.generate(mode)}>
+								{busy ? ko("Generating…", "생성 중…") : interpolate ? ko("Interpolate A→B", "A→B 보간 생성") : ko("Generate action", "동작 생성")}
+							</button>
+						</div>
+						{!enabled && <p className="inspector-hint">{ko("Generation requests stay blocked on the server until owner testing is complete.", "소유자 테스트가 끝날 때까지 생성 요청은 서버에서 차단됩니다.")}</p>}
+						{i2vMotion.dailyRemaining !== null && <p className="inspector-hint">{ko(`${i2vMotion.dailyRemaining} motion generations left today`, `오늘 남은 생성 ${i2vMotion.dailyRemaining}회`)}</p>}
+					</div>
+				</div>
+			</div>
+		</div>
+	);
+}

package/src/ik-camera.js

@@ -0,0 +1,3 @@
+export function chooseIkEntryPose({ rememberedPose, editorPose, shotPose, lookThroughShot }) {
+	return rememberedPose ?? (lookThroughShot ? shotPose : editorPose);
+}

package/src/main.jsx

@@ -1,5 +1,10 @@
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
+// First stylesheet on the page: it fixes the cascade-layer order before any
+// component sheet (topbar.css, viewport.css, pose.css...) opens a layer.
+import "./styles/tokens.css";
+import "./styles/themes.css";
+import { applyTheme, readTheme } from "./theme.js";
 import App from "./App.jsx";
 import ErrorBoundary from "./error-boundary.jsx";
 import "./styles.css";
@@ -11,6 +16,7 @@ import { fetchPlaygroundProject, isPlaygroundEmbed, playgroundSceneUrl, stashPla
 registerPwa();
 void initAnalytics();
 document.documentElement.lang = LOCALE;
+applyTheme(readTheme());
 
 async function boot() {
 	// The landing-page playground needs its preset in hand before the first

package/src/motion/generation.js

@@ -0,0 +1,105 @@
+// Pure request construction. The caller supplies one rolled seed and sampled
+// poses; no rig, store, random source, notification or network is touched here.
+import { StudioProtocolError, compileStudioBeats } from '../studio-agent-protocol.js';
+import { TIMELINE_FRAME_FPS as FPS } from '../scenes.js';
+import { judgeAuthoredPath, alignArdyPath } from '../ardy/waypoints.js';
+import { planPosePin, PIN_BLOCKED } from '../ardy/pose-pin.js';
+import { blocksFromRequest, replayPayload, replayTruncated } from '../take-recipe.js';
+
+// Same half-open timeline schedule used by the editor: gaps carry the base
+// prompt, and spans shorter than three frames cannot carry a generation.
+function promptSchedule(clips, clipFrames, prompt) {
+  const segments = [];
+  let cursor = 0;
+  for (const clip of clips) {
+    const startFrame = Math.max(cursor, Math.min(clipFrames, clip.startFrame));
+    const endFrame = Math.max(startFrame, Math.min(clipFrames, clip.endFrame));
+    if (startFrame > cursor) segments.push({ startFrame: cursor, endFrame: startFrame, prompt });
+    if (endFrame - startFrame >= 3) segments.push({ startFrame, endFrame, prompt: clip.text.trim() || prompt });
+    cursor = Math.max(cursor, endFrame);
+    if (cursor >= clipFrames) break;
+  }
+  if (cursor < clipFrames) segments.push({ startFrame: cursor, endFrame: clipFrames, prompt });
+  if (!segments.length) segments.push({ startFrame: 0, endFrame: clipFrames, prompt });
+  return segments;
+}
+
+export function generationArgs({ characterId, source }) {
+  if (source.kind !== 'generate') throw generationRefusal('CAPABILITY_MISSING', 'Artifact reuse is handled by the retained artifact runtime.');
+  const schedule = compileStudioBeats(source);
+  return { characterId, durationSeconds: schedule.durationSeconds,
+    blocks: schedule.blocks.map((block, index) => ({ id: `generation-block-${index}`, text: block.text, startFrame: block.startFrame, endFrame: block.endFrameExclusive })),
+    ...(source.seed === undefined ? {} : { seed: source.seed }) };
+}
+
+export function generationRefusal(code, message, uiMessage = message) {
+  return Object.assign(new StudioProtocolError(code, message), { uiMessage });
+}
+
+export function buildGenerationRequest({ character, prompt, durationSeconds, seed,
+  waypoints = [], waypointMode = waypoints.length > 0, blocks = [], motion = null,
+  ikKeys = new Map(), startFromPose = false, posePlacement = 'start', frame = 0, poses = [],
+  preserveStrength = 0.5, recipe = null, fresh = false,
+}) {
+  const text = String(prompt ?? '').trim();
+  if (!text) throw generationRefusal('INVALID_ARGUMENT', 'Motion prompt is required - describe what the subject should do before generating');
+  if (text.length > 500) throw generationRefusal('INVALID_ARGUMENT', `Motion prompt is capped at 500 characters (currently ${text.length}) - shorten it before generating`);
+  const ikFrames = [...ikKeys.keys()].sort((a, b) => a - b);
+  const duration = motion && ikFrames.length ? motion.frames / motion.fps : Number(durationSeconds);
+  const clipFrames = Math.round(duration * FPS);
+  if (!Number.isFinite(duration) || duration < 1 || duration > 1200) throw generationRefusal('INVALID_RANGE', 'Duration must be between 1 and 1200 seconds');
+  if (!Number.isInteger(seed) || seed < 0 || seed > 2 ** 31 - 1) throw generationRefusal('INVALID_ARGUMENT', 'Seed must be an integer in 0..2147483647');
+  const warnings = [];
+  const clips = blocks.filter(clip => clip.text.trim()).sort((a, b) => a.startFrame - b.startFrame);
+  const segments = promptSchedule(clips, clipFrames, text), hasPromptSchedule = segments.length > 1;
+  const rootPath = waypointMode ? [{ frame: 0, x: character.x, z: character.z, heading: null }, ...waypoints] : [];
+  if (waypointMode) {
+    if (!waypoints.length) throw generationRefusal('INVALID_RANGE', 'Add at least one root destination before generating');
+    if (rootPath.length > 32) throw generationRefusal('INVALID_RANGE', 'The root path is capped at 32 sparse waypoints');
+    if (waypoints.some(point => point.frame <= 0 || point.frame >= clipFrames)) throw generationRefusal('INVALID_RANGE', `Root waypoint frames must stay inside 1..${clipFrames - 1}`);
+    const verdict = judgeAuthoredPath(rootPath, FPS, clipFrames, { chained: hasPromptSchedule });
+    if (verdict.errors.length) throw generationRefusal('INVALID_RANGE', `Not generated - ${verdict.errors[0]}`);
+    warnings.push(...verdict.warnings);
+  }
+  const longBlock = clips.length && segments.find(segment => segment.endFrame - segment.startFrame > 5 * FPS);
+  if (longBlock) throw generationRefusal('INVALID_RANGE', `Not generated - prompt blocks are capped at 5 s; split the ${((longBlock.endFrame - longBlock.startFrame) / FPS).toFixed(1)} s block`);
+  if (segments.some(segment => segment.prompt.length > 500)) throw generationRefusal('INVALID_ARGUMENT', 'Each motion prompt block is capped at 500 characters');
+  const aligned = waypointMode ? alignArdyPath(rootPath, character.rot, 32) : null;
+  const editedSegments = motion?.url && hasPromptSchedule
+    ? segments.filter(segment => ikFrames.some(at => at >= segment.startFrame && at < segment.endFrame)) : [];
+  const hasBlockEdits = editedSegments.length > 0;
+  const last = clipFrames - 1;
+  const poseFrame = posePlacement === 'end' ? last : posePlacement === 'middle' ? Math.round(last / 2)
+    : posePlacement === 'playhead' ? Math.max(0, Math.min(last, frame)) : 0;
+  const plan = planPosePin({ startFromPose, poseFrame, hasPromptSchedule, hasBlockEdits, waypointMode, ikFrames, clipFrames, segments, editedSegments });
+  if (plan.blockedBy === PIN_BLOCKED.SCHEDULE) warnings.push('Prompt blocks and a pose start cannot be combined - generating from the prompt alone.');
+  const body = { prompt: text, duration, posePin: plan.pin, seed };
+  let committedEditKeys = [];
+  if (plan.pin && !hasBlockEdits) body.poses = poses.map(entry => ({ ...entry }));
+  if (aligned) {
+    Object.assign(body, { waypoints: aligned.waypoints, rootMargin: 0.08, historyFrames: 4 * FPS });
+    if (hasPromptSchedule && !hasBlockEdits) body.segments = segments;
+  } else if (hasBlockEdits) {
+    const entries = plan.frames.map(at => ({ frame: at, tracks: [...(ikKeys.get(at)?.keys() ?? [])], pose: poses.find(entry => entry.frame === at)?.pose }));
+    committedEditKeys = entries.map(({ frame, tracks }) => ({ frame, tracks }));
+    body.motionEdit = { sourceMotion: motion.url, startFrame: Math.min(...editedSegments.map(segment => segment.startFrame)),
+      endFrame: Math.max(...editedSegments.map(segment => segment.endFrame)), contextBefore: 40, contextAfter: 20, edits: entries };
+  } else if (hasPromptSchedule) body.segments = segments;
+  const requestBlocks = blocksFromRequest(body, FPS), recipeBlocks = recipe?.blocks;
+  const durationFits = motion?.frames > 0 && Math.abs(motion.frames / FPS - duration) <= 1 / FPS + 1e-9;
+  const promptMatches = body.motionEdit !== undefined || (recipeBlocks?.length === requestBlocks.length && recipeBlocks.every((block, i) => block.prompt.trim() === requestBlocks[i].prompt.trim()));
+  if (!fresh && motion?.url && preserveStrength > 0 && durationFits && promptMatches && !body.segments) {
+    body.preserve = { sourceMotion: motion.url, strength: preserveStrength,
+      editRanges: editedSegments.map(({ startFrame, endFrame }) => {
+        const tracks = [...new Set(ikFrames.filter(at => at >= startFrame && at < endFrame).flatMap(at => [...ikKeys.get(at).keys()]))];
+        return { startFrame, endFrame, ...(tracks.length ? { tracks } : {}) };
+      }).filter(range => range.endFrame > range.startFrame) };
+  }
+  const replay = fresh || hasBlockEdits || !Number.isInteger(recipe?.seed) ? [] : replayPayload(recipe);
+  if (replay.length) {
+    body.replay = replay;
+    if (replayTruncated(recipe)) warnings.push(`Only ${replay.length} refinements can be replayed at once - the first ${replay.length} carry over`);
+  }
+  return { body, rootRotationDeg: aligned?.rotationDeg ?? character.rot, warnings,
+    constraintFrames: plan.frames, hasBlockEdits, hasPromptSchedule, committedEditKeys };
+}

package/src/motion-readiness-ui.jsx

@@ -43,7 +43,7 @@ export function MotionSetup({ state, checking, onRetry }) {
 				"Motion generation is optional. Sample motion, camera editing and exports work without it. Your scene and prompt blocks stay here while you set it up.",
 				"모션 생성은 선택 사항이에요. 연결 없이도 샘플 모션, 카메라 편집, 내보내기를 쓸 수 있어요. 설정하는 동안 씬과 프롬프트 블록은 그대로 유지됩니다.",
 			)}</p>
-			<p>{ko("Use an existing Kimodo host, then restart your local launcher with:", "기존 Kimodo 호스트를 사용하려면 로컬 실행기에 다음 환경변수를 설정하세요:")}</p>
+			<p>{ko("Use an existing motion generation host, then restart your local launcher with:", "기존 모션 생성 호스트를 사용하려면 로컬 실행기에 다음 환경변수를 설정하세요:")}</p>
 			<code>{`CCLAY_KIMODO_HOST=user@your-gpu-box npx cozyclay --port ${port} --no-open`}</code>
 			<p>{localStudio ? ko(
 				"Keep this tab open. After restarting the bridge on the same port, retry the connection below.",
@@ -53,11 +53,11 @@ export function MotionSetup({ state, checking, onRetry }) {
 				"새 모션 생성은 로컬 Studio에서 실행해요. 여기서 프로젝트를 저장하고 로컬 Studio에서 그 파일을 열면 편집 내용을 이어갈 수 있어요.",
 			)}</p>
 			<p>{ko(
-				"Local MLX/cpp supports one unconstrained prompt. Sequencing, pinned poses, paths and preserve need the CUDA/SSH route. Line editing needs a configured ProjFlow route.",
-				"로컬 MLX/cpp는 제약 없는 단일 프롬프트를 지원해요. 블록 연결, 포즈 고정, 경로, 테이크 보존에는 CUDA/SSH가 필요하고, 라인 편집에는 ProjFlow 설정이 필요해요.",
+				"Local MLX/cpp supports one unconstrained prompt. Sequencing, pinned poses, paths and preserve need the CUDA/SSH route. Line editing needs a configured line-edit route.",
+				"로컬 MLX/cpp는 제약 없는 단일 프롬프트를 지원해요. 블록 연결, 포즈 고정, 경로, 테이크 보존에는 CUDA/SSH가 필요하고, 라인 편집에는 라인 편집 경로 설정이 필요해요.",
 			)}</p>
 			<a href="https://github.com/NomaDamas/CozyClay/blob/main/docs/kimodo-setup.md" target="_blank" rel="noreferrer">
-				{ko("Kimodo setup and route guide", "Kimodo 설정 및 경로 안내")}
+				{ko("Motion generation setup and route guide", "모션 생성 설정 및 경로 안내")}
 			</a>
 			<button type="button" className="btn" data-testid="motion-health-retry" disabled={checking} onClick={onRetry}>
 				{checking ? ko("Checking…", "확인 중…") : ko("Recheck connection", "연결 다시 확인")}

package/src/motion-readiness.js

@@ -7,6 +7,17 @@ export function hasLineEditCapability(health) {
 	return Array.isArray(capabilities) ? capabilities.includes("lineEdit") : capabilities?.lineEdit === true;
 }
 
+/**
+ * Decide whether the hosted demo take may be seeded onto the stage. The seed
+ * is for a session with no bridge (the hosted demo). The first healthy probe
+ * latches `bridgeSeenOk`: after it, a failed probe is a blip, not "no bridge",
+ * and must never load the demo take onto the character.
+ */
+export function demoSeedGate(health, bridgeSeenOk = false) {
+	const seenOk = bridgeSeenOk || Boolean(health?.ok);
+	return { bridgeSeenOk: seenOk, seed: Boolean(health) && !health.ok && !seenOk };
+}
+
 /**
  * Derive the generation affordance state from bridge health and request shape.
  * Health is deliberately interpreted through the analytics preflight contract;