cozyclay 3.0.3 → 3.1.0

package/src/analytics.js

@@ -116,7 +116,6 @@ const EVENT_PROPERTIES = Object.freeze({
 	"project:opened": ["age_bucket"],
 	"craft:first_action": ["action_kind"],
 	"craft:first_edit": ["edit_kind", "definition_version"],
-	"motion:backend_state": ["backend", "host_configured"],
 	"motion:generate_requested": ["surface", "input_mode", "request_id"],
 	"motion:preflight_blocked": ["reason", "surface", "request_id"],
 	"motion:preflight_passed": ["backend", "surface", "request_id"],
@@ -136,19 +135,14 @@ const EVENT_PROPERTIES = Object.freeze({
 	"playground:first_action": ["action_kind"],
 	"playground:first_edit": ["edit_kind", "definition_version"],
 	"activation:completed": ["activation_path"],
-	"tutorial:started": ["surface", "tutorial_version", "start_source"],
-	"tutorial:step_entered": ["surface", "tutorial_version", "step_kind"],
-	"tutorial:step_completed": ["surface", "tutorial_version", "step_kind", "elapsed_bucket"],
-	"tutorial:completed": ["surface", "tutorial_version", "elapsed_bucket"],
-	"tutorial:dismissed": ["surface", "tutorial_version", "step_kind"],
 	"sculpt_run": ["outcome", "rounds", "final_iou", "duration_ms", "had_target"],
 	...EXECUTION_TELEMETRY_PROPERTY_KEYS,
 });
 const FEATURE_NAMES = new Set([
 	"pose_edit", "pose_save", "camera_fly", "orbit", "dolly_rail", "crane_graph", "timeline_scrub",
 	"prompt_block_add", "shot_add", "shot_cut", "export_pose", "export_frame", "export_video",
-	"export_depth_video", "export_keyframe_pack", "fal_motion_open",
-	"mcp_connected", "auto_color", "plan_view", "camera_tutorial",
+	"export_depth_video", "export_keyframe_pack",
+	"mcp_connected", "auto_color", "plan_view",
 ]);
 // `site` and `playground` arrive through `npx cozyclay --via <source>` from the
 // landing page's copy commands; the others are the first-launch prompt answers.
@@ -159,7 +153,6 @@ const MOTION_ERROR_CODES = new Set(["aborted", "unsupported_route", "generation_
 const MOTION_PROPERTY_VALUES = Object.freeze({
 	// `fal` is the Studio's AI video route (H3 Max Turbo through api.cozyclay.org).
 	backend: new Set(["none", "local_kimodo", "hosted", "fal"]),
-	host_configured: new Set([true, false]),
 	surface: new Set(["timeline", "line_edit", "trail", "mcp", "fal_card", "agent"]),
 	input_mode: new Set(["prompt", "pose", "edit", "a_to_b", "still"]),
 	// `locked`: the AI video route is not enabled for this account yet.
@@ -176,13 +169,6 @@ const EXPORT_PROPERTY_VALUES = Object.freeze({
 	duration_bucket: new Set(["lt1s", "1-3s", "3-10s", "10-30s", "gte30s"]),
 	failure_code: EXPORT_FAILURE_CODES,
 });
-const TUTORIAL_PROPERTY_VALUES = Object.freeze({
-	surface: new Set(["studio", "playground"]),
-	tutorial_version: new Set([1]),
-	start_source: new Set(["query", "settings", "landing"]),
-	step_kind: new Set(["fly", "walk", "dolly", "orbit", "shot", "rail", "play"]),
-	elapsed_bucket: new Set(["lt1s", "1-3s", "3-10s", "10-30s", "gte30s"]),
-});
 // Sculpt mode (#739): one sculpt_run per finished run. Numbers only: no
 // reference image, recipe, part name or sculpt id ever rides along.
 export const SCULPT_RUN_OUTCOMES = Object.freeze(["done", "cancelled", "failed"]);
@@ -242,7 +228,7 @@ let deviceProfileStarted = false;
 // move action_count_bucket.
 const PASSIVE_EVENTS = new Set([
 	"app:session_started", "app:session_ended", "install:first_launch",
-	"motion:backend_state", "app:error", "device:profile",
+	"app:error", "device:profile",
 ]);
 
 function storage() {
@@ -320,7 +306,6 @@ export function sanitizeProps(event, props) {
 				if (typeof props[key] !== "string" || !/^[a-f0-9]{32}$/.test(props[key])) continue;
 			} else if (!MOTION_PROPERTY_VALUES[key]?.has(props[key])) continue;
 		}
-		if (event.startsWith("tutorial:") && !TUTORIAL_PROPERTY_VALUES[key]?.has(props[key])) continue;
 		if (event.startsWith("workflow:") || event.startsWith("agent:") || event.startsWith("mcp:")) {
 			if (key === "run_id" || key === "turn_id" || key === "request_id") {
 				if (typeof props[key] !== "string" || !/^[a-f0-9]{32}$/.test(props[key])) continue;
@@ -372,136 +357,6 @@ export function sanitizeProps(event, props) {
 	return sanitized;
 }
 
-/**
- * Convert the bridge health payload into the analytics contract. The bridge
- * only exposes a safe location label; the configured host itself never leaves
- * the local process. A missing/unhealthy bridge is the useful `none` bucket.
- */
-export function motionBackendState(health) {
-	if (!health || health.ok !== true) return { backend: "none", host_configured: false };
-	if (typeof health.backend === "string" && ["none", "local_kimodo", "hosted"].includes(health.backend)) {
-		return {
-			backend: health.backend,
-			host_configured: health.host_configured === true
-				|| (typeof health.host === "string" && health.host.trim().length > 0),
-		};
-	}
-	const host = typeof health.host === "string" ? health.host.trim() : "";
-	return {
-		// The current /ardy bridge is the local Kimodo integration even when it
-		// dispatches to a configured GPU box over SSH. A future hosted API can
-		// opt into the explicit `backend: "hosted"` field above.
-		backend: "local_kimodo",
-		host_configured: Boolean(host),
-	};
-}
-
-/** Read only structured readiness; raw health/error prose never classifies intent. */
-export function motionPreflightReason(health, { body = {}, lineEditSupported = false } = {}) {
-	if (!health || health.backend === "none" || (health.ok !== true && (health.host_configured === false || health.reason === "unconfigured"))) return "unconfigured";
-	if (health.ok !== true) return "unreachable";
-	if ((body.lineEdit || body.replay?.length) && !lineEditSupported) return "unsupported_route";
-	// The #267 local MLX/cpp route supports a single unconstrained prompt.
-	// ProjFlow line edits have their own capability/runner, even on a local bridge.
-	if (!body.lineEdit && health.host === "local" && health.device === "local" && (
-		body.segments?.length > 1 || body.posePin || body.waypoints?.length || body.motionEdit || body.preserve
-	)) return "unsupported_route";
-	return null;
-}
-
-export function motionFailureCode(error, fallbackCode) {
-	try {
-		if (error?.name === "AbortError") return "aborted";
-		if (MOTION_ERROR_CODES.has(fallbackCode)) return fallbackCode;
-		if (error instanceof Error) return "generation_failed";
-	} catch {
-		// Cross-realm error objects may have throwing getters.
-	}
-	return "unknown";
-}
-
-/** One explicit request, not an authoring draft. All methods are telemetry-only:
- * no return value may decide whether generation runs. Duplicate/out-of-order
- * callbacks cannot advance the funnel, and application is separate from success.
- */
-export function startMotionRequest(metadata, dependencies = {}) {
-	let phase = "requested";
-	let props = null;
-	let startedAt = NaN;
-	let now = () => performance.now();
-	let capture = track;
-	const clock = () => { try { return now(); } catch { return NaN; } };
-	const emit = (event, extra = {}) => {
-		if (!props) return;
-		try {
-			Promise.resolve(capture(event, sanitizeProps(event, { ...props, ...extra }))).catch(() => {
-				// A rejected transport must not change generation.
-			});
-		} catch {
-			// Telemetry is best effort, including capture/payload failures.
-		}
-	};
-	try {
-		now = dependencies.now ?? now;
-		capture = dependencies.capture ?? capture;
-		const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
-		const request_id = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-		props = { ...sanitizeProps("motion:generate_requested", metadata), request_id };
-		emit("motion:generate_requested");
-	} catch {
-		// Omit telemetry without secure randomness; never derive an ID from content.
-		props = null;
-	}
-	return {
-		preflight(health, options) {
-			if (phase !== "requested") return;
-			try {
-				const reason = motionPreflightReason(health, options);
-				phase = reason ? "blocked" : "passed";
-				if (props) props.backend = motionBackendState(health).backend;
-				emit(reason ? "motion:preflight_blocked" : "motion:preflight_passed", reason ? { reason } : {});
-			} catch {
-				// A malformed telemetry input cannot stop the real request.
-			}
-		},
-		/** A route that decides readiness without the /ardy health payload (the
-		 * Fal card): refuse with one closed reason, such as `locked`. */
-		block(reason) {
-			if (phase !== "requested") return;
-			phase = "blocked";
-			emit("motion:preflight_blocked", { reason });
-		},
-		/** The same route's acceptance, naming the backend that will run it. */
-		pass(backend) {
-			if (phase !== "requested") return;
-			phase = "passed";
-			if (props) props.backend = backend;
-			emit("motion:preflight_passed");
-		},
-		start() {
-			if (phase !== "passed") return;
-			phase = "started";
-			startedAt = clock();
-			emit("motion:job_started");
-		},
-		succeed() {
-			if (phase !== "started") return;
-			phase = "succeeded";
-			emit("motion:job_succeeded", { duration_bucket: bucketMs(clock() - startedAt) });
-		},
-		fail(error, fallbackCode) {
-			if (phase !== "started") return;
-			phase = "failed";
-			emit("motion:job_failed", { duration_bucket: bucketMs(clock() - startedAt), error_code: motionFailureCode(error, fallbackCode) });
-		},
-		apply() {
-			if (phase !== "succeeded") return;
-			phase = "applied";
-			emit("motion:result_applied");
-		},
-	};
-}
-
 export const FEATURE_USAGE_NAMES = Object.freeze([...FEATURE_NAMES]);
 
 export function bucketCount(value) {

package/src/app-stage.jsx

@@ -62,7 +62,7 @@ export {
 
 export * from "./stage-attach-frames.js";
 
-export { Character } from "./stage-characters.jsx";
+export { Character, PlaybackCharacter } from "./stage-characters.jsx";
 
 export {
 	ShotRig,

package/src/asset-pane.jsx

@@ -49,9 +49,6 @@ const OBJECT_GLYPHS = {
 	cylinder: "M5 7c0-1.38 3.13-2.5 7-2.5s7 1.12 7 2.5-3.13 2.5-7 2.5S5 8.38 5 7z M5 7v10c0 1.38 3.13 2.5 7 2.5s7-1.12 7-2.5V7",
 	cone: "M12 3.5 5 17 M12 3.5 19 17 M5 17c0 1.38 3.13 2.5 7 2.5s7-1.12 7-2.5",
 	plane: "M12 7.5 21 12l-9 4.5L3 12z",
-	chair: "M7 3.5h10v8.5H7z M5.5 12h13v3h-13z M7 15v5.5 M17 15v5.5",
-	car: "M3 15.5v-3l2.5-.5 2.5-4h8l3 4 2 .5v3z M6 15.5a1.75 1.75 0 1 0 3.5 0 M14.5 15.5a1.75 1.75 0 1 0 3.5 0 M8 12h10",
-	"small-plane": "M12 3v18 M3 11.5l9-2 9 2v2l-9-1-9 1z M8.5 19.5 12 18.5l3.5 1",
 };
 
 const STORAGE_FOLDER = "__storage";
@@ -368,12 +365,11 @@ function matchesQuery(label, query) {
 	return !query || String(label).toLowerCase().includes(query);
 }
 
-/** Folder ids in display order. Basic Shapes and Sets split the object
- * catalogue by its own groups; Props holds what the user imported. */
+/** Folder ids in display order. Basic Shapes holds the object catalogue's
+ * primitives; Props holds what the user imported. */
 const FOLDERS = [
 	{ id: "basic", label: () => ko("Basic Shapes", "기본 도형") },
 	{ id: "characters", label: () => ko("Characters", "인물") },
-	{ id: "sets", label: () => ko("Sets", "세트") },
 	{ id: "props", label: () => ko("Props", "소품") },
 	{ id: "cameras", label: () => ko("Cameras", "카메라") },
 	{ id: "motions", label: () => ko("Motions", "모션") },
@@ -389,7 +385,7 @@ function catalogueTile(entry, props) {
 			key={key}
 			assetKey={key}
 			label={label}
-			type={entry.group === "Primitives" ? ko("Shape", "도형") : ko("Set piece", "세트 소품")}
+			type={ko("Shape", "도형")}
 			title={ko(`Drag ${entry.label} into the scene, or double-click to place it at the origin`, `${label}을(를) 씬에 드래그하거나 더블클릭해 원점에 놓으세요`)}
 			preview={<ObjectPreview kind={entry.kind} color={entry.color} />}
 			selected={props.selectedKey === key}
@@ -408,10 +404,9 @@ export function FolderGrid({ folder, query, ...props }) {
 	const { imageAssetIds, meshAssetIds, shots = [], takeVersions = [], poses = [], onShotOpen, onTakeOpen, selectedKey, onSelect } = props;
 	let tiles = [];
 	let empty = null;
-	if (folder === "basic" || folder === "sets") {
-		const group = folder === "basic" ? "Primitives" : "Set pieces";
+	if (folder === "basic") {
 		tiles = OBJECT_LIBRARY
-			.filter((entry) => entry.group === group && matchesQuery(displayObjectLabel(entry.label), query))
+			.filter((entry) => entry.group === "Primitives" && matchesQuery(displayObjectLabel(entry.label), query))
 			.map((entry) => catalogueTile(entry, props));
 	} else if (folder === "characters") {
 		tiles = CHARACTER_ASSETS.filter((asset) => matchesQuery(asset.label, query)).map((asset) => {

package/src/auto-flat.js

@@ -0,0 +1,10 @@
+/**
+ * The viewport's auto-colour material: a solid-view response for
+ * auto-coloured surfaces. A neutral studio shade lets the derived hue reach
+ * the eye unmultiplied; under our warm key light a plain standard material
+ * turns every hue olive. Full roughness kills the specular sheen and a
+ * self-light of the same hue lifts the shadow side.
+ */
+export function autoFlat(hex) {
+	return { color: hex, roughness: 1, metalness: 0, emissive: hex, emissiveIntensity: 0.4 };
+}

package/src/bus-tasks.js

@@ -72,7 +72,9 @@ export function createBusTasks({ ports, emit }) {
 		control(id, args, request, before, busy) {
 			if (id === 'task.undo') {
 				const task = finished.get(args.taskId) ?? fail('UNDO_EXPIRED', `Task ${args.taskId} is not a finished task this editor still holds.`);
-				const moved = [...task.final].filter(([key, token]) => tokenOf(key) !== token).map(([key]) => key);
+				// A key moved when its token did and its content did too: a later task undone first puts the same content back
+				// under a new token, and that is not a change.
+				const moved = [...task.final].filter(([key, { token, value }]) => tokenOf(key) !== token && JSON.stringify(snapshot(key).value) !== value).map(([key]) => key);
 				if (moved.length) fail('UNDO_CONFLICT', `Changed since the task finished: ${listOf(moved)}; undo those first or edit by hand.`);
 				const historyEntryId = restore(task, [...task.pre.values()], 'undone');
 				finished.delete(args.taskId);
@@ -89,7 +91,7 @@ export function createBusTasks({ ports, emit }) {
 				return receipt(id, task, request, before);
 			}
 			const task = open.get(args.taskId) ?? fail('STALE_TARGET', `Task ${args.taskId} is not open.`);
-			if (id === 'task.requestScope') { grant(task, args.scope); return receipt(id, task, request, before); }
+			if (id === 'task.requestScope') { grant(task, args.scope); emit?.({ type: 'task.scope', taskId: task.taskId, scope: [...task.keys] }); return receipt(id, task, request, before); }
 			if (id === 'task.mark') { task.mark = { values: [...task.keys].map(snapshot), keys: new Set(task.keys) }; return receipt(id, task, request, before); }
 			if (id === 'task.rollback') {
 				const mark = task.mark ?? fail('STALE_TARGET', 'The task has no mark to roll back to.');
@@ -104,7 +106,7 @@ export function createBusTasks({ ports, emit }) {
 				const historyEntryId = restore(task, [...task.pre.values()], 'cancelled');
 				return receipt(id, task, request, before, { historyEntryId, affectedIds: task.affectedIds });
 			}
-			task.final = new Map([...task.pre.keys()].map(key => [key, tokenOf(key)]));
+			task.final = new Map([...task.pre.keys()].map(key => [key, { token: tokenOf(key), value: JSON.stringify(snapshot(key).value) }]));
 			finished.set(task.taskId, task);
 			while (finished.size > FINISHED_KEPT) finished.delete(finished.keys().next().value);
 			emit?.({ type: 'task.finished', taskId: task.taskId });
@@ -116,8 +118,10 @@ export function createBusTasks({ ports, emit }) {
 		 * task's edit restores to (undo_edit of it), after keeping each key's first pre-image.
 		 */
 		admit(task, entry, args, request, before) {
-			if (!task && (request.origin === 'ui' || !open.size)) return null;
+			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) {
 				const held = keys.find(key => scopeConflict(null, [key], open));
 				if (held) fail('SCOPE_BUSY', `${scopeConflict(null, [held], open)}; this command waits for that task.`);
@@ -137,12 +141,14 @@ export function createBusTasks({ ports, emit }) {
 		record(point, recorded) {
 			if (!point || !recorded?.ok) return recorded;
 			const { task } = point, state = ports.read(), warnings = [];
+			let grew = false;
 			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); if (!point.keys.includes(key)) { task.pre.set(key, { key, value: undefined }); point.values.push({ key, value: undefined }); } }
+				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 (grew) emit?.({ type: 'task.scope', taskId: task.taskId, scope: [...task.keys] });
 			for (const key of task.keys) task.tokens.set(key, tokenOf(key));
 			if (recorded.authored) {
 				task.edits.push({ receiptId: recorded.receiptId, values: point.values, keys: point.keys, mark: point.mark });

package/src/command-bus.js

@@ -286,7 +286,7 @@ export function createCommandBus({ registry, ports }) {
         domainRevision = domain ? current.domainRevisions?.[domain] : null;
       };
       const nestedIds = new Set();
-      const context = { origin: request.origin, signal: controller.signal,
+      const context = { origin: request.origin, signal: controller.signal, taskId: request.taskId ?? null,
         check() {
           controller.signal.throwIfAborted();
           const current = ports.read();

package/src/commands/motion3-compile.js

@@ -1,12 +1,16 @@
-// Where a motion compile runs. In the browser: one module Web Worker (motion3/compile-worker.js), started
-// on the first compile and reused, jobs answered in arrival order, so a compile costs the worker's time
-// and never blocks the viewport (the main thread runs the compiler ~4x slower and freezes while it does).
-// Where there is no Worker (Node, tests) or the worker fails: the same job on the calling thread,
-// synchronously, so `registry.run("motion.compile", ...)` there still answers at once. The answer is the
-// same either way (compile-job.js runs the same code on the same plain inputs).
+// Where a motion compile runs. In the browser: a pool of module Web Workers (motion3/compile-worker.js), at most
+// POOL of them, each started on first need and reused; a job takes an idle worker or waits in arrival order, so a
+// compile costs a worker's time and never blocks the viewport (the main thread runs the compiler ~4x slower and freezes
+// while it does). Two workers let two Studio tasks compile at once (parallel tasks, case 10) without a third
+// starving the editor's cores; the rest wait, and the panel shows which task's compile is waiting (compileActivity).
+// Where there is no Worker (Node, tests) or a worker fails: the same job on the calling thread, synchronously, so
+// `registry.run("motion.compile", ...)` there still answers at once. The answer is the same either way (compile-job.js
+// runs the same code on the same plain inputs), whichever worker runs it.
 import { runCompileJob } from "../motion3/compile-job.js";
 import { StudioProtocolError } from "../studio-agent-protocol.js";
 
+const POOL = 2;
+
 /** A job error (or a worker's serialized one) as the Studio's protocol error when it carries a code. */
 function rethrow(error) {
 	if (error?.code && !(error instanceof StudioProtocolError)) throw new StudioProtocolError(error.code, error.message);
@@ -21,43 +25,63 @@ function browserWorker() {
 	return new Worker(new URL("../motion3/compile-worker.js", import.meta.url), { type: "module", name: "motion-compile" });
 }
 
+// What the editor's compiles are doing, for the panel: { running: [meta], waiting: [meta] } (meta: { taskId, characterId }).
+const watchers = new Set();
+let activity = { running: [], waiting: [] };
+const publish = next => { activity = next; for (const watcher of watchers) watcher(activity); };
+export const compileActivity = () => activity;
+export function watchCompileActivity(watcher) { watchers.add(watcher); return () => watchers.delete(watcher); }
+
 /**
- * createCompileRunner({ spawn }) -> { run(job) -> answer | Promise<answer>, takeWarning() -> string | null }
+ * createCompileRunner({ spawn, size }) -> { run(job, meta?) -> answer | Promise<answer>, takeWarning() -> string | null }
  * spawn() -> a Worker-like object (postMessage, onmessage, onerror, terminate) or null for the calling thread.
  */
-export function createCompileRunner({ spawn = browserWorker } = {}) {
-	let worker, dead = false, warning = null, next = 0;
-	const pending = new Map();
-	/** The worker failed (would not start, or crashed): every job from now on, and those in flight, run here. */
+export function createCompileRunner({ spawn = browserWorker, size = POOL } = {}) {
+	let dead = false, warning = null, next = 0;
+	const slots = [], queue = [];
+	const report = () => publish({ running: slots.filter(slot => slot.job).map(slot => slot.job.meta), waiting: queue.map(item => item.meta) });
+	/** A worker failed (would not start, or crashed): every job from now on, and those in flight or waiting, run here. */
 	const fallBack = reason => {
 		dead = true;
-		worker?.terminate?.();
-		worker = null;
 		warning ??= `The motion compile worker stopped (${reason}); compiling on the main thread, which is slower and blocks the editor while it runs.`;
-		for (const [id, { job, resolve, reject }] of pending) { pending.delete(id); try { resolve(local(job)); } catch (error) { reject(error); } }
+		const orphans = [...slots.flatMap(slot => (slot.job ? [slot.job] : [])), ...queue.splice(0)];
+		for (const slot of slots.splice(0)) slot.worker?.terminate?.();
+		for (const { job, resolve, reject } of orphans) { try { resolve(local(job)); } catch (error) { reject(error); } }
+		report();
 	};
-	const started = () => {
-		if (worker || dead) return worker;
+	/** One more worker in the pool: its slot, or null when none can start (dead: every job runs here from now on). */
+	const grow = () => {
+		let worker;
 		try { worker = spawn(); } catch (error) { fallBack(error?.message ?? String(error)); return null; }
 		if (!worker) { dead = true; return null; }
+		const slot = { worker, job: null };
 		worker.onmessage = ({ data: { id, value, error } }) => {
-			const job = pending.get(id);
-			if (!job) return;
-			pending.delete(id);
+			const job = slot.job;
+			if (!job || job.id !== id) return;
+			slot.job = null;
 			if (error) { try { rethrow(error); } catch (thrown) { job.reject(thrown); } } else job.resolve(value);
+			pump();
 		};
 		worker.onerror = event => { event?.preventDefault?.(); fallBack(event?.message || "worker error"); };
 		worker.onmessageerror = () => fallBack("an answer could not be read");
-		return worker;
+		slots.push(slot);
+		return slot;
+	};
+	const pump = () => {
+		while (!dead && queue.length) {
+			const slot = slots.find(candidate => !candidate.job) ?? (slots.length < size ? grow() : null);
+			if (!slot) break;
+			slot.job = queue.shift();
+			try { slot.worker.postMessage({ id: slot.job.id, job: slot.job.job }); } catch (error) { fallBack(error?.message ?? String(error)); return; }
+		}
+		if (dead) for (const item of queue.splice(0)) { try { item.resolve(local(item.job)); } catch (error) { item.reject(error); } }
+		report();
 	};
 	return {
-		run(job) {
-			if (!started()) return local(job);
-			return new Promise((resolve, reject) => {
-				const id = ++next;
-				pending.set(id, { job, resolve, reject });
-				try { worker.postMessage({ id, job }); } catch (error) { fallBack(error?.message ?? String(error)); }
-			});
+		run(job, meta = {}) {
+			// No worker can start here (Node, tests): answer on this thread at once, as before.
+			if (dead || (!slots.length && !grow())) return local(job);
+			return new Promise((resolve, reject) => { queue.push({ id: ++next, job, meta, resolve, reject }); pump(); });
 		},
 		/** The fallback note, once (a receipt warning), or null. */
 		takeWarning() { const note = warning; if (note) warning = ""; return note || null; },

package/src/commands/motion3.js

@@ -105,10 +105,10 @@ 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) => {
+	const compile = (character, spec, opts = {}, bake, taskId = null) => {
 		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 } : {}) });
+		return runner.run({ model: character.model, scene: sceneFor(character), spec, ...opts, ...(placed ? { bake: placed } : {}) }, { taskId, characterId: character.id });
 	};
 	/** The whole output, kept in the store (motion.report, delta) and cut to the receipt budget (report.js). */
 	const report = (r, head, extra = {}) => {
@@ -145,7 +145,7 @@ export function register(registry, ports) {
 		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));
 		// the take is always baked: the user watches every draft, installed or not
-		return after(compile(character, source, { probes, repair }, {}), r => {
+		return after(compile(character, source, { probes, repair }, {}, context?.taskId), 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;

package/src/commands/project.js

@@ -12,7 +12,7 @@ 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 });
 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", "tutorial", "launch"] }, name });
+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" };
 const browse = { id: "project.browse", label: "Browse projects", description: "Show the project browser.", kind: "transient", exposure: "ui-only", input: input() };
 export const declarations = Object.freeze([rename, save, saveAs, exportAsAnimation, opening, fresh, starter, restore, browse]);

package/src/commands/shot.js

@@ -1,6 +1,6 @@
 // One semantic entry point for timeline, camera controls and agent framing.
 import { createCameraBlock, updateCameraBlock, removeCameraRail } from '../camera-block.js';
-import { addShotAtFrame, createShot, cutAtFrame, duplicateShot, removeShot, reorderShot, resizeShot, renameShot, moveCameraKey, removeCameraKey } from '../cuts.js';
+import { addShotAtFrame, appendShotGrowingTake, createShot, cutAtFrame, duplicateShot, removeShot, reorderShot, resizeShot, renameShot, moveCameraKey, removeCameraKey } from '../cuts.js';
 import { reflowStillShots, stillFrameCount, STILL_FRAME_COUNT_MAX, STILL_HOLD_DEFAULT } from '../shot-authoring.js';
 import { ko } from '../locale.js';
 import { track } from '../analytics.js';
@@ -17,6 +17,7 @@ import './elements/shot.js';
 import { changedIds, fail, shotLabel } from './shared.js';
 
 const id = StudioSchemas.TargetGuard.properties.targetId;
+const TAKE_FRAME_MAX = 28800;
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 const number = { type: 'number' };
 const frame = { type: 'integer', minimum: 0 };
@@ -30,7 +31,7 @@ const extra = [
   mutation('shot.moveKey', 'Move camera key', input({ shotId: id, keyId: id, frame })),
   mutation('shot.removeKey', 'Remove camera key', input({ shotId: id, keyId: id })),
   mutation('shot.clearKeys', 'Clear camera keys', input({ shotId: id })),
-  mutation('shot.setTimeline', 'Set shot timeline', input({ frameCount: { type: 'integer', minimum: 24, maximum: 28800 } })),
+  mutation('shot.setTimeline', 'Set shot timeline', input({ frameCount: { type: 'integer', minimum: 24, maximum: TAKE_FRAME_MAX } })),
   mutation('shot.setLens', 'Set camera lens', input({ fovDeg: { ...number, minimum: 14, maximum: 90 } })),
   mutation('shot.frame', 'Frame the shot', { ...input({ ...STUDIO_TOOL_SCHEMAS.frame_shot.properties, preset: { type: 'string' } }, []), oneOf: [STUDIO_TOOL_SCHEMAS.frame_shot, input({ preset: { type: 'string' } })] },
     'Frame a shot on one character (the frame_shot tool): framing.intent { size, level, view, side, focalMm } or framing.exact { position, lookAt, focalMm }. Without keyAtFrame a shot that holds one framing is reframed whole: a held shot. keyAtFrame adds a camera key there; every key eases in and out, so the camera slows to a stop at each one: key a pan or zoom from one spot with two keys (its start and end), lay a moving camera as a rail (shot.setCameraRail) and cut to a new shot for a new view. On a rail shot it puts the shot back on keys. Answers checks { derivedSize, screenFraction, clipped, behindCamera, occluded, cameraSide } for the subject at that frame.'),
@@ -84,6 +85,17 @@ export function register(registry, ports) {
     const created = written.find(shot => shot.id === still.id), { selection, view } = ports.readView();
     ports.publishView({ selection, view: { ...view, frame: created.startFrame }, shotId: created.id });
   }
+  // A clip shot goes in the free time at (or after) the playhead; with none left the take grows at its end,
+  // in the same write so one undo takes both back, and the playhead lands in the new shot.
+  function createClip() {
+    const current = owner().read(), { frameCount } = owner().state(), framing = owner().capture();
+    const placed = addShotAtFrame(current, ports.state().frame, frameCount, framing);
+    if (placed !== current) return owner().write(placed);
+    const grown = appendShotGrowingTake(current, frameCount, framing, TAKE_FRAME_MAX) ?? fail('INVALID_ARGUMENT', `The take is at its longest (${TAKE_FRAME_MAX} frames); shorten or remove a shot first.`);
+    owner().writeState(before => ({ ...before, ...grown }));
+    const added = grown.shots.find(shot => !current.some(row => row.id === shot.id)), { selection, view } = ports.readView();
+    if (added) ports.publishView({ selection, view: { ...view, frame: added.startFrame }, shotId: added.id });
+  }
   function duplicate(shotId) {
     const source = shotOf(shotId), copied = { kind: source.kind, caption: source.caption, cast: structuredClone(source.cast), stylizedAssetId: source.stylizedAssetId };
     if (source.kind !== 'still') {
@@ -130,7 +142,7 @@ export function register(registry, ports) {
   // aimHeight moves a cast aim off the chest to a world height (a whole body, a face).
   const aimOf = (aim, aimHeight) => (aim?.ids && aimHeight !== undefined ? { ids: aim.ids, height: aimHeight } : aim);
   const methods = {
-    'shot.create': () => storyboard() ? createStill() : owner().write(current => addShotAtFrame(current, ports.state().frame, owner().state().frameCount, owner().capture())),
+    'shot.create': () => storyboard() ? createStill() : createClip(),
     'shot.createStill': args => createStill(args),
     'shot.setCaption': ({ shotId, caption }) => patchShot(shotId, shot => ({ ...shot, caption })),
     'shot.setCastOverride': ({ shotId, characterId, override }) => owner().setCastOverride(shotId, characterId, override),
@@ -188,7 +200,7 @@ export function register(registry, ports) {
   const hasShots = state => state.shots.length > 0 || 'There are no shots yet; add one with shot.create.';
   const availability = {
     'shot.createStill': () => true,
-    'shot.create': state => storyboard() || addShotAtFrame(state.shots, state.frame, state.frameCount, null) !== state.shots || `There is no free room for a new shot at the playhead (frame ${state.frame}); move it with operate_studio { frame } or shorten a shot.`,
+    'shot.create': state => storyboard() || addShotAtFrame(state.shots, state.frame, state.frameCount, null) !== state.shots || appendShotGrowingTake(state.shots, state.frameCount, null, TAKE_FRAME_MAX) !== null || `The take is at its longest (${TAKE_FRAME_MAX} frames); shorten or remove a shot first.`,
     'shot.split': state => state.shots.some(shot => state.frame > shot.startFrame && state.frame <= shot.endFrame) || `The playhead (frame ${state.frame}) is not inside a shot after its first frame; move it with operate_studio { frame }.`,
     'shot.clearCameraRail': state => state.shots.some(shot => createCameraBlock(shot.camera).cameraRail) || 'No shot has a camera rail; lay one with shot.setCameraRail.',
   };

package/src/controls.jsx

@@ -53,14 +53,6 @@ export function aimAt(position, target) {
  * `getPivot()` is optional and returns a world point to orbit; without one,
  * Alt-drag orbits a point straight ahead of the lens.
  */
-/** Coarse navigation signal for onboarding surfaces (the landing-page
- * tutorial listens through the playground bridge). Fires once per gesture
- * start, not per frame. */
-function announceNav(kind, key = null) {
-	if (typeof window === "undefined") return;
-	window.dispatchEvent(new CustomEvent("cozyclay:nav", { detail: { kind, key } }));
-}
-
 export function FlyControls({ enabled, cameraLocked = false, camRef, look, getPivot, onFlyStateChange, onCameraChange }) {
 	const { gl, invalidate } = useThree();
 	const keys = useRef(new Set());
@@ -136,7 +128,6 @@ export function FlyControls({ enabled, cameraLocked = false, camRef, look, getPi
 			if (gesture.current?.kind !== "fly") return;
 			const key = KEY_BY_CODE[e.code];
 			if (key) {
-				if (!keys.current.has(key) && key !== "shift") announceNav("walk", key);
 				keys.current.add(key);
 				e.preventDefault();
 			}
@@ -220,7 +211,6 @@ export function FlyControls({ enabled, cameraLocked = false, camRef, look, getPi
 			lockAttempts = 0;
 			if (e.pointerType !== "touch" && e.pointerType !== "pen") requestNavLock();
 			if (kind === "fly") flyStateRef.current?.(true);
-			announceNav(kind);
 			scheduleInvalidate();
 		};
 
@@ -309,7 +299,6 @@ export function FlyControls({ enabled, cameraLocked = false, camRef, look, getPi
 				return;
 			}
 			cam.position.addScaledVector(forwardFrom(look.current.yaw, look.current.pitch), -e.deltaY * DOLLY_STEP);
-			announceNav("dolly");
 			cameraChangeRef.current?.();
 		};
 

package/src/cuts.js

@@ -127,6 +127,17 @@ export function addShotAtFrame(shots, frame, frameCount, currentFraming, duratio
 	return [...list, createShot(`Shot ${list.length + 1}`, target, endFrame, keys)].sort((a, b) => a.startFrame - b.startFrame);
 }
 
+/** Add Shot when the take has no free time left: the take grows by one default
+ * shot at its end and the new shot fills that, so the button never silently does
+ * nothing. Existing shots are untouched. Null past maxFrameCount. */
+export function appendShotGrowingTake(shots, frameCount, currentFraming, maxFrameCount) {
+	const list = Array.isArray(shots) ? shots : [];
+	const startFrame = Math.max(frameNumber(frameCount, 1), ...list.map((shot) => shot.endFrame + 1));
+	const grownCount = startFrame + DEFAULT_SHOT_FRAMES;
+	if (grownCount > maxFrameCount) return null;
+	return { shots: addShotAtFrame(list, startFrame, grownCount, currentFraming), frameCount: grownCount };
+}
+
 export function resizeShot(shots, shotId, edge, rawFrame, frameCount) {
 	const shot = shotById(shots, shotId);
 	if (edge !== "start" && edge !== "end") return shots;

package/src/domains/cast.js

@@ -546,7 +546,7 @@ export function useCast(appContext) {
 		return current.length;
 	}
 
-	/** ARDY-demo style authoring: each empty-floor press in the Shot view drops
+	/** Click-to-place authoring: each empty-floor press in the Shot view drops
 	    the next waypoint where it was clicked; the frame gap comes from walking
 	    distance. The bird's-eye board selects and drags existing waypoints. */
 	function addFloorWaypoint(point) {
@@ -715,7 +715,8 @@ export function useCast(appContext) {
 	}
 	function undoScene() {
 		const receipt = appContext.bus.run('edit.undo');
-		if (receipt.status === 'noop') appContext.notify(ko("Nothing to undo", "실행 취소할 작업이 없어요"));
+		// A refusal says why: the last edit belongs to a running task (parallel tasks), which its own card undoes.
+		if (receipt.status === 'noop' || receipt.ok === false) appContext.notify(receipt.ok === false ? ko(receipt.message ?? "Undo was refused", `실행 취소 불가: ${receipt.message ?? ""}`) : ko("Nothing to undo", "실행 취소할 작업이 없어요"));
 		return receipt;
 	}
 	function redoScene() {