cozyclay 2.0.2 → 2.1.1

package/src/ardy/auto-physics.js

@@ -50,8 +50,6 @@ import { findBone, ikTouch, ikBakeKeyframe, solveHipsTranslate, solveIk } from "
  * into the clip outside its keyed range by ikEvaluate's blend window.
  */
 
-/* --- body segments ---------------------------------------------------------- */
-
 /**
  * Segment mass fractions of total body mass, from Dempster's cadaver study
  * (Dempster, W.T., "Space Requirements of the Seated Operator", WADC TR
@@ -113,8 +111,6 @@ export function computeCenterOfMass(rig) {
 	return com.divideScalar(total);
 }
 
-/* --- airborne detection ----------------------------------------------------- */
-
 /** Shortest run of airborne frames worth correcting. Anything briefer is a
  * one- or two-frame detection blip from a foot skimming the floor, not a
  * flight phase, and fitting a parabola to it would amplify the noise. */
@@ -215,20 +211,18 @@ export function frameAirborne(rig, planted, lift = AIRBORNE_LIFT) {
 	return heightsAirborne(markerHeights(rig), planted, lift);
 }
 
-/* --- grounded contact ------------------------------------------------------ */
-
 /** Contact must stay close to its clip-relative low and vertically settled.
  * The final run gate below is stricter still: an ankle that wanders more than
  * three centimetres was walking, not planted, and is never snapped backward. */
 export const GROUND_CONTACT_LIFT = 0.06;
-export const GROUND_CONTACT_VERTICAL_SPEED = 0.6;
+const GROUND_CONTACT_VERTICAL_SPEED = 0.6;
 export const GROUND_CONTACT_HORIZONTAL_SPEED = 0.12;
-export const GROUND_CONTACT_MIN_SECONDS = 0.10;
+const GROUND_CONTACT_MIN_SECONDS = 0.10;
 export const GROUND_LOCK_MAX_PULL = 0.03;
 export const GROUND_LOCK_EPSILON = 0.005;
 export const GROUND_LOCK_REACH_LIFT = 0.005;
-export const GROUND_FLOOR_MAX_LIFT = 0.15;
-export const GROUND_FLOOR_EPSILON = 0.005;
+const GROUND_FLOOR_MAX_LIFT = 0.15;
+const GROUND_FLOOR_EPSILON = 0.005;
 
 const FOOT_SIDES = [
 	{ side: "left", chainId: "leftFoot", ankle: "mixamorigLeftFoot", toe: "mixamorigLeftToeBase", height: "LeftFoot" },
@@ -494,8 +488,6 @@ export function edgeTaperWeight(index, length, taper = EDGE_TAPER) {
 	return x * x * (3 - 2 * x);
 }
 
-/* --- ballistic fit ---------------------------------------------------------- */
-
 /** Standard gravity (m/s²). */
 export const GRAVITY = 9.81;
 
@@ -628,7 +620,7 @@ export function fitBallistic(samples, fps, g = GRAVITY, { fitFrom = 0, fitTo = n
  * `residual` is the RMS distance of the samples from that curve — how
  * un-ballistic the arc was to begin with.
  */
-export function fitBallisticArc(samples, fps, g = GRAVITY) {
+function fitBallisticArc(samples, fps, g = GRAVITY) {
 	const list = samples ?? [];
 	const rate = Number.isFinite(fps) && fps > 0 ? fps : 30;
 	const times = list.map((_, index) => index / rate);
@@ -650,8 +642,6 @@ export function fitBallisticArc(samples, fps, g = GRAVITY) {
 	return { positions, y0, v0, g, residual: Math.sqrt(sumSq / list.length) };
 }
 
-/* --- the driver ------------------------------------------------------------- */
-
 /** Deviation from the fitted parabola a span must reach before it is worth
  * correcting. 5 mm is well under the eye's threshold on a character-sized
  * silhouette and comfortably above the noise in a generated root track. */
@@ -666,7 +656,7 @@ export const MAX_CORRECTION = 0.5;
 /** Worst RMS a fit may have and still be believed. A real flight phase fits a
  * parabola to a couple of centimetres; a mis-detected span (a whole walk
  * misread as one jump) fits to a metre or more. */
-export const MAX_FIT_RESIDUAL = 0.25;
+const MAX_FIT_RESIDUAL = 0.25;
 
 /** Clearance kept between the lowest foot marker and the floor when a
  * downward correction is applied. */

package/src/ardy/collision-blockers.js

@@ -34,8 +34,8 @@ const DEG = Math.PI / 180;
 
 /** Namespace prefixes. Kept as exports so the App's QA surface and the tests
  * agree on the spelling instead of both hard-coding a string. */
-export const OBJECT_BLOCKER_PREFIX = "obj:";
-export const CHARACTER_BLOCKER_PREFIX = "char:";
+const OBJECT_BLOCKER_PREFIX = "obj:";
+const CHARACTER_BLOCKER_PREFIX = "char:";
 
 /** `obj:<sceneObjectId>` — one box per scene object. */
 export function objectBlockerId(sceneObjectId) {
@@ -58,8 +58,6 @@ export function blockerCharacterId(blockerId) {
 	return cut > 0 ? rest.slice(0, cut) : null;
 }
 
-/* --- scene objects ---------------------------------------------------------- */
-
 /**
  * Resolve an object's world size. `objectSize` (scene-objects.js) is the ONE
  * owner of footprint × scale, so it is reused rather than re-derived here — a
@@ -157,8 +155,6 @@ export function sceneObjectBlockers(sceneObjects, { library = null, frame = null
 	return out;
 }
 
-/* --- other cast members ----------------------------------------------------- */
-
 /** rigs may arrive as the App's plain `{ [characterId]: rig }` map or as a Map;
  * both are read through one iterator so a caller never has to convert. */
 function rigEntries(rigs) {
@@ -264,7 +260,7 @@ export function characterBlockers(rigs, activeId = null, { radii = null, charact
 export function collisionBlockers({ rigs = null, activeId = null, characterIds = null, sceneObjects = null, library = null, frame = null, take = null, skipIds = null, radii = null } = {}) {
 	return [
 		...characterBlockers(rigs, activeId, { radii, characterIds }),
-		...sceneObjectBlockers(sceneObjects ?? [], { library, frame, take, skipIds, characters: characterIds }),
+		...sceneObjectBlockers(sceneObjects, { library, frame, take, skipIds, characters: characterIds }),
 	];
 }
 

package/src/ardy/fix-collisions.js

@@ -39,8 +39,6 @@ import {
  * outside its keyed range by ikEvaluate's blend window.
  */
 
-/* --- capsule table ---------------------------------------------------------- */
-
 /**
  * Body capsules. `movable.chain`/`movable.joint` name the IK chain and the
  * joint of that chain to drive ("mid" = elbow/knee, "effector" = wrist/
@@ -77,8 +75,6 @@ const CAPSULE_DEFS = [
 	{ id: "rightFoot", start: "mixamorigRightFoot", end: "mixamorigRightToeBase", radiusJoint: "RightFoot", maxRadius: 0.07, movable: { chain: "rightFoot", joint: "effector" }, priority: 1 },
 ];
 
-/* --- fingers ---------------------------------------------------------------- */
-
 /**
  * FINGER CAPSULES. The hand capsule spans wrist → middle-finger base, which is
  * a palm: it still reads a pose where the FINGERS are buried in a thigh and the
@@ -302,8 +298,6 @@ export function buildCollisionCapsules(rig, radii = null) {
 	return capsules;
 }
 
-/* --- rest-relative calibration ---------------------------------------------- */
-
 /** Stable key for an unordered capsule pair. */
 function pairKey(idA, idB) {
 	return idA < idB ? `${idA}|${idB}` : `${idB}|${idA}`;
@@ -389,8 +383,6 @@ export function restPairOverlaps(rig, radii = null) {
 	return overlaps;
 }
 
-/* --- detection -------------------------------------------------------------- */
-
 /** Closest points between two segments (Ericson, Real-Time Collision
  * Detection — the textbook segment/segment distance). Writes into outA/outB
  * and returns the squared distance. */
@@ -458,8 +450,6 @@ function capsulesAdjacent(ca, cb) {
 	return ca.bones.some((ba) => cb.bones.some((bb) => bonesRelated(ba, bb)));
 }
 
-/* --- hinged pairs ------------------------------------------------------------ */
-
 /**
  * HINGED PAIRS. A blanket "skip everything within HOP_LIMIT" made whole classes
  * of real interpenetration invisible: a knee driven into the belly is
@@ -585,8 +575,6 @@ function pairGeometry(ca, cb) {
 	return geometry;
 }
 
-/* --- external blockers ------------------------------------------------------- */
-
 /**
  * EXTERNAL BLOCKERS. Everything above is the character against itself; a hand
  * swinging through a chair is the same problem against the SET. Callers pass
@@ -1016,8 +1004,6 @@ function chainsInPlay(pens) {
 	return ids;
 }
 
-/* --- escape direction ------------------------------------------------------- */
-
 /**
  * REST-BIASED ESCAPE. The separation normal is the SHORTEST way out, which for
  * a deep hit is regularly the wrong side of the blocker: a forearm driven into
@@ -1075,11 +1061,11 @@ export const MIN_ALIGN = 0.35;
  * biases only choose the side. Weighted like HOME_BIAS, because it is the same
  * kind of hint and answers the same question — where does this limb belong.
  */
-export const CONTINUITY_BIAS = 0.6;
+const CONTINUITY_BIAS = 0.6;
 
 /** The weight the STEP CAP's retry uses when the plain one produced a jump: the
  * previous frame's direction outvotes the rest pose rather than tying with it. */
-export const CONTINUITY_BIAS_STRONG = 1.6;
+const CONTINUITY_BIAS_STRONG = 1.6;
 
 /**
  * THE STEP CAP, as a multiple of the clip's own worst adjacent step for the
@@ -1089,18 +1075,18 @@ export const CONTINUITY_BIAS_STRONG = 1.6;
  * to lead or lag the clip's own motion by a good margin while a 20× jump — the
  * flail QA measured — cannot fit inside it.
  */
-export const STEP_CAP_FACTOR = 2.5;
+const STEP_CAP_FACTOR = 2.5;
 
 /** Ceiling on that cap, in metres. A clip whose hand already crosses the frame
  * in one step must not thereby license a half-metre correction jump; ~24 frames
  * a second, so 0.25 m is 6 m/s of hand — past any human hand speed a viewer
  * would read as continuous. */
-export const STEP_CAP_ABS = 0.25;
+const STEP_CAP_ABS = 0.25;
 
 /** Floor on that cap, in metres. A perfectly static clip has a zero worst step,
  * and a cap of zero would refuse every frame that follows a corrected one. 5 mm
  * is the millimetre noise of the proxies themselves. */
-export const STEP_CAP_FLOOR = 0.005;
+const STEP_CAP_FLOOR = 0.005;
 
 /** The bone a capsule's push actually drives: mid joint (elbow/knee) for an
  * upper segment, effector (wrist/ankle) for a lower segment or an end sphere. */
@@ -1157,8 +1143,6 @@ function escapeVector(rig, capsule, chains, normal, contactPoint, distance, weig
 	return biased.multiplyScalar(distance / Math.max(MIN_ALIGN, align));
 }
 
-/* --- side preservation ------------------------------------------------------ */
-
 /** Chains whose end joint must not change sides of the body because of a fix. */
 const SIDE_CHAINS = ["leftHand", "rightHand"];
 
@@ -1184,9 +1168,6 @@ function sagittalSide(rig, point) {
 	return point.clone().sub(origin).dot(lateral.normalize());
 }
 
-/* --- resolution ------------------------------------------------------------- */
-
-
 const NO_PUSH = Object.freeze({ ran: false, moved: false });
 
 /**
@@ -1339,7 +1320,6 @@ export function fixCollisions(rig, chains, {
 		return outcome.moved;
 	};
 
-	/* --- one pass, at a given home-bias weight ----------------------------- */
 	// Every push of a pass is computed from the pose the pass STARTED in, so the
 	// same penetration list can be replayed at a different weight (the side
 	// guard below) and produce a deterministic result either way.
@@ -1376,7 +1356,6 @@ export function fixCollisions(rig, chains, {
 		return passChanged;
 	};
 
-	/* --- side-preservation guard ------------------------------------------- */
 	/**
 	 * A hand must not change sides of the body because of a fix. The heuristic,
 	 * deliberately blunt: measure each arm chain's WRIST against the sagittal
@@ -1433,7 +1412,6 @@ export function fixCollisions(rig, chains, {
 	 * permitted chain when a filter is in force. */
 	const fixablePens = (capsules) => fixablePenetrations(capsules, { offset, slackFactor, blockers, onlyChains });
 
-	/* --- what this frame started as, so a bad fix can be refused whole ------ */
 	/** Every bone a fix or a yield can write, with its full local transform. */
 	const frameSnapshot = () => {
 		const entries = [];
@@ -1540,7 +1518,6 @@ export function fixCollisions(rig, chains, {
 		changed = changed || passChanged;
 		if (!passChanged) break;
 	}
-	/* --- capped torso/head yield -------------------------------------------- */
 	/**
 	 * The last resort, and only ever a last one: the limb passes are over and a
 	 * movable × static pair is still penetrating, so the STATIC side leans away
@@ -1725,7 +1702,6 @@ export function fixCollisions(rig, chains, {
 	// changed the pose, and the caller must key it.
 	changed = changed || poseDirty;
 
-	/* --- the accept gate ---------------------------------------------------- */
 	/**
 	 * A frame's fix is kept only if it is BETTER than the pose it started from.
 	 * Two ways it can fail to be, each measured against the entry pose:
@@ -1857,7 +1833,6 @@ export function fixCollisionsRange({
 	const start = Math.max(0, Math.round(startFrame));
 	const end = Math.max(start, Math.round(endFrame));
 
-	/* --- sweep 1: record the clip as it stands, writing nothing ------------ */
 	const bones = layerBones(chains, fkJoints);
 	const chainIds = [...chains.keys()];
 	const readChainQuats = () => new Map(chainIds.map((id) => [id, chains.get(id).bones.map((b) => b.quaternion.clone())]));
@@ -1892,7 +1867,6 @@ export function fixCollisionsRange({
 		if (!layerActive) clipQuats.push(readChainQuats());
 	}
 
-	/* --- what a frame-to-frame step is allowed to be ------------------------ */
 	/**
 	 * THE STEP CAP, per chain, measured on the clip the pass was handed. A
 	 * correction is allowed to move a limb; what it is not allowed to do is move
@@ -1923,7 +1897,6 @@ export function fixCollisionsRange({
 		stepCap.set(id, Math.min(STEP_CAP_ABS, Math.max(STEP_CAP_FLOOR, STEP_CAP_FACTOR * worst)));
 	}
 
-	/* --- sweep 2: fix each frame against that recorded pose ---------------- */
 	const keyed = [];
 	// Frame → deepest penetration left standing. A map, not a list: a frame the
 	// blend-window round revisits reports its LAST word, and a frame that round
@@ -1937,7 +1910,6 @@ export function fixCollisionsRange({
 		if (residual > 0) residuals.set(frame, residual);
 		else residuals.delete(frame);
 	};
-	/* --- temporal continuity ------------------------------------------------ */
 	/**
 	 * WHY THIS EXISTS. Every frame above is solved on its own, from the clip,
 	 * which is what makes each one honest — and what made a RUN of them garbage.
@@ -2192,7 +2164,6 @@ export function fixCollisionsRange({
 		};
 	}
 
-	/* --- sweep 3: the blend window's own frames, ONCE ----------------------- */
 	/**
 	 * Sweeps 1 and 2 judge every frame against the CLIP, which is what stops the
 	 * pass chasing its own tail. The cost is that the ramp each new key runs out
@@ -2241,7 +2212,6 @@ export function fixCollisionsRange({
 		keyed.sort((a, b) => a - b);
 	}
 
-	/* --- final sweep: the truth on the pose the viewer will actually see ----- */
 	/**
 	 * Everything above judges a frame at the moment it is solved. What the viewer
 	 * gets is the EVALUATED pose — clip plus every key's blend ramp — and the last

package/src/ardy/ik-drag.js

@@ -40,21 +40,23 @@ export function chainsChangedBy(chains, write) {
 
 /**
  * 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
+ * live pose: snapshot every node under `rig`, let `applyRaw(rig, frame)` 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) {
+function captureRawBase(rig, chains, fkJoints, ids, applyRaw, frame = null) {
 	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);
+		applyRaw(rig, frame);
 		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()));
+			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());
@@ -83,7 +85,7 @@ 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 base = applyRaw && rig ? captureRawBase(rig, chains, fkJoints, list, applyRaw, frame) : null;
 	const scratch = createIkState();
 	ikBakeKeyframe(chains, scratch, frame, fkJoints, list, null, base?.baseQuats ?? null);
 	const entry = scratch.keys.get(frame);
@@ -99,3 +101,82 @@ export function bakeIkDragKey(chains, fkJoints, frame, ids, applyRaw = null) {
 	}
 	return entry;
 }
+
+/** Apply one drag's correction delta to a raw pose. The source key is captured
+ * at the drag frame, while `base` belongs to a different raw frame. */
+function applyIkDragCorrection(chains, fkJoints, sourceEntry, base) {
+	if (!sourceEntry || !base) return;
+	for (const [id, key] of sourceEntry) {
+		const chain = chains?.get(id);
+		if (chain) {
+			const rawQuats = base.baseQuats.get(id);
+			if (rawQuats && key.q) {
+				const sourceQuats = key.baseQ;
+				chain.bones.forEach((bone, index) => {
+					if (!rawQuats[index] || !key.q[index]) return;
+					const delta = sourceQuats?.[index]
+						? sourceQuats[index].clone().invert().multiply(key.q[index])
+						: null;
+					if (!delta) return;
+					bone.quaternion.copy(rawQuats[index]).multiply(delta);
+				});
+			}
+			// `chainP` is an absolute legacy/explicit translation payload. A drag
+			// correction does not retain the source frame's raw chain positions, so
+			// carrying it to another clip frame would freeze that frame's segment
+			// lengths. Motion IK drags solve rotations; leave chain translations to
+			// the raw clip unless a future key format carries a translation delta.
+			chain.bones[0].updateMatrixWorld(true);
+			continue;
+		}
+		const joint = fkJoints?.get(id);
+		if (!joint) continue;
+		const rawQ = base.baseQuats.get(id)?.[0];
+		if (rawQ && key.q?.[0]) {
+			const sourceQ = key.baseQ?.[0];
+			if (sourceQ) {
+				const delta = sourceQ.clone().invert().multiply(key.q[0]);
+				joint.bone.quaternion.copy(rawQ).multiply(delta);
+			}
+		}
+		const rawPos = base.basePositions.get(id);
+		if (rawPos && key.p && key.basePos) {
+			joint.bone.position.copy(rawPos).add(key.p.clone().sub(key.basePos));
+		}
+		joint.bone.updateMatrixWorld(true);
+	}
+}
+
+/** Bake the captured drag correction at the inclusive range boundaries. */
+export function bakeIkDragRange(chains, fkJoints, sourceEntry, startFrame, endFrame, ids, applyRaw = null) {
+	const frames = [...new Set([Math.round(startFrame), Math.round(endFrame)])].sort((a, b) => a - b);
+	const result = new Map();
+	const rig = chains?.values().next().value?.rig;
+	const saved = [];
+	rig?.traverse((node) => saved.push([node, node.position.clone(), node.quaternion.clone(), node.scale.clone()]));
+	const correctionRange = { start: frames[0], end: frames.at(-1) };
+	try {
+		for (const frame of frames) {
+			if (!applyRaw || !rig) {
+				result.set(frame, sourceEntry
+					? new Map([...sourceEntry].map(([id, key]) => [id, { ...key, correctionRange: { ...correctionRange } }]))
+					: null);
+				continue;
+			}
+			const applyFrame = () => applyRaw(rig, frame);
+			const base = captureRawBase(rig, chains, fkJoints, ids, applyFrame);
+			applyFrame();
+			applyIkDragCorrection(chains, fkJoints, sourceEntry, base);
+			const entry = bakeIkDragKey(chains, fkJoints, frame, ids, applyFrame);
+			result.set(frame, entry ? new Map([...entry].map(([id, key]) => [id, { ...key, correctionRange: { ...correctionRange } }])) : null);
+		}
+	} 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 result;
+}

package/src/ardy/ik-key-json.js

@@ -6,7 +6,7 @@ import * as THREE from "three";
  * positions as {x,y,z}. Optional fields are written only when the key has
  * them, so a key without a stored `blend` stays one without it.
  */
-export function ikTrackKeyJson(key) {
+function ikTrackKeyJson(key) {
 	const quaternion = (q) => ({ x: q.x, y: q.y, z: q.z, w: q.w });
 	const vector = (p) => ({ x: p.x, y: p.y, z: p.z });
 	return {
@@ -16,6 +16,7 @@ export function ikTrackKeyJson(key) {
 		...(key.basePos ? { basePos: vector(key.basePos) } : {}),
 		...(key.chainP ? { chainP: key.chainP.map(vector) } : {}),
 		...(key.keepTranslations ? { keepTranslations: true } : {}),
+		...(key.correctionRange ? { correctionRange: { start: key.correctionRange.start, end: key.correctionRange.end } } : {}),
 		...(key.blend != null ? { blend: key.blend } : {}),
 		...(key.pin != null ? { pin: key.pin } : {}),
 	};
@@ -37,6 +38,7 @@ export function ikTrackKeyFromJson(key) {
 		...(key.basePos ? { basePos: vector(key.basePos) } : {}),
 		...(key.chainP ? { chainP: key.chainP.map(vector) } : {}),
 		...(key.keepTranslations ? { keepTranslations: true } : {}),
+		...(key.correctionRange ? { correctionRange: { start: key.correctionRange.start, end: key.correctionRange.end } } : {}),
 		...(key.blend != null ? { blend: key.blend } : {}),
 		...(key.pin != null ? { pin: key.pin } : {}),
 	};

package/src/ardy/ik.js

@@ -64,8 +64,7 @@ function pointSegmentDistance(point, start, end) {
 	return point.distanceTo(start.clone().addScaledVector(segment, t));
 }
 
-/* --- bind-pose geometry ------------------------------------------------------
- *
+/*
  * `rig.userData.poseBind` (primed by primeBindPose at clone time) is the only
  * record of the UNTOUCHED skeleton once a clip is playing: ARDY playback writes
  * per-bone translations AND rotations every frame, so "where is this bone"
@@ -100,8 +99,7 @@ function bindLocalMatrix(rig, node, out, delta = null) {
 	return out.compose(bindPosition, bindQuaternion, node.scale);
 }
 
-/* --- the REST pose -----------------------------------------------------------
- *
+/*
  * The bind pose is a T-pose; the pose a character actually STANDS in is
  * DEFAULT_POSE — "arms hanging naturally at their sides" — which poses.js
  * applies as Euler deltas PRE-multiplied onto each bind local rotation. The two
@@ -319,7 +317,7 @@ export function measureContactRadii(rig) {
  * Bone points and vertices are read in the same pose, for the same reason
  * measureContactRadii does: this is cached forever off whichever frame called
  * first, so it must not be able to depend on that frame. */
-export function measureContactHeights(rig) {
+function measureContactHeights(rig) {
 	if (!rig) return {};
 	const cached = contactHeightCache.get(rig);
 	if (cached) return cached;
@@ -792,8 +790,6 @@ export function solveHipsTranslate(joint, worldDelta, startLocalPos) {
 	bone.updateMatrixWorld(true);
 }
 
-/* --- state ----------------------------------------------------------------- */
-
 /** Mutable per-rig IK layer state. `targets` are the live handle positions
  * (world space) the handles render at and the solver reaches for. `keys`
  * maps frame → Map(trackId → {q, p}) — FK LOCAL rotations of the solved
@@ -959,8 +955,6 @@ export function ikRemoveKeyframe(ikState, frame) {
 	ikState.keys.delete(frame);
 }
 
-/* --- foot planting (ground snap) -------------------------------------------- */
-
 /** The two leg chains that get planted. */
 const LEG_IDS = ["leftFoot", "rightFoot"];
 
@@ -1200,20 +1194,28 @@ function trackIslands(keys, trackId, blendWindow) {
 	const frames = [];
 	for (const [f, entry] of keys) {
 		const key = entry.get(trackId);
-		if (key) frames.push([f, key.blend ?? blendWindow]);
+		if (key) frames.push([f, key.blend ?? blendWindow, key.correctionRange ?? null]);
 	}
 	if (!frames.length) return [];
 	frames.sort((a, b) => a[0] - b[0]);
+	// Paired boundary keys keep the selected interval connected even when an
+	// older key lies inside it. Use their current frame positions so retiming
+	// the timeline keeps the interval attached to its keys.
+	const rangeEnd = new Map();
+	const rangeId = range => range ? `${range.start}:${range.end}` : null;
+	for (const [f, , range] of frames) if (range) rangeEnd.set(rangeId(range), f);
 	const islands = [];
-	let [first, firstBlend] = frames[0];
+	let [first, firstBlend, firstRange] = frames[0];
+	let connectedUntil = rangeEnd.get(rangeId(firstRange)) ?? first;
 	let [prev, prevBlend] = frames[0];
 	for (let index = 1; index < frames.length; index += 1) {
-		const [f, blend] = frames[index];
-		if (f - prev > Math.max(prevBlend, blend)) {
+		const [f, blend, range] = frames[index];
+		if (f > connectedUntil && f - prev > Math.max(prevBlend, blend)) {
 			islands.push([first, prev, firstBlend, prevBlend]);
 			first = f;
 			firstBlend = blend;
 		}
+		connectedUntil = Math.max(connectedUntil, rangeEnd.get(rangeId(range)) ?? f);
 		prev = f;
 		prevBlend = blend;
 	}

package/src/ardy/motion-calibration.js

@@ -3,7 +3,7 @@
 // transform recorded by the scene (uniform scale, Y rotation and translation).
 // It deliberately leaves local joint rotations untouched.
 
-export const MOTION_CALIBRATION_LIMITS = Object.freeze({
+const MOTION_CALIBRATION_LIMITS = Object.freeze({
 	minScale: 0.1,
 	maxScale: 10,
 	maxOffset: 100,

package/src/ardy/npz.js

@@ -54,8 +54,6 @@ export class NpzError extends Error {
 	}
 }
 
-/* --- CRC-32 (IEEE 802.3, reflected) -------------------------------------- */
-
 const CRC_TABLE = (() => {
 	const table = new Uint32Array(256);
 	for (let n = 0; n < 256; n += 1) {
@@ -72,8 +70,6 @@ function crc32(bytes) {
 	return (c ^ 0xffffffff) >>> 0;
 }
 
-/* --- zip container -------------------------------------------------------- */
-
 /** Locate the End of Central Directory record, scanning back from EOF. */
 function findEocd(view) {
 	// EOCD is 22 bytes + a comment of up to 65535; the scan window also covers
@@ -219,8 +215,6 @@ async function inflateRaw(bytes, cap) {
 	return out;
 }
 
-/* --- npy member ----------------------------------------------------------- */
-
 const DTYPE_RE = /^([<>=|])([A-Za-z?])([0-9]{1,4})$/;
 
 /**
@@ -403,8 +397,6 @@ function checkRotationMatrix(rows, frame, joint) {
 	}
 }
 
-/* --- archive decode ------------------------------------------------------- */
-
 /**
  * Decode an ARDY motion npz from raw bytes.
  *

package/src/ardy/physics-panel.jsx

@@ -1,7 +1,8 @@
-import React, { useEffect, useState, useSyncExternalStore } from "react";
+import { useEffect, useState, useSyncExternalStore } from "react";
 import { SUPPORT_SITES } from "./physics-review.js";
 import { useMotionCommands } from '../domains/motion.js';
 import "./physics-panel.css";
+import { isImeComposing } from "../ime.js";
 
 // Only the progress panel subscribes. Publishing a percentage must not
 // rerender the full timeline/Studio hundreds of times during a solve.
@@ -31,7 +32,7 @@ export function PhysicsPanel({ ko, disabled, running, progress: progressStore, p
 		const onKeyDown = (event) => {
 			if (event.metaKey || event.ctrlKey || event.altKey) return;
 			if (event.key === "Escape") { event.preventDefault(); onCancel?.(); }
-			if (event.key === "Enter") { event.preventDefault(); onApply?.(); }
+			if (event.key === "Enter" && !isImeComposing(event)) { event.preventDefault(); onApply?.(); }
 		};
 		window.addEventListener("keydown", onKeyDown);
 		return () => window.removeEventListener("keydown", onKeyDown);

package/src/ardy/physics-review.js

@@ -31,16 +31,17 @@ export function copyPhysicsKeys(keys) {
 		...(k.baseQ ? { baseQ: k.baseQ.map((q) => q.clone()) } : {}),
 		...(k.basePos ? { basePos: k.basePos.clone() } : {}),
 		...(k.chainP ? { chainP: k.chainP.map((p) => p.clone()) } : {}),
+		...(k.correctionRange ? { correctionRange: { ...k.correctionRange } } : {}),
 	}]))]));
 }
 export function physicsKeyStamp(keys) {
-	return JSON.stringify([...keys].sort((a, b) => a[0] - b[0]).map(([f, e]) => [f, [...e].sort(([a], [b]) => a.localeCompare(b)).map(([id, k]) => [id, k.p?.toArray(), k.q?.map((q) => q.toArray()), k.basePos?.toArray(), k.baseQ?.map((q) => q.toArray()), k.keepTranslations, k.chainP?.map((p) => p.toArray())])]));
+	return JSON.stringify([...keys].sort((a, b) => a[0] - b[0]).map(([f, e]) => [f, [...e].sort(([a], [b]) => a.localeCompare(b)).map(([id, k]) => [id, k.p?.toArray(), k.q?.map((q) => q.toArray()), k.basePos?.toArray(), k.baseQ?.map((q) => q.toArray()), k.keepTranslations, k.chainP?.map((p) => p.toArray()), k.correctionRange])]));
 }
 
 /** Measured skin, shared exact transforms; never a cached bind-pose sole. */
 export function createSupportSampler(rig) { return createSurfaceSampler(rig, SUPPORT_SITES); }
 
-export function sitePoint(row, site) {
+function sitePoint(row, site) {
 	return site.kind === "foot" ? (row.toes?.[site.id] ?? row.support[site.id]?.position) : row.support[site.id]?.position;
 }
 

package/src/ardy/physics-support.js

@@ -5,7 +5,7 @@ import { SEGMENT_MASSES } from "./auto-physics.js";
 const G = 9.81;
 const V = () => new THREE.Vector3();
 const smooth = (t) => { t = Math.max(0, Math.min(1, t)); return t * t * (3 - 2 * t); };
-export const SUPPORT_LIMITS = Object.freeze({ gap: .025, force: .22, moment: .10, maxDrop: .60, friction: .6 });
+const SUPPORT_LIMITS = Object.freeze({ gap: .025, force: .22, moment: .10, maxDrop: .60, friction: .6 });
 
 /** Cached bone lookup and an explicit approximate segmented physical body.
  * Mass is normalized: reported forces are body weights, not measured Newtons.

package/src/ardy/physics-surface.js

@@ -3,7 +3,7 @@ import { findBone } from "./ik.js";
 
 // Extra measured patches are not IK handles. They let a seated/lying body
 // support itself without pretending its feet are planted.
-export const BODY_SUPPORT_SITES = [
+const BODY_SUPPORT_SITES = [
 	["pelvis", "Hips", /Hips$/], ["abdomen", "Spine", /Spine$/],
 	["chest", "Spine1", /Spine[12]$/], ["head", "Head", /Head/],
 	["neck", "Neck", /Neck$/], ["leftShoulder", "LeftShoulder", /LeftShoulder$/], ["rightShoulder", "RightShoulder", /RightShoulder$/],

package/src/ardy/platform-fit-panel.jsx

@@ -1,5 +1,6 @@
 import React, { useEffect, useSyncExternalStore } from "react";
 import "../panels/pose.css";
+import { isImeComposing } from "../ime.js";
 
 const FOOT_NAMES = { leftFoot: ["Left foot", "왼발"], rightFoot: ["Right foot", "오른발"] };
 function stepLabel(step, ko) {
@@ -18,7 +19,7 @@ export function PlatformFitPanel({ ko, disabled, running, progress: progressStor
 		const onKeyDown = (event) => {
 			if (event.metaKey || event.ctrlKey || event.altKey) return;
 			if (event.key === "Escape") { event.preventDefault(); onCancel?.(); }
-			if (event.key === "Enter") { event.preventDefault(); onApply?.(); }
+			if (event.key === "Enter" && !isImeComposing(event)) { event.preventDefault(); onApply?.(); }
 		};
 		window.addEventListener("keydown", onKeyDown);
 		return () => window.removeEventListener("keydown", onKeyDown);