cozyclay 2.1.1 → 3.0.0

package/src/ardy/waypoints.js

@@ -1,369 +0,0 @@
-const cleanZero = (value) => (Object.is(value, -0) || Math.abs(value) < 1e-9 ? 0 : value);
-import { isKo } from "../locale.js";
-import { TIMELINE_FRAME_FPS } from "../timeline-fps.js";
-
-const DEFAULT_WAYPOINT_SPACING_FRAMES = Math.round(0.4 * TIMELINE_FRAME_FPS);
-
-/**
- * ARDY root constraints live in the actor's clip-local coordinates. CozyClay's
- * plan uses scene-world coordinates and rotates Subject 1 as a scene object, so
- * both translation and actor yaw must be removed before generation. Playback
- * applies the exact inverse transform when it places the generated root.
- */
-export function toArdyWaypoints(waypoints, actorRotationDeg = 0) {
-	if (!waypoints.length) return [];
-	const origin = waypoints[0];
-	const yaw = (actorRotationDeg * Math.PI) / 180;
-	const cos = Math.cos(yaw);
-	const sin = Math.sin(yaw);
-	return waypoints.map((waypoint) => {
-		const worldX = waypoint.x - origin.x;
-		const worldZ = waypoint.z - origin.z;
-		return {
-			frame: waypoint.frame,
-			x: cleanZero(cos * worldX - sin * worldZ),
-			z: cleanZero(sin * worldX + cos * worldZ),
-			heading: waypoint.heading ?? null,
-		};
-	});
-}
-/**
- * Densify an authored root path for ARDY motion generation: rebase to
- * clip-local coordinates exactly like toArdyWaypoints, interpolate on the
- * authored polyline, and emit one sample roughly every `spacing` frames
- * (capped at maxPoints). Authored frames are always kept, the first
- * sample is always frame 0, and frames are strictly ascending without
- * duplicates. The spacing is deliberately loose: a sample every 2-3
- * frames rails the root so hard the model gives up its gait cadence and
- * ice-skates; ~0.4 s between position pins leaves room for real steps
- * while the interpolated headings still steer the facing.
- * Each sample heading is the path tangent (central difference between
- * neighbors; adjacent-segment direction at the ends), carried forward
- * through stalls shorter than 1e-6 and 0 when the whole path is
- * stationary; headings are always finite numbers in [-2π, 2π].
- */
-export function densifyArdyWaypoints(waypoints, actorRotationDeg = 0, maxPoints = 32, spacing = DEFAULT_WAYPOINT_SPACING_FRAMES) {
-	if (waypoints.length < 2) return [];
-	const local = toArdyWaypoints(waypoints, actorRotationDeg);
-
-	// Authored frames and positions, deduplicated: these are the
-	// interpolation endpoints every sample set must contain.
-	const authored = [];
-	for (const point of local) {
-		if (authored.length === 0 || authored[authored.length - 1].frame !== point.frame) {
-			authored.push({ frame: point.frame, x: point.x, z: point.z });
-		}
-	}
-	if (authored.length === 1) {
-		return [{ frame: authored[0].frame, x: authored[0].x, z: authored[0].z, heading: 0 }];
-	}
-
-	const denseCount = authored[authored.length - 1].frame - authored[0].frame + 1;
-	const limit = Math.max(0, Math.floor(maxPoints));
-	const gapSpacing = Math.max(1, Math.floor(spacing));
-	// One filler per started `spacing` chunk beyond the first, per gap.
-	let spacingExtra = 0;
-	for (let i = 0; i < authored.length - 1; i += 1) {
-		spacingExtra += Math.max(0, Math.ceil((authored[i + 1].frame - authored[i].frame) / gapSpacing) - 1);
-	}
-	const extra = Math.max(0, Math.min(limit, denseCount, authored.length + spacingExtra) - authored.length);
-
-	// Distribute the extra samples across the gaps between authored frames
-	// in proportion to gap length (largest remainder), so spacing stays
-	// uniform while authored frames are always kept.
-	const gaps = [];
-	for (let i = 0; i < authored.length - 1; i += 1) {
-		gaps.push(authored[i + 1].frame - authored[i].frame);
-	}
-	const gapSizes = gaps.map(() => 0);
-	if (extra > 0) {
-		const total = gaps.reduce((sum, size) => sum + size, 0);
-		const raw = gaps.map((size) => (extra * size) / total);
-		const base = raw.map((value) => Math.floor(value));
-		const order = raw
-			.map((value, i) => [value - base[i], i])
-			.sort((a, b) => b[0] - a[0]);
-		let used = base.reduce((sum, value) => sum + value, 0);
-		for (const [, i] of order) {
-			if (used >= extra) break;
-			const add = Math.min(extra - used, gaps[i] - 1 - base[i]);
-			base[i] += add;
-			used += add;
-		}
-		for (let i = 0; i < gaps.length; i += 1) gapSizes[i] = base[i];
-	}
-
-	const frames = [];
-	for (let i = 0; i < authored.length; i += 1) {
-		if (i > 0) {
-			const count = gapSizes[i - 1];
-			if (count > 0) {
-				const step = gaps[i - 1] / (count + 1);
-				for (let j = 0; j < count; j += 1) {
-					frames.push(authored[i - 1].frame + Math.round((j + 1) * step));
-				}
-			}
-		}
-		frames.push(authored[i].frame);
-	}
-
-	// C1 resampling: cubic Hermite through the authored pins, with each pin's
-	// velocity as the finite-difference average of its two segment velocities
-	// (one-sided at the ends). A C0 polyline pins an instantaneous direction
-	// flip at every interior waypoint — and, when authored frames imply
-	// different paces, an instantaneous speed jump — which the generator can
-	// only satisfy by braking and pivoting on the pin: the hitch you see as
-	// the root crosses waypoint 2. Hermite keeps authored pins exact, keeps a
-	// uniform straight path exactly linear, and turns corners into arcs where
-	// both travel direction and speed ramp continuously. (A near-180° reversal
-	// will swing wide of the pin — that wide swing is the C1 answer to an
-	// about-face, not an error.)
-	const segmentVelocity = (a, b) => ({
-		x: (b.x - a.x) / (b.frame - a.frame),
-		z: (b.z - a.z) / (b.frame - a.frame),
-	});
-	const stalledSegment = (a, b) => (b.x - a.x) * (b.x - a.x) + (b.z - a.z) * (b.z - a.z) < 1e-12;
-	const velocity = authored.map((point, i) => {
-		const prev = authored[i - 1];
-		const next = authored[i + 1];
-		// A knot beside a stall comes to a full stop: leaking a neighbour's
-		// velocity into a hold would make the "stationary" span drift, and a
-		// walker entering a hold decelerates to zero anyway.
-		if (!prev) return stalledSegment(point, next) ? { x: 0, z: 0 } : segmentVelocity(point, next);
-		if (!next) return stalledSegment(prev, point) ? { x: 0, z: 0 } : segmentVelocity(prev, point);
-		if (stalledSegment(prev, point) || stalledSegment(point, next)) return { x: 0, z: 0 };
-		const before = segmentVelocity(prev, point);
-		const after = segmentVelocity(point, next);
-		return { x: (before.x + after.x) / 2, z: (before.z + after.z) / 2 };
-	});
-	const samples = [];
-	let seg = 0;
-	for (const frame of frames) {
-		while (frame > authored[seg + 1].frame) seg += 1;
-		const start = authored[seg];
-		const end = authored[seg + 1];
-		const span = end.frame - start.frame;
-		const t = (frame - start.frame) / span;
-		const h00 = (1 + 2 * t) * (1 - t) * (1 - t);
-		const h10 = t * (1 - t) * (1 - t);
-		const h01 = t * t * (3 - 2 * t);
-		const h11 = t * t * (t - 1);
-		const v0 = velocity[seg];
-		const v1 = velocity[seg + 1];
-		samples.push({
-			frame,
-			x: cleanZero(h00 * start.x + h10 * span * v0.x + h01 * end.x + h11 * span * v1.x),
-			z: cleanZero(h00 * start.z + h10 * span * v0.z + h01 * end.z + h11 * span * v1.z),
-			heading: 0,
-		});
-	}
-
-	// Path-tangent headings. Interior samples use the central difference
-	// between neighbors, the ends use their adjacent segment; displacements
-	// under 1e-6 (stalls) carry the previous heading, 0 when stationary.
-	// Sign convention measured against the deployed generator, not assumed.
-	// With the path aligned so heading[0] = 0 matches the model's forced
-	// frame-0 facing, the generated hips reproduce the SENT angle exactly
-	// (a probe sending mirrored headings walked the second segment facing
-	// +77.7° while travelling at −77.7°). Earlier mirror-looking results
-	// came from clips whose frame-0 facing conflicted with heading[0] and
-	// corrupted the whole track. Model heading = atan2(dx, dz) of the
-	// facing/travel direction; 0 faces +Z.
-	let previousHeading = 0;
-	for (let i = 0; i < samples.length; i += 1) {
-		let dx = 0;
-		let dz = 0;
-		if (samples.length > 1) {
-			if (i === 0) {
-				dx = samples[1].x - samples[0].x;
-				dz = samples[1].z - samples[0].z;
-			} else if (i === samples.length - 1) {
-				dx = samples[i].x - samples[i - 1].x;
-				dz = samples[i].z - samples[i - 1].z;
-			} else {
-				dx = samples[i + 1].x - samples[i - 1].x;
-				dz = samples[i + 1].z - samples[i - 1].z;
-			}
-		}
-		if (dx * dx + dz * dz >= 1e-12) previousHeading = Math.atan2(dx, dz);
-		samples[i].heading = cleanZero(previousHeading);
-	}
-	return samples;
-}
-/**
- * Align an authored root path for ARDY generation: compute the clip-local
- * first travel tangent (first non-zero authored displacement, squared
- * length >= 1e-12) and fold it into the total rotation so the densified
- * path starts with heading 0, the model's forced frame-0 +Z facing. The
- * returned rotationDeg is the scene->clip total rotation; handing it to
- * toSceneRootOffset at playback restores scene coordinates exactly.
- */
-export function alignArdyPath(waypoints, actorRotationDeg = 0, maxPoints = 32) {
-	if (waypoints.length < 2) return { waypoints: [], rotationDeg: actorRotationDeg };
-	// Fold the first *sampled* travel direction into the rotation, not the
-	// authored chord: the C1 resampler bends inside the first segment, so only
-	// the dense samples know the true first step. Rotation is rigid, so
-	// densifying again with the folded rotation rotates those samples exactly
-	// and heading[0] lands on 0 by construction.
-	const probe = densifyArdyWaypoints(waypoints, actorRotationDeg, maxPoints);
-	let phi = 0;
-	for (let i = 0; i < probe.length - 1; i += 1) {
-		const dx = probe[i + 1].x - probe[i].x;
-		const dz = probe[i + 1].z - probe[i].z;
-		if (dx * dx + dz * dz >= 1e-12) {
-			phi = Math.atan2(dx, dz);
-			break;
-		}
-	}
-	const rotationDeg = actorRotationDeg + (phi * 180) / Math.PI;
-	return {
-		waypoints: densifyArdyWaypoints(waypoints, rotationDeg, maxPoints),
-		rotationDeg,
-	};
-}
-
-/** Rotate an ARDY clip-local root offset back into CozyClay scene space. */
-export function toSceneRootOffset(x, z, actorRotationDeg = 0) {
-	const yaw = (actorRotationDeg * Math.PI) / 180;
-	const cos = Math.cos(yaw);
-	const sin = Math.sin(yaw);
-	return {
-		x: cleanZero(cos * x + sin * z),
-		z: cleanZero(-sin * x + cos * z),
-	};
-}
-
-/**
- * A full-body pose also constrains the root. On a root path it must share the
- * frame-zero origin; otherwise the two constraints can pull the clip apart.
- */
-export function poseConstraintFrame(requestedFrame, clipFrames, hasRootPath) {
-	if (hasRootPath) return 0;
-	return Math.max(0, Math.min(Math.round(requestedFrame) || 0, clipFrames - 1));
-}
-
-// What the generator can actually express, learned the hard way: waypoints
-// are inpainting observations ARDY cannot refuse, so a request outside the
-// training distribution collapses into foot-sliding instead of erroring.
-// These limits keep authored paths inside that distribution.
-export const PATH_LIMITS = Object.freeze({
-	speedMinMps: 0.5, // below this, "walking" cannot cycle a gait — feet slide
-	speedMaxMps: 3.0, // above this is out of the locomotion band entirely
-	holdEpsM: 0.05, // a displacement this small is a deliberate hold, any duration
-	minPinGapFrames: 8, // authored pins closer than this over-rail the root
-	speedRatioWarn: 2, // adjacent legs differing more than 2x force a gait change
-	turnRateWarnDegPerS: 120, // sharper turns need wider arcs than the path gives
-	tailMaxS: 2, // unconstrained tail after the last pin inherits its history
-	clipMaxS: 10, // ARDY's trained window; one-shot constrained calls cannot exceed it
-});
-
-const NATURAL_WALK_MPS = 1.4;
-
-/**
- * Judge the segment a candidate pin would create after `last`. Returns
- * { ok, error?, warnings: [] } — `error` blocks the placement and always
- * names the fix (a workable frame or distance), `warnings` accompany a
- * placement that is legal but will read oddly.
- * @param {{frame:number,x:number,z:number}} last      the previous pin (or the frame-0 start)
- * @param {{frame:number,x:number,z:number}} candidate the pin being authored
- * @param {number} fps
- * @param {{frame:number,x:number,z:number}|null} prev the pin before `last`, for ratio/turn warnings
- */
-export function judgeNextWaypoint(last, candidate, fps, prev = null) {
-	const gap = candidate.frame - last.frame;
-	if (gap < PATH_LIMITS.minPinGapFrames) {
-		return {
-			ok: false,
-			error: isKo ? `핀 사이에는 최소 ${PATH_LIMITS.minPinGapFrames}프레임(${(PATH_LIMITS.minPinGapFrames / fps).toFixed(1)}초)이 필요해요 — ${last.frame + PATH_LIMITS.minPinGapFrames}프레임 이후로 이동해 주세요` : `pins need at least ${PATH_LIMITS.minPinGapFrames} frames between them (${(PATH_LIMITS.minPinGapFrames / fps).toFixed(1)} s) — scrub past frame ${last.frame + PATH_LIMITS.minPinGapFrames}`,
-			warnings: [],
-		};
-	}
-	const dist = Math.hypot(candidate.x - last.x, candidate.z - last.z);
-	if (dist <= PATH_LIMITS.holdEpsM) return { ok: true, warnings: [] }; // a hold: legal at any length
-	const dt = gap / fps;
-	const speed = dist / dt;
-	if (speed > PATH_LIMITS.speedMaxMps) {
-		const neededFrames = Math.ceil((dist / PATH_LIMITS.speedMaxMps) * fps);
-		return {
-			ok: false,
-			error: isKo ? `${speed.toFixed(1)} m/s는 사람이 움직이기엔 너무 빨라요(최대 ${PATH_LIMITS.speedMaxMps}) — ${last.frame + neededFrames}프레임 이후에 핀을 찍거나 더 가까운 곳을 눌러 주세요` : `${speed.toFixed(1)} m/s is faster than anyone moves (max ${PATH_LIMITS.speedMaxMps}) — pin frame ${last.frame + neededFrames} or later, or click closer`,
-			warnings: [],
-		};
-	}
-	if (speed < PATH_LIMITS.speedMinMps) {
-		const walkFrame = last.frame + Math.max(PATH_LIMITS.minPinGapFrames, Math.round((dist / NATURAL_WALK_MPS) * fps));
-		const neededDist = (PATH_LIMITS.speedMinMps * dt).toFixed(1);
-		return {
-			ok: false,
-			error: isKo ? `${speed.toFixed(2)} m/s는 자연스럽게 걷기엔 너무 느려요(최소 ${PATH_LIMITS.speedMinMps}) — 대신 약 ${walkFrame}프레임에 핀을 찍거나 최소 ${neededDist} m 이상 떨어진 곳을 눌러 주세요` : `${speed.toFixed(2)} m/s is below a sustainable walk (min ${PATH_LIMITS.speedMinMps}) — pin frame ~${walkFrame} instead, or click at least ${neededDist} m away`,
-			warnings: [],
-		};
-	}
-	const warnings = [];
-	if (prev) {
-		const prevDist = Math.hypot(last.x - prev.x, last.z - prev.z);
-		if (prevDist > PATH_LIMITS.holdEpsM) {
-			const prevSpeed = prevDist / ((last.frame - prev.frame) / fps);
-			const ratio = Math.max(speed, prevSpeed) / Math.max(Math.min(speed, prevSpeed), 1e-6);
-			if (ratio > PATH_LIMITS.speedRatioWarn) {
-				warnings.push(isKo ? `이전 구간보다 속도가 ${ratio.toFixed(1)}배 달라요 — 걸음 변화가 눈에 보일 수 있어요` : `${ratio.toFixed(1)}x speed change from the previous leg — expect a visible gait shift`);
-			}
-			const before = Math.atan2(last.x - prev.x, last.z - prev.z);
-			const after = Math.atan2(candidate.x - last.x, candidate.z - last.z);
-			let turn = Math.abs(after - before);
-			if (turn > Math.PI) turn = 2 * Math.PI - turn;
-			const turnRate = (turn * 180) / Math.PI / dt;
-			if (turnRate > PATH_LIMITS.turnRateWarnDegPerS) {
-				warnings.push(isKo ? `${dt.toFixed(1)}초 동안 ${Math.round((turn * 180) / Math.PI)}° 회전은 걷는 동선치고 너무 급해요 — 프레임이나 거리를 더 주세요` : `${Math.round((turn * 180) / Math.PI)}° turn in ${dt.toFixed(1)} s is sharper than a walking arc — give it more frames or distance`);
-			}
-		}
-	}
-	return { ok: true, warnings };
-}
-
-/**
- * Re-judge a whole authored path (frame-0 start included) before generation:
- * placement-time checks can be invalidated later by removing a middle pin.
- * @returns {{errors: string[], warnings: string[]}}
- */
-export function judgeAuthoredPath(rootPath, fps, clipFrames, { chained = false } = {}) {
-	const errors = [];
-	const warnings = [];
-	const ordered = [...rootPath].sort((a, b) => a.frame - b.frame);
-	for (let i = 1; i < ordered.length; i += 1) {
-		const verdict = judgeNextWaypoint(ordered[i - 1], ordered[i], fps, i >= 2 ? ordered[i - 2] : null);
-		if (!verdict.ok) errors.push(isKo ? `구간 ${i} (${ordered[i - 1].frame}->${ordered[i].frame}프레임): ${verdict.error}` : `leg ${i} (frame ${ordered[i - 1].frame}->${ordered[i].frame}): ${verdict.error}`);
-		else for (const warning of verdict.warnings) warnings.push(isKo ? `구간 ${i}: ${warning}` : `leg ${i}: ${warning}`);
-	}
-	// The trained window binds ONE model call. A chained rollout (a prompt
-	// schedule) makes a call per block, so the whole clip may exceed it —
-	// each block is capped separately by the bridge and the box generator.
-	if (!chained && clipFrames / fps > PATH_LIMITS.clipMaxS) {
-		errors.push(
-			isKo
-				? `이동 경로는 전체 클립을 한 번의 모델 호출로 만들어요. 모션 모델이 학습한 길이는 ${PATH_LIMITS.clipMaxS}초까지예요 — 클립을 ${PATH_LIMITS.clipMaxS}초로 줄이거나 프롬프트를 블록으로 나눠 이어 만들기를 사용해 주세요`
-				: `a root path generates the whole clip in one model call, and the motion model's trained window is ${PATH_LIMITS.clipMaxS} s — shorten the clip to ${PATH_LIMITS.clipMaxS} s, or split the prompt into blocks so the path rides a chained rollout`,
-		);
-	}
-	const tail = (clipFrames - 1 - (ordered[ordered.length - 1]?.frame ?? 0)) / fps;
-	if (ordered.length > 1 && tail > PATH_LIMITS.tailMaxS) {
-		warnings.push(
-			isKo
-				? `마지막 핀 뒤에 클립이 ${tail.toFixed(1)}초 남아 있어요 — 제약이 없는 끝부분은 경로가 끝난 상태를 그대로 이어가요`
-				: `${tail.toFixed(1)} s of clip remain after the last pin — the unconstrained tail continues whatever the path ends in`,
-		);
-	}
-	return { errors, warnings };
-}
-
-/** Place a newly-authored keyframe where it is immediately visible and draggable. */
-export function defaultWaypointPosition(waypoints, subject) {
-	if (!waypoints.length) return { x: subject.x, z: subject.z };
-	const last = waypoints[waypoints.length - 1];
-	if (waypoints.length > 1) {
-		const previous = waypoints[waypoints.length - 2];
-		return { x: last.x + (last.x - previous.x), z: last.z + (last.z - previous.z) };
-	}
-	const yaw = (subject.rot * Math.PI) / 180;
-	return { x: last.x + Math.sin(yaw), z: last.z + Math.cos(yaw) };
-}

package/src/ardy-bridge-contract.js

@@ -1,281 +0,0 @@
-import { ko, isKo } from "./locale.js";
-import { LINE_EDIT_TRACK_IDS, PINNED_CURVE_ENDS } from "./line-edit.js";
-import { FK_TRACKS, IK_TRACKS, MID_TRACKS } from "./ardy/ik.js";
-
-// Two clocks, one boundary. The app timeline runs the production 24 fps —
-// the rate the reference footage and the recorded export are counted in.
-// ARDY Core generates on its trained 20 fps clock and that cannot move, so
-// takes are RETIMED inbound (bridge → app, retimeMotion) and frame numbers
-// are CONVERTED outbound (app → bridge, toArdyFrame). Nothing between the
-// boundaries may mix the clocks.
-export const TIMELINE_FPS = 24;
-// The motion bridge uses the Studio's fixed 24 fps production clock.
-export const ARDY_FPS = 24;
-export const toArdyFrame = (frame) => Math.round((frame * ARDY_FPS) / TIMELINE_FPS);
-
-// Outbound converters: timeline-frame entries → strictly-ascending bridge
-// frames. Rounding can land two timeline frames on one bridge frame; the
-// first wins — the bridge refuses non-ascending lists outright.
-/** Where a placed pose lands, in TIMELINE frames, for a clip of `clipFrames`. */
-export function posePlacementFrame(placement, clipFrames, playheadFrame) {
-	const last = Math.max(0, clipFrames - 1);
-	if (placement === "end") return last;
-	if (placement === "middle") return Math.round(last / 2);
-	if (placement === "playhead") return Math.max(0, Math.min(last, playheadFrame));
-	return 0;
-}
-
-export function toArdyFrameEntries(entries) {
-	const out = [];
-	for (const entry of entries) {
-		const frame = toArdyFrame(entry.frame);
-		if (out.length && frame <= out[out.length - 1].frame) continue;
-		out.push({ ...entry, frame });
-	}
-	return out;
-}
-
-export function toArdySegments(segments) {
-	const out = [];
-	for (const segment of segments) {
-		const startFrame = toArdyFrame(segment.startFrame);
-		const endFrame = toArdyFrame(segment.endFrame);
-		if (endFrame <= startFrame) continue; // a zero-length rounding remnant covers nothing
-		out.push({ ...segment, startFrame, endFrame });
-	}
-	return out;
-}
-
-export const DEFAULT_DURATION_S = 15; // pre-motion timeline duration; shown as duration × TIMELINE_FPS frames
-export const DEFAULT_PLAYBACK_SPEED = 1;
-export const BRIDGE_RECHECK_MS = 3000;
-export const ARDY_PROMPT_HORIZON_FRAMES = 2 * TIMELINE_FPS; // core model horizon: 2 seconds, counted on the timeline clock
-export const MAX_WAYPOINTS = 32; // ARDY bridge contract: a root path holds 2..32 distinct waypoint frames
-export const ARDY_PROMPT_MAX = 500; // bridge contract: prompt must be non-empty, capped at 500 chars
-export const ARDY_DURATION_MIN = 1; // the UI works in whole seconds; the bridge floor is 0.15 s
-export const ARDY_DURATION_MAX = 1200; // bridge contract: duration capped at 1200 s
-export const ARDY_SEED_MAX = 2 ** 31 - 1; // bridge contract: optional seed, integer in 0..2**31-1
-// Scheduled inpainting (contract C3): how hard a regeneration holds onto the
-// take that is already loaded. 0 turns preserving OFF entirely; 0.5 is the
-// paper's recommended setting. The app ships this RAW number and nothing else:
-// the strength -> denoising-schedule mapping (sigma_s = round(1000 * strength),
-// sigma_e = min(50, sigma_s), diffusion time 0..1000) lives on the box side, and
-// duplicating it here is exactly how the two would silently drift apart.
-export const ARDY_PRESERVE_DEFAULT = 0.5;
-export const DEFAULT_PROMPT_CLIPS = [];
-
-/** The prompt-block schedule: every authored block in frame order, with the gaps
- * between them filled by the base prompt so the bridge always receives one
- * contiguous 0..clipFrames sequence. Blocks shorter than 3 frames are dropped —
- * they cannot carry a generation.
- * Pure and shared on purpose: the request assembly decides which blocks count as
- * "edited", and the preserve panel has to name the SAME blocks. Re-deriving them
- * approximately beside the slider is how the UI starts promising a locality the
- * wire does not carry. */
-export function buildPromptSchedule(sourcePromptClips, clipFrames, prompt) {
-	const segments = [];
-	let cursor = 0;
-	for (const clip of sourcePromptClips) {
-		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 === 0) segments.push({ startFrame: 0, endFrame: clipFrames, prompt });
-	return segments;
-}
-
-/** The DISTINCT ik track ids keyed inside the half-open timeline span
- * [startFrame, endFrame). `ikState.keys` is Map(frame -> Map(trackId -> pose)),
- * so a frame with several dragged effectors contributes all of them. */
-export function ikTracksInRange(ikState, ikFrames, startFrame, endFrame) {
-	const tracks = new Set();
-	for (const frame of ikFrames) {
-		if (frame < startFrame || frame >= endFrame) continue;
-		for (const trackId of ikState?.keys?.get(frame)?.keys() ?? []) tracks.add(trackId);
-	}
-	return [...tracks];
-}
-
-/* Which limb a keyed IK track frees once the preserve mask is grouped
-   (contract C3v2). The single source of truth for track -> mask group is
-   TRACK_GROUPS in tools/kimodo/preserve-mask.mjs; nothing under tools/ may be
-   imported into src/, so the rule is transcribed here — as USER-FACING LABELS
-   only, never as a second copy of the mapping the wire depends on:
-     leftHand,  leftElbow  -> leftArm     rightHand, rightElbow -> rightArm
-     leftFoot,  leftKnee   -> leftLeg     rightFoot, rightKnee  -> rightLeg
-     head,      neck       -> head        spine, chest, leftShoulder,
-     hips                  -> torso AND root      rightShoulder -> torso
-   The track ids are the same namespace on both sides (src/ardy/ik.js owns
-   them), so the app ships whatever ids it has and the mask builder maps them.
-   Torso and pelvis tracks are worded as the whole body: the pelvis carries the
-   global transform as well as a bone, and naming a limb beside it would promise
-   a locality the mask does not have. */
-export const PRESERVE_TRACK_LIMBS = {
-	leftHand: "leftArm",
-	leftElbow: "leftArm",
-	rightHand: "rightArm",
-	rightElbow: "rightArm",
-	leftFoot: "leftLeg",
-	leftKnee: "leftLeg",
-	rightFoot: "rightLeg",
-	rightKnee: "rightLeg",
-	head: "head",
-	neck: "head",
-	spine: "body",
-	chest: "body",
-	leftShoulder: "body",
-	rightShoulder: "body",
-	hips: "body",
-};
-// A fixed reading order, so the same edit always reads back the same way.
-export const PRESERVE_LIMB_ORDER = ["head", "leftArm", "rightArm", "leftLeg", "rightLeg"];
-export const preserveLimbLabel = (limb) => ({
-	head: ko("head", "머리"),
-	leftArm: ko("left arm", "왼팔"),
-	rightArm: ko("right arm", "오른팔"),
-	leftLeg: ko("left leg", "왼발"),
-	rightLeg: ko("right leg", "오른발"),
-}[limb]);
-
-/** One muted line naming what a grouped preserve run will regenerate, or "" when
- * no track can be attributed — then the request carries no `tracks` either and
- * the panel's existing whole-take wording is already the truth. */
-export function preserveTracksSummary(tracks) {
-	const limbs = new Set();
-	for (const trackId of tracks) {
-		const limb = PRESERVE_TRACK_LIMBS[trackId];
-		if (limb) limbs.add(limb);
-	}
-	if (limbs.size === 0) return "";
-	if (limbs.has("body")) return ko("regenerates the whole body", "몸 전체를 다시 생성");
-	const names = PRESERVE_LIMB_ORDER.filter((limb) => limbs.has(limb)).map(preserveLimbLabel);
-	return isKo ? `${names.join("·")}만 다시 생성` : `regenerates ${names.join(" · ")} only`;
-}
-
-/* --------------------------- line editing (C6) ---------------------------
- * "Grab the joint's motion path and pull it; the joint follows the pulled path
- * exactly" (ProjFlow). The arithmetic lives in ./line-edit.js; what stays here
- * is the panel's own vocabulary and the one thing App owns that the pure module
- * cannot — the mapping from a track id to a HUMAN LABEL, which is read straight
- * out of ik.js's three tables so the picker can never drift from the pose
- * studio's own naming. An id in LINE_EDIT_TRACK_IDS with no entry in those
- * tables is a bug, and falling back to the raw id makes it visible instead of
- * silent. */
-export const LINE_EDIT_TRACK_OPTIONS = LINE_EDIT_TRACK_IDS.map((id) => ({
-	value: id,
-	label: [...IK_TRACKS, ...MID_TRACKS, ...FK_TRACKS].find((track) => track.id === id)?.label ?? id,
-}));
-/** The same human label, by id — what a version-strip chip says a refinement
- * touched ("Refine · Left Hand"). */
-export const lineTrackLabel = (id) => LINE_EDIT_TRACK_OPTIONS.find((option) => option.value === id)?.label ?? id;
-/** The default edited track: a wrist is the joint the paper's own demo draws
- * with, and the one whose screen trajectory a user can actually see. */
-export const LINE_EDIT_DEFAULT_TRACK = "leftHand";
-/** Draw a grab handle every Nth frame. Fewer would leave the curve looking
- * un-grabbable in the gaps; more turns a 200-frame range into a solid bead of
- * dots. The hit test tolerates CURVE_GRAB_RADIUS_PX regardless, so the handles
- * are an affordance rather than the actual geometry. */
-export const LINE_CURVE_MARKER_STRIDE = 4;
-/** The shortest curve with anything draggable in it: both ends are hard-pinned
- * to the original trajectory, so a range needs more than 2 x PINNED_CURVE_ENDS
- * frames before the middle can move at all. */
-export const MIN_CURVE_POINTS = PINNED_CURVE_ENDS * 2 + 1;
-/** How long a released drag has to sit still before it costs a preview. Long
- * enough that pull-pull-pull is one request instead of three, short enough that
- * the loop still feels like it answers the gesture — a preview round trip is
- * ~1 s on the warm service, so 150 ms is noise against it. */
-export const LINE_PREVIEW_DEBOUNCE_MS = 150;
-/** How often the line-edit capability is re-probed while the bridge is up and
- * the answer is still no.
- *
- * The bridge answers `capabilities.lineEdit` from a LAZY ssh probe of the
- * ProjFlow box behind a 5 s cache, so the very first /ardy/health of a session
- * can land on a cold cache and come back false — a box that is perfectly fine
- * two seconds later. Asking once per bridge-up transition therefore made the
- * whole mode dead until a reload (first boot broken, second boot fine, which is
- * exactly how it was reported). A capability is an ADVERTISEMENT, so it is
- * allowed to arrive late; what is not allowed is to assume it. 4 s sits just
- * under the bridge's own 5 s TTL, so a retry can actually see a new answer
- * rather than re-reading the same cached false. */
-export const LINE_CAPABILITY_RETRY_MS = 4000;
-/** Why a validateLineEdit code refused, said once, in the user's language.
- * Keyed by the pure module's stable codes so the copy and the check can never
- * disagree about which field was wrong. */
-export const LINE_EDIT_REFUSALS = {
-	sourceMotion: ["The current take has no bridge source — generate it once before editing a path", "현재 테이크에 브리지 원본이 없어요 — 궤적을 편집하기 전에 한 번 생성하세요"],
-	track: ["Pick a joint to edit first", "먼저 편집할 관절을 고르세요"],
-	frameRange: ["The frame range must sit inside the clip and span at least 2 frames", "프레임 구간은 클립 안에 있어야 하고 최소 2프레임이어야 해요"],
-	points: ["Pull a longer stretch of the path — a single point is not a path", "궤적을 좀 더 길게 잡아당겨 주세요 — 점 하나는 경로가 아니에요"],
-	camera: ["The camera could not be captured — nudge the view and try again", "카메라를 캡처하지 못했어요 — 뷰를 조금 움직인 뒤 다시 시도하세요"],
-	prompt: ["The motion prompt is not usable for a line edit", "모션 프롬프트를 라인 편집에 쓸 수 없어요"],
-	pins: ["The pinned moments could not be sent — try clearing them and pinning again", "찍은 순간을 보낼 수 없어요 — 지우고 다시 찍어 보세요"],
-	shape: ["The line edit could not be assembled", "라인 편집을 구성하지 못했어요"],
-};
-/** Why curveToPoints2d refused. Same shape, different stage: these are about
- * the CURVE, before there is a payload to validate. */
-export const LINE_CURVE_REFUSALS = {
-	empty: ["This joint is not visible over the chosen frames — frame it in view first", "선택한 구간에서 이 관절이 보이지 않아요 — 먼저 화면 안에 들어오도록 잡아 주세요"],
-	offscreen: ["The pulled path leaves the frame — keep it inside the dashed border", "잡아당긴 궤적이 화면을 벗어났어요 — 점선 테두리 안에 두세요"],
-};
-
-// Named ingest failures, in both locales. A reason the user cannot act on is
-// not a message: each line says what was wrong with THIS source.
-export const MULTIMODEL_REASONS = {
-	"url-empty": ["Enter a video URL first", "영상 URL을 먼저 입력하세요"],
-	"url-protocol-relative": ["Use a full https:// address", "https:// 로 시작하는 전체 주소를 쓰세요"],
-	"url-scheme-unsupported": ["Only http(s) or a local /path is accepted", "http(s) 또는 로컬 /경로만 사용할 수 있어요"],
-	"url-platform-page": [
-		"YouTube/Vimeo pages are players, not video files, and block browser downloads. Start the dev bridge to use the URL directly, or download the clip and use Choose video.",
-		"유튜브·비메오 주소는 영상 파일이 아니라 플레이어 페이지이고 브라우저 다운로드를 막습니다. 개발 브리지를 켜면 URL을 그대로 쓸 수 있고, 아니면 영상을 내려받아 '영상 선택'을 쓰세요.",
-	],
-	"url-malformed": ["That address could not be parsed", "주소를 해석할 수 없어요"],
-	"fetch-failed": ["The host refused a browser download (CORS or offline)", "호스트가 브라우저 다운로드를 거부했어요(CORS 또는 오프라인)"],
-	"not-a-video": ["That address did not return a video (check the path)", "그 주소는 영상을 반환하지 않았어요(경로를 확인하세요)"],
-	"decode-failed": ["This browser cannot decode that video", "이 브라우저가 디코딩할 수 없는 영상이에요"],
-	"duration-unreadable": ["The clip length could not be read", "클립 길이를 읽지 못했어요"],
-	"dimensions-unreadable": ["The frame size could not be read", "프레임 크기를 읽지 못했어요"],
-	"probe-timeout": ["The video never reported metadata", "영상이 메타데이터를 보내지 않았어요"],
-	"fetch-unavailable": ["This browser cannot download files", "이 브라우저는 파일을 내려받을 수 없어요"],
-	"footage-load-timeout": ["The clip never became seekable", "클립이 탐색 가능한 상태가 되지 않았어요"],
-	"seek-timeout": ["Seeking inside the clip stalled", "클립 내부 탐색이 멈췄어요"],
-	"pose-runtime-unavailable": ["The pose engine is missing from this build", "이 빌드에 포즈 엔진이 없어요"],
-	"pose-model-download-failed": ["The pose model could not be downloaded (offline?)", "포즈 모델을 내려받지 못했어요(오프라인인가요?)"],
-	"pose-engine-download-failed": ["The pose engine could not be downloaded (offline?)", "포즈 엔진을 내려받지 못했어요(오프라인인가요?)"],
-	"pose-engine-init-failed": ["The pose engine failed to start on this device", "이 기기에서 포즈 엔진을 시작하지 못했어요"],
-	"rest-unavailable": ["The rig rest data (/ardy/cskel27-rest.json) could not be loaded", "리그 레스트 데이터(/ardy/cskel27-rest.json)를 불러오지 못했어요"],
-	"no-person-found": ["No person was detected in the footage", "영상에서 사람을 감지하지 못했어요"],
-	"no-person-in-photo": ["No person was detected in that photograph", "사진에서 사람을 감지하지 못했어요"],
-	"image-load-timeout": ["The photograph never finished decoding", "사진 디코딩이 끝나지 않았어요"],
-	"pose-partly-occluded": ["Shoulders and hips must both be visible in the photograph", "사진에 어깨와 골반이 모두 보여야 해요"],
-	"no-usable-pose": ["A person was seen, but no stable pose could be fitted", "사람은 보였지만 안정적인 포즈를 만들지 못했어요"],
-	"rig-not-loaded": ["Subject 1's rig is not loaded yet", "인물 1 리그가 아직 로드되지 않았어요"],
-	"bridge-unreachable": ["The dev bridge did not answer", "개발 브리지가 응답하지 않아요"],
-	"bridge-footage-incomplete": ["The bridge stream ended without footage", "브리지 전송이 영상 없이 끝났어요"],
-	"footage-url-invalid": ["That address could not be used for a bridge download", "이 주소는 브리지 다운로드에 쓸 수 없어요"],
-	"footage-probe-failed": ["The bridge could not read that page's video info", "브리지가 그 페이지의 영상 정보를 읽지 못했어요"],
-	"footage-live-unsupported": ["Live streams have no fixed length and cannot be ingested", "라이브 스트림은 길이가 없어 인제스트할 수 없어요"],
-	"footage-too-long": ["That video is over 15 minutes — trim or pick a shorter one", "15분이 넘는 영상이에요 — 잘라내거나 더 짧은 걸 골라 주세요"],
-	"footage-download-failed": ["The bridge could not download that video", "브리지가 영상을 내려받지 못했어요"],
-	"footage-normalize-failed": ["The bridge could not convert that video for extraction", "브리지가 영상을 추출용으로 변환하지 못했어요"],
-	"footage-timeout": ["The bridge download took too long and was stopped", "브리지 다운로드가 너무 오래 걸려 중단됐어요"],
-	"bridge-extract-incomplete": ["The bridge stream ended without a take", "브리지 전송이 테이크 없이 끝났어요"],
-	"extract-host-missing": ["The bridge has no GPU box configured (CCLAY_EXTRACT_HOST)", "브리지에 GPU 박스가 설정돼 있지 않아요(CCLAY_EXTRACT_HOST)"],
-	"extract-bridge-required": ["GVHMR extraction requires the local GPU bridge", "GVHMR 추출에는 로컬 GPU 브리지가 필요해요"],
-	"extract-backend-unsupported": ["This bridge is not configured for GVHMR", "이 브리지가 GVHMR로 설정되지 않았어요"],
-	"extract-upload-failed": ["The footage could not be copied to the GPU box", "영상을 GPU 박스로 복사하지 못했어요"],
-	"extract-upload-too-large": ["That clip is too large to upload for extraction (300 MB cap)", "추출 업로드 한도(300MB)를 넘는 영상이에요"],
-	"extract-upload-empty": ["No video bytes arrived at the bridge", "브리지에 영상 데이터가 도착하지 않았어요"],
-	"extract-footage-unknown": ["The bridge no longer holds that download — re-ingest the URL", "브리지에 그 다운로드가 더 이상 없어요 — URL을 다시 넣어 주세요"],
-	"extract-run-failed": ["GVHMR failed on the GPU box (see the bridge log)", "GPU 박스에서 GVHMR 실행이 실패했어요(브리지 로그 확인)"],
-	"extract-no-person": ["The GPU box tracked no person in that footage", "GPU 박스가 영상에서 사람을 추적하지 못했어요"],
-	"extract-convert-failed": ["The extracted take could not be converted for the timeline", "추출된 테이크를 타임라인용으로 변환하지 못했어요"],
-	"extract-timeout": ["GPU extraction took too long and was stopped", "GPU 추출이 너무 오래 걸려 중단됐어요"],
-};
-
-// Extraction samples and bakes straight onto the production clock — an
-// extracted take never touches ARDY, so it never needs retiming either.
-export const MULTIMODEL_SAMPLE_FPS = TIMELINE_FPS;