cozyclay 2.1.1 → 3.0.1

package/src/motion3/repair.js

@@ -0,0 +1,83 @@
+// C6. Repair: apply the QA patches (qa/patch.js) that make the motion better, round by round.
+// Each round takes the top 3 groups that carry a patch and tries them one at a time, each with
+// the patch the latest compile gives that group. When none is kept, the top 2 groups just past
+// their limit with no patch, or a missed goal, get a small local search (repair-tune.js: the
+// responsible skill's args, the key pair of a speed spike, or for a goal where the body stands
+// and how it leans); the best candidate is the round's change. A change
+// is kept only when the summed severity (qa/severity.js) drops and no goal that held fails, else
+// it is undone. A round that keeps nothing ends the repair. The compiler is deterministic and
+// the candidates come in a fixed order, so the repair is too; no new compile starts after 20 s.
+import { applyPatch } from "./json-patch.js";
+import { groupKey } from "./qa/severity.js";
+import { tuneCandidates } from "./repair-tune.js";
+
+const TRIES = 3, TUNE_GROUPS = 2, LIMIT_MS = 20000;
+const groupsOf = r => r?.qa?.groups ?? [];
+const totalOf = r => groupsOf(r).reduce((sum, g) => sum + (g.severity ?? 0), 0);
+const failedOf = r => (r?.qa?.goals ?? []).filter(g => !g.ok).length;
+const groupIn = (r, key) => groupsOf(r).find(g => groupKey(g) === key);
+const heldOf = r => (r?.qa?.goals ?? []).filter(g => g.ok).map(g => g.name);
+/** Lower summed severity, no more failed goals, and every goal that held still holds. */
+const better = (r, than) => totalOf(r) < totalOf(than) - 1e-9 && failedOf(r) <= failedOf(than) && heldOf(than).every(n => heldOf(r).includes(n));
+
+/**
+ * repairSpec(spec, { rounds }, compile) -> { spec, result, repair }
+ * @param {object} spec  the agent's spec (patches address it)
+ * @param {{ rounds?: number }} opts  1..8 (default 4)
+ * @param {(spec: object) => object} compile  spec -> pipeline.js compileSpec result (qa.groups[i].patch)
+ * @returns {{ spec: object, result: object, repair: { rounds: number, compiles: number,
+ *   applied: { kind: string, subject: string, patch: object[], severity: number[] }[], rejected: number } }}
+ */
+export function repairSpec(spec, opts, compile) {
+	const want = Math.min(8, Math.max(1, Math.round(Number(opts?.rounds ?? 4)) || 4)), t0 = performance.now();
+	const late = () => performance.now() - t0 >= LIMIT_MS;
+	let current = spec, result = compile(spec), compiles = 1, rejected = 0, rounds = 0;
+	const applied = [];
+	/** Compiles current + patch; null (counted as rejected) when the patch or the spec fails. */
+	const attempt = patch => {
+		try {
+			const next = applyPatch(current, patch);
+			compiles += 1;
+			return { next, r: compile(next) };
+		} catch {
+			rejected += 1;
+			return null;
+		}
+	};
+	const keep = (g, key, patch, { next, r }) => {
+		applied.push({ kind: g.kind, subject: g.subject, patch, severity: [g.severity, groupIn(r, key)?.severity ?? 0] });
+		current = next; result = r;
+	};
+	/** The best tune candidate for group g (repair-tune.js); true when it is kept. */
+	const tune = g => {
+		let best = null;
+		for (const patch of tuneCandidates(g, current)) {
+			if (late()) break;
+			const t = attempt(patch);
+			if (!t) continue;
+			if (better(t.r, best?.r ?? result)) { if (best) rejected += 1; best = { ...t, patch }; } else rejected += 1;
+			if (best && totalOf(best.r) === 0 && !failedOf(best.r)) break;
+		}
+		if (best) keep(g, groupKey(g), best.patch, best);
+		return Boolean(best);
+	};
+	while (rounds < want && !late()) {
+		const keys = groupsOf(result).filter(g => g.patch).slice(0, TRIES).map(groupKey);
+		const near = groupsOf(result).filter(g => tuneCandidates(g, current).length).slice(0, TUNE_GROUPS).map(groupKey);
+		if (!keys.length && !near.length) break;
+		rounds += 1;
+		let kept = 0;
+		for (const key of keys) {
+			const g = groupIn(result, key);
+			if (!g?.patch || late()) continue;
+			const t = attempt(g.patch);
+			if (t && better(t.r, result)) { keep(g, key, g.patch, t); kept += 1; } else if (t) rejected += 1;
+		}
+		for (const key of kept ? [] : near) {
+			const g = groupIn(result, key);
+			if (g && !late() && tune(g)) { kept += 1; break; }
+		}
+		if (!kept) break;
+	}
+	return { spec: current, result, repair: { rounds, compiles, applied, rejected } };
+}

package/src/motion3/report.js

@@ -0,0 +1,67 @@
+// C7. Output budget: a motion action's output must fit the receipt (8 KiB, of which the receipt
+// head and readback take about 1.5 KB), so fitOutput keeps the most useful parts within
+// MOTION_OUTPUT_BUDGET bytes of JSON and says what it cut in `more`; the cut parts stay in the
+// spec store (spec-store.js) and motion.report pages through them. Keep order (first = last cut):
+//   1. frames, fps, installed, specId, qa.ok/total/goals, observations, delta, repair  (always;
+//      observations are bounded: a fixed set of joints and limbs, about 1 KB)
+//   2. the first MIN_FULL qa.groups in full
+//   3. probes
+//   4. timeline (the planted spans go first, then entries from the end)
+//   5. the other groups as one-liners { kind, subject, count, severity, first, last }
+//   6. fixed, search, skills, ms
+// Room left after that turns one-liners back into full groups, from the top.
+
+export const MOTION_OUTPUT_BUDGET = 6000;
+const MIN_FULL = 4;
+const size = v => new TextEncoder().encode(JSON.stringify(v)).length;
+const oneLine = g => ({ kind: g.kind, subject: g.subject, count: g.count, severity: g.severity, first: g.first, last: g.last });
+
+/**
+ * full output -> output within `budget` bytes of JSON. When something was cut it carries
+ * more: { specId, groups, timeline, probes }, how many items of each part are missing or
+ * shortened; motion.report { specId, part, from } pages the whole part.
+ */
+export function fitOutput(full, budget = MOTION_OUTPUT_BUDGET) {
+	if (size(full) <= budget) return full;
+	const { qa, observations, probes, timeline, fixed, search, skills, ms, ...head } = full;
+	const groups = qa?.groups ?? [], more = { specId: full.specId, groups: 0, timeline: 0, probes: 0 };
+	const out = { ...head, ...(qa ? { qa: { ...qa, groups: [] } } : {}), ...(observations ? { observations } : {}) };
+	// the counts in `more` may still grow by a digit or two after a check
+	const fits = extra => size({ ...out, ...extra, more }) <= budget - 32;
+	const nFull = Math.min(MIN_FULL, groups.length);
+	if (qa) out.qa.groups = groups.slice(0, nFull);
+	if (probes) {
+		const kept = {};
+		for (const [k, v] of Object.entries(probes)) if (fits({ probes: { ...kept, [k]: v } })) kept[k] = v;
+		out.probes = kept; more.probes = Object.keys(probes).length - Object.keys(kept).length;
+	}
+	if (timeline) {
+		const lean = timeline.map(({ planted, ...rest }) => rest), list = fits({ timeline }) ? timeline : lean;
+		let n = list.length;
+		while (n > 0 && !fits({ timeline: list.slice(0, n) })) n--;
+		out.timeline = list.slice(0, n);
+		more.timeline = list === lean ? timeline.length : timeline.length - n;
+	}
+	for (let i = nFull; i < groups.length && fits({ qa: { ...out.qa, groups: [...out.qa.groups, oneLine(groups[i])] } }); i++) out.qa.groups.push(oneLine(groups[i]));
+	for (const [k, v] of [["fixed", fixed], ["search", search], ["skills", skills], ["ms", ms]]) if (v !== undefined && fits({ [k]: v })) out[k] = v;
+	for (let i = nFull; i < out.qa?.groups.length && fits({ qa: { ...out.qa, groups: out.qa.groups.map((g, j) => (j === i ? groups[i] : g)) } }); i++) out.qa.groups[i] = groups[i];
+	// last resort (huge hints): full groups become one-liners from the end
+	for (let i = nFull - 1; i >= 0 && !fits({}); i--) out.qa.groups[i] = oneLine(groups[i]);
+	more.groups = groups.length - (out.qa?.groups ?? []).filter(g => "worst" in g).length;
+	return { ...out, more };
+}
+
+/**
+ * One page of a stored part for motion.report: items from index `from` on, as many as fit the
+ * budget (at least one). parts = { groups: [], timeline: [], probes: { name: result } }.
+ * @returns {{ specId: string, part: string, from: number, items: any[], next: number | null }}
+ */
+export function reportPage(parts, specId, part, from = 0, budget = MOTION_OUTPUT_BUDGET) {
+	const all = part === "probes" ? Object.entries(parts?.probes ?? {}).map(([name, r]) => ({ name, ...r })) : parts?.[part] ?? [];
+	const page = { specId, part, from, items: [], next: null };
+	for (let i = from; i < all.length; i++) {
+		if (page.items.length && size({ ...page, items: [...page.items, all[i]], next: i + 1 }) > budget) { page.next = i; break; }
+		page.items.push(all[i]);
+	}
+	return page;
+}

package/src/motion3/rigs/index.js

@@ -0,0 +1,14 @@
+// Bind skeletons of the bodies a take can be compiled for (tools/motion3/extract-rig.mjs).
+import xBot from "./x-bot-tpose.json" with { type: "json" };
+import yBot from "./y-bot-tpose.json" with { type: "json" };
+import { createSkeleton } from "../compiler/skeleton.js";
+
+const RIGS = { "x-bot-tpose": xBot, "y-bot-tpose": yBot };
+const cache = new Map();
+
+/** Skeleton for a character model id, or null for a body motion3 cannot drive. */
+export function skeletonFor(model) {
+	if (!RIGS[model]) return null;
+	if (!cache.has(model)) cache.set(model, createSkeleton(RIGS[model]));
+	return cache.get(model);
+}