cozyclay 3.1.1 → 3.1.3

package/src/asset-pane.jsx

@@ -162,8 +162,8 @@ function StorageAssetRow({ id, onDelete, deleting, usageCount = 0, graphSignatur
 	const failed = thumb === null;
 	const mesh = Boolean(thumb?.mesh);
 	const name = thumb?.name || (failed ? ko("(unreadable image)", "(읽을 수 없는 이미지)") : mesh ? ko("Untitled model", "이름 없는 모델") : ko("Untitled image", "이름 없는 이미지"));
-	const usageLabel = ko(`Used by ${usageCount} scene object${usageCount === 1 ? "" : "s"}`, `${usageCount}개 씬 오브젝트에서 사용 중`);
-	const deleteLabel = ko(`Delete ${name} from storage`, `${name}을(를) 저장소에서 삭제`);
+	const usageLabel = ko(`Used by ${usageCount} scene object${usageCount === 1 ? "" : "s"}`, `${usageCount}개 씬 오브젝트에서 사용 중`, `被 ${usageCount} 个场景物体使用`);
+	const deleteLabel = ko(`Delete ${name} from storage`, `${name}을(를) 저장소에서 삭제`, `从存储中删除 ${name}`);
 	const confirmationId = `asset-storage-warning-${id}`;
 	const kindLabel = thumb?.kind === "mesh" ? ko("Model", "모델") : thumb?.kind === "environment" ? ko("HDR environment", "HDR 환경") : thumb?.kind === "matte" ? ko("Matte", "매트") : ko("Image", "이미지");
 	return (
@@ -183,7 +183,7 @@ function StorageAssetRow({ id, onDelete, deleting, usageCount = 0, graphSignatur
 			{confirmation ? (
 				<div className="asset-storage-confirm">
 					<span id={confirmationId} role="alert">{inUse
-						? ko(`Permanently delete this image from storage? It is used by ${usageCount} scene object${usageCount === 1 ? "" : "s"} and those objects will lose it.`, `저장소에서 이 이미지를 영구 삭제할까요? ${usageCount}개 씬 오브젝트가 사용 중이며 해당 오브젝트에서 사라집니다.`)
+						? ko(`Permanently delete this image from storage? It is used by ${usageCount} scene object${usageCount === 1 ? "" : "s"} and those objects will lose it.`, `저장소에서 이 이미지를 영구 삭제할까요? ${usageCount}개 씬 오브젝트가 사용 중이며 해당 오브젝트에서 사라집니다.`, `要从存储中永久删除此图片吗？它正被 ${usageCount} 个场景物体使用，那些物体会失去它。`)
 						: ko("Unused by every scene. Delete it?", "모든 씬에서 사용되지 않아요. 삭제할까요?")}</span>
 					<button type="button" className="asset-storage-delete" aria-label={deleteLabel} aria-describedby={confirmationId} disabled={deleting} onClick={async () => {
 						if (await onDelete(id, inUse ? usageCount : undefined, confirmation.graphSignature)) setConfirmation(null);
@@ -209,7 +209,7 @@ function StorageManager({ unusedAssetIds, usedAssetIds, usageCounts, graphSignat
 					<h3>{ko("Manage storage", "저장 공간 관리")}</h3>
 					<p>{ko("Review unused and in-use stored images. Deleted images can be restored until this page is reloaded.", "사용하지 않는 이미지와 사용 중인 저장 이미지를 확인하세요. 삭제한 이미지는 이 페이지를 새로 고치기 전까지 복원할 수 있어요.")}</p>
 				</div>
-				{trashCount > 0 && <button type="button" className="asset-storage-undo" onClick={onUndo}>{ko(`Undo last delete (${trashCount})`, `마지막 삭제 실행 취소 (${trashCount})`)}</button>}
+				{trashCount > 0 && <button type="button" className="asset-storage-undo" onClick={onUndo}>{ko(`Undo last delete (${trashCount})`, `마지막 삭제 실행 취소 (${trashCount})`, `撤销上次删除（${trashCount}）`)}</button>}
 			</div>
 			{loading ? (
 				<div className="asset-storage-list" aria-busy="true">
@@ -301,8 +301,8 @@ function ImageAssetTile({ id, onAssetGrab, onAssetPlace, selectedKey, onSelect,
 			type={failed ? ko("Unreadable", "읽을 수 없음") : ko("Image", "이미지")}
 			failed={failed}
 			title={failed
-				? ko(`${label} — could not decode; delete it from Manage storage`, `${label} — 불러오지 못했어요. 저장소 관리에서 삭제할 수 있어요`)
-				: ko(`Drag ${label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`)}
+				? ko(`${label} — could not decode; delete it from Manage storage`, `${label} — 불러오지 못했어요. 저장소 관리에서 삭제할 수 있어요`, `${label} — 无法解码；请在存储管理中删除`)
+				: ko(`Drag ${label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`, `将 ${label} 拖入场景，或双击将其放在原点`)}
 			preview={thumb
 				? <img className="content-tile-img" src={thumb.url} alt="" draggable={false} />
 				: <span className="content-tile-skeleton" aria-hidden="true" />}
@@ -329,8 +329,8 @@ function MeshAssetTile({ id, onAssetGrab, onAssetPlace, selectedKey, onSelect, q
 			type={failed ? ko("Unreadable", "읽을 수 없음") : ko("Model", "모델")}
 			failed={failed}
 			title={failed
-				? ko(`${label} — could not read; delete it from Manage storage`, `${label} — 불러오지 못했어요. 저장소 관리에서 삭제할 수 있어요`)
-				: ko(`Drag ${label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`)}
+				? ko(`${label} — could not read; delete it from Manage storage`, `${label} — 불러오지 못했어요. 저장소 관리에서 삭제할 수 있어요`, `${label} — 无法读取；请在存储管理中删除`)
+				: ko(`Drag ${label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`, `将 ${label} 拖入场景，或双击将其放在原点`)}
 			preview={failed ? <span className="content-tile-skeleton" aria-hidden="true" /> : <MeshPreview />}
 			selected={selectedKey === key}
 			onSelect={onSelect}
@@ -386,7 +386,7 @@ function catalogueTile(entry, props) {
 			assetKey={key}
 			label={label}
 			type={ko("Shape", "도형")}
-			title={ko(`Drag ${entry.label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`)}
+			title={ko(`Drag ${entry.label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`, `将 ${entry.label} 拖入场景，或双击将其放在原点`)}
 			preview={<ObjectPreview kind={entry.kind} color={entry.color} />}
 			selected={props.selectedKey === key}
 			onSelect={props.onSelect}
@@ -418,7 +418,7 @@ export function FolderGrid({ folder, query, ...props }) {
 					assetKey={key}
 					label={asset.label}
 					type={ko("Character", "인물")}
-					title={ko(`Drag ${asset.label} into the scene, or double-click to place it at the origin`, `${asset.label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`)}
+					title={ko(`Drag ${asset.label} into the scene, or double-click to place it at the origin`, `${asset.label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`, `将 ${asset.label} 拖入场景，或双击将其放在原点`)}
 					preview={<CharacterPreview model={asset.id} />}
 					selected={selectedKey === key}
 					onSelect={onSelect}
@@ -454,7 +454,7 @@ export function FolderGrid({ folder, query, ...props }) {
 					assetKey={key}
 					label={label}
 					type={ko("Camera", "카메라")}
-					title={ko(`${label} — double-click to open it in Camera mode`, `${label} — 더블클릭하면 카메라 모드에서 엽니다`)}
+					title={ko(`${label} — double-click to open it in Camera mode`, `${label} — 더블클릭하면 카메라 모드에서 엽니다`, `${label} — 双击可在摄影机模式中打开`)}
 					preview={<CameraPreview />}
 					selected={selectedKey === key}
 					onSelect={onSelect}
@@ -474,7 +474,7 @@ export function FolderGrid({ folder, query, ...props }) {
 						assetKey={key}
 						label={label}
 						type={ko("Motion", "모션")}
-						title={ko(`${label} — double-click to load this take`, `${label} — 더블클릭하면 이 테이크를 불러옵니다`)}
+						title={ko(`${label} — double-click to load this take`, `${label} — 더블클릭하면 이 테이크를 불러옵니다`, `${label} — 双击加载此动作片段`)}
 						preview={<MotionPreview />}
 						selected={selectedKey === key}
 						onSelect={onSelect}
@@ -484,7 +484,7 @@ export function FolderGrid({ folder, query, ...props }) {
 			});
 		if (!takeVersions.length) empty = ko("No takes for this character yet. Ask the agent to compile one.", "이 인물의 테이크가 아직 없어요. 에이전트에게 모션 컴파일을 요청하세요.");
 	} else if (folder === "poses") {
-		tiles = poses.map((pose, index) => ({ pose, index, label: pose?.name || pose?.label || ko(`Pose ${index + 1}`, `포즈 ${index + 1}`) }))
+		tiles = poses.map((pose, index) => ({ pose, index, label: pose?.name || pose?.label || ko(`Pose ${index + 1}`, `포즈 ${index + 1}`, `姿势 ${index + 1}`) }))
 			.filter(({ label }) => matchesQuery(label, query))
 			.map(({ pose, index, label }) => {
 				const key = `pose:${pose?.id ?? index}`;
@@ -634,7 +634,7 @@ export default function AssetPane({
 					data-testid="content-search"
 					value={search}
 					placeholder={tab === "content" ? ko("Search objects", "오브젝트 검색") : ko("Search", "검색")}
-					aria-label={tab === "content" ? ko(`Search ${folderLabel}`, `${folderLabel} 검색`) : ko("Search the log", "로그 검색")}
+					aria-label={tab === "content" ? ko(`Search ${folderLabel}`, `${folderLabel} 검색`, `搜索 ${folderLabel}`) : ko("Search the log", "로그 검색")}
 					onChange={(event) => setSearch(event.target.value)}
 				/>
 			</header>

package/src/bus-task-scopes.js

@@ -1,18 +1,64 @@
 // The document targets a command writes, known before it runs, for tasks that edit one scene at once (parallel Studio
-// tasks, P1). A key names one target: object:<id> (a group carries its subtree), character:<id> (its placement, its
-// take, its IK), shot:<id> (its camera, rail and keys), or one of the singletons stage (light, environment, lens),
-// timeline (frame count, shot order and ranges) and scene (documents, the cast library, a replace of a whole kind).
-// timeline and scene are exclusive: no other task runs beside them. A command that only creates (object.add, a kit,
-// character.add) needs no key: what it makes joins its task. A command this table does not know writes scene, so a
-// new command is safe until it is named here.
+// tasks, P1). A key names one target: object:<id> (a group carries its subtree), character:<id>:<layer> (one owned
+// layer of a character, below), shot:<id> (its camera, rail and keys), or one of the singletons stage (light,
+// environment, lens), timeline (frame count, shot order and ranges) and scene (documents, the cast library, a replace of
+// a whole kind). timeline and scene are exclusive: no other task runs beside them. A command that only creates
+// (object.add, a kit, character.add) needs no key: what it makes joins its task. A command this table does not know
+// writes scene, so a new command is safe until it is named here.
+// A character is four layers, so one task can place her while another makes her motion: placement (where she stands,
+// her scale, parent, visibility, tint, static pose: every cast field the others do not own), take (the motion take, its
+// timing edit and the root path), ik (the IK keys and range pins on top of the take) and props (what she holds; the
+// held object's own key goes with it). Playback already stacks them placement < take < ik; the split only says who may
+// write which. A plain character:<id> is all four (the scope a task names; a receipt's id): it overlaps every layer.
 const EXCLUSIVE_KEYS = new Set(['timeline', 'scene']);
-const KEY = /^(?:(?:object|character|shot):[A-Za-z0-9][A-Za-z0-9._:-]*|stage|timeline|scene)$/;
+const CHARACTER_LAYERS = Object.freeze(['placement', 'take', 'ik', 'props']);
+const ID = '[A-Za-z0-9][A-Za-z0-9._:-]*';
+const KEY = new RegExp(`^(?:(?:object|character|shot):${ID}|stage|timeline|scene)$`);
 export const isScopeKey = key => typeof key === 'string' && key.length <= 140 && KEY.test(key);
+const LAYERED = /^character:(.+?)(?::(placement|take|ik|props))?$/s;
+/** { id, layer } of a character key (layer null for the plain key), or null for any other key. */
+export function layerOf(key) {
+	const match = LAYERED.exec(key);
+	return match ? { id: match[1], layer: match[2] ?? null } : null;
+}
+const layers = (id, names = CHARACTER_LAYERS) => names.map(name => `character:${id}:${name}`);
+/** The keys a scope names, with a plain character:<id> spelled out as its four layers. */
+export const expandScope = keys => [...new Set(keys.flatMap(key => { const of = layerOf(key); return of && !of.layer ? layers(of.id) : [key]; }))];
+/** True when one key's target covers part of the other's: the same key, or a plain character key and one of its layers. */
+export function keysOverlap(a, b) {
+	if (a === b) return true;
+	const x = layerOf(a), y = layerOf(b);
+	return Boolean(x && y && x.id === y.id && (!x.layer || !y.layer));
+}
 
 const SCENE = ['cast.replace', 'cast.setCustomPoses', 'cast.showExtras', 'cast.removePose', 'objects.replace', 'shot.replace', 'ai.prepareShot'];
 const TIMELINE = ['shot.create', 'shot.createStill', 'shot.split', 'shot.duplicate', 'shot.remove', 'shot.reorder', 'shot.setRange', 'shot.setTimeline'];
 const CREATE = ['object.add', 'object.createKit', 'asset.import', 'character.add'];
 const CHARACTER = /^(character\.|characters?\b|cast\.(savePose|setLayer)$|ik\.|motion\.)/;
+// The layers each character command writes, read from what it changes: a compile installs a take and clears the IK
+// keys on it (motion domain replace), a timing edit moves the IK keys with the frames they address, a pose that clears
+// motion clears both, and attaching a prop changes what she holds. A command this table does not name writes all four.
+const WRITES = {
+	'character.move': ['placement'], 'characters.arrange': ['placement'], 'cast.setLayer': ['take'], 'motion.set': ['take'],
+	'motion.compile': ['take', 'ik'], 'motion.clear': ['take', 'ik'], 'motion.keyObject': ['take', 'ik', 'props'], 'object.attach': ['props'],
+	...Object.fromEntries(['addWaypoint', 'moveWaypoint', 'removeWaypoint', 'clearWaypoints'].map(verb => [`character.${verb}`, ['take']])),
+	...Object.fromEntries(['cut', 'setSegmentSpeed', 'removeSegment', 'trim', 'resetTiming'].map(verb => [`motion.${verb}`, ['take', 'ik']])),
+	...Object.fromEntries(['character.setIkKey', 'character.removeIkKey', 'character.clearIkKeys', 'ik.setKey', 'ik.removeKey', 'ik.clearKeys', 'ik.applyPose',
+		'motion.rangePin.apply', 'motion.rangePin.remove'].map(id => [id, ['ik']])),
+};
+// A cast field the take or the IK layer owns (the rest is placement); a model swap is a different body under all four.
+const FIELD_LAYER = { layer: 'take', motionTake: 'take', waypoints: 'take', ikEdits: 'ik', ikKeys: 'ik', model: null };
+const fieldLayers = fields => fields.some(field => FIELD_LAYER[field] === null) ? CHARACTER_LAYERS
+	: [...new Set(fields.map(field => FIELD_LAYER[field] ?? 'placement'))];
+const poseLayers = args => args.clearMotion ? ['placement', 'take', 'ik'] : ['placement'];
+/** The layer keys a character command writes on character `id`. */
+function characterKeys(id, args) {
+	if (WRITES[id]) return WRITES[id];
+	if (id === 'character.update') return fieldLayers(Object.keys(args.patch ?? {}));
+	if (id === 'character.set') return fieldLayers(Object.keys(args.set ?? {}));
+	if (id === 'character.setPose' || id === 'cast.savePose') return poseLayers(args);
+	return CHARACTER_LAYERS;
+}
 
 /** object:<id> and every object under it. */
 function objectKeys(ids, state) {
@@ -34,7 +80,9 @@ export function commandKeys(id, args = {}, state = {}, entry = {}) {
 	if (CREATE.includes(id)) return [];
 	if (id === 'objects.batch') return [...new Set(args.ops.flatMap(op => commandKeys(op.name, op.args, state)))];
 	if (id === 'objects.arrange') return [...new Set(arrangeKeys(args.ops, state))];
-	if (id === 'characters.arrange') return args.ops.flatMap(op => op.op === 'create' ? [] : [`character:${op.characterId}`]);
+	if (id === 'characters.arrange') return args.ops.flatMap(op => op.op === 'create' ? [] : layers(op.characterId, characterKeys(id, op)));
+	// A set or a take edit of several characters at once names each one (an op is { id, set }).
+	if ((id === 'character.set' || id === 'motion.set') && args.ops) return [...new Set(args.ops.flatMap(op => layers(op.id, characterKeys(id, op))))];
 	if (id.startsWith('stage.') || id === 'shot.setLens') return ['stage'];
 	if (TIMELINE.includes(id)) return ['timeline'];
 	if (id.startsWith('shot.')) {
@@ -44,9 +92,9 @@ export function commandKeys(id, args = {}, state = {}, entry = {}) {
 	if (id === 'object.group') return objectKeys([args.parent, ...args.children], state);
 	if (id === 'object.ungroup') return objectKeys(args.children, state);
 	if (id === 'object.remove') return objectKeys(args.ids, state);
-	if (id === 'object.attach' || id === 'motion.keyObject') return [`character:${args.characterId}`, ...objectKeys([args.objectId], state)];
+	if (id === 'object.attach' || id === 'motion.keyObject') return [...layers(args.characterId, characterKeys(id, args)), ...objectKeys([args.objectId], state)];
 	if (id.startsWith('object.')) return objectKeys([args.id ?? args.objectId], state);
-	if (CHARACTER.test(id) && (args.characterId ?? args.id)) return [`character:${args.characterId ?? args.id}`];
+	if (CHARACTER.test(id) && (args.characterId ?? args.id)) return layers(args.characterId ?? args.id, characterKeys(id, args));
 	return ['scene'];
 }
 
@@ -62,7 +110,7 @@ export function keyOfId(id, state = {}) {
 export function scopeConflict(taskId, keys, tasks) {
 	for (const other of tasks.values()) {
 		if (other.taskId === taskId) continue;
-		const held = keys.find(key => other.keys.has(key) || EXCLUSIVE_KEYS.has(key) || [...other.keys].some(k => EXCLUSIVE_KEYS.has(k)));
+		const held = keys.find(key => EXCLUSIVE_KEYS.has(key) || [...other.keys].some(k => EXCLUSIVE_KEYS.has(k) || keysOverlap(key, k)));
 		if (held) return `${held} is held by task ${other.taskId}${other.title ? ` (${other.title})` : ''}`;
 	}
 	return null;

package/src/bus-task-targets.js

@@ -2,20 +2,37 @@
 // key is its rows (an object's row; a character's cast row and motion layer; a shot's row) or, for stage and timeline,
 // the whole slices; restoring puts every row back where it stood (or removes a row the task created) in one composed
 // entry, so undo, history and saves see an ordinary edit. scene is not restorable: documents have no undo.
+// A character layer (bus-task-scopes.js) is the fields of those two rows it owns: restoring it writes only them back
+// into the row as it stands now, so cancelling the task that placed her keeps the take another task made meanwhile.
 import { StudioProtocolError } from './studio-agent-protocol.js';
+import { layerOf } from './bus-task-scopes.js';
 
 const ROWS = { object: [['objects', null]], character: [['cast', 'characters'], ['motion', null]], shot: [['shot', 'shots']] };
 const WHOLE = { stage: ['stage'], timeline: ['shot', 'motion'] };
 const split = key => { const at = key.indexOf(':'); return at < 0 ? [key] : [key.slice(0, at), key.slice(at + 1)]; };
+// The fields of the cast row (scenes.js createCharacterEntry) and the motion layer (emptyMotionLayer) each layer owns;
+// placement is every other cast field, props no field of either (what she holds lives on the objects).
+const LAYER_FIELDS = {
+	cast: { take: ['layer', 'motionTake'], ik: ['ikEdits'], props: [] },
+	motion: { placement: [], take: ['take', 'fullTake', 'takeRecipe', 'takeVersions'], ik: ['ikKeys', 'ikPins', 'ikPinResiduals', 'committedIkEdits'], props: [] },
+};
+const CAST_OWNED = new Set(['id', ...Object.values(LAYER_FIELDS.cast).flat()]);
+const fieldsOf = (domain, layer, row) => LAYER_FIELDS[domain][layer] ?? Object.keys(row).filter(field => !CAST_OWNED.has(field));
+// A character with no motion layer yet reads as the empty one (motion-intent-codec.js emptyMotionLayer).
+const EMPTY = { motion: { take: null, fullTake: null, takeRecipe: null, takeVersions: [], ikKeys: [], ikPins: [], ikPinResiduals: [], committedIkEdits: [] } };
+const pick = (row, fields) => Object.fromEntries(fields.map(field => [field, row[field]]));
 
 function put(slice, part) {
 	if ('whole' in part) return part.whole;
-	const rows = (part.path ? slice[part.path] : slice).filter(row => row.id !== part.id);
-	if (part.row) rows.splice(Math.min(part.index, rows.length), 0, part.row);
+	const all = part.path ? slice[part.path] : slice, at = all.findIndex(row => row.id === part.id), rows = all.filter(row => row.id !== part.id);
+	// A layer goes back into the row as it is now; a row removed since comes back whole; a layer never removes a row.
+	if ('fields' in part && at >= 0) rows.splice(at, 0, { ...all[at], ...part.fields });
+	else if (part.row) rows.splice(Math.min(part.index, rows.length), 0, part.row);
+	else if ('fields' in part) return slice;
 	return part.path ? { ...slice, [part.path]: rows } : rows;
 }
 
-/** snapshotTarget(key) and restoreTargets([{ key, value }]) over the app's store domains (ports.storeDomain, ports.beginAction). */
+/** snapshotTarget(key), restoreTargets([{ key, value }]) and readLayer(key) over the app's store domains (ports.storeDomain, ports.beginAction). */
 export function taskTargetPorts(ports) {
 	const store = domain => ports.storeDomain?.(domain)?.documentStore;
 	const rowParts = (kind, id, read) => ROWS[kind].filter(([domain]) => store(domain)).map(([domain, path]) => {
@@ -23,17 +40,26 @@ export function taskTargetPorts(ports) {
 		const index = read ? rows.findIndex(row => row.id === id) : -1;
 		return { domain, path, id, index, row: index < 0 ? undefined : rows[index] };
 	});
+	// A layer's parts: its fields of each row that has some, beside the whole row (to put back a row removed since).
+	const layerParts = ({ id, layer }) => rowParts('character', id, true).flatMap(part => {
+		const row = part.row ?? EMPTY[part.domain], fields = row ? fieldsOf(part.domain, layer, row) : [];
+		return fields.length ? [{ ...part, fields: pick(row, fields) }] : [];
+	});
+	const snapshotTarget = key => {
+		const [kind, id] = split(key), of = layerOf(key);
+		if (of?.layer) return layerParts(of);
+		if (WHOLE[kind]) return WHOLE[kind].filter(store).map(domain => ({ domain, whole: store(domain).read(domain) }));
+		return ROWS[kind] ? rowParts(kind, id, true) : null;
+	};
 	return {
-		snapshotTarget(key) {
-			const [kind, id] = split(key);
-			if (WHOLE[kind]) return WHOLE[kind].filter(store).map(domain => ({ domain, whole: store(domain).read(domain) }));
-			return ROWS[kind] ? rowParts(kind, id, true) : null;
-		},
+		snapshotTarget,
+		/** A layer's token: its own fields only, so an edit of another layer of the same character leaves it as it was. */
+		readLayer: key => JSON.stringify(snapshotTarget(key).map(part => part.fields)),
 		restoreTargets(values) {
 			const parts = values.flatMap(({ key, value }) => {
 				if (value === null) throw new StudioProtocolError('CAPABILITY_MISSING', `${key} cannot be restored: a document change has no undo.`);
 				const [kind, id] = split(key);
-				return value ?? rowParts(kind, id, false);
+				return value ?? rowParts(kind, layerOf(key)?.id ?? id, false);
 			});
 			const domains = [...new Set(parts.map(part => part.domain))];
 			if (!domains.length) return { historyEntryId: null };

package/src/bus-tasks.js

@@ -8,7 +8,7 @@
 // next command on a target the user changed answers STALE_TARGET once. Ctrl+Z stops at a running task's entry.
 // A single agent turn (agent.turn.*) is untouched: tasks and a turn never run together.
 import { StudioProtocolError, validateReceipt } from './studio-agent-protocol.js';
-import { commandKeys, keyOfId, scopeConflict, isScopeKey } from './bus-task-scopes.js';
+import { commandKeys, keyOfId, scopeConflict, isScopeKey, layerOf, expandScope, keysOverlap } from './bus-task-scopes.js';
 
 const fail = (code, message) => { throw new StudioProtocolError(code, message); };
 const VERBS = ['begin', 'requestScope', 'mark', 'rollback', 'finish', 'cancel', 'undo'];
@@ -17,7 +17,11 @@ const listOf = keys => [...keys].slice(0, 6).join(', ') + (keys.length > 6 ? ` a
 
 export function createBusTasks({ ports, emit }) {
 	const open = new Map(), finished = new Map(), entryTask = new Map();
+	// A character layer has its own token (its fields only), so another task's edit of her other layers never makes it
+	// stale; an editor without layer reads falls back to the whole character's.
 	const tokenOf = key => {
+		const of = layerOf(key);
+		if (of?.layer) return ports.readLayer?.(key) ?? ports.readTarget?.(of.id) ?? 'absent';
 		const [kind, id] = key.split(/:(.*)/s);
 		if (id !== undefined) return ports.readTarget?.(id) ?? 'absent';
 		const state = ports.read();
@@ -32,14 +36,16 @@ export function createBusTasks({ ports, emit }) {
 		if (!ports.restoreTargets) fail('CAPABILITY_MISSING', 'This editor cannot restore task targets.');
 		const { historyEntryId = null } = ports.restoreTargets(values) ?? {};
 		if (historyEntryId) entryTask.set(historyEntryId, task.taskId);
-		task.restored = [...new Set(values.map(({ key }) => key.includes(':') ? key.slice(key.indexOf(':') + 1) : ports.read().host.sceneId))];
+		task.restored = [...new Set(values.map(({ key }) => layerOf(key)?.id ?? (key.includes(':') ? key.slice(key.indexOf(':') + 1) : ports.read().host.sceneId)))];
 		for (const { key } of values) task.tokens.set(key, tokenOf(key));
 		emit?.({ type: `task.${action}`, taskId: task.taskId, keys: values.map(v => v.key) });
 		return historyEntryId;
 	}
-	function grant(task, keys) {
-		const bad = keys.find(key => !isScopeKey(key));
-		if (bad !== undefined) fail('INVALID_ARGUMENT', `"${bad}" is not a scope key: object:<id>, character:<id>, shot:<id>, stage, timeline or scene.`);
+	// A plain character:<id> is held as its four layers: the commands name layers, and each layer keeps its own token.
+	function grant(task, scope) {
+		const bad = scope.find(key => !isScopeKey(key));
+		if (bad !== undefined) fail('INVALID_ARGUMENT', `"${bad}" is not a scope key: object:<id>, character:<id> (or one layer: character:<id>:placement, :take, :ik, :props), shot:<id>, stage, timeline or scene.`);
+		const keys = expandScope(scope);
 		const conflict = scopeConflict(task.taskId, keys, open);
 		if (conflict) fail('SCOPE_BUSY', `${conflict}; wait for it, or ask for what is free.`);
 		for (const key of keys) if (!task.keys.has(key)) { task.keys.add(key); task.tokens.set(key, tokenOf(key)); }
@@ -121,7 +127,7 @@ export function createBusTasks({ ports, emit }) {
 			if (!task && !open.size) return null;
 			const keys = entry?.id ? commandKeys(entry.id, args, before, entry) : [];
 			// The user's own edit is never refused; a running task whose scope it touches hears of it (the panel's card).
-			if (!task && request.origin === 'ui') { for (const other of open.values()) { const mine = keys.filter(key => other.keys.has(key)); if (mine.length) emit?.({ type: 'task.userEdit', taskId: other.taskId, keys: mine }); } return null; }
+			if (!task && request.origin === 'ui') { for (const other of open.values()) { const mine = keys.filter(key => [...other.keys].some(held => keysOverlap(key, held))); if (mine.length) emit?.({ type: 'task.userEdit', taskId: other.taskId, keys: mine }); } return null; }
 			if (!task) {
 				const held = keys.find(key => scopeConflict(null, [key], open));
 				if (held) fail('SCOPE_BUSY', `${scopeConflict(null, [held], open)}; this command waits for that task.`);
@@ -135,18 +141,25 @@ export function createBusTasks({ ports, emit }) {
 				fail('STALE_TARGET', `${listOf(moved)} changed outside this task (the user, or an undo) since it last looked; read it again, then retry.`);
 			}
 			for (const key of keys) if (!task.pre.has(key)) task.pre.set(key, snapshot(key));
-			return { task, keys, values: keys.map(snapshot), mark: task.mark };
+			return { task, keys, values: keys.map(snapshot), mark: task.mark, fence: new Map(keys.map(key => [key, tokenOf(key)])) };
 		},
+		/**
+		 * A task's job fences on its own keys, not the whole target: another task placing the character while this one
+		 * compiles her take is not a change under the compile. moved(point) names what changed since admit or rebase(point).
+		 */
+		moved: point => [...point.fence].filter(([key, token]) => tokenOf(key) !== token).map(([key]) => key),
+		rebase(point) { for (const key of point.fence.keys()) point.fence.set(key, tokenOf(key)); },
 		/** Files a task's receipt: ids it created join its scope, it may be undone newest first, readers hear of it. */
 		record(point, recorded) {
 			if (!point || !recorded?.ok) return recorded;
 			const { task } = point, state = ports.read(), warnings = [];
 			let grew = false;
+			// A character the task holds one layer of is its own: the command was admitted on that layer.
 			for (const id of recorded.affectedIds ?? []) {
 				const key = keyOfId(id, state);
-				if (!key || task.keys.has(key)) continue;
-				if (scopeConflict(task.taskId, [key], open)) warnings.push({ code: 'SCOPE_DENIED', message: `${key} changed outside the task's scope.` });
-				else { task.keys.add(key); grew = true; if (!point.keys.includes(key)) { task.pre.set(key, { key, value: undefined }); point.values.push({ key, value: undefined }); } }
+				if (!key || [...task.keys].some(held => keysOverlap(key, held))) continue;
+				if (scopeConflict(task.taskId, [key], open)) { warnings.push({ code: 'SCOPE_DENIED', message: `${key} changed outside the task's scope.` }); continue; }
+				for (const made of expandScope([key])) { task.keys.add(made); grew = true; if (!point.keys.includes(made)) { task.pre.set(made, { key: made, value: undefined }); point.values.push({ key: made, value: undefined }); } }
 			}
 			if (grew) emit?.({ type: 'task.scope', taskId: task.taskId, scope: [...task.keys] });
 			for (const key of task.keys) task.tokens.set(key, tokenOf(key));

package/src/character-kind.js

@@ -3,7 +3,7 @@
 // (PROXY_FIGURE_MODEL) is a placement-only stand-in with no bones at all, so
 // those tools refuse it by name instead of failing on a missing rig.
 import { isProxyFigure } from "./scenes.js";
-import { isKo } from "./locale.js";
+import { isKo, isZh } from "./locale.js";
 import { StudioProtocolError } from "./studio-agent-protocol.js";
 
 export const CHARACTER_CAPABILITIES = Object.freeze(["rig", "ik", "pose", "motion"]);
@@ -45,29 +45,30 @@ export function characterCapabilities(character) {
 
 // The noun each refusal names. A feature id not listed here is used verbatim.
 const FEATURE_LABELS = {
-	rig: ["the rig", "리그"],
-	ik: ["IK", "IK"],
-	pose: ["Pose mode", "포즈 모드"],
-	motion: ["Compiled motion", "모션 컴파일"],
-	take: ["Loading a take", "테이크 불러오기"],
+	rig: ["the rig", "리그", "骨骼"],
+	ik: ["IK", "IK", "IK"],
+	pose: ["Pose mode", "포즈 모드", "姿势模式"],
+	motion: ["Compiled motion", "모션 컴파일", "编译动作"],
+	take: ["Loading a take", "테이크 불러오기", "加载动作片段"],
 };
 
 // A character's kind (rig or capsule figure) is fixed at creation; character.update refuses a kind change.
 export const KIND_FIXED_REFUSAL = Object.freeze({
 	en: "A character's kind is chosen when it is created; add a new character instead.",
 	ko: "캐릭터 종류는 만들 때 정합니다. 새 캐릭터를 추가하세요.",
+	zh: "角色的类型在创建时确定；请改为添加新角色。",
 });
 
-export function kindRefusal(feature, ko = false) {
-	const label = FEATURE_LABELS[feature]?.[ko ? 1 : 0] ?? feature;
-	return ko
-		? `캡슐 인물은 리그가 없어요 - ${label}는 리그 캐릭터에서만 됩니다.`
-		: `Capsule figures have no rig - ${label} works on rigged characters only.`;
+export function kindRefusal(feature, ko = false, zh = false) {
+	const label = FEATURE_LABELS[feature]?.[ko ? 1 : zh ? 2 : 0] ?? feature;
+	if (ko) return `캡슐 인물은 리그가 없어요 - ${label}는 리그 캐릭터에서만 됩니다.`;
+	if (zh) return `胶囊人物没有骨骼 — ${label}仅适用于带骨骼的角色。`;
+	return `Capsule figures have no rig - ${label} works on rigged characters only.`;
 }
 
 /** Throw TARGET_NOT_READY when `character` is a capsule figure. The protocol
  * message is English (the agent reads it); `uiMessage` is the locale's. */
 export function refuseRigOnly(character, feature) {
 	if (!isProxyFigure(character)) return;
-	throw Object.assign(new StudioProtocolError("TARGET_NOT_READY", kindRefusal(feature, false)), { uiMessage: kindRefusal(feature, isKo) });
+	throw Object.assign(new StudioProtocolError("TARGET_NOT_READY", kindRefusal(feature, false)), { uiMessage: kindRefusal(feature, isKo, isZh) });
 }

package/src/command-bus.js

@@ -173,12 +173,13 @@ export function createCommandBus({ registry, ports }) {
       affectedIds: [...tx.affectedIds], delta: [], checks: { coverage: 'wire-transaction' }, warnings: toastWarnings(tx.toasts),
       undo: tx.historyEntryId ? { historyEntryId: tx.historyEntryId, entries: 1, canUndoDirect: true } : null });
   }
+  // a refusal may list every problem of the request at once (a motion spec: up to 12 lines), so it keeps 2000 characters
   function refusal(request, before, error, mutated) {
     const changed = mutated ?? (ports.read().revision !== before.revision);
     return validateReceipt({ ok: false, commandId: request.commandId, host: before.host,
       code: refusalCode(error), phase: changed ? 'commit' : 'admission', affectedIds: [], expectedTargets: [], currentTargets: [],
       mutated: changed, preserved: { authoredState: changed ? 'changed' : 'unchanged' }, recovery: { action: 'inspect', retryAllowed: false },
-      message: [...String(error.message || error)].slice(0, 500).join('') });
+      message: [...String(error.message || error)].slice(0, 2000).join('') });
   }
   /** Findings first, toasts after; past the schema's twelve, say how many were left out. */
   const receiptWarnings = (findings = [], toasts = [], omitted = 0, limit = 12) => {
@@ -283,17 +284,19 @@ export function createCommandBus({ registry, ports }) {
       const rebase = () => {
         const current = ports.read();
         token = targetId ? ports.readTarget?.(targetId) : null;
-        domainRevision = domain ? current.domainRevisions?.[domain] : null;
+        domainRevision = domain ? current.domainRevisions?.[domain] : null; if (scoped?.keys.length) tasks.rebase(scoped);
       };
       const nestedIds = new Set();
-      const context = { origin: request.origin, signal: controller.signal, taskId: request.taskId ?? null,
+      // callId: the agent's tool call (a script's nested commands share it), for motion.compile's stop rule (repair-watch.js)
+      const context = { origin: request.origin, signal: controller.signal, taskId: request.taskId ?? null, turnId: request.turnId ?? null, callId: typeof request.callId === 'string' ? request.callId : null,
         check() {
           controller.signal.throwIfAborted();
           const current = ports.read();
           // Name the fence that tripped: the three share one code, and a bare "something changed" leaves the user and the agent guessing.
           if (!same(current.host, before.host)) fail('STALE_TARGET', 'The open document or scene changed while the job was running.');
           if (domain && !task && current.domainRevisions?.[domain] !== domainRevision) fail('STALE_TARGET', `The ${domain} data changed while the job was running (revision ${domainRevision} to ${current.domainRevisions?.[domain]}); an edit landed between the request and its result.`);
-          if (targetId && ports.readTarget?.(targetId) !== token) fail('STALE_TARGET', `${targetId} changed while the job was running.`);
+          // Inside a task the fence is the task's own keys (bus-tasks.js moved): another task's layer of the target is not a change under it.
+          const moved = scoped?.keys.length ? tasks.moved(scoped) : targetId && ports.readTarget?.(targetId) !== token ? [targetId] : []; if (moved.length) fail('STALE_TARGET', `${moved.join(', ')} changed while the job was running.`);
         },
         commit(apply) {
           context.check();

package/src/commands/ai.js

@@ -26,6 +26,6 @@ export function register(registry, ports) {
 			const shot = result.shot && { id: result.shot.id, name: result.shot.name, range: { startFrame: result.shot.startFrame, endFrameExclusive: result.shot.endFrame + 1 } };
 			const referenceFrames = (result.frame ? 1 : 0) + (result.frameB ? 1 : 0);
 			return { affectedIds: [], output: { prompt: result.prompt, mode: result.mode, modelLabel: result.modelLabel ?? null, shot, aspectRatio: result.aspectRatio, cameraMode: result.camera?.mode ?? null, referenceFrames },
-				summary: `Prepared the ${result.mode} prompt${result.modelLabel ? ` for ${result.modelLabel}` : ""} for ${shot ? `${shot.name} [${shot.range.startFrame}, ${shot.range.endFrameExclusive})` : "the current camera"}; the Studio's result panel shows it with ${referenceFrames} reference frame${referenceFrames === 1 ? "" : "s"} for the user to copy and download.` };
+				summary: `Prepared the ${result.mode} prompt${result.modelLabel ? ` for ${result.modelLabel}` : ""} for ${shot ? `${shot.name} [${shot.range.startFrame}, ${shot.range.endFrameExclusive})` : "the current camera"}; the Studio's result panel shows it with ${referenceFrames} reference frame${referenceFrames === 1 ? "" : "s"} for the user to copy and export.` };
 		} });
 }

package/src/commands/export.js

@@ -15,6 +15,6 @@ export function register(registry, ports) {
 			const result = await ports.exportShotVideo({ shotId: shotId ?? null, ...(scope ? { scope } : {}) }, context);
 			if (!result?.fileName) fail("TARGET_NOT_READY", "The video export did not finish; the editor's export panel shows why and offers Retry.");
 			return { affectedIds: shot ? [shot.id] : [], output: { fileName: result.fileName, frameCount: result.frameCount },
-				summary: `Recorded ${scope === "timeline" ? "the whole timeline" : shot ? shotLabel(shot) : "the shot"} to ${result.fileName} (${result.frameCount} frames); the browser was asked to download it.` };
+				summary: `Recorded ${scope === "timeline" ? "the whole timeline" : shot ? shotLabel(shot) : "the shot"} to ${result.fileName} (${result.frameCount} frames); it was handed to the configured export folder or the browser download.` };
 		} });
 }

package/src/commands/motion3.js

@@ -22,6 +22,7 @@ import { qaSay } from "../qa-label.js";
 import { carryEdit } from "../motion3/edit-carry.js";
 import { normalizeCompileArgs } from "../motion3/lenient.js";
 import { createCompileRunner } from "./motion3-compile.js";
+import { createRepairWatch } from "../motion3/repair-watch.js";
 import { peopleOf } from "../motion3/people.js";
 
 const TIMELINE_FPS = 24;
@@ -84,6 +85,8 @@ function asArgument(run) {
 
 export function register(registry, ports) {
 	const store = createSpecStore();
+	// the stop rule: output.stuck when more compiles stopped paying (repair-watch.js)
+	const watch = createRepairWatch();
 	const owner = () => ports.storeDomain("motion");
 	const mounted = () => Boolean(ports.storeDomain?.("motion")) || "The motion owner is not mounted.";
 	const always = () => true;
@@ -105,10 +108,21 @@ export function register(registry, ports) {
 	 * spec on the character's rig and the current scene (compile-job.js) -> { stored (the spec a take keeps and its specId
 	 * names), qa, ..., take when bake is given }, at once or as a promise. opts: probes, checks, lenient, repair.
 	 */
-	const compile = (character, spec, opts = {}, bake, taskId = null) => {
+	const compile = (character, spec, opts = {}, bake, taskId = null, scene = sceneFor(character)) => {
 		rigOf(character);
 		const placed = bake && { position: [character.x ?? 0, character.y ?? 0, character.z ?? 0], yaw: character.rot ?? 0, ...bake };
-		return runner.run({ model: character.model, scene: sceneFor(character), spec, ...opts, ...(placed ? { bake: placed } : {}) }, { taskId, characterId: character.id });
+		return runner.run({ model: character.model, scene, spec, ...opts, ...(placed ? { bake: placed } : {}) }, { taskId, characterId: character.id });
+	};
+	// where a take was baked: the body's place and a hash of the scene's bodies (a take kept for the stop rule fits only
+	// there): 0.14 ms for 860 bodies, where their JSON took 0.9 ms and 295 KB a key
+	const placeKey = (character, scene) => {
+		let h = 2166136261;
+		const mix = v => { h = Math.imul(h ^ Math.round(v * 1e4), 16777619); };
+		for (const [id, o] of Object.entries(scene.objects ?? {})) {
+			for (let i = 0; i < id.length; i++) mix(id.charCodeAt(i) / 1e4);
+			for (const list of [o.pos, o.half, ...o.R]) for (let i = 0; i < list.length; i++) mix(list[i]);
+		}
+		return `${character.model} ${[character.x ?? 0, character.y ?? 0, character.z ?? 0, character.rot ?? 0].join(" ")} ${(h >>> 0).toString(36)}`;
 	};
 	/** The whole output, kept in the store (motion.report, delta) and cut to the receipt budget (report.js). */
 	const report = (r, head, extra = {}) => {
@@ -144,8 +158,9 @@ export function register(registry, ports) {
 		// a base the store forgot (a reload) may still be the installed take's spec: a document read names it by specId
 		const installedSpec = () => { const take = owner().motionFor(characterId); return take?.spec && specIdOf(take.spec) === base ? structuredClone(take.spec) : null; };
 		const patched = [], source = spec ?? asArgument(() => applyPatch(store.get(base) ?? installedSpec() ?? unknownSpec("base", base), patch ?? [], patched));
+		const scene = sceneFor(character), at = placeKey(character, scene);
 		// the take is always baked: the user watches every draft, installed or not
-		return after(compile(character, source, { probes, repair }, {}, context?.taskId), r => {
+		return after(compile(character, source, { probes, repair }, {}, context?.taskId, scene), r => {
 			const { qa, take } = r, notes = [...patched, ...(r.notes ?? [])];
 			// ifClean: install only a clean final result (qa.ok includes the goals; after repair when asked)
 			const wanted = install === "ifClean" ? qa.ok : install;
@@ -158,11 +173,16 @@ export function register(registry, ports) {
 				if (installs) timing = put(character, take, context);
 			}
 			const delta = base === undefined ? {} : { delta: deltaOf(store.parts(base)?.groups ?? [], qa.groups, base) };
-			const how = kept ? "; already installed, unchanged" : install === "ifClean" ? (installs ? "; installed" : "; not installed") : "";
-			const output = report(r, { frames: r.frameCount, fps: TIMELINE_FPS, installed: wanted, ...adjustedOf(notes) }, { ...delta, ...(r.repair ? { repair: r.repair } : {}), ...(timing ? { timing } : {}) });
+			// the stop rule (repair-watch.js): a note, and the best take so far put on when the note would leave the take empty or worse
+			const own = specIdOf(r.stored), carried = owner().motionFor(characterId)?.spec, current = carried ? specIdOf(carried) : null;
+			const { say: stuck, install: best } = watch.note({ characterId, turnId: context?.turnId, callId: context?.callId, specId: own, base, qa, at, take, installed: Boolean(installs || kept), current });
+			if (best) timing = put(character, best.take, context) ?? timing;
+			const self = best?.specId === own, how = kept ? "; already installed, unchanged" : self ? "; installed as the best take so far"
+				: best ? `; not installed; the best take so far, ${best.specId}, installed` : install === "ifClean" ? (installs ? "; installed" : "; not installed") : "";
+			const output = report(r, { frames: r.frameCount, fps: TIMELINE_FPS, installed: Boolean(wanted) || self, ...(stuck ? { stuck } : {}), ...adjustedOf(notes) }, { ...delta, ...(r.repair ? { repair: r.repair } : {}), ...(timing ? { timing } : {}) });
 			// agent-progress.js: viewport ghost, timeline beats, agent panel
-			publishDraft(characterId, { take, installed: installs || kept, specId: output.specId, label: r.label, qa, timeline: r.timeline });
-			return { affectedIds: installs ? [characterId] : [], summary: `Compiled ${r.frameCount} frames; QA ${qaSay(qa)}${how}${adjustedSay(notes)}.`, output, ...workerWarning() };
+			publishDraft(characterId, { take, installed: installs || kept || self, specId: output.specId, label: r.label, qa, timeline: r.timeline });
+			return { affectedIds: installs || best ? [characterId] : [], summary: `Compiled ${r.frameCount} frames; QA ${qaSay(qa)}${how}${adjustedSay(notes)}.`, output, ...workerWarning() };
 		});
 	} });
 	registry.register({ ...declarations[1], available: mounted, run({ characterId, checks }) {

package/src/commands/project.js

@@ -10,7 +10,8 @@ const rename = { id: "project.rename", label: "Rename project", description: "Re
 const save = { ...studioActionDeclaration("project.save"), input: input({ name }) };
 const saveAs = { ...save, id: "project.saveAs", label: "Save project as" };
 const exportAsAnimation = studioActionDeclaration("project.exportAsAnimation");
-const opening = document("project.open", "Open a project file", { serialized: { type: "string", maxLength: 400_000_000 }, handleToken: token, projectToken: token });
+// The deadline covers the user in the file picker, so it is the hub's ceiling, not the 30 s default.
+const opening = { ...document("project.open", "Open a project file", { serialized: { type: "string", maxLength: 400_000_000 }, handleToken: token, projectToken: token }), timeoutMs: 300_000 };
 const fresh = document("project.new", "Start a new project", { name, previsMode: { type: "string", enum: [...PREVIS_MODES] } });
 const starter = document("project.openStarter", "Open a starter project", { id: token, source: { type: "string", enum: ["starter", "launch"] }, name });
 const restore = { ...document("project.restore", "Restore the remembered project", { handleToken: token }), exposure: "ui-only" };

package/src/commands/shot.js

@@ -68,7 +68,7 @@ export function register(registry, ports) {
     const next = reflowStillShots(shots), frameCount = stillFrameCount(next);
     if (frameCount > STILL_FRAME_COUNT_MAX) {
       const en = `Storyboard is full (${STILL_FRAME_COUNT_MAX} frames); shorten a hold or remove a panel.`;
-      throw studioActionRefusal('INVALID_ARGUMENT', en, ko(en, `스토리보드가 가득 찼습니다 (${STILL_FRAME_COUNT_MAX}프레임). 홀드를 줄이거나 패널을 지우세요.`));
+      throw studioActionRefusal('INVALID_ARGUMENT', en, ko(en, `스토리보드가 가득 찼습니다 (${STILL_FRAME_COUNT_MAX}프레임). 홀드를 줄이거나 패널을 지우세요.`, `故事板已满（${STILL_FRAME_COUNT_MAX} 帧）；请缩短停留时长或删除一个面板。`));
     }
     const clip = next.find(shot => shot.kind !== 'still' && next.some(still => still.kind === 'still' && still.startFrame <= shot.endFrame && still.endFrame >= shot.startFrame));
     if (clip) fail('TARGET_NOT_READY', `The stills would overlap the clip shot ${clip.name} (frames ${clip.startFrame}-${clip.endFrame}); move or remove it first.`);

package/src/commands/view.js

@@ -14,7 +14,7 @@ const operations = Object.entries({ ...groups, 'view.update': Object.keys(fields
 }));
 export const declarations = Object.freeze([...operations, ...["view.setPartColours", "view.setGuideMode", "view.setInset", "view.setGhosts"].map(studioActionDeclaration)]);
 // A storyboard project has no Motion department; every door says so the same way.
-export const STORYBOARD_MOTION_REFUSAL = Object.freeze({ en: 'Motion tools are not part of a Storyboard project.', ko: '모션 도구는 스토리보드 프로젝트에 없어요.' });
+export const STORYBOARD_MOTION_REFUSAL = Object.freeze({ en: 'Motion tools are not part of a Storyboard project.', ko: '모션 도구는 스토리보드 프로젝트에 없어요.', zh: '故事板项目不包含动作工具。' });
 export const viewCommand = args => Object.entries(groups).find(([, keys]) => Object.keys(args).every(key => keys.includes(key)))?.[0] ?? 'view.update';
 
 export function register(registry, ports) {
@@ -24,7 +24,7 @@ export function register(registry, ports) {
 		const state = ports.readView();
 		// Pose mode is IK editing: without a rig to solve there is nothing to pose.
 		if (args.mode === 'pose' && args.mode !== state.view.mode && !ports.canPose()) fail('TARGET_NOT_READY', 'Pose mode needs a loaded character rig to edit with IK.');
-		if (args.mode === 'motion' && state.previsMode === 'storyboard') throw studioActionRefusal('TARGET_NOT_READY', STORYBOARD_MOTION_REFUSAL.en, ko(STORYBOARD_MOTION_REFUSAL.en, STORYBOARD_MOTION_REFUSAL.ko));
+		if (args.mode === 'motion' && state.previsMode === 'storyboard') throw studioActionRefusal('TARGET_NOT_READY', STORYBOARD_MOTION_REFUSAL.en, ko(STORYBOARD_MOTION_REFUSAL.en, STORYBOARD_MOTION_REFUSAL.ko, STORYBOARD_MOTION_REFUSAL.zh));
 		const selection = args.selection === undefined ? state.selection : args.selection;
 		if (selection) {
 			const found = selection.kind === 'scene' ? selection.id === state.host.sceneId : selection.kind === 'camera' ? selection.id === 'camera'