cozyclay 2.1.1 → 3.0.1

package/src/ardy/foot-lock.js

@@ -1,230 +0,0 @@
-/* Pure-math foot locking, ported from Daniel Holden's article "Inverse
- * Kinematics and Foot Locking" (https://theorangeduck.com/page/inverse-kinematics-foot-locking).
- * Foot slide is a velocity error: instead of snapping a planted toe to the
- * floor, the locked contact target is blended in and out with cubic
- * inertialization so position and velocity stay continuous, the TOE (never
- * the heel) is the locked point, and IK stays a minimal modification of the
- * source pose. Everything here is a pure function over THREE.Vector3 data —
- * no rig, scene, or playback access — so callers decide how targets reach
- * the skeleton. */
-import * as THREE from "three";
-
-/* Shared read-only zero vector for "the contact point is stationary". Never
- * mutated; Vector3 methods that would mutate it are never called on it. */
-const ZERO = new THREE.Vector3();
-
-/* Cubic inertialization weights (Holden eq. for the cubic ease). w0/w1 blend
- * position, w2/w3 blend velocity; w1/w2 carry the blendTime units. blendTime
- * is guarded so a zero blend degrades to "snap now" instead of dividing by
- * zero. */
-function cubicWeights(time, blendTime) {
-	const bt = Math.max(blendTime, 1e-8);
-	const t = Math.min(Math.max(time / bt, 0), 1);
-	const t2 = t * t;
-	const t3 = t2 * t;
-	return {
-		w0: 2 * t3 - 3 * t2 + 1,
-		w1: (t3 - 2 * t2 + t) * bt,
-		w2: (6 * t2 - 6 * t) / bt,
-		w3: 3 * t2 - 4 * t + 1,
-	};
-}
-
-/* Re-target the inertializer: fold the current offset state at `time` into a
- * fresh offset that reproduces the same output trajectory relative to the new
- * destination, then restart the blend clock. Source is where the motion is
- * coming from (the pre-switch target), destination where it goes next. */
-export function inertializeCubicTransition(offsetPosition, offsetVelocity, time, sourcePosition, sourceVelocity, destinationPosition, destinationVelocity, blendTime) {
-	const { w0, w1, w2, w3 } = cubicWeights(time.value, blendTime);
-	return {
-		offsetPosition: sourcePosition.clone().addScaledVector(offsetPosition, w0).addScaledVector(offsetVelocity, w1).sub(destinationPosition),
-		offsetVelocity: sourceVelocity.clone().addScaledVector(offsetPosition, w2).addScaledVector(offsetVelocity, w3).sub(destinationVelocity),
-		time: { value: 0 },
-	};
-}
-
-/* Advance the inertialized output one step: the input stream plus the decaying
- * offset. `time` is a mutable { value } box so the offset state can be handed
- * around without wrapping it in a class. */
-export function inertializeCubicUpdate(position, velocity, time, inputPosition, inputVelocity, offsetPosition, offsetVelocity, deltaTime, blendTime) {
-	// Holden evaluates the weights at time+deltaTime so the step lands at the
-	// end of the interval, not its start.
-	const { w0, w1, w2, w3 } = cubicWeights(time.value + deltaTime, blendTime);
-	position.copy(inputPosition).addScaledVector(offsetPosition, w0).addScaledVector(offsetVelocity, w1);
-	velocity.copy(inputVelocity).addScaledVector(offsetPosition, w2).addScaledVector(offsetVelocity, w3);
-	time.value += deltaTime;
-	return position;
-}
-
-/* Fresh foot-lock state for one toe. `position` seeds both the filtered
- * output and the "previous input" so the first finite-difference velocity is
- * not polluted by an arbitrary origin. */
-export function createFootLockState(position) {
-	return {
-		position: position.clone(),
-		velocity: new THREE.Vector3(),
-		inputPosition: position.clone(),
-		inputVelocity: new THREE.Vector3(),
-		offsetPosition: new THREE.Vector3(),
-		offsetVelocity: new THREE.Vector3(),
-		time: { value: 0 },
-		contact: position.clone(),
-		locked: false,
-	};
-}
-
-/* Per-frame foot locking for one toe (Holden's UpdateFootLockingState).
- * contactHeight plants the lock at floor height; pass null to keep the input
- * y. options.contactPoint (used by footLockTrack for span anchors) overrides
- * the first-contact input position as the locked point. */
-export function updateFootLockState(state, inputPosition, inputContact, contactHeight, deltaTime, { unlockDistance = 0.2, lockDistance = 0.1, blendTime = 0.2, contactPoint = null } = {}) {
-	// Input velocity by finite difference: slide is a velocity error, so the
-	// corrector needs to know how fast the raw toe was drifting.
-	const dt = Math.max(deltaTime, 1e-8);
-	state.inputVelocity.copy(inputPosition).sub(state.inputPosition).divideScalar(dt);
-
-	if (!state.locked && inputContact && state.position.distanceTo(inputPosition) < lockDistance) {
-		// Lock onto the TOE: capture the contact point (input, dropped to the
-		// requested height) and hand the current motion error to the
-		// inertializer as a transition from the input onto the stationary
-		// contact.
-		state.locked = true;
-		if (contactPoint) {
-			// An explicit anchor (e.g. a hand-placed ground mark) IS the contact
-			// point — its y is authoritative, never re-derived from the input.
-			state.contact.copy(contactPoint);
-		} else {
-			state.contact.copy(inputPosition);
-			if (contactHeight === null || contactHeight === undefined) state.contact.y = inputPosition.y;
-			else state.contact.y = contactHeight;
-		}
-		const next = inertializeCubicTransition(state.offsetPosition, state.offsetVelocity, state.time, inputPosition, state.inputVelocity, state.contact, ZERO, blendTime);
-		state.offsetPosition.copy(next.offsetPosition);
-		state.offsetVelocity.copy(next.offsetVelocity);
-		state.time.value = next.time.value;
-	} else if (state.locked && (!inputContact || state.position.distanceTo(inputPosition) > unlockDistance)) {
-		// Release: transition from the stationary contact back onto the moving
-		// input so the toe catches up instead of teleporting.
-		state.locked = false;
-		const next = inertializeCubicTransition(state.offsetPosition, state.offsetVelocity, state.time, state.contact, ZERO, inputPosition, state.inputVelocity, blendTime);
-		state.offsetPosition.copy(next.offsetPosition);
-		state.offsetVelocity.copy(next.offsetVelocity);
-		state.time.value = next.time.value;
-	}
-
-	const target = state.locked ? state.contact : inputPosition;
-	const targetVelocity = state.locked ? ZERO : state.inputVelocity;
-	inertializeCubicUpdate(state.position, state.velocity, state.time, target, targetVelocity, state.offsetPosition, state.offsetVelocity, deltaTime, blendTime);
-	state.inputPosition.copy(inputPosition);
-	return state.position;
-}
-
-/* Offline driver: run the per-frame state over a whole clip. `inputs` is one
- * toe position per frame; `contacts` is booleans per frame, or — when
- * `anchors` is given — span objects { start, end, anchor? }. anchors[f] being
- * a Vector3 pins the locked contact to that exact point (e.g. a hand-placed
- * ground mark) instead of wherever the toe first touched; with contactHeight
- * null the input y is kept. Frame 0 just initialises the state. */
-export function footLockTrack(inputs, contacts, { fps = 30, blendTime = 0.2, lockDistance = 0.1, unlockDistance = 0.2, contactHeight = null, anchors = null } = {}) {
-	const count = inputs.length;
-	const flags = new Array(count).fill(false);
-	const points = new Array(count).fill(null);
-	// Contacts arrive either as per-frame booleans or as {start,end,anchor?}
-	// spans; expand spans so both shapes feed the same flags/points.
-	for (let f = 0; f < count; f++) {
-		const c = contacts[f];
-		if (typeof c === "boolean") {
-			flags[f] = c;
-		} else if (c && Number.isFinite(c.start)) {
-			for (let g = Math.max(0, c.start); g <= Math.min(count - 1, c.end); g++) {
-				flags[g] = true;
-				if (points[g] === null && c.anchor instanceof THREE.Vector3) points[g] = c.anchor;
-			}
-		}
-	}
-	if (anchors !== null) {
-		// Per-frame anchors name a specific frame, so they outrank span anchors.
-		for (let f = 0; f < count; f++) {
-			if (anchors[f] instanceof THREE.Vector3) points[f] = anchors[f];
-		}
-	}
-
-	const state = createFootLockState(inputs[0]);
-	const out = [state.position.clone()];
-	const deltaTime = 1 / Math.max(fps, 1e-6);
-	for (let f = 1; f < count; f++) {
-		updateFootLockState(state, inputs[f], flags[f], contactHeight, deltaTime, { lockDistance, unlockDistance, blendTime, contactPoint: points[f] });
-		out.push(state.position.clone());
-	}
-	return out;
-}
-
-/* Holden's offline relaxation: given SOURCE toe/pelvis tracks and per-frame
- * contact flags, absorb contact-slide drift without inventing motion. Inputs
- * are never mutated; clones are relaxed and returned. Contact frames collapse
- * toward a shared ground point (hard); air frames chase their neighbour plus
- * the SOURCE relative displacement so the gait survives (soft); the in-frame
- * leg-length constraint keeps extension at what the source had instead of
- * pulling the hips down. */
-export function relaxToePath(toes, pelvis, contacts, { iterations = 200, softFactor = 0.05, hardFactor = 0.9, toeMinHeight = 0, restLengths = null, relaxPelvis = false } = {}) {
-	const count = toes.length;
-	const sourceToes = toes.map((t) => t.clone());
-	const outToes = toes.map((t) => t.clone());
-	const outPelvis = pelvis.map((p) => p.clone());
-	// Rest lengths default to the source pose: the point is to stop the leg
-	// stretching further than the animation ever did.
-	const rest = restLengths ?? sourceToes.map((t, i) => outPelvis[i].distanceTo(t));
-	const tmp = new THREE.Vector3();
-	const target = new THREE.Vector3();
-
-	// Move `point` factor of the way to `target`, clamping y up to minY when
-	// requested; returns the applied distance so the caller can early-exit.
-	const relaxPoint = (point, to, factor, minY) => {
-		const ox = point.x, oy = point.y, oz = point.z;
-		point.lerp(to, factor);
-		if (minY !== null && point.y < minY) point.y = minY;
-		return Math.hypot(point.x - ox, point.y - oy, point.z - oz);
-	};
-	// Soft target for frame i: neighbour j plus the SOURCE i-j displacement,
-	// so air frames preserve stride rather than smearing into each other.
-	const chaseNeighbour = (out, source, i, j, factor, minY) => {
-		target.copy(out[j]).add(source[i]).sub(source[j]);
-		return relaxPoint(out[i], target, factor, minY);
-	};
-
-	for (let iter = 0; iter < iterations; iter++) {
-		let largest = 0;
-		for (let i = 1; i < count; i++) {
-			if (contacts[i - 1] && contacts[i]) {
-				// Both frames planted: they belong at ONE spot, so pull both
-				// toward their midpoint dropped to the ground height.
-				target.copy(outToes[i]).add(outToes[i - 1]).multiplyScalar(0.5);
-				target.y = Array.isArray(toeMinHeight) ? Math.max(toeMinHeight[i] ?? 0, toeMinHeight[i - 1] ?? 0) : toeMinHeight;
-				largest = Math.max(largest, relaxPoint(outToes[i], target, hardFactor, null));
-				largest = Math.max(largest, relaxPoint(outToes[i - 1], target, hardFactor, null));
-			} else {
-				largest = Math.max(largest, chaseNeighbour(outToes, sourceToes, i, i - 1, softFactor, Array.isArray(toeMinHeight) ? toeMinHeight[i] : toeMinHeight));
-				largest = Math.max(largest, chaseNeighbour(outToes, sourceToes, i - 1, i, softFactor, Array.isArray(toeMinHeight) ? toeMinHeight[i - 1] : toeMinHeight));
-				if (relaxPelvis) {
-					largest = Math.max(largest, chaseNeighbour(outPelvis, pelvis, i, i - 1, softFactor, null));
-					largest = Math.max(largest, chaseNeighbour(outPelvis, pelvis, i - 1, i, softFactor, null));
-				}
-			}
-		}
-		// In-frame constraint: hold |pelvis - toe| at the rest length by
-		// moving the toe (splitting the correction with the pelvis only when
-		// asked — moving the pelvis is the "pull the hips down" failure the
-		// article warns about).
-		for (let i = 0; i < count; i++) {
-			tmp.copy(outToes[i]).sub(outPelvis[i]);
-			const d = tmp.length();
-			if (d < 1e-9) continue;
-			const correction = ((d - rest[i]) * softFactor) / d;
-			outToes[i].addScaledVector(tmp, -correction);
-			if (relaxPelvis) outPelvis[i].addScaledVector(tmp, correction);
-			largest = Math.max(largest, Math.abs(correction) * d);
-		}
-		if (largest < 1e-5) break;
-	}
-	return { toes: outToes, pelvis: outPelvis };
-}

package/src/ardy/motion-calibration.js

@@ -1,118 +0,0 @@
-// Pure scene-space calibration for decoded GVHMR motion.  Extraction owns a
-// camera-independent coordinate system; this pass applies the optional rigid
-// transform recorded by the scene (uniform scale, Y rotation and translation).
-// It deliberately leaves local joint rotations untouched.
-
-const MOTION_CALIBRATION_LIMITS = Object.freeze({
-	minScale: 0.1,
-	maxScale: 10,
-	maxOffset: 100,
-});
-
-const finite = (value, fallback) => {
-	const number = Number(value);
-	return Number.isFinite(number) ? number : fallback;
-};
-
-function wrapDegrees(value) {
-	const wrapped = ((value + 180) % 360 + 360) % 360 - 180;
-	// Keep the canonical positive half-open interval stable for exact 180.
-	return Object.is(wrapped, -0) ? 0 : wrapped;
-}
-
-/**
- * Return a safe, JSON-friendly calibration envelope.  Missing values are the
- * identity transform; finite values outside the scene envelope are clamped so
- * persisted metadata cannot throw a take metres away or produce NaNs.
- */
-export function normalizeMotionCalibration(value, limits = MOTION_CALIBRATION_LIMITS) {
-	const source = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-	const minScale = Math.max(Number.EPSILON, finite(limits?.minScale, MOTION_CALIBRATION_LIMITS.minScale));
-	const maxScale = Math.max(minScale, finite(limits?.maxScale, MOTION_CALIBRATION_LIMITS.maxScale));
-	const maxOffset = Math.max(0, finite(limits?.maxOffset, MOTION_CALIBRATION_LIMITS.maxOffset));
-	const rawScale = finite(source.scale, 1);
-	const rawYaw = finite(source.yawDeg ?? source.yaw, 0);
-	const clampOffset = (entry) => Math.max(-maxOffset, Math.min(maxOffset, finite(entry, 0)));
-	return {
-		scale: Math.max(minScale, Math.min(maxScale, rawScale > 0 ? rawScale : 1)),
-		yawDeg: wrapDegrees(rawYaw),
-		offsetX: clampOffset(source.offsetX ?? source.offset_x),
-		offsetY: clampOffset(source.offsetY ?? source.offset_y),
-		offsetZ: clampOffset(source.offsetZ ?? source.offset_z),
-	};
-}
-
-function copyArray(values) {
-	if (values == null) return values;
-	if (typeof values.slice === "function") return values.slice();
-	return Array.from(values);
-}
-
-function validArray(values, length) {
-	return values != null && typeof values.length === "number" && values.length >= length;
-}
-
-/**
- * Apply a rigid scene calibration to root and posed-joint positions.
- *
- * The input take is never mutated.  The result follows the same
- * `{ motion, diagnostics }` contract as the other ARDY correction passes.
- * `rotMats` are local joint rotations, so a world-space yaw does not change
- * them and the original array is intentionally retained by reference.
- */
-export function applyMotionCalibration(motion, metadata = motion?.sceneCalibration, options = {}) {
-	const identity = normalizeMotionCalibration(null, options.limits);
-	const baseDiagnostics = {
-		status: "not-needed",
-		applied: false,
-		changedFrames: 0,
-		maxDisplacement: 0,
-		maxRootDisplacement: 0,
-		maxJointDisplacement: 0,
-		calibration: identity,
-	};
-	if (!motion || typeof motion !== "object") return { motion, diagnostics: { ...baseDiagnostics, status: "invalid-motion" } };
-	const calibration = normalizeMotionCalibration(metadata, options.limits);
-	const frames = Number(motion.frames);
-	const hasRoot = Number.isInteger(frames) && frames >= 0 && validArray(motion.rootPos, frames * 3);
-	const hasJoints = Number.isInteger(frames) && frames >= 0 && validArray(motion.posedJoints, 0) && motion.posedJoints.length % (frames * 3 || 1) === 0;
-	if (!hasRoot && !hasJoints) return { motion, diagnostics: { ...baseDiagnostics, status: "invalid-motion", calibration } };
-	const isIdentity = calibration.scale === 1 && calibration.yawDeg === 0 && calibration.offsetX === 0 && calibration.offsetY === 0 && calibration.offsetZ === 0;
-	if (isIdentity) return { motion, diagnostics: { ...baseDiagnostics, calibration } };
-
-	const radians = calibration.yawDeg * Math.PI / 180;
-	const cos = Math.cos(radians), sin = Math.sin(radians), transform = (x, y, z) => {
-		const sx = calibration.scale * x, sy = calibration.scale * y, sz = calibration.scale * z;
-		return [cos * sx + sin * sz + calibration.offsetX, sy + calibration.offsetY, -sin * sx + cos * sz + calibration.offsetZ];
-	};
-	const rootPos = hasRoot ? copyArray(motion.rootPos) : motion.rootPos;
-	const posedJoints = hasJoints ? copyArray(motion.posedJoints) : motion.posedJoints;
-	let maxRootDisplacement = 0, maxJointDisplacement = 0, changedFrames = 0;
-	const displacement = (before, after) => {
-		if (![...before, ...after].every(Number.isFinite)) return 0;
-		return Math.hypot(after[0] - before[0], after[1] - before[1], after[2] - before[2]);
-	};
-	for (let frame = 0; frame < frames; frame += 1) {
-		let frameChanged = false;
-		if (hasRoot) {
-			const offset = frame * 3, before = [motion.rootPos[offset], motion.rootPos[offset + 1], motion.rootPos[offset + 2]], after = transform(...before);
-			rootPos[offset] = after[0]; rootPos[offset + 1] = after[1]; rootPos[offset + 2] = after[2];
-			maxRootDisplacement = Math.max(maxRootDisplacement, displacement(before, after)); frameChanged ||= displacement(before, after) > 1e-9;
-		}
-		if (hasJoints) {
-			const jointCount = motion.posedJoints.length / (frames * 3);
-			for (let joint = 0; joint < jointCount; joint += 1) {
-				const offset = (frame * jointCount + joint) * 3, before = [motion.posedJoints[offset], motion.posedJoints[offset + 1], motion.posedJoints[offset + 2]], after = transform(...before);
-				posedJoints[offset] = after[0]; posedJoints[offset + 1] = after[1]; posedJoints[offset + 2] = after[2];
-				maxJointDisplacement = Math.max(maxJointDisplacement, displacement(before, after)); frameChanged ||= displacement(before, after) > 1e-9;
-			}
-		}
-		if (frameChanged) changedFrames += 1;
-	}
-	const diagnostics = {
-		status: "calibrated", applied: true, changedFrames,
-		maxDisplacement: Math.max(maxRootDisplacement, maxJointDisplacement),
-		maxRootDisplacement, maxJointDisplacement, calibration,
-	};
-	return { motion: { ...motion, rootPos, posedJoints }, diagnostics };
-}

package/src/ardy/motion-edit.js

@@ -1,213 +0,0 @@
-import { retimeMotion } from "./retime.js";
-import { sliceMotion } from "./trim.js";
-
-const SPEED_MIN = 0.1;
-const SPEED_MAX = 4;
-const SPEED_STEP = 0.1;
-const normalizeSpeed = (speed) => Math.round(Number(speed) / SPEED_STEP) * SPEED_STEP;
-
-const segmentSourceFrames = (segment) => segment.sourceEnd - segment.sourceStart + 1;
-const segmentTimelineFrames = (segment) => Math.max(1, Math.round(segmentSourceFrames(segment) / segment.speed));
-
-export function createMotionEdit(frames) {
-	if (!Number.isInteger(frames) || frames < 1) {
-		throw new Error("createMotionEdit: frames must be a positive integer");
-	}
-	return [{ id: "motion-0", sourceStart: 0, sourceEnd: frames - 1, speed: 1 }];
-}
-
-export function motionEditDuration(edit) {
-	if (!Array.isArray(edit) || edit.length < 1) return 0;
-	return edit.reduce((total, segment) => total + segmentTimelineFrames(segment), 0);
-}
-
-export function motionEditLayout(edit) {
-	let cursor = 0;
-	return edit.map((segment) => {
-		const frames = segmentTimelineFrames(segment);
-		const item = {
-			...segment,
-			timelineStart: cursor,
-			timelineEnd: cursor + frames - 1,
-			timelineFrames: frames,
-		};
-		cursor += frames;
-		return item;
-	});
-}
-
-export function timelineFrameToMotionFrame(edit, frame) {
-	const layout = motionEditLayout(edit);
-	if (layout.length < 1) return Math.max(0, Math.round(frame) || 0);
-	const timelineFrame = Math.max(0, Math.min(Number.isFinite(frame) ? frame : 0, layout.at(-1).timelineEnd));
-	const segment = layout.find((item) => timelineFrame <= item.timelineEnd) ?? layout.at(-1);
-	if (segment.timelineFrames <= 1) return segment.sourceStart;
-	const local = timelineFrame - segment.timelineStart;
-	const progress = local / (segment.timelineFrames - 1);
-	return segment.sourceStart + progress * (segment.sourceEnd - segment.sourceStart);
-}
-
-/** The inverse of timelineFrameToMotionFrame: which timeline frame shows a
- * SOURCE frame under this edit. Returns null when no segment covers it (the
- * source range was deleted or trimmed away). When two segments cover the same
- * source frame (a cut boundary), the first segment answers. */
-export function motionFrameToTimelineFrame(edit, sourceFrame) {
-	if (!Array.isArray(edit) || edit.length < 1 || !Number.isFinite(sourceFrame)) return null;
-	const layout = motionEditLayout(edit);
-	const segment = layout.find((item) => sourceFrame >= item.sourceStart && sourceFrame <= item.sourceEnd);
-	if (!segment) return null;
-	if (segment.sourceEnd === segment.sourceStart) return segment.timelineStart;
-	const progress = (sourceFrame - segment.sourceStart) / (segment.sourceEnd - segment.sourceStart);
-	return Math.round(segment.timelineStart + progress * (segment.timelineFrames - 1));
-}
-
-/**
- * Where an OLD timeline frame lands after a segment edit (#79): old timeline
- * → source → new timeline, each leg piecewise-linear per segment. Returns
- * null when the frame's source content no longer exists in the new edit.
- * Anything pinned to timeline frames (IK correction keys, prompt clips) must
- * ride this mapping when segments change, or it stays glued to frame NUMBERS
- * while the POSES those numbers address move away.
- */
-export function remapTimelineFrame(previousEdit, nextEdit, frame) {
-	const source = timelineFrameToMotionFrame(previousEdit, frame);
-	return motionFrameToTimelineFrame(nextEdit, source);
-}
-
-/** Migrate a frame-keyed Map through a segment edit. Values move untouched;
- * a speed-up can land two old frames on one new frame — the earlier old
- * frame wins so an authored key is never silently replaced by a later one —
- * and keys whose source frames were deleted drop out. */
-export function remapFrameKeyMap(keys, previousEdit, nextEdit) {
-	const out = new Map();
-	for (const frame of [...keys.keys()].sort((a, b) => a - b)) {
-		const mapped = remapTimelineFrame(previousEdit, nextEdit, frame);
-		if (mapped === null || out.has(mapped)) continue;
-		out.set(mapped, keys.get(frame));
-	}
-	return out;
-}
-
-export function splitMotionEdit(edit, timelineFrame) {
-	if (!Array.isArray(edit) || edit.length < 1) return edit;
-	const layout = motionEditLayout(edit);
-	const cut = Math.round(timelineFrame);
-	if (cut <= 0 || cut >= motionEditDuration(edit)) return edit;
-	const index = layout.findIndex((segment) => cut > segment.timelineStart && cut <= segment.timelineEnd);
-	if (index < 0) return edit;
-	const segment = layout[index];
-	const sourceCut = Math.max(
-		segment.sourceStart + 1,
-		Math.min(segment.sourceEnd, Math.round(timelineFrameToMotionFrame(edit, cut))),
-	);
-	if (sourceCut <= segment.sourceStart || sourceCut > segment.sourceEnd) return edit;
-	const next = [...edit];
-	next.splice(index, 1,
-		{ id: `${segment.id}-a`, sourceStart: segment.sourceStart, sourceEnd: sourceCut - 1, speed: segment.speed },
-		{ id: `${segment.id}-b`, sourceStart: sourceCut, sourceEnd: segment.sourceEnd, speed: segment.speed },
-	);
-	return next;
-}
-
-export function setMotionSegmentSpeed(edit, id, speed) {
-	const normalized = normalizeSpeed(speed);
-	if (!Number.isFinite(normalized) || normalized < SPEED_MIN || normalized > SPEED_MAX) {
-		throw new Error("setMotionSegmentSpeed: speed must be between 0.1 and 4.0 in 0.1 steps");
-	}
-	return edit.map((segment) => segment.id === id ? { ...segment, speed: Number(normalized.toFixed(1)) } : segment);
-}
-
-/** Delete one segment from the edit. The last remaining segment stays: an
- * empty edit has no duration, and "no motion" is clearMotion's job, not a
- * segment operation's. Unknown ids return the edit unchanged. */
-export function removeMotionSegment(edit, id) {
-	if (!Array.isArray(edit) || edit.length < 2) return edit;
-	const next = edit.filter((segment) => segment.id !== id);
-	return next.length === edit.length ? edit : next;
-}
-
-/** The speed that renders a segment across `timelineFrames` production
- * frames — the drag-resize inverse of segmentTimelineFrames. Clamped to the
- * same 0.1x..4x range and 0.1 grid setMotionSegmentSpeed enforces, so a drag
- * can never commit a speed the numeric input would reject. */
-export function motionSegmentSpeedForFrames(segment, timelineFrames) {
-	const frames = Math.max(1, Math.round(Number(timelineFrames) || 1));
-	const raw = segmentSourceFrames(segment) / frames;
-	const clamped = Math.min(SPEED_MAX, Math.max(SPEED_MIN, raw));
-	return Number(normalizeSpeed(clamped).toFixed(1));
-}
-
-export function trimMotionEdit(edit, startFrame, endFrame) {
-	if (!Array.isArray(edit) || edit.length < 1) return edit;
-	const duration = motionEditDuration(edit);
-	if (
-		!Number.isInteger(startFrame) ||
-		!Number.isInteger(endFrame) ||
-		startFrame < 0 ||
-		endFrame >= duration ||
-		startFrame > endFrame
-	) {
-		throw new Error(`trimMotionEdit: range ${startFrame}..${endFrame} is outside 0..${duration - 1}`);
-	}
-	const layout = motionEditLayout(edit);
-	return layout.flatMap((segment) => {
-		const overlapStart = Math.max(startFrame, segment.timelineStart);
-		const overlapEnd = Math.min(endFrame, segment.timelineEnd);
-		if (overlapStart > overlapEnd) return [];
-		const sourceStart = Math.ceil(timelineFrameToMotionFrame(edit, overlapStart));
-		const sourceEnd = Math.floor(timelineFrameToMotionFrame(edit, overlapEnd));
-		return [{
-			id: `${segment.id}-trim-${sourceStart}`,
-			sourceStart: Math.max(segment.sourceStart, sourceStart),
-			sourceEnd: Math.min(segment.sourceEnd, sourceEnd),
-			speed: segment.speed,
-		}];
-	}).filter((segment) => segment.sourceStart <= segment.sourceEnd);
-}
-
-function copyFrame(source, sourceFrame, target, targetFrame, stride) {
-	const from = sourceFrame * stride;
-	target.set(source.subarray(from, from + stride), targetFrame * stride);
-}
-
-export function renderMotionEdit(full, edit) {
-	if (!full || !Number.isInteger(full.frames) || full.frames < 1 || !Number.isFinite(full.fps) || full.fps <= 0) {
-		throw new Error("renderMotionEdit: motion must have positive frames and fps");
-	}
-	const segments = Array.isArray(edit) && edit.length ? edit : createMotionEdit(full.frames);
-	const rendered = segments.map((segment) => {
-		const sliced = sliceMotion(full, segment.sourceStart, segment.sourceEnd);
-		return segment.speed === 1 ? sliced : retimeMotion(sliced, full.fps / segment.speed);
-	});
-	const frames = rendered.reduce((total, motion) => total + motion.frames, 0);
-	const rotStride = full.rotMats.length / full.frames;
-	const rootStride = full.rootPos.length / full.frames;
-	const posedStride = full.posedJoints.length / full.frames;
-	const rotMats = new Float32Array(frames * rotStride);
-	const rootPos = new Float32Array(frames * rootStride);
-	const posedJoints = new Float32Array(frames * posedStride);
-	let cursor = 0;
-	for (let index = 0; index < rendered.length; index += 1) {
-		const motion = rendered[index];
-		const segment = segments[index];
-		for (let frame = 0; frame < motion.frames; frame += 1) {
-			const finalFrame = frame === motion.frames - 1 && segment.speed > 1;
-			const sourceMotion = finalFrame ? full : motion;
-			const sourceFrame = finalFrame ? segment.sourceEnd : frame;
-			copyFrame(sourceMotion.rotMats, sourceFrame, rotMats, cursor + frame, rotStride);
-			copyFrame(sourceMotion.rootPos, sourceFrame, rootPos, cursor + frame, rootStride);
-			copyFrame(sourceMotion.posedJoints, sourceFrame, posedJoints, cursor + frame, posedStride);
-		}
-		cursor += motion.frames;
-	}
-	return {
-		...full,
-		frames,
-		fps: full.fps,
-		rotMats,
-		rootPos,
-		posedJoints,
-		anchorFrame: 0,
-		editSegments: segments.map((segment) => ({ ...segment })),
-	};
-}

package/src/ardy/motion-url.js

@@ -1,55 +0,0 @@
-/**
- * Query-string gate for externally supplied motion URLs (`/app/?motion=`).
- *
- * The hosted demo hands a visitor a result link that opens the app with a
- * `?motion=<url>` query. That value is attacker-controllable, so it is a
- * security boundary, not a convenience: only same-origin paths and the
- * hosted demo API may ever reach `loadMotionFromUrl`'s fetch. Everything
- * else — foreign hosts, downgraded schemes, `javascript:`, protocol-relative
- * tricks, userinfo-embedded lookalikes — resolves to `null` and the app
- * silently falls back to its normal seed behavior.
- *
- * Kept as a plain module (no React, no DOM) so the allowlist is testable
- * under Node: see test/demo/verify-motion-url-allowlist.mjs.
- */
-
-/** Hosts allowed to serve motion npz files cross-origin, over https only. */
-export const MOTION_URL_ALLOWED_HOSTS = ["api.cozyclay.org"];
-
-/**
- * Extract and validate the `motion` query parameter.
- *
- * @param {string} search - a query string (`location.search`)
- * @param {string} origin - the page origin (`location.origin`)
- * @returns {string|null} a same-origin path (`/demo/x.npz`) or an absolute
- *   https URL on an allowlisted host; `null` when absent or not allowed.
- */
-export function motionUrlFromQuery(search, origin) {
-	let value;
-	try {
-		value = new URLSearchParams(search ?? "").get("motion");
-	} catch {
-		return null;
-	}
-	if (!value) return null;
-	let base;
-	let parsed;
-	try {
-		base = new URL(origin);
-		parsed = new URL(value, base);
-	} catch {
-		return null;
-	}
-	// Userinfo is only ever used to disguise the real host
-	// (https://api.cozyclay.org@evil.example/x.npz) — reject it outright,
-	// even for the page's own origin.
-	if (parsed.username || parsed.password) return null;
-	// Same-origin: return the path form so dev (http://127.0.0.1:5180) and
-	// production resolve identically.
-	if (parsed.origin === base.origin) return parsed.pathname + parsed.search;
-	// Cross-origin: https only, exact host match (a non-standard port makes
-	// `host` differ from the allowlist entry and is therefore rejected).
-	if (parsed.protocol !== "https:") return null;
-	if (!MOTION_URL_ALLOWED_HOSTS.includes(parsed.host)) return null;
-	return parsed.href;
-}