cozyclay 2.1.0 → 3.0.0

package/src/motion3/skills/index.js

@@ -0,0 +1,83 @@
+// Skill library: parameterised spec builders the agent calls with spec.use instead of writing
+// every key. use: [{ skill, args, f0 }] expands, in order, into keys, anchors, props, fits,
+// objects, checks and channels (the extra channels a skill keys) before compile; each skill reads the pose the earlier keys leave at its
+// f0. The agent's own keys come after the skill keys (a key of the agent wins on the same
+// frame), and the agent's own anchors/props/fits replace a skill's of the same name.
+import { stateAt } from "../compiler/walk.js";
+import { didYouMean, suggestField } from "../compiler/vocab.js";
+import { USE_FIELDS } from "../schema/fields.js";
+import { SKILL_INFO } from "./info.js";
+import { standIdle, walkTo, reachGrip } from "./basic.js";
+import { sitInSeat, exitCar } from "./car.js";
+import { smokeCigarette } from "./smoke.js";
+
+const SKILLS = { standIdle, sitInSeat, exitCar, walkTo, reachGrip, smokeCigarette };
+export const SKILL_NAMES = Object.keys(SKILLS);
+const bad = msg => { throw new Error(`MOTION_SPEC_INVALID: ${msg}`); };
+const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+function mergeNamed(into, part, what, tag) {
+	for (const [name, v] of Object.entries(part ?? {})) {
+		if (into[name] && !same(into[name], v)) bad(`${tag} defines ${what}.${name} differently from an earlier skill; rename one or define it yourself in spec.${what}`);
+		into[name] = v;
+	}
+}
+
+/** Lists merge without duplicates; anything else (an unknown check, a non-list) passes on for the validator to name. */
+function mergeChecks(into, part) {
+	for (const [name, v] of Object.entries(part ?? {})) {
+		if (name === "limits" && v && typeof v === "object" && !Array.isArray(v)) { into.limits = { ...into.limits, ...v }; continue; }
+		if (!Array.isArray(v) || (into[name] !== undefined && !Array.isArray(into[name]))) { into[name] = v; continue; }
+		const list = into[name] ?? (into[name] = []);
+		for (const item of v) if (!list.some(x => same(x, item))) list.push(item);
+	}
+}
+
+/** use[i].args against the skill's args (skills/info.js); lenient ignores unknown ones. */
+function argsOk(u, i, lenient) {
+	if (u.args !== undefined && (!u.args || typeof u.args !== "object" || Array.isArray(u.args))) bad(`use[${i}].args must be an object, got ${JSON.stringify(u.args)}`);
+	const known = Object.keys(SKILL_INFO[u.skill].args);
+	if (!lenient) for (const a of Object.keys(u.args ?? {})) if (!known.includes(a)) bad(`use[${i}].args.${a} is not an arg of ${u.skill}${suggestField(a, known)} (args: ${known.join(", ")})`);
+}
+
+/**
+ * spec with `use` -> { spec: plain spec (no use), used: [{ skill, f0, end, paced?, cut? }] }; lenient ignores
+ * unknown use[i] fields and args. auto (frames-auto.js) lets a skill that holds to the last
+ * frame end where its own motion ends. A skill whose release or settle the last frame cuts ends
+ * there holding (cut says so); one that needs frames past the last for its own motion is refused.
+ */
+export function expandUse(spec, { sk, scene, lenient = false, auto = false }) {
+	if (!spec.use?.length) return { spec, used: [] };
+	if (!Array.isArray(spec.use)) bad("spec.use must be an array of { skill, args, f0 }");
+	const own = (spec.keys ?? []).map((k, i) => ({ ...k, src: `keys[${i}]` }));
+	const merged = { anchors: {}, props: {}, objects: {}, fits: [], checks: {}, channels: [] }, skillKeys = [], used = [];
+	spec.use.forEach((u, i) => {
+		const tag = `use[${i}] ${u?.skill}`;
+		if (!SKILLS[u?.skill]) bad(`use[${i}].skill "${u?.skill}" is not a skill${didYouMean(String(u?.skill), SKILL_NAMES)} (skills: ${SKILL_NAMES.join(", ")})`);
+		for (const f of Object.keys(u)) if (!USE_FIELDS.includes(f) && !lenient) bad(`use[${i}] has unknown field "${f}"${suggestField(f, USE_FIELDS)}; an entry is { skill, args, f0 }`);
+		argsOk(u, i, lenient);
+		if (!Number.isInteger(u.f0) || u.f0 < 0 || u.f0 > spec.frames - 1) bad(`use[${i}].f0 must be an integer frame within 0..${spec.frames - 1}, got ${JSON.stringify(u.f0)}`);
+		const keys = [...skillKeys, ...own];
+		const ctx = { sk, scene, frames: spec.frames, auto, self: spec.fix !== false && spec.fix?.self !== false, f0: u.f0, args: structuredClone(u.args ?? {}), tag, keys, state: structuredClone(stateAt(keys, u.f0)), anchors: { ...merged.anchors, ...spec.anchors } };
+		const part = SKILLS[u.skill](ctx), last = Math.max(part.end ?? u.f0, ...part.keys.map(k => k.f));
+		if (last > spec.frames - 1) bad(`${tag} needs ${last - u.f0} frames from f${u.f0} (to f${last}), past the last frame f${spec.frames - 1}; set frames >= ${last + 1} or frames: "auto"`);
+		skillKeys.push(...part.keys.map(k => ({ ...k, src: k.src ?? tag })));
+		mergeNamed(merged.anchors, part.anchors, "anchors", tag);
+		mergeNamed(merged.props, part.props, "props", tag);
+		mergeNamed(merged.objects, part.objects, "objects", tag);
+		for (const fit of part.fits ?? []) if (!merged.fits.some(x => same(x, fit))) merged.fits.push(fit);
+		for (const ch of part.channels ?? []) if (!merged.channels.includes(ch)) merged.channels.push(ch);
+		mergeChecks(merged.checks, part.checks);
+		used.push({ skill: u.skill, f0: u.f0, end: part.end, ...(part.paced ? { paced: part.paced } : {}), ...(part.cut ? { cut: part.cut } : {}) });
+	});
+	const out = { ...spec, keys: [...skillKeys, ...own], anchors: { ...merged.anchors, ...spec.anchors }, props: { ...merged.props, ...spec.props },
+		objects: { ...merged.objects, ...spec.objects } };
+	const channels = [...new Set([...merged.channels, ...(Array.isArray(spec.channels) ? spec.channels : [])])];
+	if (channels.length) out.channels = channels;
+	const mine = spec.fits ?? [];
+	out.fits = [...merged.fits.filter(f => !mine.some(m => m.side === f.side && m.anchor === f.anchor)), ...mine];
+	mergeChecks(merged.checks, spec.checks);
+	out.checks = merged.checks;
+	delete out.use;
+	return { spec: out, used };
+}

package/src/motion3/skills/info.js

@@ -0,0 +1,65 @@
+// What each skill takes and does, for motion.describe { topic: "skills" } and the expander (an
+// arg not listed here is refused; a lenient reload ignores it): args (JSON Schema fragments),
+// required args, what must come before it (needs), how many frames it runs from f0 and what it
+// adds to the spec. A test keeps the names equal to SKILL_NAMES (skills/index.js). `tune` names
+// the numeric args repair may nudge (arg -> one step) when a near-limit QA group names the skill
+// as its cause (repair-tune.js); the start value is the arg as sent, else its schema default.
+// `place` names the args that set where the body stands (arg -> one step, m): repair-tune.js
+// steps them when a GOAL group misses and this skill placed the body last.
+import { WALK_FIELDS } from "../schema/fields.js";
+import { WALK_TYPES, num, int, str, side, ref } from "../schema/types.js";
+import { FINGER_PRESETS } from "../compiler/vocab.js";
+
+/** The last frame of a walk (generator or walkTo): feet together 18 frames after the last step. */
+export const walkEnd = gen => gen.f0 + 16 + (gen.steps ?? 8) * (gen.period ?? 20) + 18;
+
+const xz = d => ({ type: "array", items: { type: "number" }, minItems: 2, maxItems: 2, description: d });
+const carArgs = names => Object.fromEntries(names.map(n => [n, str(n === "car" ? "car prefix: fills <car>_Seat_Driver, _Seat_Driver_Back, _Door_L/R, _Door_Handle, _Steering_Wheel" : "scene object id (overrides the car default)")]));
+const walkArgs = Object.fromEntries(WALK_FIELDS.filter(f => f !== "type" && f !== "f0").map(f => [f, WALK_TYPES[f]]));
+
+export const SKILL_INFO = {
+	standIdle: {
+		args: { at: xz("[x, z] world m; default the root keyed before f0"), heading: num("degrees (yaw); default the keyed yaw"), until: int("hold the pose to this frame") },
+		needs: "args.at, or a root keyed before f0", frames: "1 (to args.until when given)",
+		adds: ["keys: a standing pose, FK arms down"], example: { f0: 0, args: { at: [0, 0], heading: 0 } },
+		place: { at: 0.03 },
+	},
+	walkTo: {
+		args: { to: xz("[x, z] world m: the heading turns toward it and the steps cover the distance"), ...walkArgs,
+			heading: { oneOf: [num(), WALK_TYPES.heading], description: "degrees: h1, or [h0, h1]" },
+			arrive: int("with to and no steps/period/step/swing: the frame to end by (feet together); the engine picks the cadence (observations.planned)") },
+		needs: "a standing pose keyed before f0", frames: "16 + steps * period + 18",
+		adds: ["keys: a walk ending feet together"], example: { f0: 10, args: { to: [0.5, 1.5] } },
+		tune: { lift: 0.01, halfWidth: 0.01, firstStep: 0.01, step: 0.01 }, place: { firstStep: 0.03, step: 0.03 },
+	},
+	reachGrip: {
+		args: { anchor: str("not ending in _l/_r"), side: side("the hand"), reach: int("frames to reach", { default: 20 }), hold: int("frames held", { default: 22 }),
+			release: int("frames to let go", { default: 12 }), elbow: ref("vec3", "elbow pole"), fingers: { enum: FINGER_PRESETS, default: "grip" },
+			define: { type: "object", description: "an anchor (topic anchors) named args.anchor" }, orient: { type: "boolean", description: "false: no grip turn" } },
+		required: ["anchor", "side"], needs: "args.anchor in spec.anchors or args.define", frames: "reach + hold + release (54 by default)",
+		adds: ["props.<anchor>Grip (fingers point)", "fits: fingers onto the anchor", "checks.contacts \"fingers on <anchor>\"", "checks.allow hand on the anchor's object",
+			"keys: w_<anchor>_<side>, fingers_<side>, armw_<side>"],
+		example: { f0: 10, args: { anchor: "bar", side: "r", define: { kind: "world", p: [-0.2, 1.2, 0.33] } } },
+		tune: { reach: 2, release: 2 },
+	},
+	sitInSeat: {
+		args: { ...carArgs(["car", "seat", "seatBack", "wheel"]), offset: { ...ref("vec3", "hips from the seat top, seat frame"), default: [0, 0.17, 0.02] }, floor: num("floor y under the feet, m") },
+		needs: "args.car or args.seat (a scene box)", frames: "1", adds: ["keys: seated, hands at the wheel", "checks.supports seat", "checks.allow seat, back, wheel"],
+		example: { f0: 0, args: { car: "Car" } },
+	},
+	exitCar: {
+		args: { ...carArgs(["car", "seat", "door", "handle"]), side: side("driver door side, default l"), channel: str("the door hinge channel", { default: "door" }) },
+		needs: "seated in the car before f0 (sitInSeat); a car on the ground (seat base y 0.4)", frames: "246",
+		adds: ["objects: door and handle hinges", "anchors handle, lthigh, rthigh", "props.grip", "fits, checks.contacts, checks.allow"],
+		example: { f0: 0, args: { car: "Car" } },
+	},
+	smokeCigarette: {
+		args: { until: int("hold to this frame; default the last frame; under f0+264 the beats are paced to fit"),
+			kit: { type: "object", properties: { cig: str("the cigarette kit's rootId (object.createKit)"), lighter: str("the lighter kit's rootId"), exhale: str("the exhale kit's rootId (or an effect): it follows the mouth") },
+				required: ["cig", "lighter"], additionalProperties: false, description: "kits the skill carries and lights: it adds their spec.objects entries itself" } },
+		needs: "a stand or squat keyed before f0", frames: "265 nominal; fits 199..264 by pacing",
+		adds: ["anchors lpocket, rpocket, hold, mouth, flame", "props cig, lighter", "channels cig_vis, lit_vis, flame_vis, ember_vis, exhale, ember",
+			"checks contacts, orient, below, appear, mouthPoints"],
+		example: { f0: 0, args: {} },
+	},
+};

package/src/motion3/skills/smoke-kit.js

@@ -0,0 +1,109 @@
+// smokeCigarette from any posture, and dressed with kits (docs/motion-api-v3.1.md C15).
+//   args.kit = { cig, lighter, exhale? }: the kit roots object.createKit made (src/kits/) ride the
+//   props cig and lighter at the grip (at/along pin the root to the palm), and their lit parts
+//   switch with the skill's channels. A part is found by what it is, not by its name: under the
+//   cigarette a glowing body and a light (the ember: ember_vis, level ember) and an effect (the
+//   tip smoke: ember_vis); under the lighter a glowing body (the flame) and a light (flame_vis).
+//   exhale is the exhale kit's root (or any effect): it follows the mouth, facing forward, and shows
+//   while the exhale channel is on (C16: { follow: "landmark:mouth", aim: "face", visible: "exhale" }).
+//   squat: with the hips keyed low before f0 the cigarette rests over the right knee, not beside
+//   the hip where the thigh is, and the hand leaves (and comes back to) the lips straight ahead
+//   first (anchor mouthOut): a straight move between the lips and the knee would cross the hand's
+//   detour circle around the leaning torso going down, where the detour jumps.
+import { skillError } from "./book.js";
+import { groupsOf } from "../scene.js";
+import { pose } from "../compiler/pose.js";
+import { bonePoint } from "../compiler/skeleton.js";
+import { add, sub, scale, len, apply, ry } from "../compiler/math.js";
+import { HAND_CLEAR, keepOut, wristBody } from "../body.js";
+
+const KIT_FIELDS = ["cig", "lighter", "exhale"];
+/** The exhale emitter's entry: at the lips, its +Y (the puff) along the face, shown while breathing out. */
+const EXHALE = { follow: "landmark:mouth", aim: "face", visible: "exhale" };
+const KIT_OF = { cig: "cigarette", lighter: "lighter" };
+/** Below this share of the rig's standing hips height the pose before f0 is a squat. */
+const SQUAT_HIPS = 0.7;
+/** The resting cigarette hand over the right knee, from the knee joint in the body frame (m): out, up, forward. */
+const OVER_KNEE = [-0.05, 0.07, 0.1];
+/** A knee farther than this share of the arm's length from the shoulder: the hand rests on the thigh short of it. */
+const REST_REACH = 0.88;
+/** Where the hand goes first from the lips in a squat: this far straight ahead of the mouth (m, body frame). */
+const OUT_AHEAD = 0.2;
+/** A squat's side pocket from the root (body frame, the left side; m): out, up, ahead. */
+const SIDE_POCKET = [0.245, 0.08, 0.02];
+/** The pockets on the standing body (body frame: left +x), where the hands fetch the kit. */
+export const POCKET = { l: [0.13, -0.035, 0.08], r: [-0.13, -0.035, 0.08] };
+
+/** [id, entry, body] of every record under group `root` in a motion scene (bodies and box-less records). */
+function partsUnder(scene, root) {
+	const rows = Object.entries(scene?.objects ?? {}).map(([id, o]) => [id, o, true]).concat(Object.entries(scene?.others ?? {}).map(([id, o]) => [id, o, false]));
+	return rows.filter(([, o]) => o.ancestors?.includes(root));
+}
+
+function rootOf(ctx, kit, role) {
+	const id = kit[role];
+	if (typeof id !== "string" || !groupsOf(ctx.scene)[id]) skillError(ctx.tag, `args.kit.${role} ${JSON.stringify(id)} is not a group in the scene; object.createKit { kit: "${KIT_OF[role]}" } answers its rootId`);
+	return id;
+}
+
+/** How deep a kit may sit in the thigh its pocket is on, and in the hip over it (a squat folds the pocket into the hip crease): it comes out of (and goes back into) the pocket there. */
+const POCKET_DEPTH = { cig: 0.03, lighter: 0.045 };
+/** Squatting, the kit comes out of a side pocket past the fat leg capsules (thigh, hips, shin) the scene check reads. */
+const SQUAT_POCKET = 0.07;
+/** ...and the hand in a side pocket touches the thigh and the hip that deep (m). */
+const POCKET_TOUCH = 0.04;
+
+/**
+ * The spec.objects entries args.kit asks for and the pocket allowances (null without it). at:
+ * absolute frames { cig, lit, unlit } the cigarette and the lighter appear and the lighter goes back; squat: the squat pockets.
+ */
+export function kitObjects(ctx, at) {
+	const kit = ctx.args.kit;
+	if (kit === undefined) return null;
+	if (!kit || typeof kit !== "object" || Array.isArray(kit)) skillError(ctx.tag, `args.kit must be { cig, lighter, exhale? } (kit root ids), got ${JSON.stringify(kit)}`);
+	for (const f of Object.keys(kit)) if (!KIT_FIELDS.includes(f)) skillError(ctx.tag, `args.kit has unknown field "${f}"; fields: ${KIT_FIELDS.join(", ")}`);
+	const cig = rootOf(ctx, kit, "cig"), lighter = rootOf(ctx, kit, "lighter");
+	const objects = {
+		[cig]: { prop: "cig", grab: at.cig, at: [0, 0, 0], along: [0, 0, 1], visible: "cig_vis" },
+		[lighter]: { prop: "lighter", grab: at.lit, release: at.unlit, at: [0, 0, 0], along: [0, 1, 0], visible: "lit_vis" },
+	};
+	for (const [id, o, body] of partsUnder(ctx.scene, cig)) {
+		if ((body && o.glow) || (!body && o.renderer === "light")) objects[id] = { visible: "ember_vis", level: "ember" };
+		else if (!body && o.renderer === "effect") objects[id] = { visible: "ember_vis" };
+	}
+	for (const [id, o, body] of partsUnder(ctx.scene, lighter)) if ((body && o.glow) || (!body && o.renderer === "light")) objects[id] = { visible: "flame_vis" };
+	if (kit.exhale !== undefined) {
+		if (typeof kit.exhale !== "string" || !(ctx.scene?.others?.[kit.exhale] || ctx.scene?.objects?.[kit.exhale] || groupsOf(ctx.scene)[kit.exhale])) {
+			skillError(ctx.tag, `args.kit.exhale ${JSON.stringify(kit.exhale)} is not a scene object; object.createKit { kit: "exhale" } answers its rootId (it follows the mouth)`);
+		}
+		objects[kit.exhale] = { ...EXHALE };
+	}
+	const deep = d => (at.squat ? SQUAT_POCKET : d);
+	const allow = [["thigh_r", cig, deep(POCKET_DEPTH.cig)], ["thigh_l", lighter, deep(POCKET_DEPTH.lighter)], ["hips", cig, deep(POCKET_DEPTH.cig)], ["hips", lighter, deep(POCKET_DEPTH.lighter)],
+		...(at.squat ? [["shin", cig, SQUAT_POCKET], ["shin", lighter, SQUAT_POCKET],
+			// the hands in the side pockets brush the thigh and the hip (qa/body-checks.js)
+			["hand_l", "thigh_l", POCKET_TOUCH], ["hand_r", "thigh_r", POCKET_TOUCH], ["hand", "hips", POCKET_TOUCH]] : [])].map(([part, object, depth]) => ({ part, object, depth }));
+	return { objects, allow };
+}
+
+/**
+ * For a squat keyed before f0, the body-frame anchors { hold, mouthOut }: the resting hand over the
+ * right knee and the point the hand leaves the lips toward; null when the pose is not a squat.
+ */
+export function squatAnchors(ctx) {
+	const { sk, state } = ctx, I = sk.index, P = sk.restWorldPos;
+	if (!(state.root[1] < SQUAT_HIPS * P[I.Hips][1])) return null;
+	const { s } = pose(sk, state), yaw = state.yaw ?? 0, shoulder = s.P[I.RightArm], body = p => apply(ry(-yaw), sub(p, state.root));
+	const arm = len(sub(P[I.RightForeArm], P[I.RightArm])) + len(sub(P[I.RightHand], P[I.RightForeArm]));
+	const over = add(s.P[I.RightLeg], apply(ry(yaw), OVER_KNEE)), far = len(sub(over, shoulder));
+	const hold = body(far > REST_REACH * arm ? add(shoulder, scale(sub(over, shoulder), REST_REACH * arm / far)) : over);
+	const out = add(body(bonePoint(s, I.Head, sk.landmarks.mouth)), [0, 0, OUT_AHEAD]);
+	// squatting, the front pockets fold into the hip crease under the thighs: with fix.self (smoke.js) the hands go to the side pockets,
+	// SIDE_POCKET from the root (body frame), kept off the skin (the hand comes in from the side)
+	const skin = wristBody(sk), pocket = (side, sg) => {
+		const at = add(state.root, apply(ry(yaw), [sg * SIDE_POCKET[0], SIDE_POCKET[1], SIDE_POCKET[2]]));
+		return body(skin ? keepOut(skin.body, sk, s, at, HAND_CLEAR, skin.skip) : at);
+	};
+	const r3 = p => p.map(v => Math.round(v * 1000) / 1000);
+	return { hold: r3(hold), mouthOut: r3(out), lpocket: r3(pocket("Left", 1)), rpocket: r3(pocket("Right", -1)) };
+}

package/src/motion3/skills/smoke.js

@@ -0,0 +1,160 @@
+// smokeCigarette, extracted from the car-exit fixture: the right hand takes a cigarette from the
+// right pocket to the lips, the left hand brings a lighter from the left pocket under the tip,
+// lights it, puts it back; exhale, look around, a second drag, hold until `until`. Everything is
+// body-relative (pockets, holding point) or measured (mouth), so it works wherever the character
+// stands, and from any pose keyed before f0 (a squat): the head turns from its own pitch, the
+// right arm's poles lean with the torso (pitch + spine_pitch), and a squat rests the hand over
+// the knee (smoke-kit.js). Channels exhale (1 while breathing out) and ember (the tip's level:
+// 0.6 idle, 2 on a drag) drive kits; args.kit binds them (smoke-kit.js). It runs 265 frames from
+// f0 (f0..f0+264); a shorter span down to 75% of that (199 frames) paces every beat to fit.
+import { keyBook, skillError } from "./book.js";
+import { kitObjects, squatAnchors, POCKET } from "./smoke-kit.js";
+import { apply, rx } from "../compiler/math.js";
+
+// Wrist twist / flex per hand pose (degrees), found by sweeping them against the QA checks.
+const WR = { TW_M: 40, FX_M: 0, TW_H: 0, FX_H: 10, TW_L: -80, FX_L: -50 };
+// with fix.self on, the wrist at the mouth bends toward the back of the hand (15 deg standing, 20 squatting over the
+// leaning chest): with the filter on the lips that brings the forearm off the chest (straight, it ran 3-6 cm into the
+// body on the fitted skin, qa/body-checks.js); past 20 standing the knuckles reach the face
+const FX_M_SELF = 15, FX_M_SQUAT = 20;
+/** Lighting brings the hands together: the lighter's hand under the cigarette's, touching it (qa/body-checks.js). */
+const LIGHTING = [["hand_l", "hand_r", 0.045], ["hand_r", "hand_l", 0.045], ["farm_r", "hand_l", 0.02], ["hand_l", "farm_r", 0.02]].map(([part, object, depth]) => ({ part, object, depth }));
+const EL_MOUTH_R = [0.4, -1, 0.6], EL_HOLD_R = [-0.4, -1, -0.3], EL_LIGHT_L = [0.9, -0.6, 0.3];
+const ALL = ["armw_r", "armw_l", "w_rpocket_r", "w_lpocket_l", "w_hold_r", "w_mouth_r", "w_flame_l", "elbow_r", "elbow_l",
+	"wtwist_r", "wflex_r", "wtwist_l", "wflex_l", "head_pitch", "head_yaw", "spine_pitch", "root", "fingers_l", "fingers_r",
+	"cig_vis", "lit_vis", "flame_vis", "ember_vis", "exhale", "ember"];
+/** The last key at its own pace is f0 + NOMINAL; a span down to PACE_MIN of it is paced to fit. */
+const NOMINAL = 264, PACE_MIN = 0.75, MIN_SPAN = Math.ceil(NOMINAL * PACE_MIN);
+/** motion.compile takes only the timeline rate (motion3.js), so seconds in a refusal are at 24 fps. */
+const secs = n => (n / 24).toFixed(1);
+const DEFAULTS = { armw_r: 0, armw_l: 0, w_rpocket_r: 0, w_lpocket_l: 0, w_hold_r: 0, w_mouth_r: 0, w_flame_l: 0, elbow_r: [-0.5, -0.4, -1], elbow_l: [0.5, -0.4, -1],
+	wtwist_r: 0, wflex_r: 0, wtwist_l: 0, wflex_l: 0, head_pitch: 0, head_yaw: 0, spine_pitch: 0, fingers_l: { grip: 0, fist: 0 }, fingers_r: { cigarette: 0 },
+	cig_vis: 0, lit_vis: 0, flame_vis: 0, ember_vis: 0, exhale: 0, ember: 0 };
+
+export function smokeCigarette(ctx) {
+	// by default it holds to the last frame (or ends with its own motion while frames is "auto"); a
+	// span short of NOMINAL down to MIN_SPAN is paced, a shorter one refused with what it needs
+	const until = ctx.args.until ?? (ctx.auto ? ctx.f0 + NOMINAL : ctx.frames - 1), span = until - ctx.f0;
+	if (span < MIN_SPAN) skillError(ctx.tag, `needs frames f${ctx.f0}..f${ctx.f0 + MIN_SPAN} at least: ${MIN_SPAN + 1} frames, ${secs(MIN_SPAN + 1)} s at 24 fps, paced ${PACE_MIN} `
+		+ `(${NOMINAL + 1} frames, ${secs(NOMINAL + 1)} s, at its own pace); it has f${ctx.f0}..f${until}, `
+		+ (ctx.args.until === undefined ? `so set frames >= ${ctx.f0 + MIN_SPAN + 1} or frames: "auto"` : `so set args.until >= ${ctx.f0 + MIN_SPAN}`));
+	if (!Array.isArray(ctx.state.root)) skillError(ctx.tag, "needs a pose keyed before f0 (root): standing or squatting");
+	const fresh = Object.fromEntries(Object.entries(DEFAULTS).filter(([c]) => ctx.state[c] === undefined));
+	if (Object.keys(fresh).length) Object.assign(ctx.state, structuredClone(fresh));
+	ctx.state.head_yaw = 0;
+	// the pose before f0 stays: the head pitches from its own angle, the right arm's poles lean with the torso
+	const head0 = ctx.state.head_pitch, lean = (ctx.state.pitch ?? 0) + ctx.state.spine_pitch, H = v => v + head0;
+	const EL_MOUTH = lean ? apply(rx(lean), EL_MOUTH_R) : EL_MOUTH_R, EL_HOLD = lean ? apply(rx(lean), EL_HOLD_R) : EL_HOLD_R;
+	const squat = squatAnchors(ctx), FX_M = ctx.self ? (squat ? FX_M_SQUAT : FX_M_SELF) : WR.FX_M;
+	if (squat) ctx.state.w_mouthOut_r = 0;
+	// a short span scales every beat's frame by `pace` (>= 0.75): rounding keeps the keys in order,
+	// and a gap of 2 frames or more stays at least 1 (the lighter reaches the tip 3 frames before
+	// the flame shows, the pocket 2 before it hides), so each switch still happens with the hand
+	// where the contacts and appear checks want it; the steps themselves are not stretched
+	const pace = span < NOMINAL ? span / NOMINAL : 1, t = f => Math.round(f * pace), book = keyBook(ctx.state, ctx.f0);
+	const k = pace === 1 ? book : { ...book, at: (f, set) => book.at(t(f), set), hold: (f, ...names) => book.hold(t(f), ...names), step: (f, ch, v) => book.step(t(f), ch, v) };
+	const root0 = ctx.state.root.slice(), yaw = ctx.state.yaw ?? 0;
+	/** The hand from the lips to the rest over f0+a..f0+b, and back; in a squat through mouthOut (smoke-kit.js). */
+	const raise = (a, b) => {
+		k.hold(a, "w_mouth_r", "w_hold_r", "wtwist_r", "wflex_r", "elbow_r", "head_pitch", "root", ...(squat ? ["w_mouthOut_r"] : []));
+		if (squat) k.at(Math.round((a + b) / 2), { w_hold_r: 0, w_mouthOut_r: 1, w_mouth_r: 0 });
+		k.at(b, { w_mouth_r: 1, w_hold_r: 0, ...(squat ? { w_mouthOut_r: 0 } : {}), wtwist_r: WR.TW_M, wflex_r: FX_M, elbow_r: EL_MOUTH, head_pitch: H(6), root: root0 });
+	};
+	const lower = (a, b) => {
+		k.hold(a, "w_mouth_r", "w_hold_r", "wtwist_r", "wflex_r", "elbow_r", "head_pitch", ...(squat ? ["w_mouthOut_r"] : []));
+		if (squat) k.at(Math.round((a + b) / 2), { w_mouth_r: 0, w_mouthOut_r: 1, w_hold_r: 0 });
+		k.at(b, { w_mouth_r: 0, w_hold_r: 1, ...(squat ? { w_mouthOut_r: 0 } : {}), wtwist_r: WR.TW_H, wflex_r: WR.FX_H, elbow_r: EL_HOLD, head_pitch: H(0) });
+	};
+	k.hold(0, ...ALL);
+	// right hand: pocket -> the cigarette appears -> mouth
+	k.at(2, { w_rpocket_r: 1, elbow_r: [-0.5, -0.4, -1] });
+	k.hold(6, "armw_r", "w_rpocket_r", "elbow_r", "fingers_r");
+	k.at(20, { armw_r: 1 });
+	k.at(28, { fingers_r: { cigarette: 1 } });
+	k.step(28, "cig_vis", 1);
+	k.hold(36, "w_rpocket_r", "w_mouth_r", "wtwist_r", "wflex_r", "elbow_r", "head_pitch");
+	k.at(58, { w_rpocket_r: 0, w_mouth_r: 1, wtwist_r: WR.TW_M, wflex_r: FX_M, elbow_r: EL_MOUTH, head_pitch: H(6) });
+	// left hand: pocket -> the lighter appears -> under the cigarette tip
+	k.at(2, { w_lpocket_l: 1, elbow_l: [0.5, -0.4, -1] });
+	k.hold(12, "armw_l", "w_lpocket_l", "elbow_l", "fingers_l");
+	k.at(26, { armw_l: 1 });
+	k.at(34, { fingers_l: { grip: 0, fist: 1 } });
+	k.step(35, "lit_vis", 1);
+	k.hold(44, "w_lpocket_l", "w_flame_l", "wtwist_l", "wflex_l", "elbow_l");
+	k.at(60, { w_lpocket_l: 0, w_flame_l: 1, wtwist_l: WR.TW_L, wflex_l: WR.FX_L, elbow_l: EL_LIGHT_L });
+	// light it: flame on, the ember appears, inhale
+	k.step(63, "flame_vis", 1);
+	k.step(73, "ember_vis", 1);
+	k.step(79, "flame_vis", 0);
+	// the ember catches, glows up while she draws (f80-f90, f200-f212) and settles to 0.6; she breathes out twice
+	k.step(73, "ember", 1);
+	k.at(80, { ember: 2 });
+	k.hold(90, "ember");
+	k.at(104, { ember: 0.6 });
+	k.hold(194, "ember");
+	k.at(200, { ember: 2 });
+	k.hold(212, "ember");
+	k.at(224, { ember: 0.6 });
+	k.step(116, "exhale", 1);
+	k.step(138, "exhale", 0);
+	k.step(238, "exhale", 1);
+	k.step(260, "exhale", 0);
+	// the left hand puts the lighter back and drops
+	k.hold(80, "w_flame_l", "w_lpocket_l", "wtwist_l", "wflex_l", "elbow_l");
+	// a squat brings the lighter back to the pocket a little slower (its path crosses the hand's detour circle on the way
+	// down); with fix.self to the side pocket slower still (at 96 the forearm pops), the lighter going in when the hand gets there
+	const back = squat && ctx.self ? 8 : 0;
+	k.at(back ? 96 + back : squat ? 100 : 96, { w_flame_l: 0, w_lpocket_l: 1, wtwist_l: 0, wflex_l: 0, elbow_l: [0.5, -0.4, -1] });
+	k.hold(101 + back, "fingers_l");
+	k.step(102 + back, "lit_vis", 0);
+	k.hold(104 + back, "armw_l", "w_lpocket_l");
+	k.at(112, { fingers_l: { grip: 0, fist: 0 } });
+	k.at(120, { armw_l: 0, w_lpocket_l: 1 });
+	k.at(123, { w_lpocket_l: 0 });
+	// the right hand lowers to the holding position; exhale with the head up
+	lower(92, 114);
+	k.at(124, { head_pitch: H(-14) });
+	k.at(140, { head_pitch: H(0) });
+	// idle: weight onto the left leg, look around
+	const lv = [Math.cos(yaw * Math.PI / 180), 0, -Math.sin(yaw * Math.PI / 180)];
+	k.hold(120, "root", "head_yaw");
+	k.at(146, { root: root0.map((v, i) => v + 0.03 * lv[i] - (i === 1 ? 0.005 : 0)), head_yaw: -22 });
+	k.at(168, { head_yaw: 0 });
+	// second drag
+	raise(170, 194);
+	lower(212, 236);
+	k.at(246, { head_pitch: H(-14) });
+	k.at(264, { head_pitch: H(0) });
+	book.hold(span, ...ALL, ...(squat ? ["w_mouthOut_r"] : []));
+	const side = Boolean(squat) && ctx.self;
+	const kit = kitObjects(ctx, { cig: ctx.f0 + t(28), lit: ctx.f0 + t(35), unlit: ctx.f0 + t(side ? 110 : 102), squat: side });
+	return {
+		keys: book.keys, end: until, ...(pace < 1 ? { paced: Math.floor(pace * 100) / 100 } : {}), channels: ["exhale", "ember"], ...(kit ? { objects: kit.objects } : {}),
+		anchors: {
+			lpocket: { kind: "body", p: (ctx.self && squat?.lpocket) || POCKET.l }, rpocket: { kind: "body", p: (ctx.self && squat?.rpocket) || POCKET.r }, hold: { kind: "body", p: squat?.hold ?? [-0.24, 0.03, 0.06] },
+			...(squat ? { mouthOut: { kind: "body", p: squat.mouthOut } } : {}),
+			mouth: { kind: "landmark", name: "mouth" }, flame: { kind: "prop", prop: "cig", point: "tip", offset: [0, -0.02, 0] },
+		},
+		props: {
+			cig: { hand: "r", origin: ["RightHandIndex2", "RightHandMiddle2"], points: { filter: [0, 0, -0.026], tip: [0, 0, 0.058] } },
+			lighter: { hand: "l", origin: ["LeftHand", "LeftHandMiddle1"], points: { body: [0.01, 0, 0], flame: [0.01, 0.036, 0] } },
+		},
+		fits: [{ side: "r", anchor: "mouth", effector: { prop: "cig", point: "filter" } }, { side: "l", anchor: "flame", effector: { prop: "lighter", point: "flame" } }],
+		checks: {
+			contacts: [
+				{ name: "filter on the lips", point: "prop:cig.filter", target: "anchor:mouth", tol: 0.01, when: "w_mouth_r" },
+				{ name: "flame under the cigarette tip", point: "prop:lighter.flame", target: "anchor:flame", tol: 0.01, when: "flame_vis" },
+			],
+			orient: [
+				{ name: "lit end points away from the face", from: "prop:cig.filter", to: "prop:cig.tip", along: "face", minCos: 0.64, when: "w_mouth_r" },
+				{ name: "lighter upright", from: "prop:lighter.body", to: "prop:lighter.flame", along: "up", minCos: 0.85, when: "flame_vis" },
+			],
+			below: [{ name: "no chicken-wing elbow", joint: "RightForeArm", ref: "RightArm", min: 0.08, when: "w_mouth_r" }],
+			appear: [
+				{ name: "cigarette from the right pocket", channel: "cig_vis", joint: "RightHand", anchor: "rpocket", tol: 0.035 },
+				{ name: "lighter from the left pocket", channel: "lit_vis", joint: "LeftHand", anchor: "lpocket", tol: 0.035 },
+			],
+			mouthPoints: ["cig.filter"], allow: [...(kit?.allow ?? []), ...LIGHTING],
+		},
+	};
+}

package/src/motion3/spec-store.js

@@ -0,0 +1,59 @@
+// C7. Spec ids and the editor's spec store. specIdOf is final (W0). The store is an LRU of
+// SPEC_STORE_SIZE entries (lane D2): put, get, keepParts and parts all count as a use, and the
+// least recently used entry goes first. It lives in the editor page's memory: a reload forgets
+// it, and the agent then sends the whole spec again (motion3.js answers an unknown base or
+// specId with that advice).
+// frames: "auto" is an intent the stored spec cannot carry: the spec a specId names (and a take
+// keeps) holds the resolved number. The pipeline marks such a spec (markFramesAuto) and the store
+// remembers the mark beside the entry, so get() answers frames: "auto" again and base + patch
+// re-resolves the length (keys appended past the old end extend it instead of failing).
+
+export const SPEC_STORE_SIZE = 64;
+const resolvedFromAuto = new WeakSet();
+
+/** Marks a spec whose numeric frames were resolved from frames: "auto" (pipeline.js); answers it. */
+export function markFramesAuto(spec) {
+	resolvedFromAuto.add(spec);
+	return spec;
+}
+
+/** Canonical JSON: object keys sorted at every level (arrays keep their order). */
+const canonical = v => (Array.isArray(v) ? `[${v.map(canonical).join(",")}]`
+	: v && typeof v === "object" ? `{${Object.keys(v).sort().filter(k => v[k] !== undefined).map(k => `${JSON.stringify(k)}:${canonical(v[k])}`).join(",")}}`
+		: JSON.stringify(v) ?? "null");
+
+/** "spec-" + the first 12 hex digits of the FNV-1a 64-bit hash of the spec's canonical JSON. */
+export function specIdOf(spec) {
+	let h = 0xcbf29ce484222325n;
+	for (const byte of new TextEncoder().encode(canonical(spec))) h = BigInt.asUintN(64, (h ^ BigInt(byte)) * 0x100000001b3n);
+	return `spec-${h.toString(16).padStart(16, "0").slice(0, 12)}`;
+}
+
+/**
+ * The editor's store of compiled specs and their full output parts (C7).
+ *   put(spec) -> specId                 remember a compiled spec (the most recent SPEC_STORE_SIZE)
+ *   get(specId) -> spec | null          a copy of a remembered spec; frames: "auto" when it was
+ *                                       resolved from "auto" (the mark sticks to the specId)
+ *   keepParts(specId, parts)            the overflow hook: { groups, timeline, probes } in full,
+ *                                       before fitOutput cuts them (report.js)
+ *   parts(specId) -> parts | null       what motion.report pages and delta compares against
+ */
+export function createSpecStore(max = SPEC_STORE_SIZE) {
+	const entries = new Map(), size = Math.max(1, max);
+	// a Map keeps insertion order: re-inserting moves an entry to the end, the first is the oldest
+	const touch = (id, entry) => { entries.delete(id); entries.set(id, entry); while (entries.size > size) entries.delete(entries.keys().next().value); return entry; };
+	const seen = id => (entries.has(id) ? touch(id, entries.get(id)) : null);
+	return {
+		put(spec) {
+			const id = specIdOf(spec), was = entries.get(id);
+			touch(id, { ...was, spec: structuredClone(spec), framesAuto: resolvedFromAuto.has(spec) || was?.framesAuto === true });
+			return id;
+		},
+		get(id) {
+			const entry = seen(id);
+			return entry?.spec ? { ...structuredClone(entry.spec), ...(entry.framesAuto ? { frames: "auto" } : {}) } : null;
+		},
+		keepParts(id, parts) { touch(id, { ...entries.get(id), parts }); },
+		parts(id) { return seen(id)?.parts ?? null; },
+	};
+}

package/src/motion3/take-edit.js

@@ -0,0 +1,155 @@
+// Timing edits on an installed take v3: the take is cut into segments, each playing a SOURCE
+// frame range at its own speed (0.1x..4x), and segments can be removed or the take trimmed.
+// The edit never touches the compiled take: renderTakeEdit resamples the source arrays (local
+// bone quaternions, hips, object tracks) onto the timeline, so undo, reload and a new compile
+// all start from the same untouched source. Frame numbers the timeline shows are edited frames;
+// keys pinned to them (IK corrections) ride remapFrameKeys when the edit changes.
+
+const SPEED_MIN = 0.1, SPEED_MAX = 4, SPEED_STEP = 0.1;
+export const TRIM_MIN_FRAMES = 12;
+const normalizeSpeed = speed => Number((Math.round(Number(speed) / SPEED_STEP) * SPEED_STEP).toFixed(1));
+const sourceFrames = segment => segment.sourceEnd - segment.sourceStart + 1;
+const timelineFrames = segment => Math.max(1, Math.round(sourceFrames(segment) / segment.speed));
+
+export function createTakeEdit(frames) {
+	if (!Number.isInteger(frames) || frames < 1) throw new Error("createTakeEdit: frames must be a positive integer");
+	return [{ id: "motion-0", sourceStart: 0, sourceEnd: frames - 1, speed: 1 }];
+}
+
+export const takeEditDuration = edit => (Array.isArray(edit) ? edit.reduce((total, segment) => total + timelineFrames(segment), 0) : 0);
+
+/** Each segment with where it sits on the timeline (inclusive frames). */
+export function takeEditLayout(edit) {
+	let cursor = 0;
+	return edit.map(segment => {
+		const frames = timelineFrames(segment), item = { ...segment, timelineStart: cursor, timelineEnd: cursor + frames - 1, timelineFrames: frames };
+		cursor += frames;
+		return item;
+	});
+}
+
+/** The (fractional) source frame a timeline frame shows. */
+export function timelineToSource(edit, frame) {
+	const layout = takeEditLayout(edit);
+	const at = Math.max(0, Math.min(Number.isFinite(frame) ? frame : 0, layout.at(-1).timelineEnd));
+	const segment = layout.find(item => at <= item.timelineEnd) ?? layout.at(-1);
+	if (segment.timelineFrames <= 1) return segment.sourceStart;
+	return segment.sourceStart + ((at - segment.timelineStart) / (segment.timelineFrames - 1)) * (segment.sourceEnd - segment.sourceStart);
+}
+
+/** The timeline frame that shows a source frame; null when no segment covers it (cut away). */
+export function sourceToTimeline(edit, source) {
+	const segment = takeEditLayout(edit).find(item => source >= item.sourceStart && source <= item.sourceEnd);
+	if (!segment) return null;
+	if (segment.sourceEnd === segment.sourceStart) return segment.timelineStart;
+	return Math.round(segment.timelineStart + ((source - segment.sourceStart) / (segment.sourceEnd - segment.sourceStart)) * (segment.timelineFrames - 1));
+}
+
+const remapTimelineFrame = (previous, next, frame) => sourceToTimeline(next, timelineToSource(previous, frame));
+
+/** Encoded frame keys ([{ frame, ... }]) through an edit change: the earlier old frame wins a
+ * shared new frame, and keys whose source frames were cut away drop out. */
+export function remapFrameKeys(keys, previous, next) {
+	const out = new Map();
+	for (const key of [...keys].sort((a, b) => a.frame - b.frame)) {
+		const frame = remapTimelineFrame(previous, next, key.frame);
+		if (frame !== null && !out.has(frame)) out.set(frame, { ...key, frame });
+	}
+	return [...out.values()];
+}
+
+/** Split the segment under timeline frame `frame` there. */
+export function splitTakeEdit(edit, frame) {
+	const layout = takeEditLayout(edit), cut = Math.round(frame);
+	if (cut <= 0 || cut >= takeEditDuration(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(timelineToSource(edit, cut))));
+	if (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 setSegmentSpeed(edit, id, speed) {
+	const normalized = normalizeSpeed(speed);
+	if (!Number.isFinite(normalized) || normalized < SPEED_MIN || normalized > SPEED_MAX) throw new Error(`speed must be between ${SPEED_MIN} and ${SPEED_MAX} in ${SPEED_STEP} steps`);
+	return edit.map(segment => (segment.id === id ? { ...segment, speed: normalized } : segment));
+}
+
+/** Drop one segment; the last one stays (no motion is motion.clear's job). */
+export function removeSegment(edit, id) {
+	if (edit.length < 2) return edit;
+	const next = edit.filter(segment => segment.id !== id);
+	return next.length === edit.length ? edit : next;
+}
+
+/** The speed that plays a segment across `frames` timeline frames (the stretch grip). */
+export function segmentSpeedForFrames(segment, frames) {
+	const raw = sourceFrames(segment) / Math.max(1, Math.round(Number(frames) || 1));
+	return normalizeSpeed(Math.min(SPEED_MAX, Math.max(SPEED_MIN, raw)));
+}
+
+/** Keep timeline frames start..end (inclusive) of the edited take. */
+export function trimTakeEdit(edit, start, end) {
+	const duration = takeEditDuration(edit);
+	if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end >= duration || start > end) throw new Error(`trim range ${start}..${end} is outside 0..${duration - 1}`);
+	return takeEditLayout(edit).flatMap(segment => {
+		const from = Math.max(start, segment.timelineStart), to = Math.min(end, segment.timelineEnd);
+		if (from > to) return [];
+		const sourceStart = Math.max(segment.sourceStart, Math.ceil(timelineToSource(edit, from) - 1e-9));
+		const sourceEnd = Math.min(segment.sourceEnd, Math.floor(timelineToSource(edit, to) + 1e-9));
+		return sourceStart <= sourceEnd ? [{ id: `${segment.id}-t${sourceStart}`, sourceStart, sourceEnd, speed: segment.speed }] : [];
+	});
+}
+
+export const isIdentityEdit = (edit, frames) => !edit || (edit.length === 1 && edit[0].sourceStart === 0 && edit[0].sourceEnd === frames - 1 && edit[0].speed === 1);
+
+/** A saved edit checked against a take of `frames` source frames; null when it is not one. */
+export function normalizeTakeEdit(value, frames) {
+	if (!Array.isArray(value) || !value.length) return null;
+	const ok = value.every(segment => segment && typeof segment.id === "string" && Number.isInteger(segment.sourceStart) && Number.isInteger(segment.sourceEnd)
+		&& segment.sourceStart >= 0 && segment.sourceStart <= segment.sourceEnd && (!Number.isFinite(frames) || segment.sourceEnd < frames)
+		&& Number.isFinite(segment.speed) && segment.speed >= SPEED_MIN && segment.speed <= SPEED_MAX);
+	return ok ? value.map(({ id, sourceStart, sourceEnd, speed }) => ({ id, sourceStart, sourceEnd, speed })) : null;
+}
+
+function nlerp(out, o, a, ia, b, ib, t) {
+	const sign = a[ia] * b[ib] + a[ia + 1] * b[ib + 1] + a[ia + 2] * b[ib + 2] + a[ia + 3] * b[ib + 3] < 0 ? -1 : 1;
+	let n = 0;
+	for (let k = 0; k < 4; k++) { out[o + k] = a[ia + k] * (1 - t) + b[ib + k] * sign * t; n += out[o + k] ** 2; }
+	n = Math.sqrt(n) || 1;
+	for (let k = 0; k < 4; k++) out[o + k] /= n;
+}
+
+function lerp(out, o, a, ia, b, ib, t, width) {
+	for (let k = 0; k < width; k++) out[o + k] = a[ia + k] + (b[ib + k] - a[ia + k]) * t;
+}
+
+/** The take as the edit plays it: the same take object when there is no edit. */
+export function renderTakeEdit(take) {
+	const edit = take && !take.editRendered ? normalizeTakeEdit(take.edit, take.frameCount) : null;
+	if (!edit || isIdentityEdit(edit, take.frameCount)) return take;
+	const D = takeEditDuration(edit), B = take.bones.length, F = take.frameCount;
+	const at = Array.from({ length: D }, (_, f) => {
+		const s = timelineToSource(edit, f), i0 = Math.min(F - 1, Math.floor(s));
+		return { i0, i1: Math.min(F - 1, i0 + 1), t: s - i0, near: Math.min(F - 1, Math.round(s)) };
+	});
+	const rot = new Float32Array(D * B * 4), hips = new Float32Array(D * 3);
+	at.forEach(({ i0, i1, t }, f) => {
+		for (let b = 0; b < B; b++) nlerp(rot, (f * B + b) * 4, take.rot, (i0 * B + b) * 4, take.rot, (i1 * B + b) * 4, t);
+		lerp(hips, f * 3, take.hips, i0 * 3, take.hips, i1 * 3, t, 3);
+	});
+	const objects = Object.fromEntries(Object.entries(take.objects ?? {}).map(([id, track]) => {
+		const next = {};
+		if (track.pos) { next.pos = new Float32Array(D * 3); at.forEach(({ i0, i1, t }, f) => lerp(next.pos, f * 3, track.pos, i0 * 3, track.pos, i1 * 3, t, 3)); }
+		if (track.quat) { next.quat = new Float32Array(D * 4); at.forEach(({ i0, i1, t }, f) => nlerp(next.quat, f * 4, track.quat, i0 * 4, track.quat, i1 * 4, t)); }
+		if (track.lvl) { next.lvl = new Float32Array(D); at.forEach(({ i0, i1, t }, f) => lerp(next.lvl, f, track.lvl, i0, track.lvl, i1, t, 1)); }
+		for (const key of ["vis", "hold"]) if (track[key]) { next[key] = new Uint8Array(D); at.forEach(({ near }, f) => { next[key][f] = track[key][near]; }); }
+		return [id, next];
+	}));
+	return { ...take, frameCount: D, frames: D, rot, hips, objects, edit, editRendered: true };
+}