paper-motion 0.2.7 → 0.4.0

package/lib/piece.mjs

@@ -0,0 +1,223 @@
+// A piece's progress: pieces/<piece>/piece.json, shared by the agent (CLI) and the user (pamo studio).
+//
+//   stage      the stage the piece is at: brief → inventory → video → final. The user sees three steps (What it says,
+//              Your video, Export); the brief is settled in the chat.
+//   stages     each stage's status: pending · working (the agent's turn) · review (the user's turn) · changes · approved
+//   brief      what, who, format, tone, action: written by the agent, editable by the user
+//   parts      per part (by its folder in chain.json): status (queued · rendering · review · changes · approved), note
+//   events     what the user did in the studio, in order; `seen` is the last one the agent has read
+//   ask        a question the agent asked in the chat and is waiting on (the studio sends the user there)
+//   agent      the app or page the agent runs in, so the studio can take the user back to it
+//
+// chain.json stays the source of what plays (order, seconds, joins); piece.json only tracks decisions.
+import fs from 'node:fs';
+import path from 'node:path';
+import { pieceDir } from './chain.mjs';
+
+export const STAGES = ['brief', 'inventory', 'video', 'final'];
+// the stages a piece had before Your video took them over: a piece at one of them is at `video` now
+const OLD_VIDEO = ['look', 'structure', 'parts', 'assembly'];
+export const STAGE_STATUS = ['pending', 'working', 'review', 'changes', 'approved'];
+export const BRIEF_KEYS = ['what', 'who', 'format', 'tone', 'action'];
+
+const now = () => new Date().toISOString();
+const file = (dir) => path.join(dir, 'piece.json');
+
+export function readPiece(dir) {
+  try { return upgrade(JSON.parse(fs.readFileSync(file(dir), 'utf8'))); } catch { return null; }
+}
+// a piece started before a stage existed: that stage counts as done when the piece is already past it
+function upgrade(p) {
+  if (!p.stages.video) {
+    const at = OLD_VIDEO.indexOf(p.stage), last = OLD_VIDEO.findLast((s) => p.stages[s]);
+    p.stages.video = at >= 0 ? { ...p.stages[p.stage] } : last && p.stages[last].status === 'approved' && STAGES.indexOf(p.stage) > 0 ? { status: 'approved' } : undefined;
+    if (at >= 0) p.stage = 'video';
+    for (const s of OLD_VIDEO) delete p.stages[s];
+    if (!p.stages.video) delete p.stages.video;
+  }
+  for (const s of STAGES) p.stages[s] ??= STAGES.indexOf(p.stage) > STAGES.indexOf(s) ? { status: 'approved', skipped: true } : { status: 'pending' };
+  return p;
+}
+
+/** Writes atomically (the studio and the CLI both write it). */
+export function writePiece(dir, p) {
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${file(dir)}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(p, null, 2) + '\n');
+  fs.renameSync(tmp, file(dir));
+  return p;
+}
+
+/** Read, change, write: `fn` mutates the piece (re-read right before writing, so concurrent writers rarely clash). */
+export function updatePiece(dir, fn) {
+  const p = readPiece(dir);
+  if (!p) throw new Error(`no piece.json in ${dir} (pamo piece init first)`);
+  fn(p);
+  p.updated = now();
+  return writePiece(dir, p);
+}
+
+export function initPiece({ cwd = process.cwd(), piece, title, brief = {}, force = false }) {
+  const dir = pieceDir(piece, cwd), old = readPiece(dir);
+  if (old && !force) {
+    // an existing piece: fill in what was given, keep the rest
+    return updatePiece(dir, (p) => { if (title) p.title = title; for (const k of BRIEF_KEYS) if (brief[k]) p.brief[k] = brief[k]; });
+  }
+  const tokens = (() => { try { return JSON.parse(fs.readFileSync(path.join(cwd, 'brand/tokens.json'), 'utf8')); } catch { return {}; } })();
+  return writePiece(dir, {
+    v: 1, piece: path.basename(dir), title: title ?? path.basename(dir), brand: tokens.brand ?? null,
+    stage: 'brief',
+    stages: Object.fromEntries(STAGES.map((s, i) => [s, { status: i ? 'pending' : 'working' }])),
+    brief: Object.fromEntries(BRIEF_KEYS.map((k) => [k, brief[k] ?? ''])),
+    parts: {}, events: [], seen: 0, created: now(), updated: now(),
+  });
+}
+
+/** The line the agent reads for an event (same family as the board reply). */
+export function eventLine(p, e) {
+  const who = e.part ? `part ${e.part}` : e.stage;
+  const what = e.kind === 'approve' ? 'approved'
+    : e.kind === 'changes' ? `changes: "${e.text}"`
+    : e.kind === 'order' ? `order ${e.text}`
+    : e.kind === 'reopen' ? 'reopened'
+    : e.kind === 'failed' ? `could not join the parts: "${e.text}"`
+    : e.say ? e.say : `${e.key}="${e.text}"${e.rerendered ? ' (re-rendered)' : ''}`;
+  // the studio joins the draft again by itself after an edit by hand; the full-quality render stays the agent's
+  const tail = `${e.rejoined ? ' (the studio is joining the draft again)' : ''}${e.rejoin ? ' · join again: pamo chain --draft' : ''}${e.refinal ? ` · the final is out of date: render it again (pamo chain ${p.piece} --motion-blur 5), then review final` : ''}`;
+  return `paper-motion: piece ${p.piece} · ${e.kind === 'order' ? '' : `${who} `}${what}${tail}`.replace(/ {2,}/g, ' ');
+}
+
+/** Appends a user event (from the studio). */
+export function addEvent(p, e) {
+  const n = (p.events.at(-1)?.n ?? 0) + 1;
+  const ev = { n, at: now(), ...e };
+  p.events.push(ev);
+  return ev;
+}
+
+/** The agent hands a stage to the user: it becomes the current stage, in review. */
+export function toReview(dir, stage, { skip = false } = {}) {
+  if (!STAGES.includes(stage)) throw new Error(`stage "${stage}": use ${STAGES.join(', ')}`);
+  return updatePiece(dir, (p) => {
+    // nothing moves on until the user approves: an earlier stage they have not approved stops the hand-over,
+    // unless the agent says outright that it is skipping it (`skip`), which marks it approved
+    const open = earlierOpen(p, stage);
+    if (open.length && !skip) throw new Error(`${open.join(', ')} not approved yet: review ${open.length > 1 ? 'them' : 'it'} first (piece review ${p.piece} ${open[0]}), or pass --skip when the user agreed to move on without ${open.length > 1 ? 'them' : 'it'}`);
+    for (const s of open) p.stages[s] = { ...p.stages[s], status: 'approved' };
+    delete p.ask;   // handing a stage over means the question in the chat is settled
+    p.stage = stage;
+    p.stages[stage] = { status: 'review', since: now() };
+  });
+}
+
+/** The stages before `stage` that the user has not approved. */
+export const earlierOpen = (p, stage) => STAGES.slice(0, STAGES.indexOf(stage)).filter((s) => p.stages[s].status !== 'approved');
+
+/** Events the agent hasn't read; marks them read when `mark`. */
+export function unseen(dir, { mark = true } = {}) {
+  let out = [];
+  const p = updatePiece(dir, (q) => { out = q.events.filter((e) => e.n > (q.seen ?? 0)); if (mark && out.length) q.seen = out.at(-1).n; });
+  return { piece: p, events: out };
+}
+
+// an event that ends the agent's wait: a decision on the stage under review, or a change asked anywhere
+const decisive = (e, stage) => (e.kind === 'approve' && e.stage === stage && !e.part) || e.kind === 'changes' || e.kind === 'reopen' || e.rejoin || e.refinal;
+
+/**
+ * Waits until the user decides on `stage` in the studio (approves it, or asks for changes), then returns every
+ * event since the agent last looked, as lines. Edits the studio already applied (texts, seconds, order) come along.
+ */
+export async function awaitDecision(dir, stage, { timeout = 30 * 60 * 1000, every = 1000, signal } = {}) {
+  const t0 = Date.now();
+  let last = 0;
+  try {
+    for (;;) {
+      if (Date.now() - last > 3000) { beat(dir, { waiting: stage }); last = Date.now(); }   // the studio shows "your agent is listening"
+      const p = readPiece(dir);
+      const fresh = p.events.filter((e) => e.n > (p.seen ?? 0));
+      if (fresh.some((e) => decisive(e, stage))) {
+        const r = unseen(dir);
+        return { done: true, piece: r.piece, events: r.events, lines: r.events.map((e) => eventLine(r.piece, e)) };
+      }
+      if (Date.now() - t0 > timeout || signal?.aborted) return { done: false, piece: p, events: fresh, lines: fresh.map((e) => eventLine(p, e)) };
+      await new Promise((res) => setTimeout(res, every));
+    }
+  } finally { unbeat(dir); }
+}
+
+// ── the agent's side of the conversation: is it listening, what did it ask, where does it live ────────────────
+// While a command waits for the user (piece review, board), it says so every few seconds in a small file beside
+// piece.json (piece.json itself stays quiet). No fresh beat means nobody reads what the user does in the studio.
+const beatFile = (dir) => path.join(dir, '.agent.json');
+export function beat(dir, info = {}) { try { fs.writeFileSync(beatFile(dir), JSON.stringify({ at: Date.now(), pid: process.pid, ...info })); } catch { /* a read-only project: the studio just won't know */ } }
+export function unbeat(dir) { try { if (JSON.parse(fs.readFileSync(beatFile(dir), 'utf8')).pid === process.pid) fs.rmSync(beatFile(dir)); } catch { /* already gone */ } }
+/** The command waiting on this piece right now, if any. */
+export function listening(dir, within = 9000) { try { const a = JSON.parse(fs.readFileSync(beatFile(dir), 'utf8')); return Date.now() - a.at < within ? a : null; } catch { return null; } }
+
+/** The agent asked the user something in the chat: the studio says so until the agent moves on. */
+export function setAsk(dir, text) { return updatePiece(dir, (p) => { p.ask = { text: String(text ?? '').trim(), at: now() }; }); }
+export function clearAsk(dir) { const p = readPiece(dir); return p?.ask ? updatePiece(dir, (q) => { delete q.ask; }) : p; }
+/** Where the agent runs (see host.mjs), kept so the studio can take the user back there. */
+export function setHost(dir, host) {
+  const p = readPiece(dir);
+  if (!p || !host || JSON.stringify(p.agent ?? null) === JSON.stringify(host)) return p;
+  return updatePiece(dir, (q) => { q.agent = host; });
+}
+
+// ── the words on screen: a scene's top-level string CONFIG entries ──────────────────────────
+const CONFIG_STRING = /^ {2}(\w+): '((?:[^'\\]|\\.)*)',?\s*(\/\/.*)?$/;
+const SKIP = new Set(['background', 'image', 'svg', 'font', 'fontFamily']);
+
+/** The editable texts of a scene: top-level CONFIG strings (not ids or file paths). */
+export function sceneTexts(html) {
+  const start = html.indexOf('const CONFIG = {'), end = html.indexOf('\n};', start);
+  if (start < 0 || end < 0) return {};
+  const out = {};
+  for (const line of html.slice(start, end).split('\n')) {
+    const m = line.match(CONFIG_STRING);
+    if (m && !SKIP.has(m[1]) && !/\.(png|jpe?g|webp|svg|mp4|webm)$/.test(m[2])) out[m[1]] = m[2].replace(/\\(.)/g, '$1');
+  }
+  return out;
+}
+
+/** Rewrites one top-level CONFIG string in a scene. */
+export function setSceneText(html, key, value) {
+  const start = html.indexOf('const CONFIG = {'), end = html.indexOf('\n};', start);
+  const head = html.slice(0, start), body = html.slice(start, end), tail = html.slice(end);
+  const lit = `'${String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+  let hit = false;
+  const next = body.split('\n').map((line) => {
+    const m = line.match(CONFIG_STRING);
+    if (!m || m[1] !== key) return line;
+    hit = true;
+    return `  ${key}: ${lit},${m[3] ? ` ${m[3]}` : ''}`;
+  }).join('\n');
+  if (!hit) throw new Error(`CONFIG has no text "${key}"`);
+  return head + next + tail;
+}
+
+// ── boards: the decisions taken on paper-motion.app, listed in the studio so the user finds them there too ──────
+const BOARD_STAGE = () => 'video';
+
+/** The piece a board belongs to: the one named, else the only one in progress before Parts. */
+export function activePiece(cwd, name) {
+  if (name) { const dir = pieceDir(name, cwd); return readPiece(dir) ? dir : null; }
+  const root = path.join(cwd, 'pieces');
+  if (!fs.existsSync(root)) return null;
+  const live = fs.readdirSync(root).map((d) => path.join(root, d)).filter((d) => { const p = readPiece(d); return p && ['brief', 'inventory', 'video'].includes(p.stage); });
+  return live.length === 1 ? live[0] : null;
+}
+
+/** Records a board shared for this piece (shown in the studio's Look or Structure stage until chosen). */
+export function attachBoard(dir, { url, id, title, kind }) {
+  return updatePiece(dir, (p) => {
+    p.boards ??= [];
+    if (id && p.boards.some((b) => b.id === id)) return;
+    p.boards.push({ url, id: id ?? null, title, kind, stage: BOARD_STAGE(p.stage), at: now(), status: 'waiting' });
+  });
+}
+
+/** Marks a board chosen with the reply line. */
+export function markBoard(dir, id, line) {
+  return updatePiece(dir, (p) => { const b = (p.boards ?? []).find((x) => x.id === id); if (b) { b.status = 'chosen'; b.line = line; } });
+}

package/lib/registry.mjs

@@ -110,21 +110,31 @@ export function llmsTxt(items, site, { full = false } = {}) {
 ## The flow (for agents)
 
 1. **Set up.** \`npx skills add solanodz/paper-motion\` (the skills) and \`npx paper-motion setup\` (the engine: Node 18+,
-   ffmpeg, Chrome). The CLI is \`npx paper-motion\` (short: \`pamo\`). Every command answers \`--help\`. Agents load
+   ffmpeg, Chrome). The CLI is \`npx paper-motion\`; where these docs write \`pamo\`, type \`npx paper-motion\` (the npm package named \`pamo\` is unrelated). \`npx paper-motion --version\` prints the version. Every command answers \`--help\`. Agents load
    skills and MCP servers when a session starts, so after installing the skills **read
    \`.claude/skills/make-video/SKILL.md\` now** (or \`.agents/skills/make-video/SKILL.md\`) and follow it in this
    session; tell the user that the MCP at ${site}/mcp, if they want it, is added before opening a session.
-2. **Interview.** Follow the \`make-video\` skill. Without the skills, ask at least: what the brand is in one plain
+2. **Open the studio: it is where the user decides.** A video is made in stages the user watches and approves in
+   a local page in three steps (What it says: brief and inventory; Your video; Export). Start the piece right after setup:
+   \`npx paper-motion piece init <piece> --title "…"\` (it starts the project's studio in the background). Then,
+   at the end of each stage, \`npx paper-motion piece review <piece> <stage>\`: the first time it opens the studio in
+   the user's browser; it waits for their decision and prints what they did, one \`paper-motion: piece …\` line each
+   (an approval, a change to make, or an edit they already made by hand: the brief, words on screen, lengths, joins,
+   order; build on those, never undo them). Quick renders for review: \`chain <piece> --drafts\` (each part on its
+   own) and \`chain <piece> --draft\` (joined). Only when the user can't open a browser, run the same stages in the
+   chat.
+3. **Interview.** Follow the \`make-video\` skill. Without the skills, ask at least: what the brand is in one plain
    line; what this video is for and where it plays (format: 16:9, 9:16, 1:1); its ground, text and accent colors or
    "no brand yet"; three words for the feel and one thing it must never look like; the one action at the end.
-   Mirror it back before proposing anything. **You never choose a look for the user.** These decisions always go
+   Mirror it back, write it into the brief (\`piece init --what … --who … --format … --tone … --action …\`) and
+   \`piece review <piece> brief\`. **You never choose a look for the user.** These decisions always go
    through a board, in this order, one board each: palette · font pair · background(s) · moves by role (how things
    enter, how one thing becomes the next, how text arrives; let them pick several with \`choose\`) · recipe or shots
    (shots are 3–6 s camera gestures: a close-up, a pass over a component, a cursor that clicks; they chain before a
    recipe or stand alone) · blocks for the moments inside it (ready-made 4–8 s pieces: annotations on a screen, a
    form, a terminal, code typing, a chart, captions, a logo sting; each recomposes for 16:9, 9:16 and 1:1). Skip a
    board only when the brand folder already settles that decision, and say so.
-3. **Propose with boards.** For each visual decision (palette, type, background, moves, recipe) pick 2–4 options from
+4. **Propose with boards.** For each visual decision (palette, type, background, moves, recipe) pick 2–4 options from
    this registry and share a board link: \`pamo board --url --title … --option id … --look palette,font\` prints it
    (format below): a short link (\`${site}/b/<id>\`, stored for 90 days) when the site answers, the long form
    with the board in the URL fragment otherwise. The user opens it, sees the options live in their look, may tune one,
@@ -134,16 +144,29 @@ export function llmsTxt(items, site, { full = false } = {}) {
    (\`--choose 1-3\`: use it for text effects and transitions), or \`paper-motion: none of bg-1, calmer ones\`. The
    reply carries every value that differs from the defaults, your pre-tuning included, so installing it reproduces what
    they saw. Never ask the user to paste anything while a command or the MCP is waiting: the choice arrives on its own.
-4. **Install the choices.** \`npx paper-motion add <id> [--set key=value …]\` in the project root, with exactly the
+5. **Install the choices.** \`npx paper-motion add <id> [--set key=value …]\` in the project root, with exactly the
    \`--set\` arguments from the reply. Moves go to \`moves/\`, backgrounds to \`brand/shader-set/set.json\`, palettes and
    fonts to \`brand/tokens.json\`, recipes to \`pieces/<id>/\`. Their choices also accumulate in a kit at ${site}/kit,
    whose prompt carries the whole \`pamo add\` command. \`add\` never overwrites a value already in the project: when
    the user re-chooses or re-tunes something you installed before, pass \`--force\`. A recipe also reads
    \`brand/motion.json\` (pace) and \`brand/sound.json\` (cues; without it the piece is silent) and the brand's name
    from \`tokens.json\` \`brand\`: write those from the interview before rendering.
-5. **Make the video.** Every move the user chose appears in the piece, and the brief says where each one plays;
+6. **Make the video.** Every move the user chose appears in the piece, and the brief says where each one plays
+   (a chosen transition may be the join between two parts of a chain: \`"join": "wipe"\` in chain.json takes its id);
    a recipe's own moves are placeholders to swap for theirs. Build \`scene.html\` (a pure function of time), check stills with \`pamo still\`, render with
    \`pamo render scene.html --motion-blur 5\`. The test shot and the final piece are real renders, not boards.
+   When the user chose a structure whose beats name blocks or shots (or several blocks in order), chain them instead:
+   \`npx paper-motion chain init <piece> --board <id> --option D\` installs each beat's block under
+   \`pieces/<piece>/<nn>-<id>/\` and writes \`chain.json\` (seconds per part; \`join\`: whip, cut, dissolve or dip);
+   write each part's \`CONFIG\` from its beat, then \`npx paper-motion chain <piece> --motion-blur 5\` renders every
+   part in the brand's look and joins them into one video. It warns when a part is cut before its land.
+   In the studio the stages are brief, inventory, video and final. When the user approves the inventory the studio
+   builds the video itself from what they kept, and then they edit it there, live (words, how each part arrives,
+   backgrounds, settings, lengths, transitions, order, adding and swapping parts, colours, type, pace); every edit
+   reaches you as a line. Review \`video\` to wait for their approval; they can render the final from the studio. \`chain --check\` warns when the total drifts from the brief's
+   length. Boards you share while a piece is open also appear in its studio (Look or Structure), so the user finds them
+   there; if your shell caps how long a command may run, share with \`--no-wait\` and then
+   \`npx paper-motion board --await <id> --wait 2\` until it prints the line (exit code 3 = not yet).
 
 ## Choosing well: the metadata
 
@@ -152,6 +175,16 @@ ${site}/registry.json is the index; every item carries, beside id, type, title,
 - \`when\`: 2–3 "use it when…" phrases.
 - \`mood\`: calm, bold, playful, technical, editorial, warm, minimal, luxury, raw.
 - Moves: \`energy\` 1 (still) to 5 (violent) and \`role\` (enter, exit, swap, emphasis, camera, text).
+- Blocks and shots: \`needs\`, the content each one shows by kind (a \`figure\`, a \`change\`, a \`screen\`, a \`command\`, a
+  \`line\`…). Choose them by what the user has to show, not by mood. Gather \`pieces/<piece>/inventory.json\` with
+  \`npx paper-motion inventory <piece> --from <their site> --from README.md --from brand\` (it reads the page and
+  screenshots it, a markdown file, a folder, or the brand's Facts and assets, and writes proposals, each with its
+  source; \`npx paper-motion inventory kinds\` lists the kinds and their fields). Complete what a proposal still
+  needs (a command's real output), add what gathering cannot see, and hand it over:
+  \`npx paper-motion piece review <piece> inventory\`. The user keeps or removes each proposal in the studio; only
+  what they kept is used. Then let \`npx paper-motion plan <piece> --seconds <n>\` propose
+  the structures: it prints the structure board to share, and \`chain init <piece> --plan <letter>\` installs the
+  chosen one with the content already in every part's CONFIG.
 - Backgrounds and palettes: \`colors\` (dominant hex) and \`mode\` (light, dark); backgrounds also \`motion\` (still, gentle, lively).
   **Every background is a color family**: a board with a \`look.palette\` shows each background recolored into that
   palette (each of its colors keeps its tone and takes the nearest palette hue, so a dark one stays dark), and the
@@ -161,7 +194,8 @@ ${site}/registry.json is the index; every item carries, beside id, type, title,
 - Font pairs: \`voice\` (serif, sans, display, mono). Recipes, shots and blocks: \`duration\`, \`formats\` and \`beats\` (the structure as a
   timeline: name, from, to, what). A recipe board plays each structure as a sketch, so the user chooses a rhythm, not a
   name; you may add one option that is a **structure of your own** for this brief (\`structure\` instead of \`id\`,
-  format below), which you then build from scratch. Give the recipe board \`choose: [1, 3]\`: picking several recipes in
+  format below), which you then build from scratch. Give each of its beats the \`id\` of the block or shot that shows
+  it: the board then plays those clips in order, so the user watches the structure instead of reading it. Give the recipe board \`choose: [1, 3]\`: picking several recipes in
   order means **one piece made of those blocks in that order**, each block's closing beat dropped except the last; the
   reply reads \`A+C · manifesto · three-things\`, and you build that sequence from scratch, using each recipe's scene as
   the reference for its block.
@@ -203,9 +237,9 @@ A recipe board may hold one option that is a structure of your own for this brie
 
 \`\`\`json
 { "label": "D", "structure": { "title": "Three cuts", "duration": 18, "beats": [
-    { "name": "Hook", "from": 0, "to": 2, "what": "one line over the field" },
-    { "name": "Proof", "from": 2, "to": 12, "what": "three shots of the product" },
-    { "name": "Close", "from": 12, "to": 18, "what": "the wordmark and the action" } ] } }
+    { "name": "Hook", "from": 0, "to": 2, "what": "one line over the field", "id": "word-swap" },
+    { "name": "Proof", "from": 2, "to": 12, "what": "three shots of the product", "id": "browser-frame" },
+    { "name": "Close", "from": 12, "to": 18, "what": "the wordmark and the action", "id": "svg-logo" } ] } }
 \`\`\`
 
 Short links: \`POST ${site}/api/boards\` with \`{ "board": … }\` returns \`{ id, url }\`; \`GET /api/boards/<id>/choice\`
@@ -261,7 +295,7 @@ export function build({ dir = resolveRegistry().dir, out, site = SITE } = {}) {
   for (const it of items) if (it.preview) { const have = Object.fromEntries(Object.entries(it.preview).filter(([, p]) => typeof p !== 'string' || fs.existsSync(path.join(out, p)))); it.preview = Object.values(have).some((p) => typeof p === 'string') ? have : undefined; }
   const index = {
     name: 'paper-motion', site, schema: `${site}/schema.json`, count: items.length, types: TYPES.filter((t) => items.some((i) => i.type === t)),
-    items: items.map(({ id, type, title, summary, tags, version, preview, related, when, mood, energy, role, colors, mode, motion, voice, duration, formats, beats, params }) => ({ id, type, title, summary, tags, version, url: `${site}/r/${id}.json`, ...Object.fromEntries(Object.entries({ when, mood, energy, role, colors, mode, motion, voice, duration, formats, beats, preview, related, params: params?.filter((p) => !p.hidden).map((p) => p.name) }).filter(([, v]) => v !== undefined)) })),
+    items: items.map(({ id, type, title, summary, tags, version, preview, related, when, mood, energy, role, colors, mode, motion, voice, duration, formats, beats, needs, repeat, params }) => ({ id, type, title, summary, tags, version, url: `${site}/r/${id}.json`, ...Object.fromEntries(Object.entries({ when, mood, energy, role, colors, mode, motion, voice, duration, formats, beats, needs, repeat, preview, related, params: params?.filter((p) => !p.hidden).map((p) => p.name) }).filter(([, v]) => v !== undefined)) })),
   };
   fs.writeFileSync(path.join(out, 'registry.json'), JSON.stringify(index, null, 2));
   fs.mkdirSync(path.join(out, 'files'), { recursive: true });