cozyclay 3.1.0 → 3.1.2

package/dist/cozyclay-package.json

@@ -1 +1 @@
-{"payload":"{\"distribution\":\"npm\",\"package\":\"cozyclay\",\"version\":\"3.1.0\",\"repository\":\"NomaDamas/CozyClay\",\"content_sha256\":\"a82f58c8669edb7800fcdb79939b1cfc242616a17675fdf278927d7f4f5d016e\"}","signature":"EmIwI46B/uZyNSY0QYgaR43ElVC4MFt2ROKPMaDioTSwJytnF2kwqj3qWkaJIPvqeVR4sN5qglBO6Ya+mOprCQ=="}
+{"payload":"{\"distribution\":\"npm\",\"package\":\"cozyclay\",\"version\":\"3.1.2\",\"repository\":\"NomaDamas/CozyClay\",\"content_sha256\":\"4d8d2ca94381f4bdb9a2983a6c3f0378ea513c73e1408c6c18baef2b2db6fc05\"}","signature":"bb1tql+IuEnYxCIbq+Xh/MJa3bL9WYcnI3Bw7STxCTwRoi7NB/L2VNd0/jR1d3qVEK4E3MGLA5GavrN5E+/7DA=="}

package/dist/index.html

@@ -394,7 +394,7 @@
         <div class="wrap start">
           <div class="start-head">
             <h2>Quick start</h2>
-            <p>Node.js 22.13+ and a Chromium browser.</p>
+            <p>Node.js 22.19+ and a Chromium browser.</p>
             <a href="#controls" id="controls-link">Full control list</a>
           </div>
           <div class="start-body">

package/dist/sitemap.xml

@@ -2,7 +2,7 @@
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
     <loc>https://cozyclay.org/</loc>
-    <lastmod>2026-10-21</lastmod>
+    <lastmod>2026-10-23</lastmod>
   </url>
   <url>
     <loc>https://cozyclay.org/greybox-to-video/</loc>

package/dist/workflow/index.html

@@ -8,13 +8,13 @@
     <meta name="theme-color" content="#101116" />
     <meta name="description" content="CozyClay visual workflow builder" />
     <title>CozyClay Workflow</title>
-    <script type="module" crossorigin src="/assets/workflow-B8Dhzexj.js"></script>
+    <script type="module" crossorigin src="/assets/workflow-C87p6E1E.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
     <link rel="modulepreload" crossorigin href="/assets/modulepreload-polyfill-P2Xu9kJm.js">
-    <link rel="modulepreload" crossorigin href="/assets/task-board-BKaM7d-9.js">
+    <link rel="modulepreload" crossorigin href="/assets/task-board-BqReHzOi.js">
     <link rel="modulepreload" crossorigin href="/assets/fflate.module-KbGj5-H6.js">
-    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-CQzEdsqu.js">
-    <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-COGOlF5T.css">
+    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-qoxcdrhj.js">
+    <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-BEjjhNEo.css">
     <link rel="stylesheet" crossorigin href="/assets/workflow-DRdwoDBT.css">
   </head>
   <body>

package/mcp/README.md

@@ -35,7 +35,7 @@ Then point a client at it. For Claude Desktop, in `claude_desktop_config.json`:
 }
 ```
 
-Restart the client; 28 tools appear.
+Restart the client; 27 tools appear.
 
 Prefer a long-lived endpoint? `node server.mjs --http 5183` serves Streamable HTTP at
 `http://127.0.0.1:5183/mcp` (one isolated session per client), with a plain status page at `/`.

package/mcp/live-hub.mjs

@@ -436,10 +436,12 @@ export class LiveHub {
 				void this.serveController(socket, frame);
 				return;
 			}
-			if (frame?.type === "event" && typeof frame.name === "string" && frame.payload && typeof frame.payload === "object") {
-				const workspaceHandle = [...this.editors.entries()].find(([, editor]) => editor === socket)?.[0];
+			// Meta and event frames both act for this socket's workspace. A meta frame
+			// relabels the tab after it opens another project; the handle stays.
+			const workspaceHandle = [...this.editors.entries()].find(([, editor]) => editor === socket)?.[0];
+			if (frame?.type === "meta" && workspaceHandle && frame.meta && typeof frame.meta === "object") this.workspaceMeta.set(workspaceHandle, frame.meta);
+			else if (frame?.type === "event" && typeof frame.name === "string" && frame.payload && typeof frame.payload === "object") {
 				if (workspaceHandle) this.onEvent?.({ workspaceHandle, workspaceId: this.workspaceId(workspaceHandle), name: frame.name, payload: frame.payload });
-				return;
 			}
 			if (frame?.type !== "result" || typeof frame.id !== "string") return;
 			const pending = this.pending.get(frame.id);

package/mcp/tool-handlers.mjs

@@ -71,6 +71,7 @@ import {
 import { classifyMove, captureFraming, moveSlate } from "../src/camera-move.js";
 import { DEFAULT_PREVIS_MODE, PREVIS_MODES, createProjectDocument, readProjectDocument } from "../src/project.js";
 import { kindRefusal } from "../src/character-kind.js";
+import { documentWithCamera, splitSavedCamera } from "./project-camera.mjs";
 
 /** The authoring state. One scene document, one camera, one project name. */
 export const state = {
@@ -1155,10 +1156,10 @@ export const createToolHandlers = ({ projectRootPromise } = {}) => {
 				title: "Sculpt a clay prop from a recipe of soft parts",
 				description:
 					"Unlike place_object, import_mesh and compare_sculpt, sculpt_object builds or changes a clay prop from a recipe of parts you write, typically after reading a reference image. It needs no file and no catalogue entry. " +
-					"recipe = { version: 1, parts: [{ id, shape, size: [x, y, z], position?, rotation?, color?, parent?, mirror?, roundness?, taper?, border? }] }. " +
+					"recipe = { version: 1, parts: [{ id, shape, size: [x, y, z], position?, rotation?, color?, parent?, mirror?, ...shape fields, material?, finish?, detail?, gradient?, op? }] }. " +
 					"Units are metres and degrees. The floor is y = 0, front is +z, and the subject's own left is +x. size is the full extent; position is the part's centre, in its parent part's frame when parent is set. " +
 					"shape: blob (soft superellipsoid: roundness 0 is an ellipsoid, 1 is a rounded box; taper narrows the top when positive and the bottom when negative), box (roundness bevels the edges), " +
-					"cylinder (taper 1 is a cone), torus (size [outer, outer, tube]), frame (a rectangular ring in x/y with a border width, for glasses rims, windows and picture frames). " +
+					"cylinder (taper 1 is a cone), torus (size [outer, outer, tube]), frame (a rectangular ring in x/y with a border width, for glasses rims, windows and picture frames), " + "lathe { profile: [[r 0..1 of half-width, y 0..1 of height], ...] bottom to top, smooth? } for turned objects (pot, vase, bottle, bowl, lampshade, mushroom), " + "tube { path: [[x, y, z] each -0.5..0.5 of size], thickness (m, diameter), taper?, closed? } for ropes, vines, cables, handles, branches and bike frames, " + "extrude { outline: [[x, y] -0.5..0.5 of size], holes?, roundness? } for flat cut shapes pushed through size z (sign, leaf, gable, gear, star), " + "loft { sections: [{ y 0..1, points: [[x, z]...] } or { y, w, d, x?, z?, roundness? }] bottom to top (first y 0, last y 1), smooth? } for cross-sections that change (hull, car body, shoe, loaf; lay it down with rotation [-90,0,0]), " + "convex { points: [[x, y, z]...] or seed + facetCount?, facets? } for rocks, boulders, gems and crystals, " + "scatter { item: blade|tuft|flower|leaf|pebble|twig, count <= 4000, spread: ground|shell, seed? } for thousands of small items as ONE part (grass, flower beds, gravel; shell covers a crown or bush it is parented to; 12000 items per recipe). " + "Any part also takes material clay|wood|straw|stone|brick|concrete|metal|glass|ceramic|plastic|rubber|fabric|paper|foliage (real texture and shine; color tints it; never fake glass with opacity or thatch with stripes) and finish matte|satin|gloss; detail { amount 0..1, scale?, seed? } for a lumpy surface (clouds, bushes, rocks, hay, bread), gradient { color, axis? y|x|z, from?, to? } to blend into a second colour (sky-lit clouds, fruit, sunset walls), " + "and op: subtract|intersect, which makes the part an undrawn cutter of its parent (windows, doors, arches; hollow a lathe with a smaller lathe of the same profile; cut deeper than the wall; mirror cuts both sides). " +
 					"mirror: true adds a copy reflected across x = 0 of the parent frame, with its children; author the subject's left (+x) side once. color is #rrggbb. At most 48 parts after mirrors. " +
 					"To fix a sculpt, pass its id with edits instead of a whole recipe: [{ set: partId, ...fields }, { add: part }, { remove: partId }] (parent: null and mirror: false clear; remove takes the part's children). " +
 					"capture: true also returns the editor's frame (connected editor only), so one call is one round. " +
@@ -1697,7 +1698,7 @@ export const createToolHandlers = ({ projectRootPromise } = {}) => {
 				// the current stage shape rather than trusted as-is.
 				const scenes = readSceneDocument(serializeSceneDocument(result.project.scenesDocument));
 				if (!scenes.document) return text(`That project was written by a newer CozyClay: ${full}`);
-				const nextDocument = scenes.document;
+				const { document: nextDocument, camera: savedCamera } = splitSavedCamera(scenes.document);
 				if (liveHub?.connected) {
 					try {
 						const loaded = await executeStudioCommand({ ...admission, action: "load_scenes", args: { document: nextDocument } });
@@ -1713,11 +1714,10 @@ export const createToolHandlers = ({ projectRootPromise } = {}) => {
 					}
 				}
 				state.doc = nextDocument;
+				Object.assign(state.camera, savedCamera);
 				state.previsMode = result.project.previsMode ?? DEFAULT_PREVIS_MODE;
 				state.name = result.project.name;
-				state.focus = null;
-				state.focusLocked = false;
-				state.markedFraming = null;
+				Object.assign(state, { focus: null, focusLocked: false, markedFraming: null });
 				return text(`Opened ${full}.\n\n${sceneReport()}`);
 			},
 		),
@@ -1753,7 +1753,7 @@ export const createToolHandlers = ({ projectRootPromise } = {}) => {
 					return text(`Could not write project: ${error.message}`);
 				}
 				const project = createProjectDocument({
-					scenesDocument: state.doc,
+					scenesDocument: documentWithCamera(state.doc, state.camera),
 					workspaceLayout: null,
 					customPoses: [],
 					name: state.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozyclay",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Open source previs software in the browser: block a scene, pose characters, author camera moves and cuts, then take the same shots to an AI video model.",
   "scripts": {
     "dev": "node tools/dev-full.mjs --host 127.0.0.1 --port 5180",
@@ -82,6 +82,8 @@
     "react-icons": "^5.7.0",
     "reactflow": "^11.11.4",
     "three": "^0.185.1",
+    "three-bvh-csg": "^0.0.18",
+    "three-mesh-bvh": "^0.9.16",
     "vite": "^8.2.0"
   },
   "bin": {

package/src/App.jsx

@@ -137,7 +137,7 @@ import {
 	pathMetrics,
 	strokeToPathPoints,
 } from "./object-path.js";
-import { carriedPointAt, sceneObjectsAt } from "./object-travel.js"; import { objectTracksOf } from "./motion3/object-tracks.js"; import { ViewGhosts } from "./view-ghosts.jsx"; import { DraftGhost } from "./draft-ghost.jsx";
+import { carriedPointAt, sceneObjectsAt } from "./object-travel.js"; import { objectTracksOf } from "./motion3/object-tracks.js"; import { ViewGhosts } from "./view-ghosts.jsx"; import { DraftGhost } from "./draft-ghost.jsx"; import { SculptSketch } from "./sculpt-sketch.jsx";
 import { routeOwnerFor } from "./route-owner.js";
 import {
 	analyticsActive,
@@ -152,6 +152,7 @@ import {
 	trackFeature,
 } from "./analytics.js";
 import { ko, isKo } from "./locale.js";
+import { saveExport } from "./export-workspace.js";
 import { characterCapabilities, kindRefusal, proxyFigureBounds } from "./character-kind.js";
 import { STARTER_SCENES, resolveSceneParam } from "./starter-scenes.js";
 import { PART_COLOURS } from "./part-colours.js";
@@ -2463,6 +2464,17 @@ export default function App() {
 			capture_plan_png: (args = {}) => appContext.live.state.capturePlanPng(requestedCaptureOutput(args) ?? undefined),
 	};
 
+	const liveSceneName = scenes.find((entry) => entry.id === activeSceneId)?.name ?? "";
+	const liveMeta = () => ({
+		project: projectName ?? "Untitled", scene: liveSceneName, cast: appContext.live.characters.length,
+		// The Workflow page's embedded preview is a live editor too; mark it apart from the authoring tab.
+		// Commands: what this editor answers; a stale tab from an older build answers a different set.
+		...(embedMode ? { embed: true } : {}), commands: [...Object.keys(liveQueries), ...Object.keys(studioBindingRef.current.handlers)],
+	});
+	// The client is created once; opening a project must still relabel the tab
+	// in live status and the --workspace <project> selector (#864).
+	useEffect(() => { liveControlRef.current?.setMeta(liveMeta()); }, [projectName, liveSceneName, appContext.live.characters.length]);
+
 	useEffect(() => {
 		const enabled = import.meta.env.DEV || window.__COZYCLAY_LIVE__ === true;
 		if (!enabled) return undefined;
@@ -2474,19 +2486,7 @@ export default function App() {
 					// Tapped so a sculpt run hears the agent's object.sculpt / sculpt.compare.
 					handlers: sculptTap.wrap({ ...liveQueries, ...studioBindingRef.current.handlers }),
 					workspaceId: liveWorkspaceIdRef.current,
-					meta: {
-						project: projectName ?? "Untitled",
-						scene: scenes.find((entry) => entry.id === activeSceneId)?.name ?? "",
-						cast: appContext.live.characters.length,
-						// The Workflow page embeds this same Studio as a preview. It is a
-						// live editor too, so an agent choosing a workspace must be able to
-						// tell the preview apart from the tab the user is authoring in.
-						...(embedMode ? { embed: true } : {}),
-						// Which live commands this editor answers. A stale tab from an
-						// older build (or a different app on the same port) answers a
-						// different set; the agent picks a workspace that has what it needs.
-						commands: [...Object.keys(liveQueries), ...Object.keys(studioBindingRef.current.handlers)],
-					},
+					meta: liveMeta(),
 					// The shared client intentionally has no disconnect UI callback.
 					// Observe only this owned socket; a stale handle must never be sent.
 					WebSocketImpl: class extends WebSocket {
@@ -2776,7 +2776,7 @@ export default function App() {
 			case "unsupported_codec": return ko("MP4 encoding is unavailable. Use a current browser with H.264 WebCodecs support (such as Chrome or Edge), enable hardware acceleration, then retry.", "MP4 인코딩을 사용할 수 없어요. H.264 WebCodecs를 지원하는 최신 Chrome·Edge 등에서 하드웨어 가속을 켠 뒤 다시 시도하세요.");
 			case "encode_failed": return ko("Video encoding failed. Retry the same request. If resources are tight, shorten the shot range or lower output resolution before starting a new export.", "영상 인코딩에 실패했어요. 같은 요청을 다시 시도하세요. 리소스가 부족하면 샷 범위를 줄이거나 출력 해상도를 낮춘 뒤 새로 내보내세요.");
 			case "render_failed": return ko("Frame rendering failed. Let the scene finish loading, then retry. If it repeats, shorten the range or reduce output resolution for a new export.", "프레임 렌더링에 실패했어요. 장면 로딩이 끝난 뒤 다시 시도하세요. 반복되면 범위나 출력 해상도를 줄여 새로 내보내세요.");
-			case "aborted": return ko("Export cancelled. No further downloads will be requested.", "내보내기를 취소했어요. 추가 다운로드는 요청하지 않아요.");
+			case "aborted": return ko("Export cancelled. No further files will be handed off.", "내보내기를 취소했어요. 추가 파일은 전달하지 않아요.");
 			default: return ko("Export could not finish. Retry the same request. For memory or resource problems, close other heavy tabs or use a shorter range / lower output resolution in a new export.", "내보내기를 완료하지 못했어요. 같은 요청을 다시 시도하세요. 메모리·리소스 문제라면 무거운 탭을 닫거나 범위·출력 해상도를 줄여 새로 내보내세요.");
 		}
 	}
@@ -2821,7 +2821,7 @@ export default function App() {
 			job.controller.signal.throwIfAborted();
 			attempt?.succeed();
 			updateExportStatus(job, "completed", { message: request.download
-				? ko("Export completed. Download requested; check your browser's downloads. The OS save is not confirmed.", "내보내기를 완료하고 다운로드를 요청했어요. 브라우저 다운로드를 확인하세요. OS 저장 완료는 확인할 수 없어요.")
+				? ko("Export completed. Check your export folder or browser downloads; the OS save is not confirmed.", "내보내기를 완료했어요. 내보내기 폴더나 브라우저 다운로드를 확인하세요. OS 저장 완료는 확인할 수 없어요.")
 				: ko("Export pipeline completed. The requesting tool handles the file handoff.", "내보내기 처리를 완료했어요. 요청한 도구에서 파일 전달을 처리합니다.") });
 			if (!request.external) {
 				if (request.kind === "video") { track("export:video_succeeded", { format: "mp4" }); trackFeature("export_video"); }
@@ -3010,11 +3010,9 @@ export default function App() {
 			const slate = (moveSequence?.slate ?? "shot").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "shot";
 			// Default plate filename: const name = `cozyclay-${slate}.mp4`
 			const name = fileName ?? `cozyclay-${slate}.mp4`;
-			const url = URL.createObjectURL(result.blob);
-			try { saveDownload(url, name); }
-			finally { setTimeout(() => URL.revokeObjectURL(url), 10_000); }
+			await saveExport(result.blob, name);
 			setRecordedVideoName(name);
-			setToast((isKo, ko) => isKo ? `${name} 다운로드 요청 · ${result.frameCount}프레임` : `Download requested: ${name} · ${result.frameCount} frames`);
+			setToast((isKo, ko) => isKo ? `${name} 내보내기 완료 · ${result.frameCount}프레임` : `${name} exported · ${result.frameCount} frames`);
 			return { ...result, fileName: name };
 		}
 		return result;
@@ -3079,13 +3077,13 @@ export default function App() {
 				{busy && !message && <p>{stage === "mux"
 					? ko("Finalizing MP4. Progress is indeterminate; this stage cannot be interrupted.", "MP4 마무리 중이에요. 진행률은 알 수 없으며 이 단계는 중단할 수 없어요.")
 					: stage === "flush" ? ko("Finishing encoder output. Progress is indeterminate.", "인코더 출력을 마무리하고 있어요. 진행률은 알 수 없어요.")
-					: kind === "frame" ? ko("Handing off existing PNGs. Synchronous downloads cannot be cancelled.", "기존 PNG를 전달하고 있어요. 동기 다운로드는 취소할 수 없어요.")
-					: stage === "archive" ? ko("Building the ZIP. Cancel takes effect after the current work unit, before download.", "ZIP을 만드는 중이에요. 취소는 현재 작업이 끝난 뒤 다운로드 전에 적용돼요.")
-					: stage === "depth" || stage === "frames" ? ko("Cancel stops at the next frame boundary, before download.", "취소하면 다운로드 전 다음 프레임 경계에서 멈춰요.")
+					: kind === "frame" ? ko("Handing off existing PNGs. The file handoff cannot be cancelled.", "기존 PNG를 전달하고 있어요. 파일 전달은 취소할 수 없어요.")
+					: stage === "archive" ? ko("Building the ZIP. Cancel takes effect after the current work unit, before the file handoff.", "ZIP을 만드는 중이에요. 취소는 현재 작업이 끝난 뒤 파일 전달 전에 적용돼요.")
+					: stage === "depth" || stage === "frames" ? ko("Cancel stops at the next frame boundary, before the file handoff.", "취소하면 파일 전달 전 다음 프레임 경계에서 멈춰요.")
 					: phase === "preparing" ? ko("Preparing the renderer and checking MP4 support…", "렌더러를 준비하고 MP4 지원을 확인하고 있어요…")
 					: ko("Encoding the requested frames, not yet a completed file.", "요청한 프레임을 인코딩 중이에요. 아직 파일이 완성되지 않았어요.")}</p>}
 				{retryable && <p>{ko("Retry keeps the original shot, camera, range and settings; it does not change your edits.", "다시 시도하면 원래 샷·카메라·범위·설정을 사용하며 편집 내용은 바꾸지 않아요.")}</p>}
-				{handedOff > 0 && <p>{ko(`${handedOff} file(s) already handed off. Retry skips those downloads; check browser downloads because OS saves cannot be confirmed.`, `파일 ${handedOff}개는 이미 전달했어요. 다시 시도할 때 해당 다운로드는 건너뛰어요. OS 저장은 확인할 수 없으니 브라우저 다운로드를 확인하세요.`)}</p>}
+				{handedOff > 0 && <p>{ko(`${handedOff} file(s) already handed off. Retry skips those files; check your export folder or browser downloads because OS saves cannot be confirmed.`, `파일 ${handedOff}개는 이미 전달했어요. 다시 시도할 때 해당 파일은 건너뛰어요. OS 저장은 확인할 수 없으니 내보내기 폴더나 브라우저 다운로드를 확인하세요.`)}</p>}
 				<div className="export-status-actions">
 					{busy && cancellable && <button type="button" data-testid="export-cancel" onClick={stopShotRecording}>{ko("Cancel export", "내보내기 취소")}</button>}
 					{retryable && <button type="button" data-testid="export-retry" disabled={recState === "recording"} onClick={() => void retryExport()}>{ko("Retry same export", "같은 내보내기 재시도")}</button>}
@@ -3094,7 +3092,7 @@ export default function App() {
 		);
 	}
 
-	function downloadOtioCutList() {
+	async function downloadOtioCutList() {
 		if (!shots.length) {
 			setToast(ko("Add at least one Shot before exporting OTIO", "OTIO를 내보내려면 샷을 하나 이상 추가하세요"));
 			return;
@@ -3113,16 +3111,11 @@ export default function App() {
 			};
 			const serialized = serializeOtio(exportScene, shots);
 			const blob = new Blob([serialized], { type: "application/json" });
-			const url = URL.createObjectURL(blob);
-			const anchor = document.createElement("a");
 			const slug = (activeScene?.name ?? "cut-list")
 				.toLowerCase()
 				.replace(/[^a-z0-9]+/g, "-")
 				.replace(/^-+|-+$/g, "") || "cut-list";
-			anchor.href = url;
-			anchor.download = `cozyclay-${slug}.otio`;
-			anchor.click();
-			setTimeout(() => URL.revokeObjectURL(url), 10_000);
+			await saveExport(blob, `cozyclay-${slug}.otio`);
 			const frameCount = shots.reduce((total, shot) => total + shot.endFrame - shot.startFrame + 1, 0);
 			setToast(isKo
 				? `OTIO 저장됨 · ${shots.length}샷 · ${frameCount}프레임`
@@ -3141,15 +3134,6 @@ export default function App() {
 	 *   - a storyboard contact sheet of the whole cut.
 	 */
 
-	function saveDownload(href, name) {
-		const anchor = document.createElement("a");
-		anchor.href = href;
-		anchor.download = name;
-		document.body.appendChild(anchor);
-		anchor.click();
-		anchor.remove();
-	}
-
 	function loadImage(dataUrl) {
 		return new Promise((resolve, reject) => {
 			const image = new Image();
@@ -3279,21 +3263,20 @@ export default function App() {
 				job.label = ko(`Shot ${order + 1} of ${targets.length}`, `샷 ${order + 1} / ${targets.length}`);
 				const pack = await buildShotKeyframePack(job.request.context.shots[index], index, null, job);
 				job.controller.signal.throwIfAborted();
-				const url = URL.createObjectURL(new Blob([pack.bytes], { type: "application/zip" }));
-				try { saveDownload(url, pack.name); job.request.handedOff.add(index); }
-				finally { setTimeout(() => URL.revokeObjectURL(url), 10_000); }
-				setToast(isKo ? `${pack.name} 다운로드 요청 · 파일 ${pack.entries.length}개` : `Download requested: ${pack.name} · ${pack.entries.length} files`);
+				await saveExport(new Blob([pack.bytes], { type: "application/zip" }), pack.name);
+				job.request.handedOff.add(index);
+				setToast(isKo ? `${pack.name} 내보내기 완료 · 파일 ${pack.entries.length}개` : `${pack.name} exported · ${pack.entries.length} files`);
 				await exportBoundary(job);
 			}
 		}));
 	}
 
 	/** Depth and normal conditioning passes of the framing on screen now. */
-	function exportRenderPasses() {
+	async function exportRenderPasses() {
 		try {
 			const dataUrls = renderPassDataUrls();
-			for (const kind of ["depth", "normal"]) saveDownload(dataUrls[kind], passFileName(kind));
-			setToast(ko("Depth and normal passes downloaded", "뎁스·노멀 패스를 다운로드했어요"));
+			for (const kind of ["depth", "normal"]) await saveExport(dataUrls[kind], passFileName(kind));
+			setToast(ko("Depth and normal passes exported", "뎁스·노멀 패스를 내보냈어요"));
 			trackFeature("export_render_pass");
 		} catch (error) {
 			setToast(error?.message || String(error));
@@ -3352,7 +3335,7 @@ export default function App() {
 				cell: { width: 480, height: 300 },
 				createCanvas: storyboardCanvas,
 			});
-			saveDownload(canvas.toDataURL("image/png"), "cozyclay-storyboard.png");
+			await saveExport(canvas.toDataURL("image/png"), "cozyclay-storyboard.png");
 			setToast(isKo ? `스토리보드 저장됨 · ${cells.length}샷` : `Storyboard saved · ${cells.length} shots`);
 			trackFeature("export_storyboard");
 		} catch (error) {
@@ -3443,8 +3426,8 @@ export default function App() {
 			}
 			const canvas = composeStoryboard({ shots: cells, columns: Math.min(3, cells.length), cell: { width: 480, height: 300 }, createCanvas: storyboardCanvas });
 			job.controller.signal.throwIfAborted();
-			saveDownload(canvas.toDataURL("image/png"), "cozyclay-storyboard.png");
-			setToast(isKo ? `콘택트 시트 다운로드 요청 · 패널 ${cells.length}개` : `Download requested: contact sheet · ${cells.length} panels`);
+			await saveExport(canvas.toDataURL("image/png"), "cozyclay-storyboard.png");
+			setToast(isKo ? `콘택트 시트 내보내기 완료 · 패널 ${cells.length}개` : `Contact sheet exported · ${cells.length} panels`);
 			return { fileName: "cozyclay-storyboard.png", panelCount: cells.length };
 		}));
 	}
@@ -3497,10 +3480,8 @@ export default function App() {
 			const bytes = every ? buildZip(entries) : buildKeyframePack(packs[0]);
 			const name = every ? "cozyclay-panels.zip" : `cozyclay-${packs[0].folder}-${slugifyTitle(target.name)}.zip`;
 			await exportBoundary(job);
-			const url = URL.createObjectURL(new Blob([bytes], { type: "application/zip" }));
-			try { saveDownload(url, name); }
-			finally { setTimeout(() => URL.revokeObjectURL(url), 10_000); }
-			setToast(isKo ? `${name} 다운로드 요청 · 파일 ${entries.length}개` : `Download requested: ${name} · ${entries.length} files`);
+			await saveExport(new Blob([bytes], { type: "application/zip" }), name);
+			setToast(isKo ? `${name} 내보내기 완료 · 파일 ${entries.length}개` : `${name} exported · ${entries.length} files`);
 			return { fileName: name, entries: entries.map((entry) => entry.name) };
 		}));
 	}
@@ -4186,27 +4167,24 @@ export default function App() {
 		}
 		const snapshot = structuredClone(result);
 		const frameJob = { source: result, done: false, request: null };
-		frameJob.request = exportRequest("frame", (job) => {
+		frameJob.request = exportRequest("frame", async (job) => {
 			if (!snapshot?.frame) throw Object.assign(new Error("The captured frame is not ready"), { exportFailureCode: "render_failed" });
 			updateExportStatus(job, "finalizing", { stage: "download", cancellable: false });
-			const save = (href, name) => {
+			const save = async (source, name) => {
 				if (job.request.handedOff.has(name)) return;
-				saveDownload(href, name);
+				await saveExport(source, name);
 				job.request.handedOff.add(name);
 			};
 			if (snapshot.partColours && !job.request.handedOff.has("blocking-frame-palette.json")) {
-				const blob = new Blob([JSON.stringify({ partColours: snapshot.partColours }, null, 2)], { type: "application/json" });
-				const url = URL.createObjectURL(blob);
-				try { save(url, "blocking-frame-palette.json"); }
-				finally { setTimeout(() => URL.revokeObjectURL(url), 1000); }
+				await save(new Blob([JSON.stringify({ partColours: snapshot.partColours }, null, 2)], { type: "application/json" }), "blocking-frame-palette.json");
 			}
 			if (snapshot.frameB) {
-				save(snapshot.frame, "blocking-frame-A-start.png");
-				save(snapshot.frameB, "blocking-frame-B-end.png");
-			} else save(snapshot.frame, "blocking-frame.png");
+				await save(snapshot.frame, "blocking-frame-A-start.png");
+				await save(snapshot.frameB, "blocking-frame-B-end.png");
+			} else await save(snapshot.frame, "blocking-frame.png");
 			frameJob.done = true;
 			setResult((current) => current === frameJob.source ? { ...current, downloaded: true } : current);
-			setToast(ko("Frame download requested. Check your browser's downloads.", "프레임 다운로드를 요청했어요. 브라우저 다운로드를 확인하세요."));
+			setToast(ko("Frame export finished. Check your export folder or browser downloads.", "프레임 내보내기가 끝났어요. 내보내기 폴더나 브라우저 다운로드를 확인하세요."));
 		});
 		frameExportRef.current = frameJob;
 		return executeExportRequest(frameJob.request);
@@ -4791,7 +4769,7 @@ export default function App() {
 									/>
 								</ObjectCarrier>
 							))}
-							<ViewGhosts rig={rigs[activeChar.id]} take={motion} frame={tlFrame} objects={sceneObjects} propTake={{ frameCount: tlFrameCount, fps: tlFps, objectTracks }} /><DraftGhost rigs={rigs} objects={sceneObjects} />
+							<ViewGhosts rig={rigs[activeChar.id]} take={motion} frame={tlFrame} objects={sceneObjects} propTake={{ frameCount: tlFrameCount, fps: tlFps, objectTracks }} /><DraftGhost rigs={rigs} objects={sceneObjects} /><SculptSketch objects={sceneObjects} />
 
 							{/* Selection marker: XYZ tripod + ring on the picked cast
 							    member; the X/Z arrows drag it across the deck. */}

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 };