footprint-storydeck 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.8.1 — footprint-narration is now footprint-story
+
+- **footprint-narration is now footprint-story.** StoryDeck's shared narration code (shown-vs-spoken text, captions,
+  chapters, the voice cache) comes from `footprint-story` 0.3.0, the same package under its new name: what StoryDeck
+  and footprint-storyreel share, now with a `/motion` door too. Nothing a deck says, shows or voices changes. A project
+  that imports `footprint-narration` itself beside StoryDeck should move to `footprint-story` (the two doors export
+  exactly what they did).
+
+## 0.8.0 — a part can have its own look (data-theme)
+
+- **A part can have its own look: `data-theme`.** `<section … data-theme="ledger">` in clicks.html puts
+  `data-theme="ledger"` on each slide of that part (plain or on a map), so a deck's theme.css can give one part its own
+  tokens and pieces — a talk in several parts, each dressed for its subject. A theme is one lower-case name (letters,
+  digits, dashes; 40 at most), refused otherwise with the part's name. A part without one is drawn byte for byte as
+  before.
+  The title and closing slides are parts, so they can have a look of their own. `check` warns (`theme-unstyled`) when a
+  part asks for a theme that theme.css never selects, and `review` ends a click's first line with its theme. The README
+  shows how the page around the slide follows the part on screen (`:root:has([data-deck-active][data-theme=…])`).
+
 ## 0.7.0 — a deck from a folder, an editing loop, co-editing and wire motion
 
 - **A packet rides its wire's curve, and a wire shows itself in.** On a `path` click, a `pkt` packet now follows the

package/README.md

@@ -240,7 +240,7 @@ through it the same way.
 A talk lives on after the room: someone opens the deck alone, or it becomes a video. The words were in the
 speaker notes all along, so narration is data on each click, and the library turns it into speech, captions and
 timing — the same words, three uses. The rules underneath — what a voice says for a number or a symbol, the clip
-cache, the captions and YouTube's chapter rule — are [footprint-narration](https://github.com/footprintjs/footprint-narration)'s,
+cache, the captions and YouTube's chapter rule — are [footprint-story](https://github.com/footprintjs/footprint-story)'s,
 shared with footprint-storyreel; StoryDeck adds what is the deck's own:
 
 - **what the voice says** — `narrationText(notes)`: the notes as a voice reads them. An acronym stays as written
@@ -249,7 +249,7 @@ shared with footprint-storyreel; StoryDeck adds what is the deck's own:
   another script its reading), numbers become words, a lone symbol that means something is said (`SAY`: & + = < > ×
   % and Greek letters), any other word without a letter is a pause that keeps its sentence end (a forced aligner
   needs letters in every word), and a line after `[draft]` (a bridge you wrote for the deck) is said, and shown apart;
-- **a clip per click, cached by what it says** — `footprint-narration/voice` (Node). A clip's key is a hash of the
+- **a clip per click, cached by what it says** — `footprint-story/voice` (Node). A clip's key is a hash of the
   voice settings and the exact words, so editing one note re-voices that click and nothing else, and an interrupted
   run keeps every batch it finished. The voice is a port (`{ name, synthesize(scenes, { work }) }`); `chatterboxKit`
   is one adapter — a local voice kit (Chatterbox, words aligned with MMS_FA; nothing is uploaded). `footprint-storydeck/voice`
@@ -259,7 +259,7 @@ shared with footprint-storyreel; StoryDeck adds what is the deck's own:
   the browser's where a click has none — captions lighting sentence by sentence (styles: `footprint-storydeck/narration.css`).
 
 ```js
-import { voiceClips, chatterboxKit } from 'footprint-narration/voice';
+import { voiceClips, chatterboxKit } from 'footprint-story/voice';
 import { narrationText } from 'footprint-storydeck/narration';
 import { embedClips } from 'footprint-storydeck/voice';
 import { notesData, notesRuntime, listenRuntime } from 'footprint-storydeck/narration-html';
@@ -290,7 +290,7 @@ would drop one entrance frame in six at 30 fps, and a test with the real ffmpeg
 ```js
 import { chromium } from 'playwright-core';
 import { renderVideo, deckStageDriver } from 'footprint-storydeck/video';
-import { clipFor } from 'footprint-narration/voice';
+import { clipFor } from 'footprint-story/voice';
 import { narrationText, writtenText } from 'footprint-storydeck/narration';
 
 const steps = clicks.map(c => {
@@ -399,10 +399,20 @@ npx footprint-storydeck build my-talk     # my-talk/index.html — one page, eve
   ticks the line (`- [x]`). Pointing costs the person a second and the agent no screenshot. Each note is signed with a
   key kept with you (`~/.storydeck/key`) for that deck's folder, so a feedback.md that came with someone else's deck is
   never read as your requests: its lines are counted, never listed.
+- **A part can have its own look.** `<section data-label="3 · Storage" … data-theme="ledger">` puts
+  `data-theme="ledger"` on each of that part's slides, so `theme.css` can dress it: redefine the tokens for it
+  (`[data-theme="ledger"] { --bg: …; --text: …; }`, and `:root.dark [data-theme="ledger"]` for dark) and give its pieces
+  their own style. Tokens inherit, so the chrome, the focus and every piece of that part follow. A theme is one
+  lower-case name (letters, digits and dashes); a part without one is drawn as before, byte for byte. The title and the
+  closing slide are parts too, so they can have their own look. To have the page around the slide (the letterbox)
+  follow the part on screen as well, select the active slide in the same rule:
+  `[data-theme="ledger"], :root:has([data-deck-active][data-theme="ledger"]) { … }`. `check` warns about a theme
+  that theme.css never selects (a misspelt name changes nothing), and `review` names each click's theme.
 - **Read first, look last.** A reviewer — a person, or a model that pays for every screenshot — reads the deck as text:
   `outline` (a line per click), `review --click 14` (its headline and words, what it lights, greys, brings in and moves,
   its route, its notes), `check` (what to fix, each with its click and its fix: a headline over 12 words, pieces that
-  light just by coming in, a click that changes nothing, a piece never shown, clicks without notes). `check --layout`
+  light just by coming in, a click that changes nothing, a piece never shown, clicks without notes, a theme theme.css
+  never styles). `check --layout`
   opens the page in a browser, offline, and finds text that spills out of its box (it needs Playwright installed beside
   StoryDeck: `npm i -D footprint-storydeck playwright-core`; without it, it says so and the other checks run). `mcp` serves the same tools to an AI assistant:
   `claude mcp add storydeck -- npx footprint-storydeck mcp my-talk`.
@@ -537,9 +547,9 @@ const { theme, toggle, setTheme } = useTheme();   // flips an html class + persi
 | `planFocus` · `focusStep` · `readFocus` · `FOCUS` | focus: per click, what it is about and what happens to the rest (also `footprint-storydeck/focus`) |
 | `readPieces` · `readStep` · `drawFocus` · `wrapStage` · `slideClass` · `focusOverlay` · `focusRuntime` | focus, written into slide HTML (also `footprint-storydeck/focus-html`; styles in `footprint-storydeck/focus.css`) |
 | `idleTour` · `tourPlan` · `tourText` | tour: a deck (or a figure) that shows its point while nobody is using it, and its plan in data and in one line (also `footprint-storydeck/tour`) |
-| `narrationText` · `writtenText` | narration: what a click says (also `footprint-storydeck/narration`); the rules beneath, sentences, captions and chapters are `footprint-narration`'s |
+| `narrationText` · `writtenText` | narration: what a click says (also `footprint-storydeck/narration`); the rules beneath, sentences, captions and chapters are `footprint-story`'s |
 | `notesData` · `notesRuntime` · `listenRuntime` | narration in the page: notes, presenter window, listen mode (also `footprint-storydeck/narration-html`; styles in `footprint-storydeck/narration.css`) |
-| `embedClips` | `footprint-storydeck/voice` (Node only): a deck's clips inside one page; the clip cache, the voice port and its local-kit adapter are `footprint-narration/voice`'s |
+| `embedClips` | `footprint-storydeck/voice` (Node only): a deck's clips inside one page; the clip cache, the voice port and its local-kit adapter are `footprint-story/voice`'s |
 | `renderVideo` · `planVideo` · `deckStageDriver` · `ffmpegMajor` | `footprint-storydeck/video` (Node only, ffmpeg 5.0+): the deck as a narrated video, with captions and chapters |
 | `exportPptx` · `pptxParts` · `zip` · `unzip` · `checkPptx` | `footprint-storydeck/pptx` (Node only): the deck as a PowerPoint file — a slide per click, its picture, notes and clip — through a footprintjs flowchart that records why |
 | `loadDeck` · `buildDeck` · `serveDeck` · `outline` · `reviewClick` · `checkDeck` · `layoutCheck` · `initDeck` · `serveMcp` · `runCli` | `footprint-storydeck/deck` (Node only): a deck folder made into one page, served for editing, read back as text — the `storydeck` command (also `npx footprint-storydeck`); its page's base styles are `footprint-storydeck/deck.css` |

package/dist/deck/check.js

@@ -43,6 +43,16 @@ function missingNotes(compiled) {
   if (!without.length || without.length * 2 > compiled.clicks.length) return [];
   return [problem("info", "no-notes", null, `click${without.length === 1 ? "" : "s"} ${without.map((c) => c.n).join(", ")} ha${without.length === 1 ? "s" : "ve"} no notes \u2014 the presenter view shows nothing there and listen mode skips ${without.length === 1 ? "it" : "them"}`)];
 }
+function unstyledThemes(compiled) {
+  const out = [], seen = /* @__PURE__ */ new Set();
+  for (const c of compiled.clicks) {
+    if (!c.theme || seen.has(c.theme)) continue;
+    seen.add(c.theme);
+    const selects = new RegExp(`\\[\\s*data-theme\\s*[~|^$*]?=\\s*(["']?)${c.theme}\\1\\s*(?:[is]\\s*)?\\]`).test(compiled.themeCss ?? "");
+    if (!selects) out.push(problem("warn", "theme-unstyled", c, `part "${c.part}" asks for data-theme="${c.theme}", which theme.css never selects \u2014 fix the name, or give it its tokens there ([data-theme="${c.theme}"] { --bg: \u2026; })`));
+  }
+  return out;
+}
 function checkDeck(compiled) {
   const out = [];
   compiled.clicks.forEach((c, i) => {
@@ -50,7 +60,7 @@ function checkDeck(compiled) {
     if (c.kind === "map") out.push(...litOnEntry(c, compiled.maps[c.map].pieces));
     out.push(...noChange(c, compiled.clicks[i - 1]));
   });
-  out.push(...neverShown(compiled), ...missingNotes(compiled));
+  out.push(...neverShown(compiled), ...missingNotes(compiled), ...unstyledThemes(compiled));
   return out;
 }
 const failure = (error) => [problem("error", "compile", null, error.message)];

package/dist/deck/compile.js

@@ -73,7 +73,7 @@ function planClicks(parts, maps, { area, canvas, icons }) {
 const head = (kicker, headline) => `<div class="head" data-chrome><div class="kicker">${esc(kicker)}</div>${headline ? `<h2>${headline}</h2>` : ""}</div>`;
 const foot = (footer, n, total) => `<div class="foot" data-chrome><span>${esc(footer)}</span><span class="count">${n} / ${total}</span></div>`;
 function drawClick(c, i, total, { footer, area, canvas }) {
-  const open = `<section data-label="${esc(c.label)}"`;
+  const open = `<section data-label="${esc(c.label)}"${c.part.theme ? ` data-theme="${esc(c.part.theme)}"` : ""}`;
   if (c.kind === "plain") return `${open} class="slide plain">${head(c.part.kicker, "")}${c.inner}${foot(footer, i + 1, total)}</section>`;
   return `${open} class="slide on-map ${slideClass(c.look)}">${head(c.part.kicker, c.headline)}<div class="map map-${c.map.name}">${wrapStage(drawFocus(c.map.html, c.look), c.look)}</div>${focusOverlay(c.look, { area, canvas: { w: canvas[0], h: canvas[1] } })}${foot(footer, i + 1, total)}</section>`;
 }
@@ -108,6 +108,7 @@ function compileDeck(source, { dev = false } = {}) {
     label: c.label,
     part: c.part.label,
     kicker: c.part.kicker,
+    theme: c.part.theme ?? null,
     kind: c.kind,
     map: c.kind === "map" ? c.map.name : null,
     headline: plainText(c.headline),

package/dist/deck/init.js

@@ -24,6 +24,7 @@ const MAP = `<!--
 const CLICKS = `<!--
   The deck, click by click.
   <section data-label="\u2026" data-kicker="\u2026">          one part of the story; without data-map it is one plain slide
+  <section \u2026 data-theme="ledger">                   optional: its slides carry data-theme, so theme.css can dress that part
   <section \u2026 data-map="map">                        a part told on map.html: every <step> inside is ONE click
     <step data-in="\u2026" data-out="\u2026" data-on="\u2026" data-focus="\u2026">
       data-in    pieces that come in (they stay)     data-out   pieces that leave

package/dist/deck/parse.js

@@ -84,6 +84,13 @@ function takeNotes(html) {
 }
 const without = (html, ranges) => ranges.reduceRight((out, r) => out.slice(0, r.start) + out.slice(r.end), html);
 const where = (label) => `"${label}"`;
+const THEME = /^[a-z][a-z0-9-]{0,39}$/;
+function themeOf(label, attrs) {
+  const theme = attrOf(attrs, "data-theme");
+  if (theme === null) return null;
+  if (!THEME.test(theme)) throw new Error(`${where(label)}: data-theme="${theme}" \u2014 a theme is one lower-case name (letters, digits and dashes, at most 40), such as "ledger"`);
+  return theme;
+}
 function readMapStep(label, k, attrs, inner) {
   const { html, notes } = takeNotes(inner);
   let heads;
@@ -113,10 +120,11 @@ function parseClicks(html) {
     seen.add(label);
     const kicker = attrOf(attrs, "data-kicker") ?? "";
     const map = attrOf(attrs, "data-map");
+    const theme = themeOf(label, attrs);
     if (map === null) {
       if (/<step\b/i.test(body)) throw new Error(`${where(label)} has <step> clicks but no data-map \u2014 name the map they are told on (data-map="map")`);
       const { html: inner, notes } = takeNotes(body);
-      parts.push({ label, kicker, map: null, body: inner, notes });
+      parts.push({ label, kicker, theme, map: null, body: inner, notes });
       continue;
     }
     if (!map.trim()) throw new Error(`${where(label)}: data-map is empty \u2014 name a map (a file in the deck, e.g. data-map="map")`);
@@ -129,7 +137,7 @@ function parseClicks(html) {
     if (!steps.length) throw new Error(`${where(label)} is told on map "${map}" but has no <step> \u2014 a map part is one click per <step>`);
     const outside = plainText(takeNotes(without(body, steps)).html);
     if (outside) throw new Error(`${where(label)}: "${outside.slice(0, 60)}" is outside every <step> \u2014 put a headline or notes inside the step they belong to`);
-    parts.push({ label, kicker, map: map.trim(), steps: steps.map(({ attrs: a, inner }, k) => readMapStep(label, k, a, inner)) });
+    parts.push({ label, kicker, theme, map: map.trim(), steps: steps.map(({ attrs: a, inner }, k) => readMapStep(label, k, a, inner)) });
   }
   if (!parts.length) throw new Error('the clicks file has no <section> \u2014 a deck is one <section data-label="\u2026"> per part');
   return parts;

package/dist/deck/review.js

@@ -2,6 +2,7 @@ import { wordCount } from "./parse.js";
 const nameOf = (pieces, i) => pieces[i].keys[0];
 const unique = (names) => [...new Set(names)];
 const list = (names, max = 14) => names.length ? `${names.slice(0, max).join(", ")}${names.length > max ? `, \u2026 (${names.length - max} more)` : ""}` : "\u2014";
+const themed = (c) => c.theme ? ` \xB7 theme ${c.theme}` : "";
 const quote = (s, max = 160) => s.length > max ? `"${s.slice(0, max - 1)}\u2026"` : `"${s}"`;
 function pieceGroups(click, pieces) {
   const by = (pred) => unique(click.look.pieces.map((p, i) => pred(p) ? nameOf(pieces, i) : null).filter(Boolean));
@@ -56,10 +57,10 @@ function reviewClick(compiled, which, { maxWords = compiled.config?.checks?.maxW
   const lines = [];
   const words = (n) => `${n} word${n === 1 ? "" : "s"}`;
   if (c.kind === "plain") {
-    lines.push(`click ${c.n} of ${compiled.clicks.length} \xB7 "${c.label}" (plain slide)`);
+    lines.push(`click ${c.n} of ${compiled.clicks.length} \xB7 "${c.label}" (plain slide)${themed(c)}`);
     lines.push(`text (${words(wordCount(c.text))}): ${quote(c.text, 300)}`);
   } else {
-    lines.push(`click ${c.n} of ${compiled.clicks.length} \xB7 "${c.label}" (map "${c.map}", step ${c.stepIndex + 1} of ${c.steps})`);
+    lines.push(`click ${c.n} of ${compiled.clicks.length} \xB7 "${c.label}" (map "${c.map}", step ${c.stepIndex + 1} of ${c.steps})${themed(c)}`);
     const hw = wordCount(c.headline);
     lines.push(`headline: ${c.headline ? `${quote(c.headline)} (${words(hw)}${hw > maxWords ? `, over ${maxWords}` : ""})` : "\u2014"}`);
     const pieces = compiled.maps[c.map].pieces;

package/dist/narration.js

@@ -1,4 +1,4 @@
-import { spokenMap, autoRules } from "footprint-narration";
+import { spokenMap, autoRules } from "footprint-story";
 const AUTO = autoRules();
 const writtenText = (notes) => (Array.isArray(notes) ? notes : [notes ?? ""]).join(" ").replace(/\[draft\]\s*/g, "").replace(/\s+/g, " ").trim();
 function narrationText(notes, { spell, say } = {}) {

package/dist/pptx.js

@@ -2,7 +2,7 @@ import { Buffer } from "node:buffer";
 import { closeSync, copyFileSync, existsSync, fstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
-import { clipFor } from "footprint-narration/voice";
+import { clipFor } from "footprint-story/voice";
 import { narrationText, writtenText } from "./narration.js";
 import { planVideo } from "./video.js";
 import { pptxParts, pngSize, plainText, isSound, AUDIO, LANG_TAG, SOUND } from "./pptxParts.js";
@@ -49,13 +49,13 @@ function headOf(file) {
 }
 function soundProblem(clip, ext) {
   const { size, head } = headOf(clip.audio);
-  if (!size) return `its clip ${clip.audio} is empty (0 bytes) \u2014 voice it again (footprint-narration/voice \xB7 voiceClips)`;
+  if (!size) return `its clip ${clip.audio} is empty (0 bytes) \u2014 voice it again (footprint-story/voice \xB7 voiceClips)`;
   return isSound(head, ext) ? null : `its clip ${clip.audio} is not a .${ext} file (no ${SOUND[ext].sign}) \u2014 voice it again, or convert it with ffmpeg`;
 }
 function clipProblem(c, { voiced, maxClip }) {
   const clip = c.clip, d = clip?.duration, ext = extOf(clip?.audio);
-  if (!clip) return voiced && c.spoken.trim() ? ["unvoiced", "it says words but has no clip \u2014 voice it (footprint-narration/voice \xB7 voiceClips), or give its step its clip"] : null;
-  if (!clip.audio || !existsSync(clip.audio)) return ["missing", `its clip ${clip.audio} is not there \u2014 voice it again (footprint-narration/voice \xB7 voiceClips)`];
+  if (!clip) return voiced && c.spoken.trim() ? ["unvoiced", "it says words but has no clip \u2014 voice it (footprint-story/voice \xB7 voiceClips), or give its step its clip"] : null;
+  if (!clip.audio || !existsSync(clip.audio)) return ["missing", `its clip ${clip.audio} is not there \u2014 voice it again (footprint-story/voice \xB7 voiceClips)`];
   if (!AUDIO[ext]) return ["unplayable", `its clip is .${ext} \u2014 PowerPoint plays .wav, .m4a and .mp3 (convert it with ffmpeg)`];
   const bytes = soundProblem(clip, ext);
   if (bytes) return ["unplayable", bytes];

package/dist/video.js

@@ -2,7 +2,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
-import { captionCues, captionFile, readCaptions, youtubeChapters } from "footprint-narration";
+import { captionCues, captionFile, readCaptions, youtubeChapters } from "footprint-story";
 const NUM = (n) => String(n).padStart(3, "0");
 const entry = (file) => `file '${path.resolve(file).replace(/'/g, "'\\''")}'`;
 const failure = (done) => done?.error ? done.error.message : done?.signal ? `signal ${done.signal}` : done?.status !== 0 ? `exit ${done?.status}` : null;

package/dist/voice.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import path from "node:path";
-import { clipFor } from "footprint-narration/voice";
+import { clipFor } from "footprint-story/voice";
 const failure = (done) => done?.error ? done.error.message : done?.signal ? `signal ${done.signal}` : done?.status !== 0 ? `exit ${done?.status}` : null;
 function embedClips(texts, { cache, profile, run = spawnSync }) {
   cache = path.resolve(cache);

package/index.d.ts

@@ -192,7 +192,7 @@ export * from './focusHtml';
 // Tour — a deck or a figure that shows its point by itself while nobody is using it (tour.d.ts).
 export * from './tour';
 // Narration — what a deck says on each click (narration.d.ts), in the page: notes, presenter, listen mode (narrationHtml.d.ts).
-// The rules a voice reads by, sentences, captions and chapters are footprint-narration's (its own types).
+// The rules a voice reads by, sentences, captions and chapters are footprint-story's (its own types).
 // footprint-storydeck/voice, /video and /pptx (Node-only) carry their own types.
 export * from './narration';
 export * from './narrationHtml';

package/narration.d.ts

@@ -1,9 +1,9 @@
 /**
  * storydeck · narration (narration.js) — what a deck says on each click. The rules a voice reads by, the sentences,
- * the captions and the chapters are footprint-narration's: import them from 'footprint-narration'.
+ * the captions and the chapters are footprint-story's: import them from 'footprint-story'.
  */
 
 /** The notes as written, for captions: [draft] marks dropped, white space collapsed. */
 export function writtenText(notes: string | readonly string[] | null | undefined): string;
-/** The notes as the voice should read them: footprint-narration's automatic rules over the written text (`spell`, `say` replace its default lists). */
+/** The notes as the voice should read them: footprint-story's automatic rules over the written text (`spell`, `say` replace its default lists). */
 export function narrationText(notes: string | readonly string[] | null | undefined, options?: { spell?: Readonly<Record<string, string>>; say?: Readonly<Record<string, string>> }): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "footprint-storydeck",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "One source, many lenses — render structured content as a Read article, a Scroll (scrollytelling) story, or a Watch deck; and make a deck from a folder with a live dev loop.",
   "type": "module",
   "license": "MIT",
@@ -118,7 +118,7 @@
     }
   },
   "dependencies": {
-    "footprint-narration": "^0.1.0",
+    "footprint-story": "^0.3.0",
     "markdown-it": "^14.1.0"
   },
   "devDependencies": {

package/plugin/skills/storydeck/SKILL.md

@@ -8,9 +8,9 @@ description: Build, focus, narrate and film talks and posts with StoryDeck — o
 A talk or a post is written once: **sections** of slide steps plus prose. StoryDeck shows it as an article
 (Read), a scrollytelling story (Scroll) or a click-through deck (Watch), decides per click what the audience
 looks at (focus), and turns the speaker notes into a voice, captions and a video (narration). Most of it is
-plain data and string builders; only `footprint-storydeck/voice`, `footprint-storydeck/video`, `footprint-storydeck/pptx` and `footprint-narration/voice` touch the
+plain data and string builders; only `footprint-storydeck/voice`, `footprint-storydeck/video`, `footprint-storydeck/pptx` and `footprint-story/voice` touch the
 file system. The narration rules underneath (what a voice says for a number, captions, chapters, the clip cache)
-are footprint-narration's, a package StoryDeck depends on and shares with footprint-storyreel.
+are footprint-story's, a package StoryDeck depends on and shares with footprint-storyreel.
 
 ## Pick the door
 
@@ -22,15 +22,15 @@ are footprint-narration's, a package StoryDeck depends on and shares with footpr
 | that focus written into slide HTML | `footprint-storydeck/focus-html` + `footprint-storydeck/focus.css`, `focusRuntime` once in the page | build + page |
 | a deck (or figure) that shows its point while nobody is using it (`idleTour`, its plan `tourPlan`, a notes line `tourText`) | `footprint-storydeck/tour`; declared as `<deck-stage data-tour="3 4 5 9:6s">` + `(${idleTour})()`, or `SlideDeck`'s `tour` / post.json's `tour` | build + page |
 | what each click says (`narrationText`, `writtenText`: `[draft]`-aware) | `footprint-storydeck/narration` | anywhere |
-| the rules beneath (`spokenMap`, `autoRules`, `SPELL`, `SAY`), sentences, captions, YouTube chapters | `footprint-narration` | anywhere |
+| the rules beneath (`spokenMap`, `autoRules`, `SPELL`, `SAY`), sentences, captions, YouTube chapters | `footprint-story` | anywhere |
 | notes (N), presenter (P), listen mode (L) in the page | `footprint-storydeck/narration-html` + `footprint-storydeck/narration.css` | build + page |
-| a clip per click in a voice, cached (`voiceClips`, `clipFor`, `chatterboxKit`, `pickSteps`) | `footprint-narration/voice` | **Node only** |
+| a clip per click in a voice, cached (`voiceClips`, `clipFor`, `chatterboxKit`, `pickSteps`) | `footprint-story/voice` | **Node only** |
 | those clips carried inside one page (`embedClips`) | `footprint-storydeck/voice` | **Node only** |
 | the deck as a narrated video | `footprint-storydeck/video` (+ ffmpeg 5.0 or newer on the path, Playwright's `chromium` passed in) | **Node only** |
 | the deck as PowerPoint (.pptx): a slide per click, its picture, notes and clip | `footprint-storydeck/pptx` — `exportPptx` (the same driver as the video; no ffmpeg; `npm i footprintjs` beside it, an optional peer) | **Node only** |
 | a deck from a folder: one page, a dev server that reloads on the same click, the deck read back as text | the `storydeck` command (`npx footprint-storydeck init · dev · outline · review · check · build · mcp`); `footprint-storydeck/deck` for scripts | **Node only** |
 
-Never import `footprint-storydeck/voice`, `footprint-storydeck/video`, `footprint-storydeck/pptx` or `footprint-narration/voice` into browser code: they use `node:fs`
+Never import `footprint-storydeck/voice`, `footprint-storydeck/video`, `footprint-storydeck/pptx` or `footprint-story/voice` into browser code: they use `node:fs`
 and child processes.
 The main entry (`footprint-storydeck`) re-exports only what runs anywhere.
 
@@ -99,7 +99,7 @@ whole path .4 s).
 **Narrate a deck in a voice.**
 
 ```js
-import { voiceClips, chatterboxKit } from 'footprint-narration/voice';
+import { voiceClips, chatterboxKit } from 'footprint-story/voice';
 import { narrationText } from 'footprint-storydeck/narration';
 import { embedClips } from 'footprint-storydeck/voice';
 import { notesData, notesRuntime, listenRuntime } from 'footprint-storydeck/narration-html';
@@ -113,14 +113,14 @@ page += notesData(clicks.map(c => c.notes)) + voice.tags + `<script>(${notesRunt
 
 The engine is a port — `{ name, synthesize(scenes, { work }) }`, scenes `{ id, text }`, results `{ id, audio,
 duration, words: [{ text, start, end }] }` — so a cloud voice or a test fake plugs in the same way as the local kit.
-A clip keeps its timed words (`clipFor(…).words`; `null` for a clip voiced before footprint-narration).
+A clip keeps its timed words (`clipFor(…).words`; `null` for a clip voiced before footprint-story).
 
 **Render the narrated video.** A strip first, then the whole.
 
 ```js
 import { chromium } from 'playwright-core';
 import { renderVideo, deckStageDriver } from 'footprint-storydeck/video';
-import { clipFor } from 'footprint-narration/voice';
+import { clipFor } from 'footprint-story/voice';
 import { narrationText, writtenText } from 'footprint-storydeck/narration';
 
 const steps = clicks.map(c => {
@@ -149,7 +149,7 @@ It is pictures + notes + sound, not editable PowerPoint shapes.
 
 - **A clip's key is its recipe**: the voice profile's settings and the exact spoken text. Change the words a
   voice reads — a note, or the `spell` list — and those clicks are voiced again; everything else stays cached.
-  `spell` replaces the default list: extend it with `{ ...SPELL, K8s: 'K eight s' }` (`SPELL` from `footprint-narration`;
+  `spell` replaces the default list: extend it with `{ ...SPELL, K8s: 'K eight s' }` (`SPELL` from `footprint-story`;
   a value is words — a letter in every word, no digits, no comma, semicolon or colon at its end — or it is refused).
 - **Every word needs letters.** A lone symbol that means something is said (`SAY`: & + = < > × % and Greek
   letters; pass `say` to change it); any other (— → ... an emoji) is a pause that keeps its sentence end. The local

package/pptx.d.ts

@@ -3,14 +3,14 @@
  * its clip. Node. The export is a footprintjs flowchart: every run leaves a record that explains it. footprintjs is an
  * optional peer dependency: `npm i footprintjs` beside StoryDeck to export.
  */
-import type { VoiceProfile } from 'footprint-narration/voice';
+import type { VoiceProfile } from 'footprint-story/voice';
 import type { VideoClip, VideoDriver, VideoStep } from './video';
 
 /** A click to export: as renderVideo takes it, plus the slide's headline (the title, before the label). */
 export interface PptxStep extends VideoStep { headline?: string }
 /** A click of a deck: its label (and headline), and its notes — narration-html's notesData entry ({ now }), a string, or a list of strings. */
 export interface DeckClick { label?: string; headline?: string; notes?: string | readonly string[] | { now: readonly string[] } | null }
-/** Where a deck's clips are: footprint-narration/voice's cache and profile, and the reading rules the clips were voiced with. */
+/** Where a deck's clips are: footprint-story/voice's cache and profile, and the reading rules the clips were voiced with. */
 export interface PptxVoice { cache: string; profile: VoiceProfile; spell?: Readonly<Record<string, string>>; say?: Readonly<Record<string, string>> }
 /** A click as exported: its number, title, notes as written, words as spoken, clip, and the seconds it stays (null: the speaker clicks). */
 export interface PlannedSlide {

package/video.d.ts

@@ -1,10 +1,10 @@
 /**
  * storydeck · video (video.js) — a narrated deck as a video: every click on screen while its clip plays. Node + ffmpeg 5.0+.
  */
-import type { Clip } from 'footprint-narration/voice';
-import type { Chapters } from 'footprint-narration';
+import type { Clip } from 'footprint-story/voice';
+import type { Chapters } from 'footprint-story';
 
-/** A cached clip as the video uses it (`words` is not read: a clip from before footprint-narration has none). */
+/** A cached clip as the video uses it (`words` is not read: a clip from before footprint-story has none). */
 export type VideoClip = Omit<Clip, 'words'> & { words?: Clip['words'] };
 /** A click to render: its label, its words as written and as spoken, and its clip (or null). */
 export interface VideoStep { label?: string; written?: string; spoken?: string; clip?: VideoClip | null }

package/voice.d.ts

@@ -1,8 +1,8 @@
 /**
  * storydeck · voice (voice.js) — a deck's clips inside one page. Node. The clip cache, the voice port and the kit
- * adapter are footprint-narration's: import them from 'footprint-narration/voice'.
+ * adapter are footprint-story's: import them from 'footprint-story/voice'.
  */
-import type { VoiceProfile } from 'footprint-narration/voice';
+import type { VoiceProfile } from 'footprint-story/voice';
 
 type Run = (cmd: string, args: string[], options?: object) => { status: number | null };