cozyclay 2.0.2 → 2.1.0

package/src/domains/cast.js

@@ -12,7 +12,8 @@ import {
 	captureHipsOffset,
 	saveCustomPoses,
 } from "../poses.js";
-import { createCharacterEntry, createCharacterLayer } from "../scenes.js";
+import { createCharacterEntry, createCharacterLayer, isProxyFigure, PROXY_FIGURE_MODEL } from "../scenes.js";
+import { kindRefusal } from "../character-kind.js";
 import {
 	DEFAULT_SUBJECT,
 	DEFAULT_SUBJECT2,
@@ -28,12 +29,12 @@ import { judgeNextWaypoint } from "../ardy/waypoints.js";
 import { StudioProtocolError } from "../studio-agent-protocol.js";
 import { studioActionRefusal } from "../studio-actions.js";
 import { createStableItemId, removeStableItem } from "../stable-items.js";
-import { trackFeature } from "../analytics.js";
+import { track, trackFeature } from "../analytics.js";
 import { requestBridgeExtract } from "../multimodel-ingest.js";
 import { loadMotionFromUrl } from "../ardy/npz.js";
 import { snapshotPlaybackBones, applyMotionFrame, restorePlaybackBones } from "../ardy/playback.js";
 
-import { HISTORY_LIMIT } from "../history.js";
+import { shotAtFrame } from "../cuts.js";
 
 const sameCastValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 
@@ -43,7 +44,7 @@ export function createCastDomain(appContext, initial, customPoses = []) {
 	let native = createDocumentStore({ owned: { cast: normalize(initial) } });
 	const listeners = new Set(), motions = new Map();
 	const notify = () => { for (const listener of listeners) listener(); };
-	let release = native.subscribe(notify), loading = false;
+	let release = native.subscribe(notify);
 	const documentStore = { ...Object.fromEntries(Object.keys(native).map(key => [key, (...args) => native[key](...args)])),
 		subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); } };
 	const state = () => documentStore.read('cast'), read = () => state().characters;
@@ -74,6 +75,25 @@ export function createCastDomain(appContext, initial, customPoses = []) {
 	function write(update) {
 		return writeState(before => ({ ...before, characters: typeof update === 'function' ? update(before.characters) : update }));
 	}
+	function update(characterId, patch) {
+		const entry = read().find(entry => entry.id === characterId);
+		if (!entry) throw new StudioProtocolError('STALE_TARGET', `Character ${characterId} is not in this scene.`);
+		const raw = appContext.ports.read(), shot = shotAtFrame(raw.shots, raw.view.frame);
+		const fields = ['x', 'z', 'rot', 'posture', 'pose'];
+		const panelPatch = Object.fromEntries(Object.entries(patch).filter(([key, value]) => fields.includes(key) && value !== undefined));
+		if (shot?.kind === 'still' && !raw.targets?.get?.(characterId)?.motion && Object.keys(panelPatch).length) {
+			const current = { ...entry, ...shot.cast[characterId] };
+			const normalized = createCharacterEntry({ ...current, ...panelPatch });
+			const override = { x: normalized.x, z: normalized.z, rot: normalized.rot };
+			for (const key of ['posture', 'pose']) if (normalized[key] != null) override[key] = normalized[key];
+			// Enlist the shot owner in the already-open command/drag session:
+			// even a mixed scale + placement edit is one shared Undo entry.
+			const shots = appContext.storeDomain('shot');
+			appContext.recordAction('shot', () => shots.setCastOverride(shot.id, characterId, override), null, true);
+			patch = Object.fromEntries(Object.entries(patch).filter(([key]) => !fields.includes(key)));
+		}
+		if (Object.keys(patch).length) write(rows => rows.map(row => row.id === characterId ? { ...row, ...patch } : row));
+	}
 	function publishMotion(characterId, motion) {
 		if (motion) motions.set(characterId, motion); else motions.delete(characterId);
 		publish(); notify();
@@ -109,7 +129,7 @@ export function createCastDomain(appContext, initial, customPoses = []) {
 		}
 		return run('run.update', { txId: gesture.txId, args });
 	}
-	const domain = { documentStore, state, read, write, writeState, run, edit, beginGesture, finishGesture,
+	const domain = { documentStore, state, read, write, update, writeState, run, edit, beginGesture, finishGesture,
 		activeId: read()[0]?.id ?? null, projection: () => projection, publishMotion, normalizeCharacters: rows => rows.map(createCharacterEntry),
 		bindRender(context) { appContext = context; },
 		beginAction: () => documentStore.beginAction('cast'), canUndo: id => documentStore.canUndo(id),
@@ -121,13 +141,11 @@ export function createCastDomain(appContext, initial, customPoses = []) {
 			write(plan.draft); return plan;
 		},
 		load(value) {
-			finishGesture(true); loading = true;
-			try {
-				release(); native.dispose(); motions.clear();
-				const next = normalize(Array.isArray(value) ? { characters: value, customPoses: state().customPoses } : value);
-				native = createDocumentStore({ owned: { cast: next } }); release = native.subscribe(notify);
-				domain.activeId = read()[0]?.id ?? null; domain.loadView?.(); notify();
-			} finally { loading = false; }
+			finishGesture(true);
+			release(); native.dispose(); motions.clear();
+			const next = normalize(Array.isArray(value) ? { characters: value, customPoses: state().customPoses } : value);
+			native = createDocumentStore({ owned: { cast: next } }); release = native.subscribe(notify);
+			domain.activeId = read()[0]?.id ?? null; domain.loadView?.(); notify();
 		},
 		dispose() { finishGesture(true); unregister(); unsubscribe(); release(); native.dispose(); listeners.clear(); },
 	};
@@ -164,7 +182,6 @@ export function useCast(appContext) {
 
 	const [poseRevision, setPoseTick] = useState(0);
 
-	/* --------------------- derived cast view + shims ---------------------- */
 	// Fallback second slot mirrors the old charB defaults so preset math and
 	// the two-subject inspector never see a hole before B exists.
 	const charA = characters[0] ?? createCharacterEntry(null, 0);
@@ -181,29 +198,12 @@ export function useCast(appContext) {
 
 	const subject2 = charB.subject ?? DEFAULT_SUBJECT2;
 
-	const rigA = rigs[charA.id] ?? null;
-
-	const rigB = (characters[1] ? rigs[charB.id] : null) ?? null;
-
 	function updateCharacterAt(index, next) {
-		const entry = domain.read()[index];
+		const base = domain.read()[index], raw = appContext.ports.read();
+		const entry = base && { ...base, ...shotAtFrame(raw.shots, raw.view.frame)?.cast[base.id] };
 		if (entry) return domain.edit('character.update', { characterId: entry.id, patch: typeof next === 'function' ? next(entry) : next });
 	}
 
-	// The shims keep the legacy call sites (inspector sliders, presets, pose
-	// studio, prompts) untouched while the list stays the source of truth.
-	const setCharA = (next) => updateCharacterAt(0, next);
-
-	const setCharB = (next) => updateCharacterAt(1, next);
-
-	const setPoseA = (pose) => updateCharacterAt(0, (entry) => ({ pose: typeof pose === "function" ? pose(entry.pose ?? DEFAULT_POSE) : pose }));
-
-	const setPoseB = (pose) => updateCharacterAt(1, (entry) => ({ pose: typeof pose === "function" ? pose(entry.pose ?? DEFAULT_POSE) : pose }));
-
-	const setSubject = (value) => updateCharacterAt(0, (entry) => ({ subject: typeof value === "function" ? value(entry.subject) : value }));
-
-	const setSubject2 = (value) => updateCharacterAt(1, (entry) => ({ subject: typeof value === "function" ? value(entry.subject) : value }));
-
 	function setShowB(next) {
 		return domain.run('cast.showExtras', { show: typeof next === 'function' ? next(domain.read().some((entry, i) => i > 0 && !entry.hidden)) : next });
 	}
@@ -221,7 +221,8 @@ export function useCast(appContext) {
 	}
 
 	function moveCharacter(charId, next) {
-		const entry = domain.read().find(entry => entry.id === charId);
+		const base = domain.read().find(entry => entry.id === charId), raw = appContext.ports.read();
+		const entry = { ...base, ...shotAtFrame(raw.shots, raw.view.frame)?.cast[charId] };
 		return domain.edit('character.update', { characterId: charId, patch: typeof next === 'function' ? next(entry) : next });
 	}
 
@@ -258,6 +259,7 @@ export function useCast(appContext) {
 	const spawnCharacter = (model, x, z) => {
 		const id = nextCharacterId(domain.read());
 		domain.run('character.add', { character: { id, model, x, z, pose: DEFAULT_POSE, subject: 'a person' } });
+		if (model === PROXY_FIGURE_MODEL) track("cast:proxy_added", { surface: "assets" });
 		appContext.shared.setSelectedHierarchyId(`character:${id}`);
 		appContext.notify(ko("Character added to the scene", "인물을 씬에 추가했어요"));
 	};
@@ -270,7 +272,6 @@ export function useCast(appContext) {
 		return `character:${key.startsWith("char:") ? key.slice(5) : key}`;
 	};
 
-	/* ------------------- active character (motion layer) ------------------- */
 	// Every character owns an animation layer (root path, prompt blocks,
 	// generated clip, IK keys). The studio's motion machinery edits ONE layer
 	// at a time — the ACTIVE character's — and selection decides who that is.
@@ -332,9 +333,6 @@ export function useCast(appContext) {
 		waypointFrames: (entry.layer?.waypoints ?? []).map((waypoint) => waypoint.frame),
 	}]), [characters, activeChar.id]);
 
-	// Undo/redo (plan §6.5). The store settles any open drag first, so a
-	// mid-drag press commits that drag as one entry and then steps past it.
-	// After a step the selection can point at a deleted object — drop it to
 	/* Cast authoring uses the registered store. The native compatibility
 	 * snapshot remains for motion/IK until its owner migrates; it must not
 	 * restore the owned cast over newer character edits. */
@@ -424,10 +422,9 @@ export function useCast(appContext) {
 	const posedRig = () => rigs[posing] ?? null;
 
 	const setPosed = (pose) => {
-		if (posingIndex >= 0) updateCharacterAt(posingIndex, { pose: typeof pose === "function" ? pose(posingChar?.pose ?? DEFAULT_POSE) : pose });
+		if (posingIndex >= 0) updateCharacterAt(posingIndex, entry => ({ pose: typeof pose === "function" ? pose(entry.pose ?? DEFAULT_POSE) : pose }));
 	};
 
-	/* ------------------------- waypoint workspace --------------------------- */
 	// A walking pace turns clicked distance into clip time, so pins land at
 	// frames the character can actually reach without ice-skating.
 	const WALK_SPEED_MPS = 1.4;
@@ -681,6 +678,23 @@ export function useCast(appContext) {
 			: ko(`Saved the current pose to the library as “${pose.label}”`, `지금 자세를 “${pose.label}”로 라이브러리에 저장했어요`));
 	}
 
+	/** A handle drag is an authored pose. When it ends, the rig as it now
+	 * stands becomes the posed character's own pose — so the scene autosaves
+	 * it and undo can step it back — instead of living only on the rig until
+	 * a reload re-applies the stored pose over it. The library is untouched;
+	 * Save pose still bottles a pose there. */
+	function commitPosedPose() {
+		const rig = posedRig();
+		if (!rig || !posingChar) return;
+		domain.run('character.setPose', { characterId: posingChar.id, clearMotion: false, pose: {
+			id: `edited:${posingChar.id}`,
+			label: ko("Edited pose", "편집한 포즈"),
+			prompt: "in the exact body pose shown in the blocking frame",
+			bones: capturePose(rig),
+			rootY: captureHipsOffset(rig),
+		} });
+	}
+
 	function savePose() {
 		const rig = posedRig();
 		if (!rig) return;
@@ -720,6 +734,8 @@ export function useCast(appContext) {
 		setPhotoPoseState("running");
 		setPhotoPoseError("");
 		try {
+			// A capsule figure has no bones for a photo to pose.
+			if (isProxyFigure(posingChar ?? activeChar)) throw new StudioProtocolError("TARGET_NOT_READY", kindRefusal("photoPose", isKo));
 			if (!rig) throw new Error("rig-not-loaded");
 			objectUrl = URL.createObjectURL(file);
 			let bones = null;
@@ -907,7 +923,9 @@ export function useCast(appContext) {
 			const live = appContext.live.state;
 			const patch = finitePatch(args, ["x", "z", "rot"]);
 			const id = nextCharacterId(live.characters);
-			replaceCharacters([...live.characters, createCharacterEntry({ id, model: args.model, subject: args.subject, pose: DEFAULT_POSE, ...patch }, live.characters.length)]);
+			const entry = createCharacterEntry({ id, model: args.model, subject: args.subject, pose: DEFAULT_POSE, ...patch }, live.characters.length);
+			replaceCharacters([...live.characters, entry]);
+			if (isProxyFigure(entry)) track("cast:proxy_added", { surface: "mcp" });
 			return { id };
 		}
 		function updateLiveCharacter(args) {
@@ -947,7 +965,6 @@ export function useCast(appContext) {
 				if (typeof block.text !== "string" || !block.text.trim()) throw new Error(`Block ${i + 1} needs text`);
 				return { id: `prompt-${stamp}-${i}`, startFrame, endFrame, text: block.text.trim() };
 			});
-			const live = appContext.live.state;
 			domain.run('character.setPromptBlocks', { characterId: domain.activeId, blocks: clips });
 			return { blocks: clips.length };
 		}
@@ -982,14 +999,14 @@ export function useCast(appContext) {
 			const motion = appContext.storeDomain('motion');
 			if (motion) motion.clear(characterId); else appContext.shared.motionDomain.clearMotionNative();
 		}, characterId, true);
-		domain.write(rows => rows.map(entry => entry.id === characterId ? { ...entry, pose } : entry));
+		domain.update(characterId, { pose });
 	};
 	appContext.updateActionPorts({ addCharacterWaypoint, moveCharacterWaypoint, removeCharacterWaypoint, clearCharacterWaypoints, setWaypointMode });
 	return {
 		...domain,
 		applyExternalCharacters, publishStudioCharacters, syncStudioLayerBuffer, undoScene, redoScene, snapshotStudioDomain, removeLegacyRootWaypoint, switchActiveCharacterLayer, createLegacyCastHandlers, toggleCharacterHidden,
 		characters, editCharacters, customPoses, posing, setPosing, posingClosing,
-		studioPick, setStudioPick, rigs, rigMountEpoch, setRigMountEpoch, setPoseTick, charA, charB, showB,
+		studioPick, setStudioPick, commitPosedPose, rigs, rigMountEpoch, setRigMountEpoch, setPoseTick, charA, charB, showB,
 		poseA, poseB, subject, subject2, updateCharacterAt, setShowB, moveCharacter, removeCharacter, reportRig,
 		spawnCharacter, charKeyToHierarchyId, charIdFromHierarchyId, activeCharacterId, setActiveCharacterId,
 		rowIdForCharIndex, activeChar, selectActiveCharacterInHierarchy, activeCharIndex, activeRig, waitForRig,

package/src/domains/motion/motion-intent-codec.js

@@ -0,0 +1,50 @@
+import * as THREE from "three";
+
+const sameMotionIntent = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+const emptyMotionLayer = id => ({ id, take: null, fullTake: null, ikKeys: [], ikPins: [], ikPinResiduals: [], committedIkEdits: [], takeRecipe: null, takeVersions: [] });
+const keyVector = p => ({ x: p.x, y: p.y, z: p.z });
+const keyQuaternion = q => ({ ...keyVector(q), w: q.w });
+function encodeMotionKeys(keys) {
+	return [...keys].sort(([a], [b]) => a - b).map(([frame, tracks]) => ({ frame, tracks: Object.fromEntries([...tracks].map(([track, key]) => [track, {
+		...(key.q ? { q: key.q.map(keyQuaternion) } : {}), ...(key.p ? { p: keyVector(key.p) } : {}),
+		...(key.baseQ ? { baseQ: key.baseQ.map(keyQuaternion) } : {}), ...(key.basePos ? { basePos: keyVector(key.basePos) } : {}),
+		...(key.chainP ? { chainP: key.chainP.map(keyVector) } : {}), ...(key.keepTranslations ? { keepTranslations: true } : {}),
+		...(key.correctionRange ? { correctionRange: { start: key.correctionRange.start, end: key.correctionRange.end } } : {}),
+		...(key.blend != null ? { blend: key.blend } : {}),
+		...(key.pin ? { pin: key.pin } : {}),
+	}])) }));
+}
+function decodeMotionKeys(rows) {
+	const q = value => new THREE.Quaternion(value.x, value.y, value.z, value.w).normalize();
+	const p = value => new THREE.Vector3(value.x, value.y, value.z);
+	return new Map(rows.map(row => [row.frame, new Map(Object.entries(row.tracks).map(([track, key]) => [track, {
+		q: key.q?.map(q) ?? null, p: key.p ? p(key.p) : null,
+		...(key.baseQ ? { baseQ: key.baseQ.map(q) } : {}), ...(key.basePos ? { basePos: p(key.basePos) } : {}),
+		...(key.chainP ? { chainP: key.chainP.map(p) } : {}), ...(key.keepTranslations ? { keepTranslations: true } : {}),
+		...(key.correctionRange ? { correctionRange: { start: key.correctionRange.start, end: key.correctionRange.end } } : {}),
+		...(key.blend != null ? { blend: key.blend } : {}),
+		...(key.pin ? { pin: key.pin } : {}),
+	}]))]));
+}
+function cloneRangePin(pin) {
+	return {
+		...pin,
+		target: pin.target.space === "world"
+			? { space: "world", position: [...pin.target.position] }
+			: { space: "object", objectId: pin.target.objectId, local: [...pin.target.local] },
+	};
+}
+function encodeRangePins(pins) {
+	return [...(pins instanceof Map ? pins.values() : pins ?? [])].map(cloneRangePin);
+}
+function decodeRangePins(rows) {
+	return new Map((rows ?? []).map((pin) => [pin.id, cloneRangePin(pin)]));
+}
+function encodeRangePinResiduals(values) {
+	return [...(values instanceof Map ? values.entries() : values ?? [])].map(([id, entries]) => [id, (entries ?? []).map((entry) => ({ ...entry }))]);
+}
+function decodeRangePinResiduals(rows) {
+	return new Map((rows ?? []).map(([id, entries]) => [id, (entries ?? []).map((entry) => ({ ...entry }))]));
+}
+
+export { sameMotionIntent, emptyMotionLayer, encodeMotionKeys, decodeMotionKeys, cloneRangePin, encodeRangePins, decodeRangePins, encodeRangePinResiduals, decodeRangePinResiduals };

package/src/domains/motion/motion-range-pin-rules.js

@@ -0,0 +1,23 @@
+import { rangePinTracks } from "../../ardy/range-pin.js";
+import { ko } from "../../locale.js";
+
+export function ensureRangePinState(state) {
+	if (!state) return state;
+	if (!(state.pins instanceof Map)) state.pins = new Map();
+	if (!(state.pinResiduals instanceof Map)) state.pinResiduals = new Map();
+	return state;
+}
+export function rangePinConflictFrames(draft, state) {
+	if (!Number.isInteger(draft?.startFrame) || !Number.isInteger(draft?.endFrame) || draft.endFrame < draft.startFrame) return [];
+	const tracks = rangePinTracks(draft), conflicts = [];
+	for (let frame = draft.startFrame; frame <= draft.endFrame; frame += 1) {
+		if (tracks.some((track) => { const key = state.keys.get(frame)?.get(track); return key && key.pin !== draft.id; })) conflicts.push(frame);
+	}
+	return conflicts;
+}
+export function overlappingRangePin(draft, state) {
+	return [...ensureRangePinState(state).pins.values()].find((pin) => pin.id !== draft.id && rangePinTracks(pin).some((track) => rangePinTracks(draft).includes(track)) && Math.max(pin.startFrame, draft.startFrame) <= Math.min(pin.endFrame, draft.endFrame));
+}
+export function rangePinOverlapMessage(pin) {
+	return pin ? ko(`A required body or limb track already has an overlapping pin (${pin.startFrame}–${pin.endFrame}).`, `필요한 몸통 또는 팔다리 파츠에 겹치는 고정이 있어요 (${pin.startFrame}–${pin.endFrame}).`) : "";
+}