cozyclay 1.10.0 → 2.0.2

package/src/app-context.js

@@ -0,0 +1,211 @@
+import { createContext, useContext } from 'react';
+import { StudioProtocolError } from './studio-agent-protocol.js';
+
+export const AppContext = createContext(null);
+export function useBus() { return useContext(AppContext).bus; }
+
+const ref = current => ({ current });
+
+// Stores own the document and its snapshots. The facade owns only the ordered
+// relationship between their committed sessions, never a second state history.
+export function createAppContext({
+  characters: charactersRef = ref(null), scenes: scenesRef = ref(null),
+  motion: motionRef = ref(null), state: liveStateRef = ref(null), getBus, notify,
+} = {}) {
+  const storeDomains = new Map(), domainBegins = new WeakMap(), observedStores = new WeakSet();
+  const entries = new Map();
+  let past = [], future = [], activeComposition = null, historyRevision = 0;
+  let currentPorts = {};
+  const storeDomain = domain => storeDomains.get(domain);
+  const registeredDomains = () => [...storeDomains.values()];
+  const ports = { storeDomain, storeDomains: registeredDomains }, actionPorts = { storeDomain, storeDomains: registeredDomains };
+  const fail = (code, message) => { throw new StudioProtocolError(code, message); };
+  const memberRetained = row => storeDomain(row.name) === row.handle && row.store.isRetained(row.id);
+  const retained = entry => entry.members.every(memberRetained);
+  const frontier = redo => redo ? future[0] : past.at(-1);
+  const ready = (entry, redo) => !activeComposition && entry === frontier(redo) && retained(entry)
+    && entry.members.every(row => redo ? row.store.canRedo() && row.store.history().future[0]?.historyEntryId === row.id : row.store.canUndo(row.id));
+  function prune() {
+    // The oldest store snapshot has no pre-image, but is still a boundary.
+    // Keep it (and partially expired compositions) so traversal cannot skip
+    // an unundoable newer transition to reach an older owner.
+    for (const [id, entry] of entries) if (!entry.members.some(row => {
+      if (storeDomain(row.name) !== row.handle) return false;
+      const history = row.store.history();
+      return row.store.isRetained(row.id) || (history.past[0] ?? history.present).historyEntryId === row.id;
+    })) entries.delete(id);
+    past = past.filter(entry => entries.has(entry.id));
+    future = future.filter(entry => entries.has(entry.id));
+  }
+  function step(entry, redo) {
+    if (!entry || !ready(entry, redo)) return false;
+    const revision = ports.revision?.current;
+    for (const row of redo ? entry.members : [...entry.members].reverse()) (redo ? row.store.redo : row.store.undo)();
+    if (redo) { future.shift(); past.push(entry); }
+    else { past.pop(); future.unshift(entry); }
+    historyRevision++;
+    // Multiple owners publish synchronously, but traversal is one authored
+    // transition at the binding boundary.
+    if (revision !== undefined) ports.revision.current = revision + 1;
+    return true;
+  }
+  function remember(members) {
+    if (!members.length) return { historyEntryId: null };
+    const id = members.length === 1 ? members[0].id : crypto.randomUUID();
+    if (entries.has(id)) return { historyEntryId: id };
+    for (const entry of future) entries.delete(entry.id);
+    future = [];
+    const entry = { id, members };
+    entry.handle = members.length === 1 ? members[0].handle : {
+      documentStore: { isRetained: wanted => wanted === id && entries.has(id) && retained(entry) },
+      canUndo: wanted => (wanted === undefined || wanted === id) && ready(entry, false),
+      stepHistory: redo => step(entry, redo),
+    };
+    entries.set(id, entry); past.push(entry); historyRevision++; prune();
+    return { historyEntryId: id };
+  }
+  function beginAction(domain, targetId = null, nested = false) {
+    if (activeComposition) {
+      if (!activeComposition.running && !nested) fail('TARGET_BUSY', 'A composed document transaction is already open.');
+      const parent = activeComposition;
+      parent.touch(domain, targetId);
+      return { run: parent.run, commit: () => ({ historyEntryId: null }), cancel: parent.cancel };
+    }
+    const members = new Map();
+    let closed = false;
+    const check = () => { if (closed) fail('STALE_TARGET', 'The composed document transaction is closed.'); };
+    const session = {
+      running: 0,
+      touches: handle => members.has(handle),
+      touch(name, targetId) {
+        check();
+        const handle = storeDomain(name);
+        if (!handle) fail('CAPABILITY_MISSING', `No document owner is registered for ${name}.`);
+        if (!members.has(handle)) members.set(handle, { name, handle, store: handle.documentStore,
+          session: domainBegins.get(handle)(targetId) });
+      },
+      run(fn) {
+        check(); session.running++;
+        try { return [...members.values()].reduceRight((next, row) => () => row.session.run(next), fn)(); }
+        finally { session.running--; }
+      },
+      commit() {
+        check();
+        const changed = [...members.values()].flatMap(row => {
+          const result = row.session.commit();
+          return result.historyEntryId ? [{ name: row.name, handle: row.handle, store: row.store, id: result.historyEntryId }] : [];
+        });
+        closed = true; activeComposition = null;
+        return remember(changed);
+      },
+      cancel(options) {
+        if (closed) return false;
+        closed = true; activeComposition = null;
+        for (const row of [...members.values()].reverse()) row.session.cancel(options);
+        return true;
+      },
+    };
+    activeComposition = session;
+    try { session.touch(domain, targetId); }
+    catch (error) { session.cancel(); throw error; }
+    return session;
+  }
+  function recordAction(domain, run, targetId = null, nested = false) {
+    const session = beginAction(domain, targetId, nested);
+    const done = result => ({ result, ...session.commit() });
+    const failed = error => { session.cancel(); throw error; };
+    try { const result = session.run(run); return result?.then ? result.then(done, failed) : done(result); }
+    catch (error) { return failed(error); }
+  }
+
+  return {
+    beginAction, recordAction, notify, storeDomain,
+    storeDomainForReceipt(receipt) {
+      const entry = entries.get(receipt?.undo?.historyEntryId);
+      return entry && retained(entry) ? entry.handle : undefined;
+    },
+    storeDomains: registeredDomains,
+    registerStoreDomain(name, handle) {
+      const store = handle.documentStore;
+      if (store && !observedStores.has(store)) {
+        observedStores.add(store);
+        const committed = result => {
+          if (result.historyEntryId && !activeComposition) remember([{ name, handle, store, id: result.historyEntryId }]);
+          return result;
+        };
+        const begin = store.beginAction, record = store.recordAction;
+        store.beginAction = (...args) => {
+          const session = begin(...args);
+          return { ...session, commit: () => committed(session.commit()) };
+        };
+        store.recordAction = (...args) => {
+          const result = record(...args);
+          return result?.then ? result.then(committed) : committed(result);
+        };
+      }
+      if (handle.beginAction && !domainBegins.has(handle)) {
+        domainBegins.set(handle, handle.beginAction.bind(handle));
+        handle.beginAction = targetId => beginAction(name, targetId);
+        handle.stepHistory = redo => {
+          const entry = frontier(redo);
+          return entry?.handle === handle && step(entry, redo);
+        };
+        if (handle.load) {
+          const load = handle.load.bind(handle);
+          handle.load = (...args) => {
+            if (activeComposition?.touches(handle)) activeComposition.cancel();
+            const result = load(...args); prune(); return result;
+          };
+        }
+      }
+      storeDomains.set(name, handle);
+      return () => {
+        if (activeComposition?.touches(handle)) activeComposition.cancel();
+        if (storeDomain(name) === handle) storeDomains.delete(name);
+        prune();
+      };
+    },
+    nextStoreHistory(redo) {
+      prune();
+      const entry = frontier(redo);
+      return entry && ready(entry, redo) ? entry.handle : undefined;
+    },
+    historyEntry(redo = false) {
+      const entry = frontier(redo);
+      return entry && ready(entry, redo) ? entry.id : null;
+    },
+    loadStoreDomains(slices) {
+      const loaded = new Set();
+      for (const [name, domain] of storeDomains) if (domain.load) {
+        domain.load(domain.sceneSlice ? domain.sceneSlice(slices) : slices[name]);
+        loaded.add(name);
+      }
+      return loaded;
+    },
+    forRender(shared) { return Object.create(this, { shared: { value: shared } }); },
+    // A change counter for project save checkpoints, not undo arbitration.
+    get undoClock() { return historyRevision; },
+    live: Object.freeze({
+      get state() { return liveStateRef.current; },
+      get characters() { return charactersRef.current; },
+      get scenes() { return scenesRef.current; },
+      get motion() { return motionRef.current; },
+    }),
+    publishLive(value) { liveStateRef.current = value; },
+    patchLive(patch) { Object.assign(liveStateRef.current, patch); },
+    patchTimeline(patch) { Object.assign(liveStateRef.current.timeline, patch); },
+    publishCharacters(value) { charactersRef.current = value; },
+    publishScenes(value) { scenesRef.current = value; },
+    publishMotion(value) { motionRef.current = value; },
+    get bus() { return getBus(); },
+    ports, actionPorts,
+    updatePorts(next) {
+      currentPorts = next;
+      for (const key of Object.keys(next)) {
+        if (key === 'revision') ports[key] = next[key];
+        else if (!ports[key]) ports[key] = (...args) => currentPorts[key](...args);
+      }
+    },
+    updateActionPorts(next) { Object.assign(actionPorts, next); },
+  };
+}

package/src/app-stage.jsx

@@ -21,9 +21,9 @@ import {
 	TRAIL_TRACKS,
 	falloffWeight,
 	jointTrailPoints,
-	nearestFrameToRay,
 	trailEditRange,
 } from "./motion-trail.js";
+import { pickTrailPoint } from "./trail-pick.js";
 import Timeline from "./ardy/timeline.jsx";
 import { FlyControls, aimAt } from "./controls.jsx";
 import { GIZMO_LAYER } from "./dualview.jsx";
@@ -482,11 +482,13 @@ export const DEMO_MOTION_PROMPT = "A person walks forward.";
 // same window so the two deletion paths feel like one rule.
 export const OBJECT_DELETE_UNDO_MS = 7000;
 export const ASSET_DELETE_UNDO_MS = 7000;
-export const CLAY = "#f2eee6";
-export const CLAY_B = "#ddd6ca";
+// Neutral grey clay: the set is the grey workbench, so the figures are grey
+// too, light enough to stand off the deck and the sky.
+export const CLAY = "#bdbec3";
+export const CLAY_B = "#a4a5aa";
 // X Bot's shell is smooth (no raised exoskeleton like Y Bot's), so it gets a
 // brighter, whiter clay to keep it readable against the set.
-export const CLAY_X = "#faf8f2";
+export const CLAY_X = "#d0d0d4";
 // Model/role default for a cast member; a user-picked entry.tint always wins
 // over this at render time.
 export const defaultCharacterTint = (entry, index) => (entry.model === "x-bot-tpose" ? CLAY_X : index === 0 ? CLAY : CLAY_B);
@@ -2671,7 +2673,7 @@ export function loadSceneStartup() {
  * re-drawn on top as a bright highlight. Grabbing any point of a line starts
  * a drag on a camera-facing plane through the grab point; the caller deforms
  * the take (motion-trail.js falloff math) so the preview updates live. */
-export const MotionTrails = memo(function MotionTrails({ motion, baseY, charScale, ikFocus, falloffFrames, pendingEdit, enabled, visible = true, onDragStart, onDragPreview, onDragEnd }) {
+export const MotionTrails = memo(function MotionTrails({ motion, rig = null, baseY, charScale, ikFocus, falloffFrames, playheadFrame, pendingEdit, enabled, visible = true, onDragStart, onDragPreview, onDragEnd }) {
 	const { camera, gl, invalidate } = useThree();
 	const [drag, setDrag] = useState(null);
 	const callbacksRef = useRef({ onDragStart, onDragPreview, onDragEnd });
@@ -2682,14 +2684,16 @@ export const MotionTrails = memo(function MotionTrails({ motion, baseY, charScal
 		for (let index = 0; index + 2 < flat.length; index += 3) out.push([flat[index], flat[index + 1], flat[index + 2]]);
 		return out;
 	};
-	// Every trail track (root + IK endpoints + head) in its handle colour.
+	// Every trail track (root + IK endpoints + head) in its handle colour,
+	// sampled where playback renders each bone on this rig (not the clip's
+	// own joints, which sit 4-15 cm off the body), so draw and pick agree.
 	const tracks = useMemo(
 		() => TRAIL_TRACKS.map((track) => {
-			const flat = jointTrailPoints(motion, track.joint, { baseY, scale: charScale });
+			const flat = jointTrailPoints(motion, track.joint, { baseY, scale: charScale, rig });
 			return flat ? { ...track, flat, points: toTriples(flat) } : null;
 		}).filter(Boolean),
 		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[motion, baseY, charScale],
+		[motion, rig, baseY, charScale],
 	);
 	const trackById = (id) => tracks.find((track) => track.id === id) ?? null;
 	// The falloff window rides whichever line is being (or was last) grabbed.
@@ -2713,7 +2717,7 @@ export const MotionTrails = memo(function MotionTrails({ motion, baseY, charScal
 	// A single pointerdown listener that measures point-to-ray distance against
 	// the cached trail arrays costs nothing while the mouse merely moves.
 	const pickRef = useRef(null);
-	pickRef.current = { tracks, enabled, falloffFrames };
+	pickRef.current = { tracks, enabled, falloffFrames, playheadFrame };
 	// Line2 instances for in-place geometry rewrites during a drag.
 	const lineRefs = useRef({});
 	const highlightRef = useRef(null);
@@ -2731,21 +2735,16 @@ export const MotionTrails = memo(function MotionTrails({ motion, baseY, charScal
 			);
 			raycaster.setFromCamera(ndc, camera);
 			const { origin, direction } = raycaster.ray;
-			// TRAIL_TRACKS order is limbs-first, hips last: an overlapping grab
-			// prefers the finer limb target, and among candidates within the
-			// threshold the closest line wins.
-			let track = null;
-			let grabFrame = 0;
-			let bestDistance = Infinity;
-			for (const candidate of pick.tracks) {
-				const near = nearestFrameToRay(candidate.flat, origin, direction, 0.2);
-				if (near && near.distance < bestDistance) {
-					track = candidate.id;
-					grabFrame = near.frame;
-					bestDistance = near.distance;
-				}
-			}
-			if (!track) return;
+			const picked = pickTrailPoint({
+				tracks: pick.tracks,
+				playheadFrame: pick.playheadFrame,
+				falloffFrames: pick.falloffFrames,
+				rayOrigin: origin,
+				rayDirection: direction,
+				maxDistance: 0.2,
+			});
+			if (!picked) return;
+			const { track, grabFrame } = picked;
 			// The grab wins over the camera controls listening in the bubble phase.
 			event.stopPropagation();
 			event.preventDefault();
@@ -2851,10 +2850,12 @@ export const MotionTrails = memo(function MotionTrails({ motion, baseY, charScal
 	);
 }, (previous, next) => (
 	previous.motion === next.motion &&
+	previous.rig === next.rig &&
 	previous.baseY === next.baseY &&
 	previous.charScale === next.charScale &&
 	previous.ikFocus === next.ikFocus &&
 	previous.falloffFrames === next.falloffFrames &&
+	previous.playheadFrame === next.playheadFrame &&
 	previous.pendingEdit === next.pendingEdit &&
 	previous.enabled === next.enabled &&
 	previous.visible === next.visible

package/src/ardy/auto-fix-panel.css

@@ -0,0 +1,108 @@
+@layer legacy {
+.auto-fix-group {
+	--auto-fix-space: 4px;
+	display: grid;
+	gap: calc(var(--auto-fix-space) * 3);
+	margin-top: calc(var(--auto-fix-space) * 3);
+}
+
+.auto-fix-card {
+	--auto-fix-space: 4px;
+	min-width: 0;
+	display: flex;
+	flex-direction: column;
+	gap: calc(var(--auto-fix-space) * 2);
+	padding: calc(var(--auto-fix-space) * 3);
+	border: 1px solid var(--line2);
+	border-radius: var(--radius);
+	background: var(--card2);
+	color: var(--fg);
+}
+
+.auto-fix-card h4 {
+	margin: 0;
+	color: var(--fg);
+	font-size: 12px;
+	font-weight: 650;
+}
+
+.auto-fix-card-head {
+	display: grid;
+	gap: var(--auto-fix-space);
+	min-width: 0;
+}
+
+.auto-fix-card .inspector-hint {
+	margin: 0;
+}
+
+.auto-fix-actions {
+	display: grid;
+	grid-template-columns: repeat(2, minmax(0, 1fr));
+	gap: calc(var(--auto-fix-space) * 2);
+}
+
+.auto-fix-actions > .btn {
+	min-width: 0;
+	margin-top: 0;
+	white-space: normal;
+	line-height: 1.3;
+}
+
+.body-collision-card .auto-fix-actions {
+	grid-template-columns: 1fr;
+}
+
+.auto-fix-card > .btn.full {
+	margin-top: 0;
+}
+
+.auto-fix-result {
+	min-width: 0;
+	padding: calc(var(--auto-fix-space) * 2);
+	border: 1px solid var(--line2);
+	border-radius: var(--radius);
+	background: var(--card2);
+	color: var(--muted);
+	font-size: 10px;
+	line-height: 1.4;
+}
+
+.auto-fix-card details {
+	border-top: 1px solid var(--line2);
+	padding-top: calc(var(--auto-fix-space) * 2);
+}
+
+.auto-fix-card details > summary {
+	color: var(--muted);
+	font-size: 11px;
+}
+
+.auto-fix-card .physics-actions {
+	margin: 0;
+}
+
+.auto-fix-card.platform-fit,
+.auto-fix-card.physics-review {
+	margin-top: 0;
+	padding-top: calc(var(--auto-fix-space) * 3);
+	border-top: 1px solid var(--line2);
+}
+
+/* Four tools: the shared .segmented pill (styles.css, loaded after this file)
+   is sized for two, so these rules need the extra class to win. Same inset
+   geometry as the base pill, one quarter wide. */
+.segmented.ik-edit-tools:before {
+	width: calc((100% - 8px) / 4);
+}
+
+.segmented.ik-edit-tools[data-active="ik"]:before { transform: translateX(0); }
+.segmented.ik-edit-tools[data-active="trail"]:before { transform: translateX(100%); }
+.segmented.ik-edit-tools[data-active="pin"]:before { transform: translateX(200%); }
+.segmented.ik-edit-tools[data-active="autofix"]:before { transform: translateX(300%); }
+
+.ik-tool-panel {
+	min-width: 0;
+}
+
+}

package/src/ardy/fix-collisions.js

@@ -1206,23 +1206,14 @@ const NO_PUSH = Object.freeze({ ran: false, moved: false });
  * limb's rest pose by escapeVector — see the REST-BIASED ESCAPE note there for
  * why the raw separation normal is not enough on a deep hit.
  */
-function pushCapsule(capsule, chains, push, ikState, { onlyChains = null, floorY = 0, normalise = null } = {}) {
+function pushCapsule(capsule, chains, push, ikState, { onlyChains = null, floorY = 0 } = {}) {
 	const target = capsule.def.movable;
 	if (!target) return NO_PUSH;
 	if (onlyChains && !onlyChains.has(target.chain)) return NO_PUSH;
 	const chain = chains?.get(target.chain);
 	if (!chain) return NO_PUSH;
-	// BIND TRANSLATIONS, HERE, FOR THIS CHAIN ONLY. solveIk resets them anyway —
-	// its segment lengths were measured at bind and its law of cosines is exact
-	// only there — so the reset happens either way; doing it HERE means the push
-	// target is read on the same skeleton the solver will produce, which keeps
-	// the baked delta the push rather than the length compensation, while every
-	// chain this run does not solve keeps the clip's own translations. Doing it
-	// to the WHOLE rig up front (what this used to do) meant detecting on a
-	// skeleton the caller never sees: phantom pairs on limbs the readout calls
-	// clean, and leg chains keyed — and snapped to bind length — for penetrations
-	// that only existed at bind.
-	if (normalise) normalise(target.chain, chain);
+	// Detection, target and solve all use the clip's current translations.
+	// A bind reset here would reintroduce length compensation into the key.
 	const rotations = chain.bones.map((bone) => bone.quaternion.clone());
 	const driven = target.joint === "mid" ? chain.bones[1] : chain.bones[2];
 	const before = driven.getWorldPosition(new THREE.Vector3());
@@ -1288,24 +1279,10 @@ function pushCapsule(capsule, chains, push, ikState, { onlyChains = null, floorY
  * pose on the rig at entry is used, which is exact whenever no earlier key is
  * already blending into this frame.
  *
- * BIND TRANSLATIONS, PER CHAIN, AT SOLVE TIME. solveIk resets a chain to its
- * bind translations the moment it runs — its segment lengths were measured at
- * bind and its law of cosines is exact only there — so the push target is read
- * AFTER that reset, on the same skeleton the solver will produce. That is what
- * keeps the baked delta the push rather than the LENGTH COMPENSATION: aiming at
- * a clip-length limb's wrist with a bind-length one turned a 15 mm lift into an
- * 11.8 ° knee swing whose components cancel only at full weight, and a partly
- * weighted blend of that wandered 31 mm.
- *
- * What this must NOT do — and used to — is normalise every chain up front,
- * before the first capsule is built. That made the pass detect on a skeleton the
- * caller never sees: on a real clip (~19 mm off bind per bone) it reported pairs
- * the UI's own readout calls clean, keyed limbs for penetrations that exist only
- * at bind (whole-clip runs moved a leg 142 mm on frames with no leg pair at all,
- * and put a toe 17 mm under the floor), and made a second press of the button
- * put an arm back inside the crate the first press took it out of. Detection now
- * reads the pose as handed over; only a chain being solved is normalised, and a
- * chain this run does not key gets its clip translations back untouched.
+ * CLIP TRANSLATIONS THROUGHOUT. The solvers measure each frame's segment
+ * lengths without changing its locals. Detection, pushes and warm starts must
+ * therefore leave those translations alone too; the bake records them so the
+ * pose measured here is the one playback reproduces.
  */
 export function fixCollisions(rig, chains, {
 	radii = null,
@@ -1328,33 +1305,6 @@ export function fixCollisions(rig, chains, {
 	const bases = baseQuats ?? new Map(
 		[...chains].map(([id, chain]) => [id, chain.bones.map((bone) => bone.quaternion.clone())]),
 	);
-	/** Bind translations, once, for a chain that is about to be solved — see
-	 * pushCapsule. Nothing else on the rig is touched, so DETECTION always reads
-	 * the pose the caller handed over (plus whatever this run has already
-	 * solved), which is the same pose detectPenetrations reports to the UI. */
-	const clipTranslations = [];
-	const normalised = new Set();
-	const normaliseChain = (id, chain) => {
-		if (normalised.has(id) || !chain?.bindPositions) return;
-		normalised.add(id);
-		chain.bones.forEach((bone, index) => {
-			clipTranslations.push([id, bone, bone.position.clone()]);
-			bone.position.copy(chain.bindPositions[index]);
-		});
-		rig.updateMatrixWorld(true);
-	};
-	/** Give the clip its translations back on every chain this pass did not
-	 * actually key. Only a keyed chain owes the bind pose its rotations were
-	 * solved in; the rest are the clip's business and are handed back untouched. */
-	const restoreTranslations = (keptIds = null) => {
-		let restored = false;
-		for (const [id, bone, position] of clipTranslations) {
-			if (keptIds?.has(id)) continue;
-			bone.position.copy(position);
-			restored = true;
-		}
-		if (restored) rig.updateMatrixWorld(true);
-	};
 	const touched = new Set();
 	let poseDirty = false;
 	/**
@@ -1377,7 +1327,7 @@ export function fixCollisions(rig, chains, {
 		const chainId = capsule.def.movable?.chain;
 		if (allowedChains && chainId && !allowedChains.has(chainId)) return false;
 		const outcome = pushCapsule(capsule, chains, vector, ikState, {
-			onlyChains, floorY, normalise: normaliseChain,
+			onlyChains, floorY,
 		});
 		if (outcome.ran) {
 			touched.add(capsule.def.movable.chain);
@@ -1549,7 +1499,6 @@ export function fixCollisions(rig, chains, {
 	for (; pass < maxIterations; pass += 1) {
 		const capsules = buildCollisionCapsules(rig, radii);
 		if (!capsules) {
-			if (!changed) restoreTranslations();
 			return { supported: false, changed, passes: pass, residual, touched: [...touched], baseQuats: bases };
 		}
 		// `changed` is cumulative across passes, so it can never report what
@@ -1803,7 +1752,6 @@ export function fixCollisions(rig, chains, {
 			&& afterFoot < Math.min(entryFoot, floorY + PUSH_FLOOR_CLEARANCE) - 1e-6;
 		if (!improved || buried) {
 			frameRestore(entryPose);
-			restoreTranslations();
 			return {
 				supported: true,
 				changed: false,
@@ -1816,8 +1764,6 @@ export function fixCollisions(rig, chains, {
 		}
 	}
 
-	// Hand the pose back as it arrived everywhere this pass did not key.
-	restoreTranslations(changed ? touched : null);
 	// Final measurement for an honest residual report.
 	if (changed) {
 		const capsules = buildCollisionCapsules(rig, radii);
@@ -2043,16 +1989,14 @@ export function fixCollisionsRange({
 		}
 		return deltas;
 	};
-	/** Seed `ids` with the previous frame's correction: bind translations (the
-	 * pose a keyed chain is evaluated at, so it is the pose worth measuring) and
-	 * this frame's rotations composed with that frame's delta. */
+	/** Seed `ids` with the previous frame's rotation correction on this frame's
+	 * own translations, the same solve space used by the fresh attempts. */
 	const applyWarmStart = (ids, deltas) => {
 		for (const id of ids) {
 			const chain = chains.get(id);
 			const delta = deltas.get(id);
 			if (!chain || !delta) continue;
 			chain.bones.forEach((bone, index) => {
-				if (chain.bindPositions) bone.position.copy(chain.bindPositions[index]);
 				if (delta[index]) bone.quaternion.multiply(delta[index]);
 			});
 		}

package/src/ardy/ik-drag.js

@@ -0,0 +1,101 @@
+import { createIkState, ikBakeKeyframe, ikTouch } from "./ik.js";
+
+/**
+ * Per-drag bookkeeping for manual IK drags over a loaded motion.
+ *
+ * A drag keys ONLY the parts it wrote, as DELTA keys over the raw clip pose at
+ * the drag frame. Keying every part ever tracked (the old behaviour) planted an
+ * absolute key for untouched parts too, which spiked them off the clip on the
+ * drag frame (bind-translation reset + absolute slerp on the ramp).
+ */
+
+/** The record for the drag in progress. IkHandles has no drag-start callback,
+ * so a record opens on the first solve and closes on drag end; a record left
+ * on another frame (a click-sized drag that never ended) is stale and resets. */
+export function ikDragRecord(current, frame) {
+	return current && current.frame === frame ? current : { frame, ids: new Set() };
+}
+
+/** Mark `id` as written by this drag and touch it into the live layer. */
+export function ikDragTouch(ikState, record, id) {
+	ikTouch(ikState, id);
+	record?.ids.add(id);
+}
+
+/** Run `write` and return the chain ids whose bone locals it changed — for
+ * solvers like applyBodyContact that only report "something moved". */
+export function chainsChangedBy(chains, write) {
+	const before = new Map();
+	for (const [id, chain] of chains) {
+		before.set(id, chain.bones.map((bone) => [bone.quaternion.clone(), bone.position.clone()]));
+	}
+	write();
+	const changed = [];
+	for (const [id, chain] of chains) {
+		const saved = before.get(id);
+		if (chain.bones.some((bone, index) => !bone.quaternion.equals(saved[index][0]) || !bone.position.equals(saved[index][1]))) changed.push(id);
+	}
+	return changed;
+}
+
+/**
+ * Read the RAW clip locals of `ids` at the current frame without disturbing the
+ * live pose: snapshot every node under `rig`, let `applyRaw(rig)` pose the clip
+ * alone (no correction layer), read chain b0..b2 quaternions and FK joint
+ * quaternion + position, then put every node back.
+ */
+export function captureRawBase(rig, chains, fkJoints, ids, applyRaw) {
+	const saved = [];
+	rig.traverse((node) => saved.push([node, node.position.clone(), node.quaternion.clone(), node.scale.clone()]));
+	const baseQuats = new Map();
+	const basePositions = new Map();
+	try {
+		applyRaw(rig);
+		for (const id of ids) {
+			const chain = chains?.get(id);
+			const joint = fkJoints?.get(id);
+			if (chain) baseQuats.set(id, chain.bones.map((bone) => bone.quaternion.clone()));
+			else if (joint) {
+				baseQuats.set(id, [joint.bone.quaternion.clone()]);
+				basePositions.set(id, joint.bone.position.clone());
+			}
+		}
+	} finally {
+		for (const [node, position, quaternion, scale] of saved) {
+			node.position.copy(position);
+			node.quaternion.copy(quaternion);
+			node.scale.copy(scale);
+		}
+		rig.updateMatrixWorld(true);
+	}
+	return { baseQuats, basePositions };
+}
+
+/**
+ * Bake the key entry (Map trackId → key) a drag leaves at `frame`, for exactly
+ * `ids`. With `applyRaw` (a motion is loaded) every entry is a delta key over
+ * the raw clip: chains carry baseQ; FK joints carry baseQ + basePos, and a
+ * joint whose rotation matches the clip is stored translation-only, the same
+ * shape ikBakeKeyframe gives based hips keys. Without `applyRaw` the entry is
+ * the plain absolute key. Returns null when nothing was keyed.
+ */
+export function bakeIkDragKey(chains, fkJoints, frame, ids, applyRaw = null) {
+	const list = [...ids];
+	if (!list.length) return null;
+	const rig = chains?.values().next().value?.rig;
+	const base = applyRaw && rig ? captureRawBase(rig, chains, fkJoints, list, applyRaw) : null;
+	const scratch = createIkState();
+	ikBakeKeyframe(chains, scratch, frame, fkJoints, list, null, base?.baseQuats ?? null);
+	const entry = scratch.keys.get(frame);
+	if (!entry || !base) return entry ?? null;
+	for (const [id, key] of entry) {
+		if (chains.has(id) || !fkJoints?.has(id)) continue;
+		const baseQ = base.baseQuats.get(id)?.[0];
+		const basePos = base.basePositions.get(id);
+		if (!baseQ || !basePos || !key.p) continue;
+		key.basePos = basePos;
+		if (key.q?.[0] && key.q[0].angleTo(baseQ) > 1e-7) key.baseQ = [baseQ];
+		else key.q = null;
+	}
+	return entry;
+}