cozyclay 2.1.1 → 3.0.1

package/src/pose-extract/browser.js

@@ -1,42 +0,0 @@
-/**
- * Browser extraction boundary shared by uploaded video and webcam frames.
- * The UI supplies an async iterable of `{ image, timeS }` and an already
- * configured detector (for MediaPipe: `detectForVideo(image, timeS * 1000)`).
- * Keeping model creation outside this module makes model URL/revision,
- * telemetry gating and first-use caching explicit at the App integration site.
- */
-
-function confidenceOf(landmarks) {
-	if (!Array.isArray(landmarks) || landmarks.length === 0) return -Infinity;
-	return landmarks.reduce((sum, point) =>
-		sum + (Number.isFinite(point?.visibility) ? point.visibility : 1), 0
-	) / landmarks.length;
-}
-
-export function selectMostConfidentPerson(result) {
-	const candidates = result?.worldLandmarks ?? result?.landmarks ?? [];
-	if (!Array.isArray(candidates) || candidates.length === 0) return null;
-	return candidates.reduce((best, candidate) =>
-		confidenceOf(candidate) > confidenceOf(best) ? candidate : best
-	, null);
-}
-
-export async function collectLandmarkTrack({ frames, detect, onProgress = () => {} }) {
-	if (!frames || typeof frames[Symbol.asyncIterator] !== "function") {
-		throw new Error("collectLandmarkTrack: frames must be an async iterable");
-	}
-	if (typeof detect !== "function") throw new Error("collectLandmarkTrack: detect must be a function");
-	const samples = [];
-	let processed = 0;
-	for await (const frame of frames) {
-		if (!frame || !Number.isFinite(frame.timeS) || frame.timeS < 0 || !("image" in frame)) {
-			throw new Error("collectLandmarkTrack: each frame needs image and non-negative timeS");
-		}
-		const result = await detect(frame.image, frame.timeS * 1000);
-		const landmarks = selectMostConfidentPerson(result);
-		if (landmarks) samples.push({ timeS: frame.timeS, landmarks });
-		processed += 1;
-		onProgress({ processed, accepted: samples.length, timeS: frame.timeS });
-	}
-	return samples;
-}

package/src/pose-extract/detector.js

@@ -1,100 +0,0 @@
-// detector.js — the App-side loader for MediaPipe's PoseLandmarker. Model
-// creation stays out of browser.js on purpose (see that header): this module
-// is where the engine version, the download sources and the failure names
-// live, so "extraction is broken" always decomposes into which piece failed.
-//
-// Both the wasm engine and the .task weights are runtime downloads. The wasm
-// must match the npm bundle compiled into this build byte-for-byte, so its
-// URL is pinned to the same version; the weights are ~9 MB of Google binaries
-// that belong in neither this repo nor its npm package. Offline is therefore
-// a NAMED failure, never a hang or a silent fallback.
-
-export const TASKS_VISION_VERSION = "0.10.17"; // must equal the @mediapipe/tasks-vision entry in package.json — the JS bundle and the wasm ABI move together
-export const POSE_WASM_BASE = `https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@${TASKS_VISION_VERSION}/wasm`;
-// "full", not "lite": every caller here is an offline pass over a still photo or
-// already-recorded footage, so the ~9 MB download and the slower per-frame cost
-// buy landmark accuracy that nothing downstream can recover once it is lost.
-// Only switch back if a realtime (camera-preview) caller ever appears.
-export const POSE_MODEL_URL =
-	"https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_full/float16/1/pose_landmarker_full.task";
-// "heavy" is the same landmark contract at the top of the accuracy ladder, paid
-// for with a ~25 MB one-time download and several times the per-frame cost. That
-// price is per FRAME, so it is only affordable where there is one: a single
-// photograph. A clip of a few hundred frames stays on "full".
-export const POSE_MODEL_URL_HEAVY =
-	"https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_heavy/float16/1/pose_landmarker_heavy.task";
-// The choice is a name at the call site, not a URL: callers say what they are
-// extracting from, and this table decides what that costs.
-export const POSE_MODELS = Object.freeze({
-	full: POSE_MODEL_URL,
-	heavy: POSE_MODEL_URL_HEAVY,
-});
-
-/**
- * Create a `{ detect, close }` pair for collectLandmarkTrack. Every failure
- * mode has its own name:
- *   pose-model-unknown         — `model` is not a key of POSE_MODELS (caller bug)
- *   pose-runtime-unavailable   — the JS bundle did not load (broken build)
- *   pose-model-download-failed — the .task weights were unreachable
- *   pose-engine-download-failed— the wasm engine was unreachable
- *   pose-engine-init-failed    — the engine loaded but refused to start
- * The GPU delegate is tried first and CPU is the retry: WebGPU blocklists
- * are common and a slower extraction beats a refused one.
- */
-export async function createPoseDetector({
-	wasmBase = POSE_WASM_BASE,
-	model = "full", // "heavy" for a single still; see POSE_MODELS
-	modelUrl, // an explicit URL wins over `model` — pinning a revision stays possible
-	fetchImpl,
-	loadRuntime,
-	numPoses = 2, // the footage guidance allows two performers in frame; selectMostConfidentPerson picks one
-	runningMode = "VIDEO", // "IMAGE" for a still: MediaPipe rejects detectForVideo outside VIDEO mode
-} = {}) {
-	const doFetch = fetchImpl ?? globalThis.fetch;
-	const resolvedModelUrl = modelUrl ?? POSE_MODELS[model];
-	if (!resolvedModelUrl) throw new Error("pose-model-unknown");
-	let runtime;
-	try {
-		runtime = await (loadRuntime ?? (() => import("@mediapipe/tasks-vision")))();
-	} catch {
-		throw new Error("pose-runtime-unavailable");
-	}
-	let modelAssetBuffer;
-	try {
-		const response = await doFetch(resolvedModelUrl);
-		if (!response.ok) throw new Error(`http-${response.status}`);
-		modelAssetBuffer = new Uint8Array(await response.arrayBuffer());
-	} catch {
-		throw new Error("pose-model-download-failed");
-	}
-	let fileset;
-	try {
-		fileset = await runtime.FilesetResolver.forVisionTasks(wasmBase);
-	} catch {
-		throw new Error("pose-engine-download-failed");
-	}
-	const optionsFor = (delegate) => ({
-		baseOptions: { modelAssetBuffer, delegate },
-		runningMode,
-		numPoses,
-		outputSegmentationMasks: false,
-	});
-	let landmarker;
-	try {
-		landmarker = await runtime.PoseLandmarker.createFromOptions(fileset, optionsFor("GPU"));
-	} catch {
-		try {
-			landmarker = await runtime.PoseLandmarker.createFromOptions(fileset, optionsFor("CPU"));
-		} catch {
-			throw new Error("pose-engine-init-failed");
-		}
-	}
-	return {
-		// One `detect(image, timestampMs)` shape for both modes so the frame
-		// supply — a clip or a still — is the only thing that differs.
-		detect: runningMode === "IMAGE"
-			? (image) => landmarker.detect(image)
-			: (image, timestampMs) => landmarker.detectForVideo(image, Math.round(timestampMs)),
-		close: () => landmarker.close?.(),
-	};
-}

package/src/pose-extract/fit.js

@@ -1,227 +0,0 @@
-/** Landmark directions -> ordinary cozyclay.pose.v1 keys, with no runtime UI dependency. */
-
-import { COZYCLAY_BONES, CSKEL27_JOINTS } from "../ardy/cskel27.js";
-import { CSKEL27_NEUTRAL } from "../ardy/cskel27-neutral.js";
-import { localToBasis, matMul, matToQuat, matTranspose } from "../ardy/convert.js";
-import { POSE_LANDMARK as L } from "./landmarks.js";
-
-function add(a, b) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }
-function sub(a, b) { return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; }
-function scale(v, amount) { return [v[0] * amount, v[1] * amount, v[2] * amount]; }
-function dot(a, b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; }
-function cross(a, b) {
-	return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}
-function norm(v) { return Math.hypot(v[0], v[1], v[2]); }
-function unit(v) { const n = norm(v); return n > 1e-8 ? scale(v, 1 / n) : null; }
-function lerp(a, b, t) { return add(a, scale(sub(b, a), t)); }
-function rotateY(v, cos, sin) { return [v[0] * cos + v[2] * sin, v[1], v[2] * cos - v[0] * sin]; }
-
-function averageLandmarks(landmarks, indices) {
-	const available = indices.map((index) => landmarks[index]).filter(Boolean);
-	if (available.length === 0) return null;
-	const weight = available.reduce((sum, entry) => sum + entry.visibility, 0);
-	if (!(weight > 0)) return null;
-	return available.reduce(
-		(sum, entry) => add(sum, scale(entry.position, entry.visibility / weight)),
-		[0, 0, 0]
-	);
-}
-
-function landmarkPoint(landmarks, index) {
-	return landmarks[index]?.position?.slice() ?? null;
-}
-
-function buildTargetPoints(landmarks) {
-	const leftHip = landmarkPoint(landmarks, L.LEFT_HIP);
-	const rightHip = landmarkPoint(landmarks, L.RIGHT_HIP);
-	const leftShoulder = landmarkPoint(landmarks, L.LEFT_SHOULDER);
-	const rightShoulder = landmarkPoint(landmarks, L.RIGHT_SHOULDER);
-	if (!leftHip || !rightHip || !leftShoulder || !rightShoulder) return null;
-	const hips = scale(add(leftHip, rightHip), 0.5);
-	const shoulders = scale(add(leftShoulder, rightShoulder), 0.5);
-	const head = averageLandmarks(landmarks, [L.NOSE, L.LEFT_EYE, L.RIGHT_EYE, L.LEFT_EAR, L.RIGHT_EAR]);
-	return {
-		Hips: hips,
-		Spine: lerp(hips, shoulders, 0.25),
-		Spine1: lerp(hips, shoulders, 0.5),
-		Spine2: lerp(hips, shoulders, 0.75),
-		Spine3: shoulders,
-		Neck: shoulders,
-		Head: head,
-		LeftShoulder: shoulders,
-		LeftArm: leftShoulder,
-		LeftForeArm: landmarkPoint(landmarks, L.LEFT_ELBOW),
-		LeftHand: landmarkPoint(landmarks, L.LEFT_WRIST),
-		LeftHandEnd: averageLandmarks(landmarks, [L.LEFT_PINKY, L.LEFT_INDEX]),
-		RightShoulder: shoulders,
-		RightArm: rightShoulder,
-		RightForeArm: landmarkPoint(landmarks, L.RIGHT_ELBOW),
-		RightHand: landmarkPoint(landmarks, L.RIGHT_WRIST),
-		RightHandEnd: averageLandmarks(landmarks, [L.RIGHT_PINKY, L.RIGHT_INDEX]),
-		LeftUpLeg: leftHip,
-		LeftLeg: landmarkPoint(landmarks, L.LEFT_KNEE),
-		LeftFoot: landmarkPoint(landmarks, L.LEFT_ANKLE),
-		LeftToeBase: landmarkPoint(landmarks, L.LEFT_FOOT_INDEX),
-		RightUpLeg: rightHip,
-		RightLeg: landmarkPoint(landmarks, L.RIGHT_KNEE),
-		RightFoot: landmarkPoint(landmarks, L.RIGHT_ANKLE),
-		RightToeBase: landmarkPoint(landmarks, L.RIGHT_FOOT_INDEX),
-		_faceForward: head && averageLandmarks(landmarks, [L.LEFT_EAR, L.RIGHT_EAR])
-			? sub(landmarkPoint(landmarks, L.NOSE) ?? head, averageLandmarks(landmarks, [L.LEFT_EAR, L.RIGHT_EAR]))
-			: null,
-	};
-}
-
-function buildNeutralPoints() {
-	return Object.fromEntries(CSKEL27_JOINTS.map((name, index) => [name, CSKEL27_NEUTRAL[index].slice()]));
-}
-
-const CHILD = {
-	Hips: "Spine", Spine: "Spine1", Spine1: "Spine2", Neck: "Head",
-	LeftShoulder: "LeftArm", LeftArm: "LeftForeArm", LeftForeArm: "LeftHand", LeftHand: "LeftHandEnd",
-	RightShoulder: "RightArm", RightArm: "RightForeArm", RightForeArm: "RightHand", RightHand: "RightHandEnd",
-	LeftUpLeg: "LeftLeg", LeftLeg: "LeftFoot", LeftFoot: "LeftToeBase",
-	RightUpLeg: "RightLeg", RightLeg: "RightFoot", RightFoot: "RightToeBase",
-};
-
-const EFFECTIVE_PARENT = {
-	Hips: null, Spine: "Hips", Spine1: "Spine", Neck: "Spine1", Head: "Neck",
-	LeftShoulder: "Spine1", LeftArm: "LeftShoulder", LeftForeArm: "LeftArm", LeftHand: "LeftForeArm",
-	RightShoulder: "Spine1", RightArm: "RightShoulder", RightForeArm: "RightArm", RightHand: "RightForeArm",
-	LeftUpLeg: "Hips", LeftLeg: "LeftUpLeg", LeftFoot: "LeftLeg",
-	RightUpLeg: "Hips", RightLeg: "RightUpLeg", RightFoot: "RightLeg",
-};
-
-function bodyAxes(points) {
-	const lateral = points.LeftUpLeg && points.RightUpLeg ? unit(sub(points.LeftUpLeg, points.RightUpLeg)) : null;
-	const up = points.Spine3 && points.Hips ? unit(sub(points.Spine3, points.Hips)) : null;
-	const forward = lateral && up ? unit(cross(lateral, up)) : null;
-	return { lateral, up, forward };
-}
-
-/**
- * Below this the forward axis is too close to vertical to carry a yaw: the
- * subject is lying down or shot straight from above. Yaw comes out of
- * atan2 over the leftover horizontal components, so its error scales as
- * 1/horizontal — at 0.12 (about 7 deg off vertical) landmark jitter of 0.01
- * already swings the angle ~5 deg, and it diverges below that.
- */
-const YAW_HORIZONTAL_MIN = 0.12;
-
-/**
- * Drop the photograph's horizontal facing: yaw belongs to the Character
- * group's `rot`, not to the saved pose, so every target point is spun about Y
- * until the subject's forward matches the neutral skeleton's forward. Returns
- * the points unchanged when either forward is too vertical to yield a yaw.
- */
-function yawAlignPoints(points, targetForward, neutralForward) {
-	if (!targetForward || !neutralForward) return points;
-	const targetHorizontal = Math.hypot(targetForward[0], targetForward[2]);
-	const neutralHorizontal = Math.hypot(neutralForward[0], neutralForward[2]);
-	if (targetHorizontal < YAW_HORIZONTAL_MIN || neutralHorizontal < YAW_HORIZONTAL_MIN) return points;
-	const angle = Math.atan2(neutralForward[0], neutralForward[2])
-		- Math.atan2(targetForward[0], targetForward[2]);
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	// _faceForward is a difference, not a position; rotation is linear, so the same spin applies.
-	return Object.fromEntries(
-		Object.entries(points).map(([name, value]) => [name, value ? rotateY(value, cos, sin) : value])
-	);
-}
-
-function frameFrom(primary, secondary) {
-	const x = unit(primary);
-	if (!x || !secondary) return null;
-	let y = sub(secondary, scale(x, dot(secondary, x)));
-	y = unit(y);
-	if (!y) {
-		const fallback = Math.abs(x[1]) < 0.9 ? [0, 1, 0] : [0, 0, 1];
-		y = unit(sub(fallback, scale(x, dot(fallback, x))));
-	}
-	if (!y) return null;
-	const z = unit(cross(x, y));
-	if (!z) return null;
-	y = unit(cross(z, x));
-	return [
-		[x[0], y[0], z[0]],
-		[x[1], y[1], z[1]],
-		[x[2], y[2], z[2]],
-	];
-}
-
-function jointFrame(name, points, axes) {
-	let primary;
-	if (name === "Head") primary = points.Head && points.Neck ? sub(points.Head, points.Neck) : null;
-	else {
-		const child = CHILD[name];
-		primary = child && points[name] && points[child] ? sub(points[child], points[name]) : null;
-	}
-	if (!primary) return null;
-	let secondary = axes.forward;
-	if (["Hips", "Spine", "Spine1", "Neck"].includes(name)) secondary = axes.lateral;
-	else if (name === "Head") secondary = points._faceForward ?? axes.forward;
-	else if (name.endsWith("Shoulder") || name.endsWith("Foot")) secondary = axes.up;
-	return frameFrom(primary, secondary);
-}
-
-function restByName(rest) {
-	if (!rest || !Array.isArray(rest.joints)) {
-		throw new Error("fitLandmarksToPose: rest must be parsed cskel27-rest.json");
-	}
-	return new Map(rest.joints.map((entry) => [entry.name, entry.rest]));
-}
-
-function meanConfidence(landmarks) {
-	const visible = landmarks.filter(Boolean);
-	return visible.length ? visible.reduce((sum, entry) => sum + entry.visibility, 0) / visible.length : 0;
-}
-
-/** Fit one normalised landmark sample into the exact pose schema consumed by poseToCskel27. */
-export function fitLandmarksToPose({ sample, rest, createdMs = 0 }) {
-	if (!sample?.valid || !Array.isArray(sample.landmarks)) {
-		throw new Error("fitLandmarksToPose: sample must be a valid normalized landmark sample");
-	}
-	const measuredPoints = buildTargetPoints(sample.landmarks);
-	if (!measuredPoints) throw new Error("fitLandmarksToPose: shoulders and hips must be visible");
-	const neutralPoints = buildNeutralPoints();
-	const neutralAxes = bodyAxes(neutralPoints);
-	// Neutral owns the forward direction; reading it off CSKEL27_NEUTRAL keeps the axis unhardcoded.
-	const targetPoints = yawAlignPoints(measuredPoints, bodyAxes(measuredPoints).forward, neutralAxes.forward);
-	const targetAxes = bodyAxes(targetPoints);
-	const rests = restByName(rest);
-	const desiredGlobal = new Map();
-	const bones = {};
-	const releasedBones = [];
-	const identity = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-
-	for (const name of COZYCLAY_BONES) {
-		const targetFrame = jointFrame(name, targetPoints, targetAxes);
-		const neutralFrame = jointFrame(name, neutralPoints, neutralAxes);
-		const parentName = EFFECTIVE_PARENT[name];
-		const parentGlobal = parentName ? desiredGlobal.get(parentName) : identity;
-		let global = parentGlobal;
-		let local = identity;
-		if (targetFrame && neutralFrame) {
-			global = matMul(targetFrame, matTranspose(neutralFrame));
-			local = matMul(matTranspose(parentGlobal), global);
-		} else {
-			releasedBones.push(name);
-		}
-		desiredGlobal.set(name, global);
-		const restRotation = rests.get(name);
-		if (!restRotation) throw new Error(`fitLandmarksToPose: rest rotation missing for ${name}`);
-		bones[name] = matToQuat(localToBasis(local, restRotation));
-	}
-
-	return {
-		pose: {
-			schema: "cozyclay.pose.v1",
-			created_ms: createdMs,
-			source: { app: "cozyclay", rig: "cskel27-video-fit", time_s: sample.timeS },
-			bones,
-		},
-		releasedBones,
-		confidence: meanConfidence(sample.landmarks),
-	};
-}

package/src/pose-extract/image-frame.js

@@ -1,51 +0,0 @@
-// image-frame.js — single-still frame supply for pose extraction. A photo is
-// the degenerate footage case: no duration, no seeking, one frame at t=0.
-// Shaped as the same async iterable videoFrames yields so collectLandmarkTrack
-// consumes a still and a clip through one code path.
-
-function waitForDecode(image, timeoutMs) {
-	// A cached image can already be complete before a listener is attached;
-	// waiting for a load event that will never fire again would hang.
-	if (image.complete && (image.naturalWidth ?? 0) > 0) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		const timer = setTimeout(() => finish(new Error("image-load-timeout")), timeoutMs);
-		const onLoad = () => finish(null);
-		const onError = () => finish(new Error("decode-failed"));
-		function finish(error) {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			image.removeEventListener?.("load", onLoad);
-			image.removeEventListener?.("error", onError);
-			if (error) reject(error);
-			else resolve();
-		}
-		image.addEventListener("load", onLoad);
-		image.addEventListener("error", onError);
-	});
-}
-
-/**
- * Decode one still and hand back the element itself — what the IMAGE-mode
- * landmarker accepts, so no canvas copy sits between the decoder and the
- * detector. Split out of imageFrames because a caller that runs its own
- * detection passes over the still (mirror.js) needs the decode without the
- * frame-supply shape, and the load/timeout rules must not be written twice.
- * Failures are named: `image-load-timeout`, `decode-failed`.
- */
-export async function decodeImage(objectUrl, { createImage, timeoutMs = 8000 } = {}) {
-	if (typeof createImage !== "function") throw new Error("imageFrames: createImage is required");
-	const image = createImage();
-	image.src = objectUrl;
-	await waitForDecode(image, timeoutMs);
-	return image;
-}
-
-/**
- * Async-iterate the one `{ image, timeS }` frame a still supplies. Shaped like
- * videoFrames so collectLandmarkTrack consumes a still and a clip alike.
- */
-export async function* imageFrames(objectUrl, options = {}) {
-	yield { image: await decodeImage(objectUrl, options), timeS: 0 };
-}

package/src/pose-extract/index.js

@@ -1,58 +0,0 @@
-/**
- * Public video-to-pose-keys contract.
- *
- * App wiring should pass MediaPipe world-landmark samples here, then merge
- * `result.keys` into the same `{ frame, pose }[]` list currently sent as
- * `body.poses`. The output is intentionally ordinary cozyclay.pose.v1 data:
- * no bridge endpoint, npz path or root-recovery schema is introduced.
- */
-
-import { fitLandmarksToPose } from "./fit.js";
-import { selectPoseKeyframes } from "./keyframes.js";
-import { filterLandmarkTrack, normalizeLandmarkTrack } from "./landmarks.js";
-
-export { collectLandmarkTrack, selectMostConfidentPerson } from "./browser.js";
-export { createPoseDetector, POSE_MODELS, POSE_MODEL_URL, POSE_MODEL_URL_HEAVY, POSE_WASM_BASE, TASKS_VISION_VERSION } from "./detector.js";
-export { sampleTimes, videoFrames } from "./video-frames.js";
-export { decodeImage, imageFrames } from "./image-frame.js";
-export { averageLandmarkSets, detectMirrorAveraged, LEFT_RIGHT_PAIRS, mirrorLandmarks } from "./mirror.js";
-export { bakeExtractedTake, bakePoseFrame } from "./take.js";
-export { fitLandmarksToPose } from "./fit.js";
-export { poseChangeScores, selectPoseKeyframes } from "./keyframes.js";
-export { filterLandmarkTrack, normalizeLandmarkSample, normalizeLandmarkTrack, POSE_LANDMARK } from "./landmarks.js";
-
-export function videoLandmarksToPoseKeys({ samples, rest, fps = 20, ...options }) {
-	if (!Number.isFinite(fps) || fps <= 0) {
-		throw new Error("videoLandmarksToPoseKeys: fps must be a positive finite number");
-	}
-	const normalized = normalizeLandmarkTrack(samples, options);
-	const filtered = filterLandmarkTrack(normalized, options.filter);
-	const { indices, scores } = selectPoseKeyframes(filtered, options);
-	const keys = [];
-	const diagnostics = [];
-	for (const sampleIndex of indices) {
-		const sample = filtered[sampleIndex];
-		const frame = Math.max(0, Math.round(sample.timeS * fps));
-		const fitted = fitLandmarksToPose({ sample, rest, createdMs: options.createdMs ?? 0 });
-		const entry = { frame, pose: fitted.pose };
-		const diagnostic = {
-			frame,
-			sampleIndex,
-			sourceTimeS: sample.timeS,
-			score: scores[sampleIndex],
-			confidence: fitted.confidence,
-			releasedBones: fitted.releasedBones,
-		};
-		const prior = keys[keys.length - 1];
-		if (prior?.frame === frame) {
-			if (diagnostic.score > diagnostics[diagnostics.length - 1].score) {
-				keys[keys.length - 1] = entry;
-				diagnostics[diagnostics.length - 1] = diagnostic;
-			}
-		} else {
-			keys.push(entry);
-			diagnostics.push(diagnostic);
-		}
-	}
-	return { keys, diagnostics };
-}

package/src/pose-extract/keyframes.js

@@ -1,74 +0,0 @@
-/** Pure pose-change scoring and keyframe selection. */
-
-function landmarkDistance(a, b) {
-	let sum = 0;
-	let weight = 0;
-	const count = Math.min(a.landmarks.length, b.landmarks.length);
-	for (let index = 0; index < count; index += 1) {
-		const pa = a.landmarks[index];
-		const pb = b.landmarks[index];
-		if (!pa || !pb) continue;
-		const confidence = Math.min(pa.visibility, pb.visibility);
-		const delta = Math.hypot(
-			pa.position[0] - pb.position[0],
-			pa.position[1] - pb.position[1],
-			pa.position[2] - pb.position[2]
-		);
-		sum += delta * confidence;
-		weight += confidence;
-	}
-	return weight > 0 ? sum / weight : 0;
-}
-
-export function poseChangeScores(samples) {
-	if (!Array.isArray(samples)) throw new Error("poseChangeScores: samples must be an array");
-	return samples.map((sample, index) => {
-		if (!sample.valid || index === 0 || index === samples.length - 1) return 0;
-		const before = samples[index - 1];
-		const after = samples[index + 1];
-		if (!before.valid || !after.valid) return 0;
-		const dtBefore = Math.max(sample.timeS - before.timeS, 1e-6);
-		const dtAfter = Math.max(after.timeS - sample.timeS, 1e-6);
-		return (
-			landmarkDistance(before, sample) / dtBefore +
-			landmarkDistance(sample, after) / dtAfter
-		);
-	});
-}
-
-/**
- * Keep valid endpoints plus the strongest local pose-change peaks. Returned
- * indices are source ordered and respect `minSpacingS` wherever possible.
- */
-export function selectPoseKeyframes(samples, options = {}) {
-	if (!Array.isArray(samples) || samples.length === 0) {
-		throw new Error("selectPoseKeyframes: samples must be a non-empty array");
-	}
-	const maxKeys = Math.max(1, Math.floor(options.maxKeys ?? 12));
-	const minSpacingS = Math.max(0, options.minSpacingS ?? 0.25);
-	const valid = samples.map((sample, index) => sample.valid ? index : -1).filter((index) => index >= 0);
-	if (valid.length === 0) return { indices: [], scores: poseChangeScores(samples) };
-	if (maxKeys === 1) return { indices: [valid[0]], scores: poseChangeScores(samples) };
-
-	const scores = poseChangeScores(samples);
-	const selected = new Set([valid[0], valid[valid.length - 1]]);
-	const peaks = valid
-		.filter((index) => index > 0 && index < samples.length - 1)
-		.filter((index) => scores[index] >= scores[index - 1] && scores[index] >= scores[index + 1])
-		.sort((a, b) => scores[b] - scores[a] || a - b);
-	const candidates = [
-		...peaks,
-		...valid
-			.filter((index) => index > 0 && index < samples.length - 1 && !peaks.includes(index))
-			.sort((a, b) => scores[b] - scores[a] || a - b),
-	];
-
-	for (const index of candidates) {
-		if (selected.size >= maxKeys) break;
-		const time = samples[index].timeS;
-		if ([...selected].every((other) => Math.abs(samples[other].timeS - time) >= minSpacingS)) {
-			selected.add(index);
-		}
-	}
-	return { indices: [...selected].sort((a, b) => a - b), scores };
-}