cozyclay 3.2.0 → 3.2.1

package/src/sculpt-shelf.js

@@ -0,0 +1,108 @@
+// The sculpt shelf (#740 S9 + S13): sculpt cards in the shared asset store
+// (`cozyclay.assets`, scene-assets.js) under `sculpt-` ids. The store belongs to
+// this browser, not to a project, so every project and every scene sees the
+// same cards: that is the cross-project library. Nothing here leaves the
+// machine; a card travels only as a `.cozysculpt.json` the user saves.
+//
+// The Content pane's Sculpts folder subscribes here; Save to shelf, import and
+// delete publish the new list. `openDb` is injectable for the node tests.
+import { deleteAsset, getAsset, listAssetIds, openAssetDb, putAsset } from "./scene-assets.js";
+import { isSculptAssetId, parseCard, readSculptCard, sculptCardFileName, sculptCardRecord, SCULPT_CARD_TYPE } from "./sculpt-shelf-file.js";
+import { renderSculptThumb } from "./sculpt-thumb.js";
+import { saveExport } from "./export-workspace.js";
+import { ko } from "./locale.js";
+
+const listeners = new Set();
+// null until the first read: the folder shows skeletons, not "no cards".
+let cards = null;
+
+function publish(next) {
+	cards = Object.freeze(next);
+	for (const listener of listeners) listener();
+}
+
+/** The cards, newest name order: [{ id, name, recipe, thumb }] or null before the first read. */
+export const sculptShelfCards = () => cards;
+export function subscribeSculptShelf(listener) {
+	listeners.add(listener);
+	return () => listeners.delete(listener);
+}
+
+async function withDb(openDb, work) {
+	const db = await openDb();
+	try {
+		return await work(db);
+	} finally {
+		db?.close?.();
+	}
+}
+
+/** Re-read every card from the store. Without IndexedDB the shelf is empty. */
+export async function refreshSculptShelf({ openDb = openAssetDb } = {}) {
+	try {
+		const read = await withDb(openDb, async (db) => {
+			const ids = (await listAssetIds(db)).filter(isSculptAssetId);
+			return (await Promise.all(ids.map((id) => getAsset(db, id)))).map(readSculptCard).filter(Boolean);
+		});
+		publish(read.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id)));
+	} catch {
+		publish([]);
+	}
+	return cards;
+}
+
+/** Store one card { name, recipe, thumb }; the same recipe overwrites its card. Answers its id. */
+export async function putSculptCard(card, { openDb = openAssetDb, subtle } = {}) {
+	const record = await sculptCardRecord(card, subtle);
+	await withDb(openDb, (db) => putAsset(db, record));
+	await refreshSculptShelf({ openDb });
+	return record.id;
+}
+
+export async function deleteSculptCard(id, { openDb = openAssetDb } = {}) {
+	if (!isSculptAssetId(id)) return false;
+	await withDb(openDb, (db) => deleteAsset(db, id));
+	await refreshSculptShelf({ openDb });
+	return true;
+}
+
+/** The stored `.cozysculpt.json` text of a card, or null when it is gone. */
+async function sculptCardText(id, { openDb = openAssetDb } = {}) {
+	const record = await withDb(openDb, (db) => getAsset(db, id));
+	return record ? new TextDecoder().decode(record.bytes) : null;
+}
+
+/** Sculpt panel's Save to shelf: a copy of the recipe, its name and a thumbnail. Answers a toast line. */
+export async function saveSculptToShelf(sculpt, { openDb = openAssetDb, renderThumb = renderSculptThumb } = {}) {
+	if (!sculpt?.recipe) return ko("Select a sculpt to save it to the shelf.", "선반에 저장할 조형물을 선택하세요.");
+	try {
+		const thumb = await renderThumb(sculpt.recipe);
+		await putSculptCard({ name: sculpt.name, recipe: sculpt.recipe, thumb }, { openDb });
+		return ko(`${sculpt.name} saved to the shelf — Content › Sculpts`, `${sculpt.name} 선반에 저장됨 — 콘텐츠 › 조형물`, `${sculpt.name} 已保存到架子 — 内容 › 雕塑`);
+	} catch (error) {
+		return ko(`Could not save to the shelf: ${error.message}`, `선반에 저장하지 못했어요: ${error.message}`, `无法保存到架子：${error.message}`);
+	}
+}
+
+/** Import `.cozysculpt.json` files as cards. Answers a toast line naming what came in or why not. */
+export async function importSculptCardFiles(files, { openDb = openAssetDb } = {}) {
+	const names = [], problems = [];
+	for (const file of Array.from(files ?? [])) {
+		const parsed = parseCard(await file.text());
+		if (!parsed.ok) problems.push(`${file.name}: ${parsed.error}`);
+		else {
+			await putSculptCard(parsed.card, { openDb });
+			names.push(parsed.card.name);
+		}
+	}
+	if (problems.length) return ko(`Not imported — ${problems.join("; ")}`, `가져오지 못했어요 — ${problems.join("; ")}`, `未导入 — ${problems.join("; ")}`);
+	return names.length ? ko(`Imported ${names.join(", ")}`, `가져옴: ${names.join(", ")}`, `已导入 ${names.join("、")}`) : "";
+}
+
+/** Save one card as `<name>.cozysculpt.json` through the export workspace (or a download). */
+export async function exportSculptCard(card, { openDb = openAssetDb } = {}) {
+	const text = await sculptCardText(card.id, { openDb });
+	if (!text) return ko("That card is no longer on the shelf.", "이 카드는 이미 선반에 없어요.");
+	const result = await saveExport(new Blob([text], { type: SCULPT_CARD_TYPE }), sculptCardFileName(card.name));
+	return ko(`Saved ${result.name ?? sculptCardFileName(card.name)}`, `${result.name ?? sculptCardFileName(card.name)} 저장됨`, `已保存 ${result.name ?? sculptCardFileName(card.name)}`);
+}

package/src/sculpt-stage.jsx

@@ -5,6 +5,9 @@ import { useFrame, useThree } from "@react-three/fiber";
 import { OrbitControls, PerspectiveCamera } from "@react-three/drei";
 import * as THREE from "three";
 import { SCULPT_LAYER, isolatedObjectIds, sculptFraming } from "./sculpt-mode.js";
+import { pickSculptPart } from "./sculpt-pick.js";
+import { SculptPartOutline } from "./sculpt-part-outline.jsx";
+import { SculptPartGizmo } from "./sculpt-part-gizmo.jsx";
 
 const SCULPT_FOV = 35;
 // Where a new sculpt lands (object.sculpt without placement): the origin.
@@ -87,9 +90,11 @@ function ClayLump({ at }) {
 
 // How long a changed part glows after an edit lands.
 const FLASH_MS = 1400;
+// A press that travels further than this is an orbit, not a click.
+const CLICK_SLOP_PX = 4;
 
-export function SculptTurntable({ camRef, objects, target, size, view, light = false, busy = false, changedParts = null }) {
-	const { scene, raycaster, invalidate } = useThree();
+export function SculptTurntable({ camRef, objects, target, size, view, light = false, busy = false, changedParts = null, parts = null }) {
+	const { scene, raycaster, invalidate, gl } = useThree();
 	const [camera, setCamera] = useState(null);
 	// The key light aims at the sculpt; its target must sit in the scene graph.
 	const [lightTarget] = useState(() => new THREE.Object3D());
@@ -146,6 +151,36 @@ export function SculptTurntable({ camRef, objects, target, size, view, light = f
 		return () => { raycaster.layers.mask = mask; };
 	}, [raycaster]);
 
+	// Part picking (#740 S7): a left click (not an orbit drag) on the sculpt
+	// selects the part under it, on empty space clears. The pointer maps into
+	// the main pane, the rect the sculpt camera's projection spans.
+	const partsRef = useRef(parts);
+	partsRef.current = parts;
+	const [pickRay] = useState(() => { const ray = new THREE.Raycaster(); ray.layers.set(SCULPT_LAYER); return ray; });
+	// The part gizmo's controls (#740 S8): a still click on one of its handles
+	// picks the part under it, but never clears the selection.
+	const gizmoRef = useRef(null);
+	useEffect(() => {
+		if (!camera) return undefined;
+		const canvas = gl.domElement;
+		let down = null;
+		const onDown = (event) => { down = event.button === 0 && event.target === canvas ? [event.clientX, event.clientY, Boolean(gizmoRef.current?.axis)] : null; };
+		const onUp = (event) => {
+			const start = down;
+			down = null;
+			if (!start || !partsRef.current?.onSelect || Math.hypot(event.clientX - start[0], event.clientY - start[1]) > CLICK_SLOP_PX) return;
+			const pane = (document.querySelector(".vp-pane.vp-main") ?? canvas).getBoundingClientRect();
+			if (pane.width < 2 || pane.height < 2) return;
+			camera.updateMatrixWorld();
+			pickRay.setFromCamera(new THREE.Vector2(((event.clientX - pane.left) / pane.width) * 2 - 1, -((event.clientY - pane.top) / pane.height) * 2 + 1), camera);
+			const hit = pickSculptPart(pickRay, nodesRef.current);
+			if (hit || !start[2]) partsRef.current.onSelect(hit);
+		};
+		canvas.addEventListener("pointerdown", onDown);
+		window.addEventListener("pointerup", onUp);
+		return () => { canvas.removeEventListener("pointerdown", onDown); window.removeEventListener("pointerup", onUp); };
+	}, [camera, gl, pickRay]);
+
 	useEffect(() => () => {
 		for (const node of taggedRef.current) node.layers.disable(SCULPT_LAYER);
 		taggedRef.current = new Set();
@@ -192,6 +227,8 @@ export function SculptTurntable({ camRef, objects, target, size, view, light = f
 			<PerspectiveCamera ref={(node) => { camRef.current = node; setCamera(node); }} makeDefault fov={SCULPT_FOV} near={0.05} far={100} />
 			{camera && <OrbitControls ref={controlsRef} camera={camera} enableDamping={false} minDistance={0.3} maxDistance={40} autoRotate={spinning} autoRotateSpeed={1.4}
 				onStart={() => setGrabbed(true)} onChange={() => invalidate()} />}
+			<SculptPartOutline nodesRef={nodesRef} selected={parts?.selected ?? null} />
+			<SculptPartGizmo camera={camera} orbitRef={controlsRef} nodesRef={nodesRef} gizmoRef={gizmoRef} recipe={target?.recipe} parts={parts} />
 			<group ref={furnitureRef}>
 				<hemisphereLight args={["#ffffff", "#3a3c42", 0.9]} />
 				<primitive object={lightTarget} position={framing.target} />

package/src/sculpt-thumb.js

@@ -0,0 +1,72 @@
+// The sculpt card's picture (#740 S9): one 256 px frame of the recipe from the
+// front three-quarter view, the turntable's look without the turntable. The
+// camera fit is pure (sculptThumbCamera, node-tested); the render needs WebGL.
+//
+// Each render gets its own small WebGLRenderer and loses its context right
+// after, so a save never holds a second context next to the viewport's. Renders
+// are serialized: two quick saves never build two scatter-heavy groups at once.
+import * as THREE from "three";
+import { buildSculptGroup, disposeSculptGroup } from "./sculpt-geometry.js";
+
+const SCULPT_THUMB_SIZE = 256;
+// Target values: SCULPT_VIEWS (sculpt-mode.js) has front, side and back only.
+const THUMB_YAW = 35;
+const THUMB_ELEVATION = 15;
+const THUMB_FOV = 30;
+
+/**
+ * Where the thumbnail camera stands for a bounding box { min: [x,y,z], max }.
+ * Yaw turns toward the subject's own left (+x) from the front (+z), elevation
+ * lifts it; the distance fits the box's bounding sphere inside the field of
+ * view with a small margin, so any recipe size fills the same frame.
+ */
+export function sculptThumbCamera(box, { yaw = THUMB_YAW, elevation = THUMB_ELEVATION, fov = THUMB_FOV } = {}) {
+	const min = box?.min ?? [0, 0, 0], max = box?.max ?? [0, 0, 0];
+	const target = [0, 1, 2].map((axis) => (min[axis] + max[axis]) / 2);
+	const radius = Math.max(0.05, Math.hypot(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2);
+	const distance = (radius / Math.sin(THREE.MathUtils.degToRad(fov) / 2)) * 1.08;
+	const y = THREE.MathUtils.degToRad(yaw), e = THREE.MathUtils.degToRad(elevation);
+	const position = [target[0] + distance * Math.sin(y) * Math.cos(e), target[1] + distance * Math.sin(e), target[2] + distance * Math.cos(y) * Math.cos(e)];
+	return { position, target, fov, near: Math.max(0.01, distance - radius * 2), far: distance + radius * 2 };
+}
+
+let queue = Promise.resolve();
+
+function renderNow(recipe) {
+	const canvas = document.createElement("canvas");
+	canvas.width = SCULPT_THUMB_SIZE;
+	canvas.height = SCULPT_THUMB_SIZE;
+	const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: true, preserveDrawingBuffer: true });
+	const group = buildSculptGroup(recipe);
+	try {
+		renderer.setSize(SCULPT_THUMB_SIZE, SCULPT_THUMB_SIZE, false);
+		renderer.setClearColor(0x000000, 0);
+		renderer.outputColorSpace = THREE.SRGBColorSpace;
+		const scene = new THREE.Scene();
+		scene.add(new THREE.HemisphereLight(0xfff6ea, 0x5a5048, 1.6));
+		const key = new THREE.DirectionalLight(0xffffff, 2.2);
+		key.position.set(2, 4, 3);
+		scene.add(key, group);
+		const box = new THREE.Box3().setFromObject(group);
+		const fit = sculptThumbCamera(box.isEmpty() ? null : { min: box.min.toArray(), max: box.max.toArray() });
+		const camera = new THREE.PerspectiveCamera(fit.fov, 1, fit.near, fit.far);
+		camera.position.fromArray(fit.position);
+		camera.lookAt(...fit.target);
+		renderer.render(scene, camera);
+		return canvas.toDataURL("image/png");
+	} finally {
+		disposeSculptGroup(group);
+		renderer.dispose();
+		renderer.forceContextLoss();
+	}
+}
+
+/** A PNG data URL of the recipe, or null when this browser cannot draw it. */
+export function renderSculptThumb(recipe) {
+	const run = queue.then(() => renderNow(recipe));
+	queue = run.catch(() => {});
+	return run.catch((error) => {
+		console.warn("[cozyclay] could not draw the sculpt card thumbnail", error);
+		return null;
+	});
+}

package/src/sculpt-views.js

@@ -0,0 +1,75 @@
+// Multi-view sculpt comparison (#970): one sculpt scored against several views
+// of its subject (the blueprint's front, side and back crops), each by
+// compareSculptToReference, then blended by weight into one IoU.
+import { compareSculptToReference } from "./sculpt-compare.js";
+import { patchSculptRecipe } from "./sculpt-recipe.js";
+
+/** The default weight of each view: the front carries the likeness, the side the depth, the back the rest. */
+export const VIEW_WEIGHTS = Object.freeze({ front: 0.6, side: 0.25, back: 0.15 });
+/** A view whose subject's height:width differs from the front's by more than this is drawn at another scale or pose: weight 0. */
+export const VIEW_RATIO_TOLERANCE = 0.35;
+
+/** front (|yaw| <= 45), back (|yaw| >= 135) or side, from the camera yaw in degrees. */
+export function viewOfYaw(yaw) {
+	const turn = Math.abs(((Number(yaw) % 360) + 540) % 360 - 180);
+	return turn <= 45 ? "front" : turn >= 135 ? "back" : "side";
+}
+
+/**
+ * The weight each view gets. `views` are [{ yaw, weight?, heightToWidth }]:
+ * an explicit weight replaces the table's; then any view whose height:width
+ * differs from the front's by more than VIEW_RATIO_TOLERANCE gets weight 0 with
+ * the reason. The front is the front view nearest yaw 0; without one the ratio
+ * rule is skipped. Returns [{ weight, excluded? }] in the views' order.
+ */
+export function viewWeights(views) {
+	const fronts = views.map((view, index) => ({ index, yaw: Math.abs(Number(view.yaw)) })).filter(({ index }) => viewOfYaw(views[index].yaw) === "front");
+	const front = fronts.sort((a, b) => a.yaw - b.yaw)[0];
+	const frontRatio = front ? views[front.index].heightToWidth : null;
+	return views.map((view, index) => {
+		const weight = view.weight ?? VIEW_WEIGHTS[viewOfYaw(view.yaw)];
+		if (!front || index === front.index || !(frontRatio > 0)) return { weight };
+		const difference = Math.abs(view.heightToWidth / frontRatio - 1);
+		if (difference <= VIEW_RATIO_TOLERANCE) return { weight };
+		return { weight: 0, excluded: `height:width ${view.heightToWidth.toFixed(2)} differs from the front's ${frontRatio.toFixed(2)} by ${Math.round(difference * 100)}% (over ${VIEW_RATIO_TOLERANCE * 100}%)` };
+	});
+}
+
+const round = value => Number(value.toFixed(3));
+
+/**
+ * Score `recipe` against every view ([{ yaw, image, weight? }], images RGBA) and
+ * blend the IoUs by weight. The report is the heaviest view's (its sheet too),
+ * with `iou` the weighted one and `views` one row per view.
+ */
+function scoreViews(recipe, views, elevation, weights) {
+	const results = views.map(view => compareSculptToReference(recipe, view.image, { yaw: view.yaw, elevation }));
+	const used = weights ?? viewWeights(views.map((view, index) => ({ yaw: view.yaw, weight: view.weight, heightToWidth: 1 / results[index].report.widthToHeight.reference })));
+	const total = used.reduce((sum, row) => sum + row.weight, 0);
+	if (!(total > 0)) throw new Error("No view carries any weight: every view was excluded or given weight 0.");
+	const primary = used.reduce((best, row, index) => (row.weight > used[best].weight ? index : best), 0);
+	const iou = results.reduce((sum, result, index) => sum + result.report.iou * used[index].weight, 0) / total;
+	const rows = results.map(({ report }, index) => ({ view: viewOfYaw(views[index].yaw), yaw: views[index].yaw, weight: round(used[index].weight / total), iou: report.iou,
+		widthToHeight: report.widthToHeight, missingByBand: report.missingByBand, extraByPart: report.extraByPart.slice(0, 3), ...(used[index].excluded ? { excluded: used[index].excluded } : {}) }));
+	return { result: { report: { ...results[primary].report, iou: round(iou), views: rows }, sheet: results[primary].sheet }, weights: used };
+}
+
+/**
+ * The multi-view twin of scoreSculptAgainstReference: same return shape
+ * ({ result, ranked?, refused? }), so sculpt.compare and compare_sculpt answer
+ * one way. Candidates are scored on the same views with the same weights.
+ */
+export function scoreSculptAgainstViews(recipe, views, { elevation = 0, candidates } = {}) {
+	if (!Array.isArray(views) || !views.length) throw new Error("views needs at least one { yaw, reference }.");
+	const { result, weights } = scoreViews(recipe, views, elevation);
+	if (!candidates) return { result };
+	const ranked = [{ label: "current", result }];
+	const refused = [];
+	for (const candidate of candidates) {
+		const patched = patchSculptRecipe(recipe, candidate.edits);
+		if (!patched.ok) refused.push({ label: candidate.label, error: patched.error });
+		else ranked.push({ label: candidate.label, result: scoreViews(patched.recipe, views, elevation, weights).result });
+	}
+	ranked.sort((a, b) => b.result.report.iou - a.result.report.iou);
+	return { result, ranked, refused };
+}

package/src/semantic-edit.js

@@ -1,6 +1,3 @@
-import { createCameraBlock } from "./camera-block.js";
-import { isBusRunActive } from "./command-bus.js";
-
 // 2: counted from the user's own command-bus receipts (#922); 1 diffed domain values and
 // missed shot, camera and object edits in the real Studio.
 export const FIRST_EDIT_VERSION = 2;
@@ -10,62 +7,6 @@ export const FIRST_EDIT_KINDS = Object.freeze([
 	"prompt_block_add", "prompt_block_edit",
 ]);
 
-// Compare authored values, not object identities. Solvers and pointer callbacks
-// can reconstruct the same pose with floating-point roundoff. Values stay local;
-// only the closed edit-kind vocabulary ever crosses the analytics boundary.
-function equal(a, b) {
-	if (a === b) return true;
-	if (typeof a === "number" && typeof b === "number") return Math.abs(a - b) < 1e-8;
-	if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
-	if (a instanceof Map || b instanceof Map) {
-		return a instanceof Map && b instanceof Map && a.size === b.size
-			&& [...a].every(([key, value]) => b.has(key) && equal(value, b.get(key)));
-	}
-	const keys = Object.keys(a);
-	return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && equal(a[key], b[key]));
-}
-const poseValue = (pose) => ({ bones: pose?.bones ?? {}, rootY: pose?.rootY ?? 0 });
-
-const keyValues = (keys = []) => keys.map(({ frame, framing }) => ({ frame, framing }));
-const shotValue = (shot) => ({ ...shot, camera: createCameraBlock(shot.camera), cameraKeys: keyValues(shot.cameraKeys) });
-
-export function semanticEditKind(domain, before, after) {
-	if (before === after) return null;
-	if (domain === "pose") return equal(before, after) ? null : "pose_edit";
-	
-	if (domain === "objects") {
-		const added = after.find((item) => !before.some((previous) => previous.id === item.id));
-		if (added) return added.renderer === "cutout" ? "cutout_insert" : "object_insert";
-		return equal(before, after) ? null : "object_transform";
-	}
-	if (domain === "characters") {
-		if (after.some((item) => !before.some((previous) => previous.id === item.id))) return "object_insert";
-		for (const item of after) {
-			const previous = before.find((entry) => entry.id === item.id);
-			if (previous && !equal(poseValue(previous.pose), poseValue(item.pose))) return "pose_edit";
-		}
-		// Motion buffers/layer synchronization are passive, not cast transforms.
-		const placement = (items) => items.map(({ id, x, y = 0, z, rot, scale = 1, hidden = false, model, tint, subject, identityImage }) => ({ id, x, y, z, rot, scale, hidden, model, tint, subject, identityImage }));
-		return equal(placement(before), placement(after)) ? null : "object_transform";
-	}
-	if (domain === "shots") {
-		if (after.some((item) => !before.some((previous) => previous.id === item.id))) return "shot_add";
-		for (const item of after) {
-			const previous = before.find((entry) => entry.id === item.id);
-			if (!previous) continue;
-			const camera = createCameraBlock(item.camera), oldCamera = createCameraBlock(previous.camera);
-			if (["cameraRail", "craneHeight", "railFollow", "dollyTiming"].some((key) => !equal(camera[key], oldCamera[key]))) return "rail_edit";
-			const keys = item.cameraKeys ?? [], oldKeys = previous.cameraKeys ?? [];
-			if (keys.length > oldKeys.length || keys.some((key) => {
-				const old = oldKeys.find((entry) => entry.frame === key.frame);
-				return old && !equal(old.framing, key.framing);
-			})) return "camera_key_record";
-		}
-		return equal(before.map(shotValue), after.map(shotValue)) ? null : "shot_edit";
-	}
-	return null;
-}
-
 /** (surface, kind) -> the surface's first edit, once: `${surface}:first_edit` with a closed kind. */
 export function createFirstEditRecorder(emit) {
 	// Dedupe once per editor App mount, independently for Studio and Playground.
@@ -80,31 +21,3 @@ export function createFirstEditRecorder(emit) {
 	record.seen = surface => seen.has(surface);
 	return record;
 }
-
-/** The same dedupe over a domain diff (semanticEditKind), for callers that hold before/after values. */
-export function createFirstEditTracker(emit) {
-	const record = createFirstEditRecorder(emit);
-	return (surface, domain, before, after) => {
-		if (record.seen(surface)) return false;
-		const kind = semanticEditKind(domain, before, after);
-		return kind ? record(surface, kind) : false;
-	};
-}
-
-// Synchronous mutation owner shared by UI and live commands. Keeping the before
-// value here avoids stale React closures and analytics inside replayable updater
-// functions. Passive writes (load, history, navigation) advance the same value
-// without reporting; a rejected reducer never publishes or reports anything.
-export function createSemanticState(initial, publish, observe, domain) {
-	let current = initial;
-	const apply = (update, authored) => {
-		const before = current;
-		const after = typeof update === "function" ? update(before) : update;
-		current = after;
-		if (authored && !isBusRunActive()) console.warn(`[bus] semantic edit for ${domain} called outside a bus run`);
-		publish(after);
-		if (authored) observe(domain, before, after);
-		return after;
-	};
-	return { set: (update) => apply(update, false), edit: (update) => apply(update, true) };
-}

package/src/settings-menu.jsx

@@ -2,7 +2,7 @@ import { useCallback, useRef, useState } from "react";
 import { ko, localeChosen } from "./locale.js";
 import PreferencesDialog from "./shell/PreferencesDialog.jsx";
 
-// App settings — language and analytics — behind one labelled topbar trigger
+// App settings — language — behind one labelled topbar trigger
 // (#193, docs/studio-ui-ia.md R4). Neither item edits the document, so they do
 // not belong on the Save/Export row as bare toggles.
 //
@@ -38,7 +38,7 @@ export default function SettingsMenu() {
 				data-testid="settings-menu-trigger"
 				aria-expanded={open}
 				aria-haspopup="dialog"
-				title={ko("Language and analytics", "언어 및 사용 통계")}
+				title={ko("Language settings", "언어 설정", "语言设置")}
 				ref={triggerRef}
 				onClick={() => (open ? close() : setOpen(true))}
 			>

package/src/shell/DetailsSlot.jsx

@@ -15,7 +15,7 @@ import PropsPanel from "../panels/PropsPanel.jsx";
 import ObjectTransformPanel from "../panels/ObjectTransformPanel.jsx";
 import ObjectLookPanel from "../panels/ObjectLookPanel.jsx";
 import { PoseStudioPanel } from "../posestudio.jsx";
-import { DEFAULT_POSE } from "../poses.js";
+import { posePanelControls } from "./pose-controls.js";
 import "../panels/details.css";
 
 export default function DetailsSlot() {
@@ -50,6 +50,7 @@ export default function DetailsSlot() {
 		savePose, beginWorkspaceResize,
 	} = useStudioShell();
 	const selection = detailsSelection({ selectedHierarchyId, selectedSceneObject, rigSelection, characters, shot, inspectorHasContent });
+	const { resetPose, fingerPanel } = posePanelControls(useStudioShell());
 	return (
 		<aside className="panel hierarchy-sidebar inspector-sidebar" data-inspector={selectedHierarchyId}>
 			{/* Save failures live above the tab content, not inside the Props
@@ -194,6 +195,8 @@ export default function DetailsSlot() {
 				pendingIkEdit={pendingIkEdit}
 				applyPendingIkEdit={applyPendingIkEdit}
 				cancelPendingIkEdit={cancelPendingIkEdit}
+				onResetPose={() => resetPose(activeChar.id)}
+				fingerPanel={fingerPanel}
 				rangePins={rangePins}
 				rangePinResiduals={rangePinResiduals}
 				rangePinSelection={rangePinSelection}
@@ -334,11 +337,7 @@ export default function DetailsSlot() {
 							setToast(ko("Couldn't find the selected pose — pick again", "선택한 포즈를 찾지 못했어요. 다시 골라 주세요"));
 						}
 					}}
-					onReset={() => {
-						if (posingChar) castDomain.run('character.setPose', { characterId: posingChar.id, pose: DEFAULT_POSE.id, clearMotion: Boolean(motion) });
-						setStudioPick(DEFAULT_POSE.id);
-						setToast(ko("Back to the default pose", "기본 포즈로 돌아왔어요"));
-					}}
+					onReset={() => { if (posingChar) resetPose(posingChar.id); }}
 					onSave={savePose}
 					onDelete={removePose}
 					onClose={closeStudio}

package/src/shell/LibrarySlot.jsx

@@ -2,6 +2,7 @@ import { useEffect, useState } from "react";
 import { useStudioShell } from "./studio-shell-context.js";
 import { ko } from "../locale.js";
 import AssetPane from "../asset-pane.jsx";
+import { dropAssetAt } from "../asset-drop.js";
 
 const CONTENT_COLLAPSED_KEY = "cozyclay.dock.content-collapsed.v1";
 
@@ -29,7 +30,7 @@ export default function LibrarySlot({ active = true }) {
 		manageAssetStorage, setManageAssetStorage, unusedAssetIds, usedAssetIds, usageCounts,
 		projectAssetGraphSignature, assetTrash, deleteUnusedAsset, undoDeletedAsset, deletingAssetId,
 		projectManifest, shots, selectTimelineShot, allPoses,
-		spawnCharacter, addSceneObject, runStudioAction,
+		spawnCharacter, addSceneObject, runStudioAction, setSelectedHierarchyId,
 	} = useStudioShell();
 	const [collapsed, setCollapsed] = useState(readContentCollapsed);
 	const [shelfShown, setShelfShown] = useState(false);
@@ -41,15 +42,12 @@ export default function LibrarySlot({ active = true }) {
 	}, [active, shelfShown, setBottomTab]);
 
 	// Double-click in Content: the same payloads the drag carries, placed at
-	// the origin through the named domain actions.
-	function placeAssetAtOrigin(payload) {
-		const origin = { x: 0, z: 0 };
-		if (payload.kind === "character") spawnCharacter(payload.id, origin.x, origin.z);
-		else if (payload.kind === "object") addSceneObject(payload.objectKind, origin);
-		else if (payload.kind === "image" || payload.kind === "mesh") {
-			runStudioAction("asset.import", { assetId: payload.assetId, placeAs: payload.kind === "mesh" ? "mesh" : "cutout", placement: origin });
-		}
-	}
+	// the origin through the same drop table (asset-drop.js).
+	const placeAssetAtOrigin = (payload) => dropAssetAt(payload, { x: 0, z: 0 }, {
+		spawnCharacter, addSceneObject, runStudioAction, select: setSelectedHierarchyId,
+		spawnCutoutAt: (assetId, placement) => runStudioAction("asset.import", { assetId, placeAs: "cutout", placement }),
+		spawnMeshAt: (assetId, placement) => runStudioAction("asset.import", { assetId, placeAs: "mesh", placement }),
+	});
 
 	return (
 		<section className="assets-pane studio-library" aria-label={ko("Library", "라이브러리")} data-content-collapsed={collapsed || undefined} hidden={!active}>

package/src/shell/MenuBar.jsx

@@ -4,6 +4,8 @@ import { useStudioShell } from "./studio-shell-context.js";
 import SourceOffer from "../source-offer.jsx";
 import { ko } from "../locale.js";
 import { noteShortcutsOpened } from "../shortcut-friction.js";
+import { appVersion } from "../app-version.js";
+import { useExportMenuTelemetry } from "../export-menu-telemetry.js";
 
 const MAC = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform ?? "");
 const MOD = MAC ? "⌘" : "Ctrl+";
@@ -197,10 +199,9 @@ export default function MenuBar({ preferences }) {
 		? panelCount ? "" : noPanels
 		: shots.length ? "" : ko("Add a shot first — a pack describes one cut", "샷을 먼저 추가하세요 — 팩은 컷 하나를 설명합니다");
 
-	// Export's flyout lives in File, so an open Export menu opens File.
-	useEffect(() => {
-		if (exportMenuOpen) setOpen("file");
-	}, [exportMenuOpen]);
+	// Export's flyout lives in File, so an open Export menu opens File; each open is counted.
+	useEffect(() => { if (exportMenuOpen) setOpen("file"); }, [exportMenuOpen]);
+	useExportMenuTelemetry(exportMenuOpen, shell);
 
 	const closeMenus = (focusTrigger) => {
 		const was = open;
@@ -632,7 +633,6 @@ function MenuDialog({ kind, onClose }) {
 		document.addEventListener("keydown", onKey);
 		return () => document.removeEventListener("keydown", onKey);
 	}, [onClose]);
-	const version = import.meta.env.VITE_APP_VERSION;
 	return createPortal(
 		<div className="menubar-dialog-backdrop" onPointerDown={(event) => { if (event.target === event.currentTarget) onClose(); }}>
 			<div className="menubar-dialog" role="dialog" aria-modal="true" aria-labelledby={titleId} data-dialog={kind}>
@@ -645,7 +645,7 @@ function MenuDialog({ kind, onClose }) {
 				{kind === "about" ? (
 					<div className="menubar-dialog-body">
 						<p>{ko("Previs studio: stage, pose, camera and motion.", "프리비즈 스튜디오: 배치, 포즈, 카메라, 모션.")}</p>
-						{version && <p className="menubar-dialog-meta">{ko("Version", "버전")} {version}</p>}
+						<p className="menubar-dialog-meta">{ko("Version", "버전")} {appVersion()}</p>
 						<SourceOffer />
 					</div>
 				) : (

package/src/shell/PreferencesDialog.jsx

@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { ko } from "../locale.js";
-import { getAnalyticsOptOut, loadAutoColor, preferenceSection, readStoredGridView } from "./preference-pages.jsx";
+import { loadAutoColor, preferenceSection, readStoredGridView } from "./preference-pages.jsx";
 import "./preferences.css";
 
 const NAV_GROUPS = [
@@ -24,7 +24,6 @@ export default function PreferencesDialog({ open, onClose, initialSection = "App
 	closeRef.current = onClose;
 	const [activeSection, setActiveSection] = useState(initialSection);
 	const [query, setQuery] = useState("");
-	const [analyticsOptOut, setAnalyticsOptOutState] = useState(getAnalyticsOptOut);
 	const [autoColor, setAutoColor] = useState(() => loadAutoColor());
 	const [gridView, setGridView] = useState(() => readStoredGridView(globalThis.localStorage));
 
@@ -69,7 +68,7 @@ export default function PreferencesDialog({ open, onClose, initialSection = "App
 	}, [open, initialSection]);
 
 	if (!open || typeof document === "undefined") return null;
-	const currentProps = { autoColor, setAutoColor, analyticsOptOut, setAnalyticsOptOutState, gridView, setGridView };
+	const currentProps = { autoColor, setAutoColor, gridView, setGridView };
 
 	return createPortal(
 		<div className="v2-preferences" data-testid="preferences-dialog-backdrop" onPointerDown={(event) => { if (event.target === event.currentTarget) closeRef.current?.(); }}>