cozyclay 3.0.0 → 3.0.2

package/dist/cozyclay-package.json

@@ -1 +1 @@
-{"payload":"{\"distribution\":\"npm\",\"package\":\"cozyclay\",\"version\":\"3.0.0\",\"repository\":\"NomaDamas/CozyClay\",\"content_sha256\":\"e6a50c77650f2894d8154267dec8faafb86cad41e859b2594f233d5a18348530\"}","signature":"rwtYOUdZUQo57FluVUioxvNg+gKzRgBC38gyKcd7GIrm5nhq3iff5eV90XV7YFAJfVHn466qu3iLBsnjKkpIDA=="}
+{"payload":"{\"distribution\":\"npm\",\"package\":\"cozyclay\",\"version\":\"3.0.2\",\"repository\":\"NomaDamas/CozyClay\",\"content_sha256\":\"7232c78719451c250c0be94e5f375e56c3c05984e94882724c50048b900c6c71\"}","signature":"+LLNPJc5HYZikPGbfrI57GjEjarn3TRJiaHrrsn4z1CuRMN958copspe2aRT+Y3j5wBo1vH0gYI2UsYn2J6sBA=="}

package/dist/index.html

@@ -301,9 +301,9 @@
         .btn, a.card, .seg button, .tutorial-steps li { transition: none; }
       }
     </style>
-    <script type="module" crossorigin src="/assets/landing-DjHD8u7k.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/analytics-C9sUnndd.js">
-    <link rel="modulepreload" crossorigin href="/assets/first-shot-handoff-CC4xe4HM.js">
+    <script type="module" crossorigin src="/assets/landing-mq5bnqFE.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/analytics-DbKG0NgD.js">
+    <link rel="modulepreload" crossorigin href="/assets/first-shot-handoff-CrGZ3n_O.js">
   </head>
   <body>
     <header class="site">

package/dist/workflow/index.html

@@ -8,11 +8,11 @@
     <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-C4yKH1p4.js"></script>
+    <script type="module" crossorigin src="/assets/workflow-dUhurYUc.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-hePW80VL.js">
-    <link rel="modulepreload" crossorigin href="/assets/analytics-C9sUnndd.js">
+    <link rel="modulepreload" crossorigin href="/assets/analytics-DbKG0NgD.js">
     <link rel="modulepreload" crossorigin href="/assets/fflate.module-KbGj5-H6.js">
-    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-Hx_FzdOH.js">
+    <link rel="modulepreload" crossorigin href="/assets/scene-asset-sync-7J-w5oNh.js">
     <link rel="stylesheet" crossorigin href="/assets/scene-asset-sync-_S8NQl5B.css">
     <link rel="stylesheet" crossorigin href="/assets/workflow-DRdwoDBT.css">
   </head>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozyclay",
-  "version": "3.0.0",
+  "version": "3.0.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",

package/src/App.jsx

@@ -1282,7 +1282,7 @@ export default function App() {
 	const [inspectorActionsOpen, setInspectorActionsOpen] = useState(false);
 
 	const objectsDomain = useObjects(appContext.forRender({
-		get animatedSceneObjects() { return animatedSceneObjects; },
+		get animatedSceneObjects() { return animatedSceneObjects; }, get attachFrameRef() { return attachFrameRef; },
 		get castMemberOf() { return castMemberOf; },
 		get charIdFromHierarchyId() { return charIdFromHierarchyId; },
 		get characters() { return characters; },

package/src/agent-progress.js

@@ -5,6 +5,7 @@
 // In-page only: nothing here is saved with the project, undone, or sent to the agent. Each character keeps its
 // last KEEP drafts; the images keep the last KEEP. A new agent turn starts clean (clearProgress).
 
+import { qaProblems } from "./qa-label.js";
 const KEEP = 12;
 const drafts = new Map(), sheets = [], listeners = new Set();
 let version = 0, counter = 0;
@@ -21,7 +22,7 @@ const pick = (row, keys) => Object.fromEntries(keys.filter(k => row?.[k] !== und
 /**
  * publishDraft(characterId, { take, installed, specId, label, qa, timeline }) -> the stored draft:
  * { n (1, 2, ... per character), at (ms), characterId, take, frames, installed, specId, label,
- *   qa: { ok, total, groups: [{ kind, subject, count, first, last, worst }], goals: [{ name, kind, ok, value, need, at }] },
+ *   qa: { ok, total, problems, groups: [{ kind, subject, count, first, last, worst }], goals: [{ name, kind, ok, value, need, at }] },
  *   timeline: the compile's beats (pipeline.js timelineOf) }.
  */
 export function publishDraft(characterId, { take, installed = false, specId = null, label = null, qa = null, timeline = [] }) {
@@ -29,7 +30,7 @@ export function publishDraft(characterId, { take, installed = false, specId = nu
 	const draft = Object.freeze({
 		n: (list.at(-1)?.n ?? 0) + 1, at: Date.now(), seq: ++counter, characterId, take, frames: take?.frameCount ?? 0,
 		installed: !!installed, specId, label,
-		qa: { ok: !!qa?.ok, total: qa?.total ?? 0,
+		qa: { ok: !!qa?.ok, total: qa?.total ?? 0, problems: qaProblems(qa),
 			groups: (qa?.groups ?? []).map(g => pick(g, ["kind", "subject", "count", "first", "last", "worst"])),
 			goals: (qa?.goals ?? []).map(g => pick(g, ["name", "kind", "ok", "value", "need", "at"])) },
 		timeline: timeline ?? [],

package/src/agent-turn-mark.js

@@ -23,8 +23,41 @@ export function markAgentTurn(id, turn) {
   const { mark } = turn;
   if (!mark) throw new StudioProtocolError('STALE_TARGET', 'The agent turn has no mark to roll back to.');
   turn.mark = null;
+  turn.edits = (turn.edits ?? []).filter(edit => edit.mark !== mark);
   // No session at the mark: everything the turn authored came after it.
   turn.session?.rollback(mark.point ?? undefined);
   turn.affectedIds = mark.affectedIds;
   return { txId: turn.txId, affectedIds: [...mark.since], toasts: [] };
 }
+
+// The turn's own edits, newest last: each keeps the savepoint before it, so undo_edit on the
+// newest one's receipt rolls back to there and the turn stays open (9240db36 was refused twice).
+/** Where the turn stands before a command runs: the savepoint, the ids so far, the open mark. */
+export const turnEditPoint = turn => turn && { point: turn.session?.savepoint() ?? null, affectedIds: new Set(turn.affectedIds), since: turn.mark && new Set(turn.mark.since), mark: turn.mark };
+
+/** Files an authored receipt of the turn with the point before it; answers the receipt. */
+export function recordTurnEdit(turn, at, recorded) {
+  if (turn && at && recorded?.ok && recorded.authored) (turn.edits ??= []).push({ ...at, receiptId: recorded.receiptId, ids: recorded.affectedIds });
+  return recorded;
+}
+
+/**
+ * edit.undo from inside the owning turn once it has authored. A receipt of the turn's newest edit
+ * rolls back to the point before it and answers the receipt (before: the bus's read at admission;
+ * read: a read after); anything else is refused with what the agent can do instead.
+ */
+export function undoTurnEdit(turn, args, request, before, read) {
+  const edits = turn.edits ?? [], at = edits.findIndex(edit => edit.receiptId === args.receiptId);
+  if (at < 0) throw new StudioProtocolError('TARGET_BUSY', `Finish the agent turn before traversing history or opening another transaction. Inside the turn, undo_edit with the receiptId of this message's newest edit reverts it${edits.length ? ` (now ${edits.at(-1).receiptId})` : ''}; an earlier message's edit is undone after this one ends.`);
+  const edit = edits[at];
+  if (at < edits.length - 1) throw new StudioProtocolError('UNDO_CONFLICT', `Later edits of this message come after it; undo them first, newest first: ${edits.slice(at + 1).reverse().map(later => later.receiptId).join(', ')}.`);
+  turn.session.rollback(edit.point ?? undefined);
+  edits.pop();
+  turn.affectedIds = edit.affectedIds;
+  // Nothing came after a mark this edit predates, so the mark moves to now: a script's rollback still finds it.
+  if (turn.mark && edit.mark !== turn.mark) turn.mark = { point: turn.session.savepoint(), affectedIds: new Set(turn.affectedIds), since: new Set() };
+  else if (turn.mark) turn.mark.since = edit.since;
+  return { ok: true, status: 'completed', kind: 'transaction', action: 'edit.undo', txId: turn.txId, commandId: request.commandId, receiptId: crypto.randomUUID(), host: before.host,
+    summary: `Undid ${edit.receiptId} inside this message.`, authored: false, revision: { before: before.revision, after: read().revision }, affectedIds: edit.ids, delta: [],
+    checks: { coverage: 'agent-turn-savepoint' }, undo: null, warnings: [], output: { undoneReceiptId: edit.receiptId } };
+}

package/src/app-context.js

@@ -1,8 +1,13 @@
-import { createContext, useContext } from 'react';
+import { createContext, useContext, useMemo } from 'react';
 import { StudioProtocolError } from './studio-agent-protocol.js';
 
 export const AppContext = createContext(null);
-export function useBus() { return useContext(AppContext).bus; }
+// Reading `bus` refreshes the studio binding (it serializes the whole scene), so a panel must not read it while it
+// renders: playback re-renders panels every frame. The hook hands back a stable handle that opens the bus per call.
+export function useBus() {
+  const app = useContext(AppContext);
+  return useMemo(() => ({ run: (...args) => app.bus.run(...args), subscribe: (...args) => app.bus.subscribe(...args) }), [app]);
+}
 
 const ref = current => ({ current });
 

package/src/command-bus.js

@@ -2,8 +2,8 @@
 // the editor ports own native state/history, and the existing journal owns
 // idempotency. Synchronous UI actions stay synchronous (including user gestures).
 import { HISTORY_LIMIT } from './history.js';
-import { StudioProtocolError, StudioSchemas, validateStudioSchema, validateReceipt, validateStudioIdentity } from './studio-agent-protocol.js';
-import { agentTurnControls, markAgentTurn } from './agent-turn-mark.js';
+import { StudioProtocolError, StudioSchemas, validateStudioSchema, validateReceipt, validateStudioIdentity, refusalCode } from './studio-agent-protocol.js';
+import { agentTurnControls, markAgentTurn, turnEditPoint, recordTurnEdit, undoTurnEdit } from './agent-turn-mark.js';
 
 // A batching/retention adapter over the existing object history owner. The
 // native store still owns every snapshot and transition; this tracks only the
@@ -102,12 +102,11 @@ export function createCommandBus({ registry, ports }) {
       finally { agentTurn = null; }
       return transactionReceipt(id, turn, request, turn.before);
     }
-    // Every Studio turn opens a turn transaction (#715), so "undo the last thing" arrives
-    // inside one. Until the turn has authored anything (no session yet) history traversal
-    // is safe: the undo lands as its own entry and a later edit still groups into the turn.
-    // After the first authored edit the turn owns the frontier and traversal waits (#735).
+    // Every Studio turn opens a turn transaction (#715), so "undo the last thing" arrives inside one. Until the
+    // turn has authored (no session yet) history traversal is safe: the undo lands as its own entry (#735).
+    // After that the turn owns the frontier: its own agent may undo its newest edit (agent-turn-mark.js).
     const traversal = id === 'edit.undo' || id === 'edit.redo';
-    if (agentTurn && !id.startsWith('job.') && !(traversal && !agentTurn.session)) fail('TARGET_BUSY', 'Finish the agent turn before traversing history or opening another transaction.');
+    if (agentTurn && !id.startsWith('job.') && !(traversal && !agentTurn.session)) { if (id === 'edit.undo' && request.turnId === agentTurn.txId) return validateReceipt(undoTurnEdit(agentTurn, args, request, before, () => ports.read())); fail('TARGET_BUSY', 'Finish the agent turn before traversing history or opening another transaction.'); }
     if (traversal) {
       const redo = id === 'edit.redo', historyEntryId = ports.history?.(redo);
       const previous = args.receiptId ? ports.receipt(args.receiptId) : historyReceipts.get(historyEntryId)
@@ -203,7 +202,7 @@ export function createCommandBus({ registry, ports }) {
   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: error.code ?? 'INVALID_ARGUMENT', phase: changed ? 'commit' : 'admission', affectedIds: [], expectedTargets: [], currentTargets: [],
+      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('') });
   }
@@ -358,13 +357,13 @@ export function createCommandBus({ registry, ports }) {
         const deadline = new Promise((_, reject) => controller.signal.addEventListener('abort', () => reject(controller.signal.reason), { once: true }));
         return Promise.race([value, deadline]);
       };
-      const value = entry.kind === 'mutation' ? recordAction(entry.undoDomain, invoke, validated.characterId ?? null) : { result: invoke(), historyEntryId: null };
+      const point = turnEditPoint(turn), value = entry.kind === 'mutation' ? recordAction(entry.undoDomain, invoke, validated.characterId ?? null) : { result: invoke(), historyEntryId: null };
       const finish = ({ result, historyEntryId }) => mapResult(result, output => {
         clearTimer();
         releaseToasts?.(); releaseToasts = null;
-        const refused = toastRefusal();
+        const refused = output?.output === undefined ? toastRefusal() : null; // a job that answered was not refused by a toast that showed meanwhile
         if (refused) throw refused;
-        return remember(receipt(entry, request, before, { ...output, affectedIds: [...new Set([...output.affectedIds, ...nestedIds])] }, historyEntryId ?? committedHistoryId, toasts, turn));
+        return recordTurnEdit(turn, point, remember(receipt(entry, request, before, { ...output, affectedIds: [...new Set([...output.affectedIds, ...nestedIds])] }, historyEntryId ?? committedHistoryId, toasts, turn)));
       });
       const finished = value?.then ? value.then(finish) : finish(value);
       const answer = finished?.then ? finished.catch(rejected) : finished;

package/src/commands/elements/character.js

@@ -1,6 +1,7 @@
 import { createCharacterEntry } from '../../scenes.js';
 import { STUDIO_ELEMENTS } from '../../studio-elements.js';
 import { registerElementKind } from '../elements.js';
+import { readCastTakes } from './take-read.js';
 
 const elements = STUDIO_ELEMENTS.filter(row => row.path.startsWith('character.')).map(row => {
   const { min, max, gizmo, ...element } = row;
@@ -9,5 +10,5 @@ const elements = STUDIO_ELEMENTS.filter(row => row.path.startsWith('character.')
   if (row.path === 'character.pose') return { ...element, readback: item => ({ text: item?.pose?.id ?? null }) };
   return element;
 });
-registerElementKind('character', { collection: true, documentKey: 'characters', elements, normalize: createCharacterEntry });
+registerElementKind('character', { collection: true, documentKey: 'characters', elements, read: readCastTakes, normalize: createCharacterEntry });
 registerElementKind('poseLibrary', { collection: true, documentKey: 'customPoses', elements: [], normalize: value => value });

package/src/commands/elements/motion.js

@@ -1,4 +1,5 @@
 import { registerElementKind } from '../elements.js';
+import { readTake } from './take-read.js';
 
 const elements = [
   { path: 'motion.take.prompt', type: 'string' },
@@ -6,4 +7,9 @@ const elements = [
   { path: 'motion.takeRecipe', type: 'object', readOnly: true },
   { path: 'motion.takeVersions', type: 'array', readOnly: true },
 ];
-registerElementKind('motion', { collection: true, elements, normalize: row => ({ ...row, take: row.take && { ...row.take } }) });
+// The full take is the take itself until an edit splits them: a read answers its source once.
+const readMotion = (rows, named) => rows.map(row => {
+  const same = Boolean(row.fullTake?.resourceId) && row.fullTake.resourceId === row.take?.resourceId;
+  return { ...row, take: readTake(row.take, named(row.id)), fullTake: readTake(row.fullTake, !same && named(row.id)) };
+});
+registerElementKind('motion', { collection: true, elements, read: readMotion, normalize: row => ({ ...row, take: row.take && { ...row.take } }) });

package/src/commands/elements/scene.js

@@ -1,4 +1,5 @@
 import { registerElementKind } from '../elements.js';
+import { readCastTakes } from './take-read.js';
 
 // Array position is the authoritative order. The owner refreshes this persisted
 // field after every move, so generic set/read and the project file agree.
@@ -8,6 +9,8 @@ registerElementKind('scene', {
     { path: 'scene.name', type: 'string' },
     { path: 'scene.order', type: 'number' },
   ],
+  // a saved scene keeps its cast's takes: a read answers their spec ids (take-read.js)
+  read: (scenes, named) => scenes.map(scene => (scene?.stage?.characters ? { ...scene, stage: { ...scene.stage, characters: readCastTakes(scene.stage.characters, named) } } : scene)),
   normalize: scene => ({ ...scene, name: scene.name.trim(), order: Math.max(0, Math.round(scene.order)) }),
 });
 registerElementKind('project', {

package/src/commands/elements/stage.js

@@ -1,6 +1,7 @@
 import { createSceneStage } from '../../scenes.js';
 import { STUDIO_ELEMENTS } from '../../studio-elements.js';
 import { registerElementKind } from '../elements.js';
+import { readCastTakes } from './take-read.js';
 
 const elements = STUDIO_ELEMENTS.filter(row => row.path.startsWith('stage.'));
 export const STAGE_FIELDS = [...new Set(elements.map(element => (element.documentPath ?? element.path.slice(6)).split('.')[0]))];
@@ -8,4 +9,4 @@ export function normalizeStage(source) {
   const normalized = createSceneStage(source);
   return Object.fromEntries(STAGE_FIELDS.map(key => [key, normalized[key]]));
 }
-registerElementKind('stage', { elements, normalize: normalizeStage });
+registerElementKind('stage', { elements, read: (stage, named) => (stage?.characters ? { ...stage, characters: readCastTakes(stage.characters, named) } : stage), normalize: normalizeStage });

package/src/commands/elements/take-read.js

@@ -0,0 +1,31 @@
+import { specIdOf } from '../../motion3/spec-store.js';
+
+// A take's source (its spec, placement and the scene boxes it was compiled against) runs to
+// ~110k characters a character, and a document read carried it in full wherever a take sits:
+// motion (as take and fullTake), the cast and stage (motionTake) and every saved scene. One read
+// of motion alone answered 460k characters, ~300k tokens a model call for the rest of the turn.
+// A read answers the take's specId instead (motion.compile { base: specId } recompiles it); a
+// character named in ids also gets its spec and placement, never the scene boxes.
+const LEFT_OUT = 'left out of this read: name this character in ids for its spec and placement, or compile { base: specId }';
+const leftOutScene = scene => `left out (the ${Object.keys(scene?.objects ?? {}).length} scene objects it was compiled against)`;
+
+/** A take source ({ schema, rig, spec, placement, scene, ... }) as a read answers it: { specId, ... }. */
+function readSource(source, named) {
+  const specId = specIdOf(source.spec);
+  if (!named) return { specId, frames: source.spec?.frames, ...(source.takeId ? { takeId: source.takeId } : {}), ...(source.edit ? { edit: source.edit } : {}), spec: LEFT_OUT };
+  const { scene, ...kept } = source;
+  return { specId, ...kept, scene: leftOutScene(scene) };
+}
+
+/** A motion layer's take descriptor, its source read as above. */
+export function readTake(take, named) {
+  if (!take?.source) return take;
+  const { source, ...descriptor } = take, specId = specIdOf(source.spec);
+  if (!named) return { ...descriptor, specId, source: LEFT_OUT };
+  const { scene, ...kept } = source;
+  return { ...descriptor, specId, source: { ...kept, scene: leftOutScene(scene) } };
+}
+
+/** Cast rows with their saved takes (motionTake) read as above. */
+export const readCastTakes = (characters, named) => (Array.isArray(characters)
+  ? characters.map(row => (row?.motionTake?.spec ? { ...row, motionTake: readSource(row.motionTake, named(row.id)) } : row)) : characters);

package/src/commands/elements.js

@@ -42,15 +42,29 @@ export function elementSetSchema(kind) {
 export function elementTarget(kind, value, id, sceneId) {
   return kinds.get(projectionKind(kind)).collection ? value.find(row => row.id === id) : id === sceneId ? value : undefined;
 }
-export function readElementDocument(projection, { ids, select } = {}, sceneId) {
+// A kind's `read` shapes what a document read answers (motion leaves out a take's bulky source
+// unless its row id was named): `named` are the ids the caller asked for by name. A read answers
+// at most DOCUMENT_READ_CHARS of kinds, the smallest first; the rest are named in `omitted` with
+// their size, to select alone or by ids. One kind alone answers whole (ids narrow it).
+const DOCUMENT_READ_CHARS = 90_000;
+export function readElementDocument(projection, { ids, select, named = ids } = {}, sceneId) {
   const entries = Object.entries(projection).flatMap(([key, value]) => {
     const kind = projectionKind(key);
     if (select && !select.includes(key) && !select.includes(kind)) return [];
     if (!ids || ids.includes(key) || ids.includes(kind) || ids.includes(sceneId)) return [[key, value]];
     const selected = kinds.get(kind).collection ? value.filter(row => ids.includes(row.id)) : [];
     return selected.length ? [[key, selected]] : [];
+  }).map(([key, value]) => {
+    const read = kinds.get(projectionKind(key))?.read;
+    return [key, read ? read(value, id => Boolean(named?.includes(id))) : value];
   });
-  return { document: structuredClone(Object.fromEntries(entries)), schema: Object.fromEntries(entries.map(([key]) => [key, elementSetSchema(projectionKind(key))])) };
+  const sized = entries.map(([key, value]) => { const schema = elementSetSchema(projectionKind(key)); return { key, value, schema, chars: JSON.stringify([value, schema]).length }; });
+  let room = DOCUMENT_READ_CHARS;
+  const fits = new Set(sized.length < 2 ? sized.map(row => row.key) : [...sized].sort((a, b) => a.chars - b.chars).filter(row => (room -= row.chars) >= 0).map(row => row.key));
+  const kept = sized.filter(row => fits.has(row.key)), omitted = sized.filter(row => !fits.has(row.key));
+  return { document: structuredClone(Object.fromEntries(kept.map(row => [row.key, row.value]))), schema: Object.fromEntries(kept.map(row => [row.key, row.schema])),
+    ...(omitted.length ? { omitted: Object.fromEntries(omitted.map(row => [row.key, row.chars])),
+      note: `Left out to keep this read under ${DOCUMENT_READ_CHARS} characters (sizes in omitted): select a kind alone, name ids, or page objects with scope "entities".` } : {}) };
 }
 export function readElement(document, path) {
   const element = kinds.get(path.slice(0, path.indexOf('.'))).elements.find(row => row.path === path);

package/src/commands/motion3.js

@@ -18,9 +18,11 @@ import { fitOutput, reportPage } from "../motion3/report.js";
 import { keyObject } from "../motion3/key-edit.js";
 import { expandUse } from "../motion3/skills/index.js";
 import { publishDraft } from "../agent-progress.js";
+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 { peopleOf } from "../motion3/people.js";
 
 const TIMELINE_FPS = 24;
 const id = { type: "string", minLength: 1 };
@@ -91,6 +93,11 @@ export function register(registry, ports) {
 		if (Math.abs((character.scale ?? 1) - 1) > 1e-6) fail("TARGET_NOT_READY", "Set the character's scale back to 1 before compiling motion.");
 		return sk;
 	};
+	// the scene a compile sees: the objects, and the other characters' installed takes as moving bodies (people.js)
+	const sceneFor = character => {
+		const state = ports.state(), people = peopleOf(state.characters, character.id, id => owner().motionFor(id));
+		return { ...motionScene(state.objects), ...(Object.keys(people).length ? { people } : {}) };
+	};
 	// one compile worker per editor in the browser, the calling thread elsewhere (motion3-compile.js)
 	const runner = createCompileRunner();
 	const workerWarning = () => { const note = runner.takeWarning(); return note ? { warnings: [note] } : {}; };
@@ -101,7 +108,7 @@ export function register(registry, ports) {
 	const compile = (character, spec, opts = {}, bake) => {
 		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: motionScene(ports.state().objects), spec, ...opts, ...(placed ? { bake: placed } : {}) });
+		return runner.run({ model: character.model, scene: sceneFor(character), spec, ...opts, ...(placed ? { bake: placed } : {}) });
 	};
 	/** The whole output, kept in the store (motion.report, delta) and cut to the receipt budget (report.js). */
 	const report = (r, head, extra = {}) => {
@@ -134,7 +141,9 @@ export function register(registry, ports) {
 		const character = characterOf(ports, characterId);
 		if ((spec === undefined) === (base === undefined)) fail("INVALID_ARGUMENT", "Send exactly one of spec or base (the specId of a compiled spec, with patch).");
 		if (patch !== undefined && base === undefined) fail("INVALID_ARGUMENT", "patch applies to base, the specId of a compiled spec; send base with it, or the whole spec.");
-		const patched = [], source = spec ?? asArgument(() => applyPatch(store.get(base) ?? unknownSpec("base", base), patch ?? [], patched));
+		// 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));
 		// the take is always baked: the user watches every draft, installed or not
 		return after(compile(character, source, { probes, repair }, {}), r => {
 			const { qa, take } = r, notes = [...patched, ...(r.notes ?? [])];
@@ -153,12 +162,12 @@ export function register(registry, ports) {
 			const output = report(r, { frames: r.frameCount, fps: TIMELINE_FPS, installed: wanted, ...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 ${qa.ok ? "clean" : `${qa.total} issues`}${how}${adjustedSay(notes)}.`, output, ...workerWarning() };
+			return { affectedIds: installs ? [characterId] : [], summary: `Compiled ${r.frameCount} frames; QA ${qaSay(qa)}${how}${adjustedSay(notes)}.`, output, ...workerWarning() };
 		});
 	} });
 	registry.register({ ...declarations[1], available: mounted, run({ characterId, checks }) {
 		const character = characterOf(ports, characterId), take = installed(characterId);
-		return after(compile(character, take.spec, { checks }), r => ({ affectedIds: [], summary: `QA ${r.qa.ok ? "clean" : `${r.qa.total} issues`}${adjustedSay(r.notes ?? [])}.`,
+		return after(compile(character, take.spec, { checks }), r => ({ affectedIds: [], summary: `QA ${qaSay(r.qa)}${adjustedSay(r.notes ?? [])}.`,
 			output: report(r, adjustedOf(r.notes ?? [])), ...workerWarning() }));
 	} });
 	registry.register({ ...declarations[2], available: mounted, run({ characterId, frames, bones = DEFAULT_BONES }) {
@@ -196,11 +205,11 @@ export function register(registry, ports) {
 	// motion.keyObject (C14): one key of a held object (or a hinge angle) in the installed take's spec, compiled
 	// and installed whatever QA says (a user edit), as one undo entry
 	registry.register({ ...declarations[5], available: mounted, target: args => args.characterId, run({ characterId, ...args }, context) {
-		const character = characterOf(ports, characterId), take = installed(characterId), scene = motionScene(ports.state().objects);
+		const character = characterOf(ports, characterId), take = installed(characterId), scene = sceneFor(character);
 		const { spec, keyed } = asArgument(() => keyObject(take.spec, scene, args, expandUse(take.spec, { sk: rigOf(character), scene, lenient: true }).spec.objects));
 		return after(compile(character, spec, { lenient: true }, { prompt: take.prompt }), r => {
 			const timing = put(character, r.take, context);
-			return { affectedIds: [characterId], summary: `${keyed.removed ? "Removed the key of" : "Keyed"} ${keyed.objectId} at f${keyed.f}; QA ${r.qa.ok ? "clean" : `${r.qa.total} issues`}; installed.`,
+			return { affectedIds: [characterId], summary: `${keyed.removed ? "Removed the key of" : "Keyed"} ${keyed.objectId} at f${keyed.f}; QA ${qaSay(r.qa)}; installed.`,
 				output: report(r, { frames: r.frameCount, fps: TIMELINE_FPS, installed: true, keyed }, timing ? { timing } : {}), ...workerWarning() };
 		});
 	} });

package/src/commands/objects.js

@@ -24,7 +24,7 @@ const PATCH_HINTS = { scale: 'use scaleX, scaleY, scaleZ', rotY: 'use rot for ya
 const mutation = (id, label, input) => ({ id, label, description: label, kind: 'mutation', undoDomain: 'objects', input });
 const semantic = [
 	mutation('object.set', 'Set object fields', setInput),
-	mutation('object.add', 'Add object', input({ kind: { type: 'string' }, placement, name: { type: 'string' }, parent: id, first: { type: 'boolean' } }, ['kind'])),
+	mutation('object.add', 'Add object', input({ kind: { type: 'string' }, placement, name: { type: 'string' }, parent: id, first: { type: 'boolean' }, text: setInput.properties.set.properties.text }, ['kind'])),
 	// A clay prop from a recipe of soft parts (docs/sculpt-from-image.md). With `id` it re-sculpts that
 	// sculpt in place (one undo); without, it creates one. The recipe is checked by sculpt-recipe.js.
 	{ ...mutation('object.sculpt', 'Sculpt a clay prop from a recipe', input({ recipe: { type: 'object', properties: {}, additionalProperties: true }, edits: { type: 'array', minItems: 1, maxItems: 48, items: { type: 'object', properties: {}, additionalProperties: true } }, id, name: { type: 'string', maxLength: 240 }, placement, parent: id }, [])),
@@ -75,7 +75,7 @@ export function register(registry, ports) {
 		'object.add': args => {
 			const before = owned().read();
 			if (args.parent !== undefined) objectOf(args.parent);
-			const object = createSceneObject(args.kind, before, args.placement);
+			const object = createSceneObject(args.kind, before, args.placement, args.text);
 			if (!object) fail('INVALID_ARGUMENT', `Unknown object kind: ${args.kind}`);
 			const placed = updateSceneObject([object], object.id, { ...(args.placement ?? {}), ...(args.name === undefined ? {} : { name: args.name }) })[0];
 			// `first`: the Outliner lists Props in record order, so a UI-made object

package/src/commands/shot.js

@@ -22,10 +22,9 @@ const number = { type: 'number' };
 const frame = { type: 'integer', minimum: 0 };
 const input = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
 const mutation = (id, label, schema, description = label) => ({ id, label, description, kind: 'mutation', undoDomain: 'shot', input: schema });
-const existing = ['shot.create', 'shot.createStill', 'shot.setCaption', 'shot.setCastOverride', 'shot.setHold', 'shot.split', 'shot.duplicate', 'shot.remove', 'shot.setRange', 'shot.setCameraRail', 'shot.clearCameraRail', 'shot.reorder'].map(studioActionDeclaration);
+const existing = ['shot.create', 'shot.createStill', 'shot.setCaption', 'shot.setCastOverride', 'shot.setHold', 'shot.split', 'shot.duplicate', 'shot.remove', 'shot.setRange', 'shot.setCameraRail', 'shot.clearCameraRail', 'shot.setCameraMode', 'shot.rename', 'shot.reorder'].map(studioActionDeclaration);
 const extra = [
   mutation('shot.set', 'Set shot fields', elementSetSchema('shot')),
-  mutation('shot.rename', 'Rename shot', input({ shotId: id, name: { type: 'string', maxLength: 240 } })),
   mutation('shot.setCamera', 'Set camera block', input({ shotId: id, patch: { type: 'object', properties: {}, additionalProperties: true } })),
   mutation('shot.addKey', 'Add camera key', input({ shotId: id, frame })),
   mutation('shot.moveKey', 'Move camera key', input({ shotId: id, keyId: id, frame })),
@@ -159,6 +158,11 @@ export function register(registry, ports) {
       patchShot(shotId, shot => ({ ...shot, camera: removeCameraRail(shot.camera) }));
     },
     'shot.rename': ({ shotId, name }) => { shotOf(shotId); owner().write(current => renameShot(current, shotId, name)); },
+    'shot.setCameraMode': ({ shotId, mode }) => {
+      const shot = shotOf(shotId);
+      if (mode === 'rail' && !createCameraBlock(shot.camera).cameraRail) fail('TARGET_NOT_READY', `${shot.name || shotId} has no camera rail; lay one with shot.setCameraRail.`);
+      patchShot(shotId, row => ({ ...row, camera: updateCameraBlock(row.camera, { mode }) }));
+    },
     'shot.setCamera': ({ shotId, patch }) => patchShot(shotId, shot => ({ ...shot, camera: updateCameraBlock(shot.camera, patch) })),
     'shot.addKey': ({ shotId, frame }) => {
       const shot = shotOf(shotId), target = Math.min(owner().state().frameCount - 1, frame);

package/src/domains/motion/take-source.js

@@ -22,7 +22,7 @@ const finite3 = value => Array.isArray(value) && value.length === 3 && value.eve
 export function takeSource(take, sceneObjects = []) {
 	if (!isTakeV3(take) || !plain(take.spec)) return null;
 	return structuredClone({ schema: TAKE_SCHEMA, rig: take.rig, spec: take.spec,
-		placement: { position: take.placement?.position ?? [0, 0, 0], yaw: take.placement?.yaw ?? 0 }, scene: motionScene(sceneObjects) });
+		placement: { position: take.placement?.position ?? [0, 0, 0], yaw: take.placement?.yaw ?? 0 }, scene: { ...motionScene(sceneObjects), ...(plain(take.people) ? { people: take.people } : {}) } });
 }
 
 /** A saved source (with the Studio take id it carried), checked and owned by the caller; null when it is not one. */
@@ -31,8 +31,10 @@ export function normalizeTakeSource(value) {
 	if (!plain(value.spec) || value.spec.schema !== SPEC_SCHEMA || !Number.isFinite(value.spec.frames)) return null;
 	if (!plain(value.placement) || !finite3(value.placement.position) || !Number.isFinite(value.placement.yaw)) return null;
 	const objects = plain(value.scene?.objects) ? value.scene.objects : {}, others = plain(value.scene?.others) ? { others: value.scene.others } : {};
+	// the joints a person anchor named when it was compiled (people.js keptPeople)
+	const people = plain(value.scene?.people) && Object.values(value.scene.people).every(p => plain(p) && Array.isArray(p.names) && Array.isArray(p.P) && p.P.length === p.frames * p.names.length * 3) ? { people: value.scene.people } : {};
 	return structuredClone({ schema: TAKE_SCHEMA, rig: value.rig, spec: value.spec,
-		placement: { position: value.placement.position, yaw: value.placement.yaw }, scene: { objects, ...others },
+		placement: { position: value.placement.position, yaw: value.placement.yaw }, scene: { objects, ...others, ...people },
 		...(typeof value.takeId === "string" && value.takeId ? { takeId: value.takeId } : {}),
 		...(normalizeTakeEdit(value.edit, value.spec.frames) ? { edit: normalizeTakeEdit(value.edit, value.spec.frames) } : {}) });
 }

package/src/draft-ghost.js

@@ -6,6 +6,7 @@
 // GIZMO_LAYER, so captures, contact sheets and exports never see it.
 import { useSyncExternalStore } from "react";
 import { ko } from "./locale.js";
+import { qaLabel } from "./qa-label.js";
 
 /** Teal: apart from the onion skin's blue (before) and orange (after). */
 export const DRAFT_GHOST_COLOR = "#2fc79a";
@@ -28,8 +29,8 @@ export function draftGhostState(draft, now) {
 	return { shown: true, opacity: +opacity.toFixed(3), frame: Math.floor((age / 1000) * fps) % take.frameCount };
 }
 
-/** "Draft 3 · QA 31" ("초안 3 · QA 31"). */
-export const draftLabel = draft => `${ko("Draft", "초안")} ${draft?.n ?? 0} · QA ${draft?.qa?.total ?? 0}`;
+/** "Draft 3 · 2 problems" ("초안 3 · 문제 2개"), "Draft 7 · QA clean": problems, not frame-level issues (qa-label.js). */
+export const draftLabel = draft => `${ko("Draft", "초안")} ${draft?.n ?? 0} · ${qaLabel(draft?.qa)}`;
 
 let shown = true;
 const listeners = new Set();

package/src/motion/beat-board-model.js

@@ -63,7 +63,7 @@ export function beatBoardModel(draft, motion) {
 	for (const block of blocks) block.rows = rows;
 	const spans = groups.map(g => ({ f0: g.first ?? 0, f1: g.last ?? g.first ?? 0, text: `${g.kind} ${g.subject}` })).sort((a, b) => a.f0 - b.f0);
 	const marks = goals.map(g => ({ f: g.at, ok: !!g.ok, text: goalText(g) })).sort((a, b) => a.f - b.f);
-	return { mode, n: draft.n, total: draft.qa?.total ?? 0, ok: !!draft.qa?.ok, blocks, spans, marks };
+	return { mode, n: draft.n, total: draft.qa?.total ?? 0, ok: !!draft.qa?.ok, qa: draft.qa ?? null, blocks, spans, marks };
 }
 
 /** One goal as a line: "✓ name 1.2 cm (≤ 2 cm)"; a distance in metres reads in cm. */

package/src/motion/beat-board.jsx

@@ -8,6 +8,7 @@ import { useSyncExternalStore } from "react";
 import { ko } from "../locale.js";
 import { latestDraft, progressVersion, subscribeProgress } from "../agent-progress.js";
 import { beatBoardModel, blockTitle } from "./beat-board-model.js";
+import { draftLabel } from "../draft-ghost.js";
 import "./beat-board.css";
 
 function stateChip(block) {
@@ -51,7 +52,7 @@ export function BeatBoard({ motion, frame, displayFrameCount, clipPct, onJump })
 			{model.mode === "draft" && (
 				<span className={"tl-beat-head" + (model.ok ? " ok" : "")} data-testid="beat-board-head"
 					title={ko("The agent's newest draft, not installed yet", "에이전트가 만든 최신 초안 (아직 적용 전)")}>
-					{ko(`Draft ${model.n} · QA ${model.total}`, `초안 ${model.n} · QA ${model.total}`)}
+					{draftLabel({ n: model.n, qa: model.qa })}
 				</span>
 			)}
 		</div>

package/src/motion3/compile-job.js

@@ -10,6 +10,7 @@ import { compileSpec, liftRequest } from "./pipeline.js";
 import { repairSpec } from "./repair.js";
 import { bakeTake } from "./take.js";
 import { skeletonFor } from "./rigs/index.js";
+import { keptPeople } from "./people.js";
 
 const TIMELINE_FPS = 24;
 const refuse = (code, message) => { throw Object.assign(new Error(message), { code }); };
@@ -52,6 +53,9 @@ export function runCompileJob({ model, scene, spec: asked, probes: sentProbes, c
 	// ms.repair: the whole repair's wall time, so a sweep that repairs every variant shows what it costs
 	const r = fixed.result, label = fixed.spec?.label ?? null, ms = fixed.repair ? { ...r.ms, repair: Math.round(performance.now() - t0) } : r.ms;
 	const take = bake ? bakeTake(sk, r.out, { position: bake.position, yaw: bake.yaw }, { spec: r.stored, prompt: ("prompt" in bake ? bake.prompt : label) ?? "" }) : undefined;
+	// a person anchor's joints ride with the take, so its saved source compiles the same without the others' takes (people.js)
+	const people = take && keptPeople(scene, [r.expanded, r.stored]);
+	if (people) take.people = people;
 	return { stored: r.stored, qa: r.qa, observations: r.observations, used: r.used, fixed: r.fixed, search: r.search, timeline: r.timeline,
 		...(r.probes ? { probes: r.probes } : {}), ...(r.notes ? { notes: r.notes } : {}), ms, frameCount: r.out.frameCount, label,
 		...(fixed.repair ? { repair: fixed.repair } : {}), ...(take ? { take } : {}) };