cozyclay 3.1.1 → 3.1.3

package/src/motion/timeline.jsx

@@ -2,7 +2,7 @@ import { useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { frameFromClientX, groupKeyRuns, KEY_RUN_MIN, rangePinBandGeometry, shotBlockGeometry } from "./timeline-coordinates.js";
 import { createPlaybackClock } from "./playback-clock.js";
 
-import { ko, isKo } from "../locale.js";
+import { ko } from "../locale.js";
 import { isImeComposing } from "../ime.js";
 import { buildRail, craneHeightAt } from "../camera-follow.js";
 import { insertPathMark, pathMarks, pathMetrics, pathProgressAt, MAX_PATH_LEAN } from "../object-path.js";
@@ -276,7 +276,7 @@ function CraneHeightEditor({ crane, railRange, durationFrames, selectedIndex, on
 					// an end point sits ON the window edge; clamp it inside so the knob stays whole. The clamp is the
 					// knob's own radius: a wider one pinned every knob of a 20 px Shot strip to one row, off its curve.
 					style={{ left: `clamp(5px, ${xFor(point.t) * 100}%, calc(100% - 5px))`, top: `clamp(5px, ${yFor(point.height) * 100}%, calc(100% - 5px))` }}
-					aria-label={ko(`Crane point ${index + 1}, ${point.height.toFixed(1)} metres`, `크레인 점 ${index + 1}, ${point.height.toFixed(1)}미터`)}
+					aria-label={ko(`Crane point ${index + 1}, ${point.height.toFixed(1)} metres`, `크레인 점 ${index + 1}, ${point.height.toFixed(1)}미터`, `摇臂点 ${index + 1}，${point.height.toFixed(1)} 米`)}
 					onPointerDown={(event) => {
 						event.preventDefault();
 						event.stopPropagation();
@@ -780,7 +780,7 @@ function ObjectTravelTrack({ object, frame, frameCount, fps, pathDraw, onPathDra
 					<span className="tl-track-label">{ko("Speed", "속도 곡선")}</span>
 					<div className="tl-lane sg-lane">
 						<SpeedGraph
-							facts={metrics && span ? `${metrics.length.toFixed(1)} m · ${seconds.toFixed(1)}${isKo ? "초" : "s"}` : null}
+							facts={metrics && span ? `${metrics.length.toFixed(1)} m · ${seconds.toFixed(1)}${ko("s", "초", "秒")}` : null}
 							timing={path.timing ?? null}
 							windowFrac={span.fills ? 1 : span.end / Math.max(1, frameCount - 1)}
 							frame={frame}
@@ -828,7 +828,7 @@ function CameraBlockEditor({
 	const numberValue = (event) => Number(event.currentTarget.value);
 	const metric = (value, places = 1) => Number(value).toFixed(places);
 	return (
-		<section className="tl-camera-editor" aria-label={ko(`Camera controls for ${shot.name}`, `${shot.name} 카메라 컨트롤`)}>
+		<section className="tl-camera-editor" aria-label={ko(`Camera controls for ${shot.name}`, `${shot.name} 카메라 컨트롤`, `${shot.name} 的摄影机控制`)}>
 			<strong className="tl-camera-editor-title">
 				<span className="tl-subject-kind">{ko("CAMERA", "카메라")}</span>
 				{shot.name}
@@ -1666,7 +1666,7 @@ export default function Timeline({
 								title={ko("Enable or disable root path constraints (P)", "루트 경로 제약 켜기/끄기 (P)")}
 								onClick={() => handlers.current.onWaypointToggle?.()}
 							>
-								{isKo ? `웨이포인트 ${waypointMode ? "켜짐" : "꺼짐"}` : `Waypoint ${waypointMode ? "on" : "off"}`}
+								{ko(`Waypoint ${waypointMode ? "on" : "off"}`, `웨이포인트 ${waypointMode ? "켜짐" : "꺼짐"}`, `路径点${waypointMode ? "开" : "关"}`)}
 							</button>
 						</div>
 						<div className="tl-head-group tl-pose-tools" role="group" aria-label={ko("Pose correction tools", "포즈 보정 도구")}>
@@ -1687,7 +1687,7 @@ export default function Timeline({
 										title={ko("Foot snap — keep the feet planted while you move the body (hips); the knees bend instead of the feet sinking through the floor", "발 스냅 — 몸(엉덩이)을 움직여도 발을 바닥에 고정합니다. 발이 바닥으로 가라앉는 대신 무릎이 구부러집니다")}
 										onClick={() => handlers.current.onFootSnapToggle?.()}
 									>
-										{isKo ? `스냅 ${footSnap ? "켜짐" : "꺼짐"}` : `Snap ${footSnap ? "on" : "off"}`}
+										{ko(`Snap ${footSnap ? "on" : "off"}`, `스냅 ${footSnap ? "켜짐" : "꺼짐"}`, `吸附${footSnap ? "开" : "关"}`)}
 									</button>
 									<button
 										type="button"
@@ -1697,7 +1697,7 @@ export default function Timeline({
 										title={ko("Body contact — keep hands, knees, feet, head, and hips above the floor", "바닥 접촉 — 손, 무릎, 발, 머리, 엉덩이가 바닥 아래로 내려가지 않게 합니다")}
 										onClick={() => handlers.current.onBodyContactToggle?.()}
 									>
-										{isKo ? `바닥 접촉 ${bodyContact ? "켜짐" : "꺼짐"}` : `Body contact ${bodyContact ? "on" : "off"}`}
+										{ko(`Body contact ${bodyContact ? "on" : "off"}`, `바닥 접촉 ${bodyContact ? "켜짐" : "꺼짐"}`, `身体接触${bodyContact ? "开" : "关"}`)}
 									</button>
 								</>)}
 							</>)}
@@ -1719,18 +1719,10 @@ export default function Timeline({
 						{waypointMode && (
 							<span className={"tl-wp-hint" + (waypointFrames.length < 2 || pathSpeed?.warn ? " warn" : "")}>
 								{waypointFrames.length < 2
-									? ko("Click the set floor in the Shot view to drop waypoints", "샷 뷰의 세트 바닥을 클릭해 웨이포인트를 놓으세요")
-									: isKo
-										? `루트 웨이포인트 ${waypointFrames.length}개` +
-											(pathSpeed
-												? ` · ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s${pathSpeed.warn ? " — 자연스러운 이동 속도 0.5–3 m/s 범위를 벗어남" : ""}`
-												: "") +
-											" · 세트 바닥을 클릭해 더 추가"
-										: `${waypointFrames.length} root waypoints` +
-											(pathSpeed
-												? ` · ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s${pathSpeed.warn ? " — outside the natural 0.5–3 m/s locomotion band" : ""}`
-												: "") +
-											" · click the set floor to add more"}
+									? ko("Click the set floor in the Shot view to drop waypoints", "샷 뷰의 세트 바닥을 클릭해 웨이포인트를 놓으세요", "在镜头视图中点击布景地面放置路径点")
+									: ko(`${waypointFrames.length} root waypoints` + (pathSpeed ? ` · ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s${pathSpeed.warn ? " — outside the natural 0.5–3 m/s locomotion band" : ""}` : "") + " · click the set floor to add more",
+										`루트 웨이포인트 ${waypointFrames.length}개` + (pathSpeed ? ` · ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s${pathSpeed.warn ? " — 자연스러운 이동 속도 0.5–3 m/s 범위를 벗어남" : ""}` : "") + " · 세트 바닥을 클릭해 더 추가",
+										`${waypointFrames.length} 个根路径点` + (pathSpeed ? ` · ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s${pathSpeed.warn ? " — 超出自然行走 0.5–3 m/s 区间" : ""}` : "") + " · 点击布景地面继续添加")}
 							</span>
 						)}
 						{badge && <span className={"tl-badge " + badge.kind}>{badge.label}</span>}
@@ -1766,7 +1758,7 @@ export default function Timeline({
 					<div className="tl-body" ref={bodyRef}>
 						<div className={"tl-surface" + (!shots.length ? " empty-shots" : "") + (pathObject ? " prop-subject" : "")} style={{ "--tl-zoom": surfaceZoom }}>
 						<div className="tl-ruler">
-							<span className="tl-ruler-label">{ko("Frame", "프레임")}</span>
+							<span className="tl-ruler-label">{ko("Frame", "프레임", "帧")}</span>
 							<div
 								className="tl-ruler-lane"
 								ref={rulerRef}
@@ -1846,7 +1838,7 @@ export default function Timeline({
 									{name === "2D Root" && pathSpeed && (
 										<em
 											className={"tl-path-speed" + (pathSpeed.warn ? " warn" : "")}
-											title={isKo ? `핀 구간 속도 ${pathSpeed.min.toFixed(1)}~${pathSpeed.max.toFixed(1)} m/s — 자연 보행은 0.8~1.2 m/s` : `Leg speeds ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s — natural gait is 0.8–1.2 m/s`}
+											title={ko(`Leg speeds ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s — natural gait is 0.8–1.2 m/s`, `핀 구간 속도 ${pathSpeed.min.toFixed(1)}~${pathSpeed.max.toFixed(1)} m/s — 자연 보행은 0.8~1.2 m/s`, `腿速 ${pathSpeed.min.toFixed(1)}–${pathSpeed.max.toFixed(1)} m/s — 自然步态为 0.8–1.2 m/s`)}
 										>
 											{pathSpeed.min === pathSpeed.max
 												? `${pathSpeed.min.toFixed(1)} m/s`
@@ -1869,7 +1861,7 @@ export default function Timeline({
 										<button
 											className="tl-track-add ik"
 											type="button"
-											title={isKo ? `현재 포즈를 ${frame}프레임에 키로 저장` : `Key the current pose at frame ${frame}`}
+											title={ko(`Key the current pose at frame ${frame}`, `현재 포즈를 ${frame}프레임에 키로 저장`, `在当前帧 ${frame} 记录姿势关键帧`)}
 											onClick={() => handlers.current.onIkKeyframeAdd?.()}
 										>
 											+
@@ -1895,7 +1887,7 @@ export default function Timeline({
 										const endFrame = Number.isFinite(Number(range?.endFrame)) ? Number(range.endFrame) : Number(range?.end ?? startFrame);
 										const start = Math.max(0, Math.min(displayFrameCount - 1, Math.round(startFrame)));
 										const end = Math.max(start, Math.min(displayFrameCount - 1, Math.round(endFrame)));
-										return <span key={`preview:${index}`} className="tl-preview-range" style={{ "--tl-f-start": framePct(start, displayFrameCount), "--tl-f-end": framePct(end, displayFrameCount) }} aria-label={ko(`Preview range ${start}–${end}`, `미리보기 범위 ${start}–${end}`)} />;
+										return <span key={`preview:${index}`} className="tl-preview-range" style={{ "--tl-f-start": framePct(start, displayFrameCount), "--tl-f-end": framePct(end, displayFrameCount) }} aria-label={ko(`Preview range ${start}–${end}`, `미리보기 범위 ${start}–${end}`, `预览范围 ${start}–${end}`)} />;
 									})}
 									{name === SHOTS_LANE && shots.length === 0 && (
 										<div className="tl-shot-empty">
@@ -1940,7 +1932,7 @@ export default function Timeline({
 												className={"tl-shot-block" + (index === cameraBlockIdx ? " selected" : "") + (index === activeShotIdx ? " active" : "") + (movingShotId === shot.id ? " moving" : "") + (!railOff && railRange && railLengthByShot.has(shot.id) ? " has-dolly" : "")}
 												data-shot-kind={shot.kind === "still" ? "still" : undefined}
 												style={{ "--tl-f-start": geometry.startPct, "--tl-f-end": geometry.endPct }}
-												title={isKo ? `${shot.name} · ${shot.startFrame}–${lastFrame}프레임 · 드래그해 순서 이동, 양끝으로 컷 조절, 아래 빈 줄을 클릭해 카메라 키 추가` : `${shot.name} · frames ${shot.startFrame}–${lastFrame} · drag to reorder, trim cuts at either edge, click the empty lower strip to add a camera key`}
+												title={ko(`${shot.name} · frames ${shot.startFrame}–${lastFrame} · drag to reorder, trim cuts at either edge, click the empty lower strip to add a camera key`, `${shot.name} · ${shot.startFrame}–${lastFrame}프레임 · 드래그해 순서 이동, 양끝으로 컷 조절, 아래 빈 줄을 클릭해 카메라 키 추가`, `${shot.name} · 第 ${shot.startFrame}–${lastFrame} 帧 · 拖动调整顺序，拖动两端修剪剪辑，点击下方空条添加摄影机关键帧`)}
 												onPointerDown={(e) => beginShotMove(e, shot, index)}
 												onPointerMove={moveShot}
 												onPointerUp={endShotMove}
@@ -1951,7 +1943,7 @@ export default function Timeline({
 												<button
 														type="button"
 														className="tl-shot-edge start"
-														aria-label={ko(`Resize start of ${shot.name}`, `${shot.name} 시작점 조절`)}
+														aria-label={ko(`Resize start of ${shot.name}`, `${shot.name} 시작점 조절`, `调整 ${shot.name} 的起点`)}
 														onPointerDown={(e) => beginShotBoundaryDrag(e, index, "start")}
 														onPointerMove={moveShotBoundary}
 														onPointerUp={endShotBoundaryDrag}
@@ -1962,7 +1954,7 @@ export default function Timeline({
 												<button
 													type="button"
 													className="tl-shot-edge end"
-													aria-label={ko(`Resize end of ${shot.name}`, `${shot.name} 끝 길이 조절`)}
+													aria-label={ko(`Resize end of ${shot.name}`, `${shot.name} 끝 길이 조절`, `调整 ${shot.name} 的终点`)}
 													onPointerDown={(e) => beginShotBoundaryDrag(e, index, "end")}
 													onPointerMove={moveShotBoundary}
 													onPointerUp={endShotBoundaryDrag}
@@ -2065,8 +2057,8 @@ export default function Timeline({
 													type="button"
 													className="tl-shot-key-surface"
 													aria-label={shot.camera?.mode === "rail" && shot.camera?.craneHeight
-														? ko(`Add crane point in ${shot.name}`, `${shot.name}에 크레인 점 추가`)
-														: ko(`Add camera key in ${shot.name}`, `${shot.name}에 카메라 키 추가`)}
+														? ko(`Add crane point in ${shot.name}`, `${shot.name}에 크레인 점 추가`, `在 ${shot.name} 中添加摇臂点`)
+														: ko(`Add camera key in ${shot.name}`, `${shot.name}에 카메라 키 추가`, `在 ${shot.name} 中添加摄影机关键帧`)}
 													title={shot.camera?.mode === "rail" && shot.camera?.craneHeight
 														? ko("Click the crane graph to add a point; click a point and drag it to change height", "크레인 그래프를 클릭해 점 추가 · 점을 눌러 끌어 높이 조절")
 														: ko("Click at a frame to store the current camera framing", "프레임 위치를 클릭해 현재 카메라 프레이밍을 저장합니다")}
@@ -2089,7 +2081,7 @@ export default function Timeline({
 									"--tl-pin-ramp-end": geometry.rampEndPct,
 									"--tl-pin-color": "var(--select, #e8a33d)",
 								}}
-								title={ko(`${pin.track} pin · frames ${pin.startFrame}–${pin.endFrame}`, `${pin.track} 고정 · ${pin.startFrame}–${pin.endFrame}프레임`)}
+								title={ko(`${pin.track} pin · frames ${pin.startFrame}–${pin.endFrame}`, `${pin.track} 고정 · ${pin.startFrame}–${pin.endFrame}프레임`, `${pin.track} 固定 · 第 ${pin.startFrame}–${pin.endFrame} 帧`)}
 								onPointerDown={(event) => {
 									if (event.button !== 0) return;
 									event.stopPropagation();
@@ -2108,7 +2100,7 @@ export default function Timeline({
 						return <span
 							className="tl-pin-pending"
 							style={{ "--tl-f-start": geometry.startPct, "--tl-f-end": geometry.endPct }}
-							aria-label={ko(`Pending pin range ${geometry.startFrame}–${geometry.endFrame}`, `대기 중인 고정 범위 ${geometry.startFrame}–${geometry.endFrame}`)}
+							aria-label={ko(`Pending pin range ${geometry.startFrame}–${geometry.endFrame}`, `대기 중인 고정 범위 ${geometry.startFrame}–${geometry.endFrame}`, `待定固定范围 ${geometry.startFrame}–${geometry.endFrame}`)}
 						/>;
 					})()}
 					{name === IK_LANE && motion?.segments && <TakeSegmentClips motion={motion} frame={frame} frameCount={frameCount} displayFrameCount={displayFrameCount} clipPct={clipPct} tools={motionTools} />}{name === IK_LANE && <BeatBoard motion={motion} frame={frame} displayFrameCount={displayFrameCount} clipPct={clipPct} onJump={(f) => handlers.current.onScrub?.(f)} />}
@@ -2121,7 +2113,7 @@ export default function Timeline({
 													key={f}
 													className={"tl-marker ik" + (f === frame ? " current" : "")}
 													style={{ "--tl-f": framePct(f, displayFrameCount) }}
-													title={isKo ? `${f}프레임의 전신 IK 키 — 클릭해 이동, 오른쪽 클릭으로 삭제` : `Full-body IK key at frame ${f} — click to jump, right-click to remove`}
+													title={ko(`Full-body IK key at frame ${f} — click to jump, right-click to remove`, `${f}프레임의 전신 IK 키 — 클릭해 이동, 오른쪽 클릭으로 삭제`, `第 ${f} 帧的全身 IK 键 — 点击跳转，右键删除`)}
 													onPointerDown={(e) => {
 														if (e.button !== 0) return;
 														e.stopPropagation();
@@ -2142,9 +2134,9 @@ export default function Timeline({
 													key={`run:${run.start}`}
 													className={"tl-ik-run" + (frame >= run.start && frame <= run.end ? " current" : "")}
 													style={{ "--tl-f": framePct(run.start, displayFrameCount), "--tl-f2": framePct(run.end, displayFrameCount) }}
-													title={isKo
-														? `${run.start}–${run.end} 전신 IK 키 (${run.length}개) — 클릭해 그 프레임으로 이동, 오른쪽 클릭으로 그 프레임 키 삭제`
-														: `IK keys ${run.start}–${run.end} (${run.length}) — click to jump to that frame, right-click to remove that frame's key`}
+													title={ko(`IK keys ${run.start}–${run.end} (${run.length}) — click to jump to that frame, right-click to remove that frame's key`,
+														`${run.start}–${run.end} 전신 IK 키 (${run.length}개) — 클릭해 그 프레임으로 이동, 오른쪽 클릭으로 그 프레임 키 삭제`,
+														`IK 键 ${run.start}–${run.end}（${run.length} 个）— 点击跳转到该帧，右键删除该帧的键`)}
 													onPointerDown={(e) => {
 														if (e.button !== 0) return;
 														e.stopPropagation();
@@ -2181,7 +2173,7 @@ export default function Timeline({
 												key={f}
 												className={"tl-marker wp" + (f === pendingWaypointFrame ? " pending" : "")}
 												style={{ "--tl-f": framePct(f, displayFrameCount) }}
-												title={isKo ? `${f}프레임의 루트 웨이포인트 — 클릭해 선택, 오른쪽 클릭으로 삭제. 탑뷰에서 ${waypointFrames.indexOf(f) + 1}번 마커를 드래그해 이동` : `Root waypoint at frame ${f} — click to select, right-click to remove; drag marker ${waypointFrames.indexOf(f) + 1} in Top-View to move`}
+												title={ko(`Root waypoint at frame ${f} — click to select, right-click to remove; drag marker ${waypointFrames.indexOf(f) + 1} in Top-View to move`, `${f}프레임의 루트 웨이포인트 — 클릭해 선택, 오른쪽 클릭으로 삭제. 탑뷰에서 ${waypointFrames.indexOf(f) + 1}번 마커를 드래그해 이동`, `第 ${f} 帧的根路径点 — 点击选中，右键删除；在顶视图中拖动第 ${waypointFrames.indexOf(f) + 1} 个标记移动`)}
 												onPointerDown={(e) => {
 													// Select only on the primary button — a right click
 													// must reach contextmenu so it removes without scrubbing.
@@ -2202,7 +2194,7 @@ export default function Timeline({
 											key={`${shot.id}:${key.frame}`}
 											className="tl-marker cam" data-edge={key.frame <= shot.startFrame ? "start" : key.frame >= shot.endFrame ? "end" : undefined}
 											style={{ "--tl-f": framePct(key.frame, displayFrameCount) }}
-											title={isKo ? `${key.frame}프레임의 카메라 키 — 클릭해 이동, 드래그로 시간 변경, 오른쪽 클릭으로 삭제` : `Camera key at frame ${key.frame} — click to jump, drag to re-time, right-click to remove`}
+											title={ko(`Camera key at frame ${key.frame} — click to jump, drag to re-time, right-click to remove`, `${key.frame}프레임의 카메라 키 — 클릭해 이동, 드래그로 시간 변경, 오른쪽 클릭으로 삭제`, `第 ${key.frame} 帧的摄影机关键帧 — 点击跳转，拖动改变时间，右键删除`)}
 											onPointerDown={(e) => beginCameraKeyDrag(e, key, index)}
 											onPointerMove={moveCameraKeyDrag}
 											onPointerUp={endCameraKeyDrag}
@@ -2229,10 +2221,8 @@ export default function Timeline({
 					{waypointMode && (
 						<span className={"tl-wp-hint" + (waypointFrames.length < 2 ? " warn" : "")}>
 							{waypointFrames.length < 2
-								? ko("Click the set floor in the Shot view to add waypoints", "샷 뷰의 세트 바닥을 클릭해 웨이포인트를 추가하세요")
-								: isKo
-									? `루트 웨이포인트 ${waypointFrames.length}개 · 세트 바닥을 클릭해 더 추가`
-									: `${waypointFrames.length} root waypoints · click the set floor to add more`}
+								? ko("Click the set floor in the Shot view to add waypoints", "샷 뷰의 세트 바닥을 클릭해 웨이포인트를 추가하세요", "在镜头视图中点击布景地面添加路径点")
+								: ko(`${waypointFrames.length} root waypoints · click the set floor to add more`, `루트 웨이포인트 ${waypointFrames.length}개 · 세트 바닥을 클릭해 더 추가`, `${waypointFrames.length} 个根路径点 · 点击布景地面继续添加`)}
 						</span>
 					)}
 					<button

package/src/motion/waypoints.js

@@ -1,4 +1,4 @@
-import { isKo } from "../locale.js";
+import { ko } from "../locale.js";
 
 // Root path pins: the limits keep an authored path a person could walk, and a
 // capsule figure that rides the path moves at a believable pace.
@@ -28,7 +28,7 @@ export function judgeNextWaypoint(last, candidate, fps, prev = null) {
 	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}`,
+			error: ko(`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}`, `핀 사이에는 최소 ${PATH_LIMITS.minPinGapFrames}프레임(${(PATH_LIMITS.minPinGapFrames / fps).toFixed(1)}초)이 필요해요 — ${last.frame + PATH_LIMITS.minPinGapFrames}프레임 이후로 이동해 주세요`, `路径点之间至少需要 ${PATH_LIMITS.minPinGapFrames} 帧（${(PATH_LIMITS.minPinGapFrames / fps).toFixed(1)} 秒）— 请移动到第 ${last.frame + PATH_LIMITS.minPinGapFrames} 帧之后`),
 			warnings: [],
 		};
 	}
@@ -40,7 +40,7 @@ export function judgeNextWaypoint(last, candidate, fps, prev = null) {
 		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`,
+			error: ko(`${speed.toFixed(1)} m/s is faster than anyone moves (max ${PATH_LIMITS.speedMaxMps}) — pin frame ${last.frame + neededFrames} or later, or click closer`, `${speed.toFixed(1)} m/s는 사람이 움직이기엔 너무 빨라요(최대 ${PATH_LIMITS.speedMaxMps}) — ${last.frame + neededFrames}프레임 이후에 핀을 찍거나 더 가까운 곳을 눌러 주세요`, `${speed.toFixed(1)} m/s 比人体移动速度快（上限 ${PATH_LIMITS.speedMaxMps}）— 请在第 ${last.frame + neededFrames} 帧或之后打点，或点击更近的位置`),
 			warnings: [],
 		};
 	}
@@ -49,7 +49,7 @@ export function judgeNextWaypoint(last, candidate, fps, prev = null) {
 		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`,
+			error: ko(`${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`, `${speed.toFixed(2)} m/s는 자연스럽게 걷기엔 너무 느려요(최소 ${PATH_LIMITS.speedMinMps}) — 대신 약 ${walkFrame}프레임에 핀을 찍거나 최소 ${neededDist} m 이상 떨어진 곳을 눌러 주세요`, `${speed.toFixed(2)} m/s 低于可持续步行速度（下限 ${PATH_LIMITS.speedMinMps}）— 请改为在第 ${walkFrame} 帧附近打点，或点击至少 ${neededDist} m 外的位置`),
 			warnings: [],
 		};
 	}
@@ -60,7 +60,7 @@ export function judgeNextWaypoint(last, candidate, fps, prev = null) {
 			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`);
+				warnings.push(ko(`${ratio.toFixed(1)}x speed change from the previous leg — expect a visible gait shift`, `이전 구간보다 속도가 ${ratio.toFixed(1)}배 달라요 — 걸음 변화가 눈에 보일 수 있어요`, `与前一段相比速度变化 ${ratio.toFixed(1)} 倍 — 步态变化可能很明显`));
 			}
 			const before = Math.atan2(last.x - prev.x, last.z - prev.z);
 			const after = Math.atan2(candidate.x - last.x, candidate.z - last.z);
@@ -68,7 +68,7 @@ export function judgeNextWaypoint(last, candidate, fps, prev = null) {
 			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`);
+				warnings.push(ko(`${Math.round((turn * 180) / Math.PI)}° turn in ${dt.toFixed(1)} s is sharper than a walking arc — give it more frames or distance`, `${dt.toFixed(1)}초 동안 ${Math.round((turn * 180) / Math.PI)}° 회전은 걷는 동선치고 너무 급해요 — 프레임이나 거리를 더 주세요`, `${dt.toFixed(1)} 秒内转向 ${Math.round((turn * 180) / Math.PI)}° 比步行弧线更急 — 请增加帧数或距离`));
 			}
 		}
 	}

package/src/motion3/compile-job.js

@@ -3,11 +3,13 @@
 // name, the motion scene (scene.js motionScene of the editor's objects: oriented boxes; shapes.js reads a sphere or a cylinder round from them), the spec as sent, and
 // what to do with it (probes, checks, lenient, repair, bake). The answer is plain data and typed arrays
 // only (the compiler's out holds closures), so it crosses a worker boundary: QA, observations, the stored
-// spec, and the baked take when asked.
+// spec, and the baked take when asked. The hint patches QA offers are compiled first (hint-check.js).
 // A refusal is an Error with a code (INVALID_ARGUMENT, MOTION_SPEC_INVALID turned into it), which the
 // client turns back into the Studio's protocol error.
 import { compileSpec, liftRequest } from "./pipeline.js";
+import { prepareSpec } from "./correct.js";
 import { repairSpec } from "./repair.js";
+import { checkHints } from "./hint-check.js";
 import { bakeTake } from "./take.js";
 import { skeletonFor } from "./rigs/index.js";
 import { keptPeople } from "./people.js";
@@ -49,7 +51,17 @@ export function runCompileJob({ model, scene, spec: asked, probes: sentProbes, c
 		const r = asArgument(() => compileSpec(sent, { sk, scene }, { ...opts, probes }));
 		return { ...r, stored: r.spec === sent ? spec : r.spec };
 	};
-	const t0 = performance.now(), fixed = repair ? repairSpec(asked, repair, once) : { spec: asked, result: once(asked) };
+	// repair patches address the stored spec, so a repair starts from it corrected (correct.js), and says what was
+	const corrected = [], start = repair && !lenient ? prepareSpec(asked, { sk, scene }, corrected) : asked;
+	// every compile's QA by its spec, so a hint patch repair already tried is not compiled again (hint-check.js)
+	const seen = new Map(), measured = s => { const r = once(s); seen.set(JSON.stringify(s), r.qa); return r; };
+	const t0 = performance.now(), fixed = repair ? repairSpec(start, repair, measured) : { spec: asked, result: measured(asked) };
+	// a hint's patch is offered only when its compile helped (hint-check.js), and only by a compile that repairs: repair has
+	// compiled most of the patches already (seen), where a plain compile paid two more compiles for them (bench replay: first
+	// compile 1.6 -> 5.2 s median) and the agent applied an offered patch as sent once in the 60 bench runs (374 direct
+	// compiles, 319 with repair; a plain compile is mostly a variant in a sweep); a plain compile keeps the hint's words only
+	if (repair) checkHints(fixed.spec, fixed.result.qa, s => seen.get(JSON.stringify(s)) ?? measured(s).qa);
+	else for (const g of fixed.result.qa?.groups ?? []) delete g.patch;
 	// ms.repair: the whole repair's wall time, so a sweep that repairs every variant shows what it costs
 	const r = fixed.result, label = fixed.spec?.label ?? null, ms = fixed.repair ? { ...r.ms, repair: Math.round(performance.now() - t0) } : r.ms;
 	const take = bake ? bakeTake(sk, r.out, { position: bake.position, yaw: bake.yaw }, { spec: r.stored, prompt: ("prompt" in bake ? bake.prompt : label) ?? "" }) : undefined;
@@ -57,7 +69,7 @@ export function runCompileJob({ model, scene, spec: asked, probes: sentProbes, c
 	const people = take && keptPeople(scene, [r.expanded, r.stored]);
 	if (people) take.people = people;
 	return { stored: r.stored, qa: r.qa, observations: r.observations, used: r.used, fixed: r.fixed, search: r.search, timeline: r.timeline,
-		...(r.probes ? { probes: r.probes } : {}), ...(r.notes ? { notes: r.notes } : {}), ms, frameCount: r.out.frameCount, label,
+		...(r.probes ? { probes: r.probes } : {}), ...(r.notes || corrected.length ? { notes: [...corrected, ...(r.notes ?? [])] } : {}), ms, frameCount: r.out.frameCount, label,
 		...(fixed.repair ? { repair: fixed.repair } : {}), ...(take ? { take } : {}) };
 }
 

package/src/motion3/compiler/channels.js

@@ -12,7 +12,11 @@
 // flow is gone by the time the arm is a quarter of the way onto it: an arm's swing and bend by its
 // own armw, the spine (which carries the shoulders) and the head (the hands work near it) by the
 // larger of the two; a reach or a held prop lands as keyed. A hold (two equal keys in a row) stays
-// exactly flat either way.
+// exactly flat either way. Overlap (overlap.js) breaks each change along the chains on top of that: the
+// lower spine, the chest (chest_*: the top spine bone's share, baked beside spine_*), the head, the upper
+// arm, the forearm and the wrist each take a later delay, one side of the body trails the other, and the
+// arm's swing and bend overshoot and settle where they stop.
+import { overlapDelay, sideTrail, settleBump, ikGap, contactGap, OVERLAP_SLOPE } from "./overlap.js";
 
 function pchipSlopes(x, y) {
 	const n = y.length, m = new Array(n).fill(0);
@@ -37,18 +41,24 @@ function pchipEval(x, y, m, q) {
 	return (2 * t3 - 3 * t2 + 1) * y[i] + (t3 - 2 * t2 + t) * h * m[i] + (-2 * t3 + 3 * t2) * y[i + 1] + (t3 - t2) * h * m[i + 1];
 }
 
-const FLOW_SMOOTH = /^(spine|head)_(yaw|pitch|roll)$|^(aswing|abend)_[lr]$/;
+const FLOW_SMOOTH = /^(spine|chest|head)_(yaw|pitch|roll)$|^(aswing|abend)_[lr]$/;
 const FLOW_LAG = { spine: 0, head: 2, arms: 3 };
+const ARM = /^(hand|armw|elbow|aswing|abend|wflex|wtwist)_[lr]$/; // one side's arm: trails as one (overlap.js sideTrail)
 const OVER_FRAC = 0.15, OVER_MAX = 6; // a smooth segment's overshoot: at most this share of its change, and degrees
-const ikSides = ch => (/^(spine|head)_/.test(ch) ? ["l", "r"] : /^(aswing|abend)_([lr])$/.test(ch) ? [ch.slice(-1)] : []);
-const lagFamily = ch => (/^spine_/.test(ch) ? "spine" : /^head_/.test(ch) ? "head" : /^(aswing|abend)_[lr]$/.test(ch) ? "arms" : null);
+const ikSides = ch => (/^(spine|chest|head)_/.test(ch) ? ["l", "r"] : /^(aswing|abend|wflex|wtwist)_([lr])$/.test(ch) ? [ch.slice(-1)] : []);
+const lagFamily = ch => (/^(spine|chest)_/.test(ch) ? "spine" : /^head_/.test(ch) ? "head" : /^(aswing|abend)_[lr]$/.test(ch) ? "arms" : null);
 
-/** spec.flow -> { smooth, lag: { spine, head, arms } }: undefined is the default, false turns both off. */
-export function flowOptions(flow) {
-	if (flow === false) return { smooth: false, lag: { spine: 0, head: 0, arms: 0 } };
+/**
+ * spec.flow -> { smooth, lag: { spine, head, arms }, overlap, seed, hands }: undefined is the default, false turns all off.
+ * overlap: true (1) | false (0) | a scale of its delays and settle (overlap.js); seed (the spec's label) picks which side trails;
+ * hands: the frames each hand works on something (overlap.js handBusy), where a free IK hand's trail stops.
+ */
+export function flowOptions(flow, seed = "", hands = { l: [], r: [] }) {
+	if (flow === false) return { smooth: false, lag: { spine: 0, head: 0, arms: 0 }, overlap: 0, seed, hands };
 	const f = flow ?? {}, lag = f.lag === false ? 0 : f.lag;
 	const each = typeof lag === "number" ? { spine: lag, head: lag, arms: lag } : { ...FLOW_LAG, ...(lag ?? {}) };
-	return { smooth: f.smooth !== false, lag: each };
+	const overlap = f.overlap === false ? 0 : typeof f.overlap === "number" ? f.overlap : 1;
+	return { smooth: f.smooth !== false, lag: each, overlap, seed, hands };
 }
 
 /** Catmull-Rom slopes, flat at a hold and at the ends, each segment's overshoot bounded. */
@@ -78,11 +88,47 @@ export function bakeChannels(keys, frameCount, flow = flowOptions()) {
 	for (const key of [...keys].sort((a, b) => a.f - b.f)) {
 		for (const [ch, value] of Object.entries(key.set ?? {})) {
 			if (!byChannel.has(ch)) byChannel.set(ch, []);
-			byChannel.get(ch).push({ f: key.f, value, step: key.step?.includes(ch) });
+			byChannel.get(ch).push({ f: key.f, value, step: key.step?.includes(ch), src: key.src });
 		}
 	}
+	// the top spine bone's share breaks after the two below it (pose.js), so it is baked as its own channel
+	const overlap = flow.overlap ?? 0, entries = [...byChannel];
+	if (overlap > 0) for (const [ch, list] of byChannel) if (/^spine_/.test(ch)) entries.push([ch.replace("spine", "chest"), list]);
+	// an arm's IK weights first: a link's own delay runs out before an arm goes onto its IK and comes back after it
+	// leaves (overlap.js), so the fade below never snaps a delayed move onto its keyed frames. Before them where each
+	// hand touches: its anchor and fit weights (never delayed) and its carries and hand goals (flow.hands); a side's
+	// trail stops short of those
+	const pre = new Map(), near = new Map(), touch = {}, trails = {};
+	if (overlap > 0) {
+		for (const [ch, list] of entries) if (/^w_.+_[lr]$/.test(ch)) pre.set(ch, bakeOne(ch, list));
+		for (const k of ["l", "r"]) touch[k] = contactGap(flow.hands?.[k] ?? [], [...pre].filter(([ch]) => ch.endsWith(`_${k}`)).map(([, b]) => b.frames), frameCount);
+		// the whole arm of a side trails as one (overlap.js sideTrail), its FK swing with its IK weight, so a blend between
+		// them never sets a late weight over an on-time swing
+		for (const k of ["l", "r"]) trails[k] = sideTrail([...byChannel].filter(([ch]) => ARM.test(ch) && ch.endsWith(`_${k}`)).map(([ch, list]) => Object.assign([...list], { weight: /^armw_/.test(ch) })), k, overlap, flow.seed ?? "", touch[k]);
+		for (const [ch, list] of entries) if (/^armw_[lr]$/.test(ch)) pre.set(ch, bakeOne(ch, list));
+	}
+	const gapOf = ch => {
+		const sides = ikSides(ch).filter(k => pre.has(`armw_${k}`)), key = sides.join("");
+		if (!sides.length) return null;
+		if (!near.has(key)) near.set(key, ikGap(sides.map(k => pre.get(`armw_${k}`).frames), frameCount));
+		return near.get(key);
+	};
 	const out = {}, plain = {};
-	for (const [ch, list] of byChannel) {
+	for (const [ch, list] of entries) {
+		const baked = pre.get(ch) ?? bakeOne(ch, list, gapOf(ch));
+		out[ch] = baked.frames;
+		if (baked.plain) plain[ch] = baked.plain;
+	}
+	// flow fades out as the arm goes onto its IK (the spine with either arm)
+	for (const [ch, keyed] of Object.entries(plain)) {
+		const ws = ikSides(ch).map(k => out[`armw_${k}`]).filter(Boolean);
+		if (!ws.length) continue;
+		out[ch] = out[ch].map((v, f) => { const w = Math.min(1, 4 * Math.max(0, ...ws.map(a => a[f]))); return v + (keyed[f] - v) * w * (2 - w); });
+	}
+	return out;
+
+	/** One channel's frames (and, for a flowing body channel, its keyed frames: plain); gap: frames to the nearest IK frame. */
+	function bakeOne(ch, list, gap = null) {
 		// later keys at the same frame win
 		const pts = [...new Map(list.map(k => [k.f, k])).values()];
 		const shape = shapeOf(pts[0].value);
@@ -91,15 +137,24 @@ export function bakeChannels(keys, frameCount, flow = flowOptions()) {
 			: shape === "vec" ? Array.from({ length: comps }, (_, i) => pts.map(p => p.value[i]))
 				: [...new Set(pts.flatMap(p => Object.keys(p.value)))].map(name => ({ name, y: pts.map(p => p.value[name] ?? 0) }));
 		const x = pts.map(p => p.f), smooth = flow.smooth && FLOW_SMOOTH.test(ch), lag = flow.lag[lagFamily(ch)] ?? 0;
-		// the trail eases out over the last 2 * lag frames, so the take ends on the last value
-		const at = f => (lag > 0 ? f - lag * Math.min(1, (frameCount - 1 - f) / (2 * lag)) : f);
+		const delay = shape === "num" ? overlapDelay(ch, pts, overlap, flow.seed ?? "", gap) : null;
+		const trail = ARM.test(ch) ? trails[ch.slice(-1)] : null, most = lag + (delay?.max ?? 0);
+		const delayAt = f => (delay ? Math.min(delay.at(f), gap ? OVERLAP_SLOPE * gap[Math.round(f)] : Infinity) : 0);
+		const end = (f, d) => Math.min(1, (frameCount - 1 - f) / (2 * d));
+		// the trail eases out over the last 2 * (its most) frames, so the take ends on the last value (the side's trail over
+		// its own: a short ease there would quicken the arm's last move); the side's trail rides the keyed curve too (plain),
+		// which an arm on its IK goes back to
+		const keyedAt = f => (trail ? f - trail.at(f) * end(f, trail.max) : f);
+		const at = f => keyedAt(f) - (most > 0 ? (lag + delayAt(f)) * end(f, most) : 0);
+		// a settle near an arm's IK would be cut by the fade below: none within its span and a few frames
+		const clear = (a, b) => { if (!gap) return true; for (let f = Math.max(0, Math.floor(a)); f <= Math.min(frameCount - 1, Math.ceil(b + most)); f++) if (gap[f] < 2) return false; return true; };
 		const evalSeries = (y, flowing = true) => {
-			const m = smooth && flowing ? smoothSlopes(x, y) : pchipSlopes(x, y);
+			const m = smooth && flowing ? smoothSlopes(x, y) : pchipSlopes(x, y), bump = flowing && shape === "num" ? settleBump(ch, pts, y, overlap, frameCount - 1, clear) : null;
 			return q => {
-				const f = flowing ? at(q) : q;
+				const f = flowing ? at(q) : keyedAt(q);
 				// a step key holds the previous value right up to its frame
 				for (let i = 1; i < pts.length; i++) if (pts[i].step && f >= x[i - 1] && f < x[i]) return y[i - 1];
-				return pchipEval(x, y, m, f);
+				return pchipEval(x, y, m, f) + (bump ? bump(f) : 0);
 			};
 		};
 		const frames = new Array(frameCount);
@@ -109,16 +164,11 @@ export function bakeChannels(keys, frameCount, flow = flowOptions()) {
 			const es = series.map(({ name, y }) => [name, evalSeries(y)]);
 			for (let f = 0; f < frameCount; f++) frames[f] = Object.fromEntries(es.map(([n, e]) => [n, e(f)]));
 		}
-		out[ch] = frames;
-		if (shape === "num" && (smooth || lag > 0) && ikSides(ch).length) { const e = evalSeries(series[0], false); plain[ch] = Array.from({ length: frameCount }, (_, f) => e(f)); }
-	}
-	// flow fades out as the arm goes onto its IK (the spine with either arm)
-	for (const [ch, keyed] of Object.entries(plain)) {
-		const ws = ikSides(ch).map(k => out[`armw_${k}`]).filter(Boolean);
-		if (!ws.length) continue;
-		out[ch] = out[ch].map((v, f) => { const w = Math.min(1, 4 * Math.max(0, ...ws.map(a => a[f]))); return v + (keyed[f] - v) * w * (2 - w); });
+		if (!(shape === "num" && (smooth || most > 0) && ikSides(ch).length)) return { frames };
+		// an arm's own channels keep the side's trail on its IK too (plain), only the links' own delays and settle fade
+		const e = evalSeries(series[0], false);
+		return { frames, plain: Array.from({ length: frameCount }, (_, f) => e(f)) };
 	}
-	return out;
 }
 
 /** Frame f's channel dict. */

package/src/motion3/compiler/compile.js

@@ -26,6 +26,7 @@ import { pose, SIDES } from "./pose.js";
 import { graspAnchor } from "./socket-grip.js";
 import { gripHand } from "./grip.js";
 import { bakeChannels, channelsAt, flowOptions } from "./channels.js";
+import { handBusy } from "./overlap.js";
 import { idleLayer, withIdle, busyHands } from "./idle.js";
 import { resolveAnchor, measureProps, armReach } from "./anchors.js";
 import { expandGenerators } from "./walk.js";
@@ -208,7 +209,7 @@ export function compileMotion(spec, { sk, scene }, opts = {}) {
 	const engine = {
 		rebake(keys) {
 			out.keys = keys;
-			out.baked = bakeChannels(keys, frameCount, flowOptions(spec.flow));
+			out.baked = bakeChannels(keys, frameCount, flowOptions(spec.flow, spec.label ?? "", handBusy(spec)));
 			ctx.socketTurns = new Map();
 			ctx.graspPlans = new Map();
 			steadyHead(out.baked, keys, frameCount);

package/src/motion3/compiler/idle.js

@@ -109,5 +109,7 @@ export function withIdle(c, layer, f) {
 	if (!d) return c;
 	const out = { ...c };
 	for (const [ch, v] of Object.entries(d)) out[ch] = Array.isArray(v) ? (Array.isArray(c[ch]) ? c[ch].map((x, i) => x + v[i]) : c[ch]) : (Number(c[ch]) || 0) + v;
+	// the top spine bone's own share (chest_*, channels.js overlap) breathes and sways with the rest of the spine
+	for (const ch of ["chest_pitch", "chest_roll"]) if (c[ch] !== undefined && d[ch.replace("chest", "spine")] !== undefined) out[ch] = c[ch] + d[ch.replace("chest", "spine")];
 	return out;
 }