cozyclay 2.0.2 → 2.1.1

package/src/workflow-send.js

@@ -0,0 +1,87 @@
+/**
+ * Send a storyboard panel to the Workflow canvas: one Upload node holding the
+ * panel PNG, wired into a fresh Video generation node whose prompt is the
+ * shot prompt plus the panel caption. The helper only appends to the draft
+ * (`cozyclay.workflow.v1`); it never runs the workflow and never touches an
+ * existing node or edge. Kept free of React so Node tests can drive it.
+ */
+
+import { loadWorkflowGraph, normalizeWorkflowGraph, WORKFLOW_STORAGE_KEY, WORKFLOW_VERSION } from "./project.js";
+import { pastedImageNodeData } from "./workflow/clipboard-image.js";
+import { DEFAULT_NODE_SCHEMAS, defaultFormValues, schemaProperties } from "./workflow/node-schema.js";
+import { buildShotPrompt } from "./shot-prompt.js";
+
+const COLUMN_GAP = 380;
+const ROW_GAP = 280;
+const FIRST_POSITION = { x: 80, y: 100 };
+const VIDEO_MODEL = { id: "video-generation", name: "Video generation" };
+
+/** The video prompt for a panel: the labelled shot block, then its caption. */
+export function panelVideoPrompt(meta, caption = "") {
+	const prompt = buildShotPrompt(meta, { target: "video" });
+	const note = typeof caption === "string" ? caption.trim() : "";
+	return note ? `${prompt}\nCAPTION: ${note}` : prompt;
+}
+
+function nodeBase(label) {
+	return { label, cost: 0, outputHistory: [], outputs: [], resultUrl: null, isLoading: false, errorMsg: null };
+}
+
+function freshId(type, taken, stamp) {
+	let id = `${type}-${stamp}`;
+	for (let n = 2; taken.has(id); n += 1) id = `${type}-${stamp}-${n}`;
+	taken.add(id);
+	return id;
+}
+
+/** Pure: the draft with the panel's two nodes and one edge appended. Every
+ * pre-existing node and edge is carried over untouched. */
+export function appendPanelToWorkflowGraph(draft, { dataUrl, mimeType = "image/png", fileName = "panel.png", prompt = "", now = Date.now() } = {}) {
+	if (typeof dataUrl !== "string" || !dataUrl.startsWith("data:image/")) throw new Error("A panel image is required");
+	const graph = normalizeWorkflowGraph(draft);
+	const taken = new Set(graph.nodes.map((node) => node.id));
+	const uploadId = freshId("upload", taken, now);
+	const videoId = freshId("video", taken, now);
+	// Below everything already on the canvas, left-aligned with it.
+	const x = graph.nodes.length ? Math.min(...graph.nodes.map((node) => node.position.x)) : FIRST_POSITION.x;
+	const y = graph.nodes.length ? Math.max(...graph.nodes.map((node) => node.position.y)) + ROW_GAP : FIRST_POSITION.y;
+	const upload = {
+		id: uploadId,
+		type: "upload",
+		position: { x, y },
+		data: { ...nodeBase("Upload"), ...pastedImageNodeData({ name: fileName, type: mimeType }, dataUrl), uploadName: fileName, thumbnail: dataUrl },
+	};
+	const formValues = { ...defaultFormValues(schemaProperties(DEFAULT_NODE_SCHEMAS, "video", VIDEO_MODEL.id)), prompt };
+	const video = {
+		id: videoId,
+		type: "video",
+		position: { x: x + COLUMN_GAP, y },
+		data: { ...nodeBase("Video"), prompt, model: VIDEO_MODEL.id, selectedModel: { ...VIDEO_MODEL }, formValues },
+	};
+	const edge = { id: `e-${uploadId}-${videoId}`, source: uploadId, target: videoId, sourceHandle: "output", targetHandle: "input" };
+	return normalizeWorkflowGraph({
+		version: WORKFLOW_VERSION,
+		nodes: [...graph.nodes, upload, video],
+		edges: [...graph.edges, edge],
+	});
+}
+
+/** Write the panel into the stored draft. Unlike storeWorkflowGraph this lets a
+ * storage failure (quota, private mode) surface, so the caller can say so. */
+export function sendPanelToWorkflow(panel, storage = globalThis.localStorage, now = Date.now()) {
+	if (!storage) throw new Error("Browser storage is unavailable");
+	// A corrupt stored draft throws here, before anything is written.
+	const draft = loadWorkflowGraph(storage, { strict: true });
+	const graph = appendPanelToWorkflowGraph(draft, { ...panel, now });
+	storage.setItem(WORKFLOW_STORAGE_KEY, JSON.stringify(graph));
+	try { globalThis.dispatchEvent?.(new CustomEvent("cozyclay:workflow-change")); } catch { /* non-browser runtime */ }
+	return graph;
+}
+
+/** A Blob's bytes as a data URL, for a stylized panel read from the asset store. */
+export function bytesToDataUrl(bytes, type = "image/png") {
+	const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+	let binary = "";
+	for (let i = 0; i < view.length; i += 0x8000) binary += String.fromCharCode.apply(null, view.subarray(i, i + 0x8000));
+	return `data:${type};base64,${btoa(binary)}`;
+}

package/tools/check-eslint.mjs

@@ -0,0 +1,57 @@
+// ESLint ratchet: fail when the error count of any rule exceeds tools/eslint-baseline.json.
+// Usage: node tools/check-eslint.mjs [--update]
+//   (no flag)  compare current counts with the baseline; exit 1 on any regression
+//   --update   rewrite the baseline with the current counts
+import { spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const baselinePath = join(root, "tools", "eslint-baseline.json");
+
+const run = spawnSync(join(root, "node_modules", ".bin", "eslint"), [".", "--format", "json"], {
+	cwd: root,
+	encoding: "utf8",
+	maxBuffer: 512 * 1024 * 1024,
+});
+// eslint exits 1 when it finds errors; anything else without JSON output is a real failure.
+let results;
+try {
+	results = JSON.parse(run.stdout);
+} catch {
+	console.error(`eslint did not produce JSON (status ${run.status})\n${run.stderr}`);
+	process.exit(2);
+}
+
+const counts = {};
+const hits = {};
+for (const file of results) {
+	for (const m of file.messages) {
+		if (m.severity !== 2) continue;
+		const rule = m.ruleId ?? "fatal";
+		counts[rule] = (counts[rule] ?? 0) + 1;
+		(hits[rule] ??= []).push(`${relative(root, file.filePath)}:${m.line}: ${m.message}`);
+	}
+}
+const sorted = Object.fromEntries(Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)));
+
+if (process.argv.includes("--update")) {
+	writeFileSync(baselinePath, `${JSON.stringify(sorted, null, "\t")}\n`);
+	console.log(`eslint: baseline updated (${Object.keys(sorted).length} rules)`);
+	process.exit(0);
+}
+
+const baseline = JSON.parse(readFileSync(baselinePath, "utf8"));
+const regressed = Object.keys(sorted).filter((rule) => sorted[rule] > (baseline[rule] ?? 0));
+if (regressed.length) {
+	for (const rule of regressed) {
+		console.log(`${rule}: ${baseline[rule] ?? 0} -> ${sorted[rule]}`);
+	}
+	console.log("");
+	for (const line of regressed.flatMap((rule) => hits[rule]).slice(0, 10)) console.log(line);
+	process.exit(1);
+}
+const total = Object.values(sorted).reduce((a, b) => a + b, 0);
+const base = Object.values(baseline).reduce((a, b) => a + b, 0);
+console.log(`eslint: ${total} errors across ${Object.keys(sorted).length} rules (baseline ${base}), 0 regressions`);

package/tools/check-knip.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+// Usage: node tools/check-knip.mjs [--update]
+// Ratchet for knip: fails (exit 1) on findings that are not in tools/knip-baseline.json.
+// --update rewrites the baseline with the current findings and exits 0.
+import { spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const baselinePath = join(root, 'tools', 'knip-baseline.json');
+
+// knip exits 1 when it finds issues; only a missing/unparseable report is a failure.
+const run = spawnSync(join(root, 'node_modules', '.bin', 'knip'), ['--reporter', 'json', '--no-progress'], {
+	cwd: root,
+	encoding: 'utf8',
+	maxBuffer: 256 * 1024 * 1024,
+});
+if (run.error) {
+	console.error(`knip failed to start: ${run.error.message}`);
+	process.exit(2);
+}
+let report;
+try {
+	report = JSON.parse(run.stdout);
+} catch {
+	console.error(`knip produced no JSON (exit ${run.status})\n${run.stderr}`);
+	process.exit(2);
+}
+
+const keys = new Set();
+for (const issue of report.issues ?? []) {
+	const file = issue.file;
+	if (issue.files === true || (Array.isArray(issue.files) && issue.files.length)) keys.add(`file ${file}`);
+	for (const e of issue.exports ?? []) keys.add(`export ${file}#${e.name}`);
+	for (const e of issue.types ?? []) keys.add(`export ${file}#${e.name}`);
+	for (const e of issue.enumMembers ?? []) keys.add(`export ${file}#${e.name}`);
+	for (const e of issue.dependencies ?? []) keys.add(`dependency ${file}#${e.name}`);
+	for (const e of issue.devDependencies ?? []) keys.add(`dependency ${file}#${e.name}`);
+	for (const e of issue.unlisted ?? []) keys.add(`unlisted ${file}#${e.name}`);
+}
+for (const f of report.files ?? []) keys.add(`file ${f}`);
+const current = [...keys].sort();
+
+if (process.argv.includes('--update')) {
+	writeFileSync(baselinePath, `${JSON.stringify(current, null, '\t')}\n`);
+	console.log(`knip: baseline updated, ${current.length} findings`);
+	process.exit(0);
+}
+
+const baseline = existsSync(baselinePath) ? JSON.parse(readFileSync(baselinePath, 'utf8')) : [];
+const known = new Set(baseline);
+const now = new Set(current);
+const added = current.filter((k) => !known.has(k));
+const fixed = baseline.filter((k) => !now.has(k));
+
+for (const k of added) console.log(`new: ${k}`);
+if (fixed.length) console.log(`fixed: ${fixed.length}`);
+console.log(`knip: ${current.length} findings, ${added.length} new, ${fixed.length} fixed (baseline ${baseline.length})`);
+process.exit(added.length ? 1 : 0);

package/tools/check-loc.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// Usage: node tools/check-loc.mjs [--update]
+// Ratchet pure source LOC; --update rewrites tools/loc-baseline.json.
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = join(fileURLToPath(new URL('.', import.meta.url)), '..');
+const baselinePath = join(root, 'tools', 'loc-baseline.json');
+const extensions = new Set(['.js', '.jsx', '.mjs']);
+const roots = ['src', 'bin', 'mcp', 'tools', 'workers'];
+
+function filesUnder(directory) {
+	const files = [];
+	for (const entry of readdirSync(join(root, directory), { withFileTypes: true })) {
+		if (entry.name === 'node_modules' || entry.name === 'dist') continue;
+		const path = join(directory, entry.name);
+		if (entry.isDirectory()) files.push(...filesUnder(path));
+		else if (entry.isFile() && extensions.has(path.slice(path.lastIndexOf('.')))) files.push(path);
+	}
+	return files;
+}
+
+function pureLoc(path) {
+	return readFileSync(join(root, path), 'utf8')
+		.split(/\r?\n/)
+		.filter((line) => line.trim() && !/^\s*\/\//.test(line)).length;
+}
+
+const current = Object.fromEntries(
+	roots.flatMap(filesUnder)
+		.map((path) => [path.replaceAll('\\', '/'), pureLoc(path)])
+		.filter(([, lines]) => lines > 250)
+		.sort(([a], [b]) => a.localeCompare(b)),
+);
+
+if (process.argv.includes('--update')) {
+	writeFileSync(baselinePath, `${JSON.stringify(current, null, '\t')}\n`);
+	console.log(`loc: baseline updated (${Object.keys(current).length} files over 250)`);
+	process.exit(0);
+}
+
+const baseline = JSON.parse(readFileSync(baselinePath, 'utf8'));
+const violations = [];
+for (const [path, lines] of Object.entries(current)) {
+	if (!(path in baseline)) violations.push(`new oversized file ${path} (${lines} lines)`);
+	else if (lines > baseline[path]) violations.push(`${path} grew ${baseline[path]} -> ${lines}`);
+}
+for (const message of violations) console.log(message);
+
+const fixed = Object.keys(baseline).filter((path) => !(path in current));
+if (fixed.length) console.log(`fixed: ${fixed.length}`);
+console.log(`loc: ${Object.keys(current).length} files over 250 (baseline ${Object.keys(baseline).length}), ${violations.length} violations`);
+process.exit(violations.length ? 1 : 0);

package/tools/demo-worker/api-client.mjs

@@ -8,7 +8,7 @@
 
 import { bodyBytes, randomNonce, signedHeaders } from "./sign-core.mjs";
 
-export class DemoApiError extends Error {
+class DemoApiError extends Error {
 	constructor(status, code, body = null) {
 		super(`demo API ${status}${code ? ` ${code}` : ""}`);
 		this.name = "DemoApiError";
@@ -77,7 +77,7 @@ function asJob(body) {
  * `fetchImpl`, `now`, and `nonceFactory` are injectable to make protocol tests
  * deterministic without changing production behavior.
  */
-export class DemoApiClient {
+class DemoApiClient {
 	constructor({
 		baseUrl = process.env.CC_DEMO_API_BASE,
 		base,
@@ -198,42 +198,36 @@ export class DemoApiClient {
 	}
 }
 
-export const ApiClient = DemoApiClient;
-
 export function createApiClient(options = {}) {
 	return new DemoApiClient(options);
 }
 
-export const createDemoApiClient = createApiClient;
-
 let defaultClient = null;
 function envClient() {
 	if (!defaultClient) defaultClient = createApiClient();
 	return defaultClient;
 }
 
-export function next(options) {
+function next(options) {
 	return envClient().next(options);
 }
 
-export function complete(jobId, leaseToken, npzBuffer, options) {
+function complete(jobId, leaseToken, npzBuffer, options) {
 	return envClient().complete(jobId, leaseToken, npzBuffer, options);
 }
 
-export function fail(jobId, leaseToken, reason, options) {
+function fail(jobId, leaseToken, reason, options) {
 	return envClient().fail(jobId, leaseToken, reason, options);
 }
 
-export function heartbeat(jobId, leaseToken, options) {
+function heartbeat(jobId, leaseToken, options) {
 	return envClient().heartbeat(jobId, leaseToken, options);
 }
 
-export function signRequest(secretOrOptions, maybeOptions) {
+function signRequest(secretOrOptions, maybeOptions) {
 	if (typeof secretOrOptions === "string") {
 		return signedHeaders({ ...(maybeOptions || {}), secret: secretOrOptions });
 	}
 	return signedHeaders(secretOrOptions);
 }
 
-export default createApiClient;
-

package/tools/demo-worker/generate.mjs

@@ -16,7 +16,7 @@ import { createLocalRunner } from "../ardy/runners/local.mjs";
 import { killGroup, track } from "../ardy/runners/proc.mjs";
 import { POLICY } from "../../workers/api/src/policy.js";
 
-export const JOB_HARD_TIMEOUT_MS = POLICY.JOB_HARD_TIMEOUT_MS;
+const JOB_HARD_TIMEOUT_MS = POLICY.JOB_HARD_TIMEOUT_MS;
 const DEFAULT_TIMEOUT_ENV = ["CC_JOB_HARD_TIMEOUT_MS", "JOB_HARD_TIMEOUT_MS"];
 let sharedRunner = null;
 
@@ -122,7 +122,7 @@ function waitForChild(child) {
  * installing ARDY. Production callers leave it unset and get
  * createLocalRunner().
  */
-export async function generate(prompt, durationS, options = {}) {
+async function generate(prompt, durationS, options = {}) {
 	// Accept both generate(prompt, duration, options) and generate({prompt,
 	// duration}, options). The latter is convenient for queue adapters and does
 	// not change the public positional contract.
@@ -298,6 +298,4 @@ export function createGenerator({ runner = null, workerReady = localWorkerReady,
 	};
 }
 
-export const generateJob = generate;
-export default generate;
 

package/tools/eslint-baseline.json

@@ -0,0 +1,23 @@
+{
+	"no-async-promise-executor": 1,
+	"no-case-declarations": 1,
+	"no-constant-binary-expression": 2,
+	"no-control-regex": 5,
+	"no-dupe-keys": 1,
+	"no-loss-of-precision": 1,
+	"no-regex-spaces": 2,
+	"no-undef": 25,
+	"no-unsafe-finally": 5,
+	"no-unused-vars": 168,
+	"no-useless-assignment": 21,
+	"no-useless-catch": 2,
+	"no-useless-escape": 7,
+	"preserve-caught-error": 16,
+	"react-hooks/immutability": 66,
+	"react-hooks/purity": 5,
+	"react-hooks/refs": 87,
+	"react-hooks/rules-of-hooks": 3,
+	"react-hooks/set-state-in-effect": 31,
+	"react-hooks/use-memo": 1,
+	"require-yield": 2
+}

package/tools/gt-render/browser.mjs

@@ -154,6 +154,29 @@ export async function openStudioClean(cdp, studioUrl) {
 	await loaded;
 }
 
+/** Load a portable project into the same Studio that a user opens. The project
+ * document is seeded before the app bundle runs, so this path exercises the
+ * real scene store and live-control connection instead of a test renderer. */
+export async function openStudioProject(cdp, studioUrl, project) {
+	const origin = new URL(studioUrl).origin;
+	if (!project?.scenesDocument || typeof project.scenesDocument !== "object") throw new Error("headless Studio needs a parsed project with scenesDocument");
+	await cdp.send("Page.enable");
+	await cdp.send("Storage.clearDataForOrigin", { origin, storageTypes: "all" });
+	const scenes = JSON.stringify(project.scenesDocument), name = String(project.name || "Headless Project");
+	const values = [
+		`localStorage.setItem('cozyclay.scenes.v5', ${JSON.stringify(scenes)})`,
+		`localStorage.setItem('cozyclay.project-session.v1', ${JSON.stringify(JSON.stringify({ name, previsMode: project.previsMode || "animation", updatedAt: Date.now() }))})`,
+		project.workflow ? `localStorage.setItem('cozyclay.workflow.v1', ${JSON.stringify(JSON.stringify(project.workflow))})` : null,
+		project.workspaceLayout ? `localStorage.setItem('cozyclay.workspace-layout.v1', ${JSON.stringify(JSON.stringify(project.workspaceLayout))})` : null,
+	].filter(Boolean);
+	const source = `${values.join("; ")};`;
+	await cdp.send("Page.addScriptToEvaluateOnNewDocument", { source });
+	const loaded = cdp.once("Page.loadEventFired");
+	await cdp.send("Page.navigate", { url: studioUrl });
+	await loaded;
+	await waitFor("Studio canvas", async () => cdp.evaluate("Boolean(document.querySelector('canvas'))"), { timeoutMs: 60000 });
+}
+
 export async function terminateAll(children) {
 	await Promise.allSettled(children.splice(0).reverse().map((child) => terminateOwned(child)));
 }

package/tools/headless-studio.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Start the real CozyClay Studio in an owned headless Chrome process.
+ *
+ * This is intentionally a source-checkout tool. It starts the same dev server,
+ * seeds a portable .cclayproject into the browser's storage before the app
+ * loads, and leaves the live hub available to `cclay live` or an MCP client.
+ */
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnOwned, terminateOwned } from "./process-supervisor.mjs";
+import { openStudioProject, startChrome, waitFor } from "./gt-render/browser.mjs";
+import { readProjectDocument } from "../src/project.js";
+
+const ROOT = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const usage = `headless-studio - start the real Studio without a visible tab
+
+  node tools/headless-studio.mjs --project shot.cclayproject
+
+Options:
+  --project <file>   portable .cclayproject to load (required)
+  --port <port>      Vite/Studio port (default 5920)
+  --live-port <port> live hub port (default 5924)
+  --cdp-port <port>  Chrome DevTools port (default 9320)
+`;
+
+function value(argv, name, fallback = undefined) {
+	const index = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
+	if (index < 0) return fallback;
+	const arg = argv[index];
+	return arg.includes("=") ? arg.slice(name.length + 1) : argv[index + 1];
+}
+function port(argv, name, fallback) {
+	const parsed = Number(value(argv, name, fallback));
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) throw new Error(`${name} must be an integer in 1..65535`);
+	return parsed;
+}
+
+const argv = process.argv.slice(2);
+if (argv.includes("--help") || argv.includes("-h")) { console.log(usage); process.exit(0); }
+const projectPath = value(argv, "--project");
+if (!projectPath) { console.error(usage); process.exit(2); }
+const projectRaw = readFileSync(resolve(projectPath), "utf8");
+const parsed = readProjectDocument(projectRaw);
+if (!parsed.ok) throw new Error(`Cannot load project: ${parsed.reason}`);
+const studioPort = port(argv, "--port", 5920);
+const livePort = port(argv, "--live-port", 5924);
+const cdpPort = port(argv, "--cdp-port", 9320);
+const children = [];
+const cleanups = [];
+let cdp = null;
+let shuttingDown = false;
+const shutdown = async (code = 0) => {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	try { cdp?.close(); } catch { /* already closed */ }
+	for (const cleanup of cleanups.splice(0).reverse()) { try { cleanup(); } catch { /* best effort */ } }
+	await Promise.allSettled(children.reverse().map((child) => terminateOwned(child)));
+	process.exitCode = code;
+};
+for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { void shutdown(128 + (signal === "SIGINT" ? 2 : 15)); });
+
+let dev = null;
+try {
+	dev = spawnOwned(process.execPath, [join(ROOT, "tools/dev-full.mjs"), "--host", "127.0.0.1", "--port", String(studioPort)], {
+		cwd: ROOT,
+		env: { ...process.env, COZYCLAY_LIVE_PORT: String(livePort) },
+		stdio: ["ignore", "inherit", "inherit"],
+	});
+	children.push(dev);
+	await waitFor("Studio server", async () => (await fetch(`http://127.0.0.1:${studioPort}/app/`)).ok, { child: dev });
+	cdp = await startChrome({ port: cdpPort, children, cleanups });
+	await openStudioProject(cdp, `http://127.0.0.1:${studioPort}/app/`, parsed.project);
+	console.log(JSON.stringify({ ok: true, studio: `http://127.0.0.1:${studioPort}/app/`, livePort, cdpPort, project: parsed.project.name, warnings: parsed.warnings }, null, 2));
+	await new Promise((resolve) => {
+		const done = () => resolve();
+		dev.once("exit", done);
+		if (dev.exitCode !== null || dev.signalCode !== null) done();
+	});
+	await shutdown(dev.exitCode ?? 1);
+} catch (error) {
+	console.error(`headless Studio: ${error?.message || error}`);
+	await shutdown(1);
+}

package/tools/kimodo/effector-constraints.mjs

@@ -99,10 +99,10 @@
 
 import { buildFullBodyConstraints } from "./pose-constraints.mjs";
 
-export const LEFT_HAND_TYPE = "left-hand";
-export const RIGHT_HAND_TYPE = "right-hand";
-export const LEFT_FOOT_TYPE = "left-foot";
-export const RIGHT_FOOT_TYPE = "right-foot";
+const LEFT_HAND_TYPE = "left-hand";
+const RIGHT_HAND_TYPE = "right-hand";
+const LEFT_FOOT_TYPE = "left-foot";
+const RIGHT_FOOT_TYPE = "right-foot";
 
 /**
  * IK/mid-joint track id -> Kimodo effector constraint type.

package/tools/kimodo/generate.mjs

@@ -50,7 +50,7 @@ const SSH_OPTS = [
 	"-o", "ServerAliveCountMax=240",
 ];
 
-export const DEFAULT_MODEL = "Kimodo-SOMA-RP-v1.1";
+const DEFAULT_MODEL = "Kimodo-SOMA-RP-v1.1";
 export const KIMODO_BACKENDS = {
   "nvidia-cuda": { repo: "$HOME/.cozyclay/kimodo", entry: ".venv/bin/kimodo_gen", mode: "cuda", promptFlag: null, durationFlag: "--duration", stepsFlag: "--diffusion_steps", outputFlag: "--output" },
   "kimodo-mlx": { repo: "$HOME/.cozyclay/kimodo-mlx", entry: "$HOME/.cozyclay/kimodo-mlx-venv/bin/python", motion: "$HOME/.cozyclay/kimodo-mlx/models/nvidia-soma-rp-v1.1", text: "$HOME/.cozyclay/kimodo-mlx/models/llm2vec-text-bundle", mode: "mlx", promptFlag: "--prompt", framesFlag: "--frames", stepsFlag: "--steps", outputFlag: null },