@litfamily/litclaude 1.0.10 → 1.0.13

package/plugins/litclaude/skills/lit-typographic-motion/engine/core/presets.mjs

@@ -0,0 +1,123 @@
+// The three preset style bibles as data (MO-B-01..03) and the auto-pick table (MO-B-00).
+// The prose bibles live in references/style-bibles.md; this module is what the engine and the gate
+// read, so palette hexes, voices, pass order and motion tokens have one source.
+
+export const PRESET_IDS = Object.freeze(["swiss-signal", "terminalcore", "tidal"]);
+
+// Font registry keys (fonts/manifest.json). Hangul runs never use a Latin face and the reverse.
+const archivo = (width, weight) => `archivo-${width}-${weight}`;
+
+export const PRESETS = Object.freeze({
+  "swiss-signal": {
+    id: "swiss-signal",
+    palette: { bg: "#0C0E13", type: "#E9EBE4", signal: "#0F7A82", accent: "#D9A441", dim: "#4B5058", mark: "#0F7A82" },
+    // Roles the MO-C-29 cluster check treats as the one signal and the one accent.
+    signalRole: "signal",
+    accentRole: "accent",
+    voices: {
+      display: { latin: archivo(100, 900), latinWidths: [75, 100, 125], hangul: "pretendard-700", weightSteps: ["pretendard-400", "pretendard-700"] },
+      body: { latin: archivo(100, 400), hangul: "pretendard-400" },
+      machine: { latin: "meslo-400", hangul: "pretendard-400" },
+    },
+    tokens: { slam: 0.18, holdMin: 0.6, holdMax: 0.9, cut: 0 },
+    passes: ["swiss-grid", "dither"],
+    passParams: {
+      "swiss-grid": { columns: 12, gutterPx: 24, marginPx: 96, baselinePx: 8, moduleSnap: true, showGuides: false, hairlineWidthPx: 1 },
+      dither: { mode: 1, paletteSize: 0, pixelScale: 1, strength: 0.3 },
+    },
+    // No bloom or halation: the bible keeps glow off the bone type, and the teal signal is too dark
+    // to cross any luminance threshold.
+    post: { exposure: 1, bloom: 0, bloomThreshold: 0.85, bloomKnee: 0, bloomRadius: 0, halation: 0, ca: 0.8, grain: 0.035, vignette: 0.25, fade: 1, flash: 0, shake: [0, 0], zoom: 1, invert: false },
+  },
+  terminalcore: {
+    id: "terminalcore",
+    palette: { bg: "#05070A", panel: "#0C1116", type: "#39FF6A", signal: "#39FF6A", signalBlue: "#2FB6FF", dim: "#7C8B93", mark: "#39FF6A" },
+    signalRole: "signal",
+    accentRole: null,
+    voices: {
+      display: { latin: "vt323", hangul: "galmuri9" },
+      body: { latin: "vt323", hangul: "pretendard-400" },
+      machine: { latin: "meslo-400", hangul: "galmuri9" },
+      chrome: { latin: "silkscreen-400", hangul: "galmuri9" },
+    },
+    tokens: { typeInCharsPerSec: 22, bootFlicker: 0.25, cut: 0 },
+    passes: ["terminal-ui", "crt", "dither", "glitch"],
+    passParams: {
+      "terminal-ui": { charGridPx: [14, 24], windowChromeWidthPx: 1.5, meterCount: 2, logLineRateCharsPerSec: 22, caretBlinkHz: 1.2 },
+      crt: { scanlineFreqPerFrame: 540, scanlineDepth: 0.22, phosphorPersistence: 0, bloomAmount: 0.2, curvature: 0.06, vignette: 0.3, triadMaskAmount: 0.12, flickerAmp: 0.03, flickerFreqHz: 8 },
+      dither: { mode: 1, paletteSize: 0, pixelScale: 2, strength: 0.35 },
+      glitch: { intensity: 0.3, sliceCount: 6, maxOffsetPx: 24, blockCorruptSize: [32, 18], rgbSplitPx: 3, holdFrames: 2, hitRatePerSec: 0.5, areaCapPct: 12 },
+    },
+    post: { exposure: 1, bloom: 0.3, bloomThreshold: 0.8, bloomKnee: 0.4, bloomRadius: 0.5, halation: 0.08, ca: 1.0, grain: 0.03, vignette: 0.15, fade: 1, flash: 0, shake: [0, 0], zoom: 1, invert: false },
+  },
+  tidal: {
+    id: "tidal",
+    // Tidal has no signal hue of its own: the teal stop is its saturated cluster, and marks
+    // (bars, the pen head) use the type colour.
+    palette: { bg: "#0E1420", type: "#E8ECEF", stopA: "#124559", stopB: "#4C3B6E", accent: "#E07856", dim: "#8A94A6", mark: "#E8ECEF" },
+    signalRole: "stopA",
+    accentRole: "accent",
+    voices: {
+      display: { latin: archivo(100, 700), latinWidths: [100], hangul: "pretendard-700", weightSteps: ["pretendard-400", "pretendard-700"] },
+      body: { latin: archivo(100, 400), hangul: "pretendard-400" },
+      machine: { latin: "meslo-400", hangul: "pretendard-400" },
+    },
+    tokens: { drift: 3.0, surgePunch: 0.3, cut: 0 },
+    passes: ["tidal-gradient", "swiss-grid", "glitch"],
+    passParams: {
+      "tidal-gradient": { flowSpeed: 0.05, warpAmount: 0.35, curlStrength: 0.35, octaves: 4, surgeOnHit: 0.35, surgeAttackSec: 0.2, surgeDecaySec: 0.4, surgeCapPerSec: 2, bandingSteps: 0, ditherAmount: 0.02 },
+      "swiss-grid": { columns: 12, gutterPx: 24, marginPx: 96, baselinePx: 8, moduleSnap: true, showGuides: false, hairlineWidthPx: 1 },
+      glitch: { intensity: 0.25, sliceCount: 5, maxOffsetPx: 18, blockCorruptSize: [32, 18], rgbSplitPx: 2, holdFrames: 2, hitRatePerSec: 0.5, areaCapPct: 10 },
+    },
+    post: { exposure: 1, bloom: 0.15, bloomThreshold: 0.85, bloomKnee: 0.4, bloomRadius: 0.6, halation: 0.1, ca: 0.6, grain: 0.03, vignette: 0.2, fade: 1, flash: 0, shake: [0, 0], zoom: 1, invert: false },
+  },
+});
+
+// MO-B-00: checked in order, first match wins, whole words only. Korean keywords must start a
+// token so they never match the tail of a longer compound; Latin keywords use word boundaries.
+export const AUTO_PICK = Object.freeze([
+  { preset: "terminalcore", korean: ["터미널", "CRT", "해커"], latin: ["terminal", "hacker", "crt"] },
+  { preset: "tidal", korean: ["물결", "파도", "잔잔한", "흐름"], latin: ["gradient", "wave", "tide", "calm"] },
+]);
+
+const escape = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+function matchesKeyword(text, keyword, korean) {
+  const pattern = korean
+    ? new RegExp(`(?<![\\p{L}\\p{N}])${escape(keyword)}`, "u")
+    : new RegExp(`(?<![\\p{L}\\p{N}])${escape(keyword)}(?![\\p{L}\\p{N}])`, "iu");
+  return pattern.test(text);
+}
+
+/**
+ * Pick the preset for a brief. An explicit style always wins; otherwise the first table row with a
+ * whole-word hit; otherwise swiss-signal. Returns the id and the reason the report prints.
+ */
+export function pickPreset({ style, text, request = "" }) {
+  if (style && style !== "auto") {
+    if (!PRESET_IDS.includes(style)) throw new Error(`unknown preset: ${style} (choose ${PRESET_IDS.join(", ")})`);
+    // A style is the user's only when their request names it; a style the agent wrote into the
+    // brief is the agent's default and is labelled so (RC8e).
+    return { presetId: style, reason: matchesKeyword(String(request), style, false) ? "user-specified" : "agent default" };
+  }
+  for (const row of AUTO_PICK) {
+    for (const keyword of row.korean) {
+      if (matchesKeyword(text, keyword, true)) return { presetId: row.preset, reason: `agent default (brief mentions "${keyword}")` };
+    }
+    for (const keyword of row.latin) {
+      if (matchesKeyword(text, keyword, false)) return { presetId: row.preset, reason: `agent default (brief mentions "${keyword}")` };
+    }
+  }
+  return { presetId: "swiss-signal", reason: "agent default (no terminal or tidal keyword in the brief)" };
+}
+
+/** The palette a render actually uses, after the terminalcore signal-hue choice. */
+export function resolvePalette(preset, { signalHue } = {}) {
+  const palette = { ...preset.palette };
+  if (preset.id === "terminalcore" && signalHue === "blue") {
+    palette.signal = palette.signalBlue;
+    palette.type = palette.signalBlue;
+    palette.mark = palette.signalBlue;
+  }
+  return palette;
+}

package/plugins/litclaude/skills/lit-typographic-motion/engine/core/text.mjs

@@ -0,0 +1,100 @@
+// Text rules shared by the timeline builder, the type kit and the gate: typographic punctuation
+// (MO-A-34), script runs (MO-FT-04), eojeol breaking (MO-A-13, MO-FT-05) and the one reading-floor
+// function (MO-C-07/08). Pure functions only.
+import { READING } from "./constants.mjs";
+
+/** Typewriter punctuation to typographic: ... -> ellipsis, straight quotes -> curly, leading elisions. */
+export function smart(text) {
+  return text
+    .replace(/\.\.\./gu, "…")
+    .replace(/(^|[\s([{—–-])'(?=(?:cause|til|em|round|n|tis|twas|\d0s)\b)/giu, "$1’")
+    .replace(/(^|[\s([{—–-])'/gu, "$1‘")
+    .replace(/'/gu, "’")
+    .replace(/(^|[\s([{—–-])"/gu, "$1“")
+    .replace(/"/gu, "”");
+}
+
+/** Typographic punctuation back to typewriter, for the machine voice showing typed input. */
+export const plain = (text) => text.replace(/[‘’]/gu, "'").replace(/[“”]/gu, '"').replace(/…/gu, "...");
+
+const HANGUL = /[ᄀ-ᇿ㄰-㆏ꥠ-꥿가-힣ힰ-퟿]/u;
+const LETTER = /\p{L}/u;
+
+/** 'hangul' | 'latin' | null (null = neutral: digit, punctuation, space, symbol). */
+export function charScript(ch) {
+  if (HANGUL.test(ch)) return "hangul";
+  if (LETTER.test(ch)) return "latin";
+  return null;
+}
+
+/**
+ * Split a string into script runs. Neutral characters (digits, punctuation, spaces) attach to the
+ * run beside them; between two different runs they attach to the run on the left, and before the
+ * first letter they attach to the run on the right. A string with no letters is one latin run.
+ * "2026년" is one hangul run; "LIT팀" is "LIT" + "팀".
+ */
+export function scriptRuns(text) {
+  const chars = Array.from(text);
+  const scripts = chars.map(charScript);
+  const first = scripts.find((s) => s !== null) ?? "latin";
+  let current = first;
+  const resolved = scripts.map((s) => {
+    if (s !== null) current = s;
+    return current;
+  });
+  const runs = [];
+  for (let i = 0; i < chars.length; i++) {
+    const last = runs[runs.length - 1];
+    if (last && last.script === resolved[i]) last.text += chars[i];
+    else runs.push({ script: resolved[i], text: chars[i], start: i });
+  }
+  return runs;
+}
+
+export function textScript(text) {
+  const kinds = new Set(Array.from(text).map(charScript).filter(Boolean));
+  if (kinds.size === 0) return "latin";
+  if (kinds.size === 2) return "mixed";
+  return [...kinds][0];
+}
+
+/** Eojeol units: whitespace-separated words. A break or reveal step never splits one. */
+export const eojeol = (text) => text.trim().split(/\s+/u).filter(Boolean);
+
+/** Counts for the reading floor: Hangul syllables, Latin words, Latin-run characters incl. spaces. */
+export function readingCounts(text) {
+  const H = (text.match(/[가-힣]/gu) ?? []).length;
+  const W = (text.match(/[\p{Script=Latin}\d'’-]+/gu) ?? []).length;
+  const C = scriptRuns(text).filter((run) => run.script === "latin").reduce((sum, run) => sum + Array.from(run.text).length, 0);
+  return { H, W, C };
+}
+
+/**
+ * The one reading floor (MO-C-07/08). `kind` is line | scene | word | reveal. A scene unit with no
+ * text has no reading floor (0); its minimum hold comes from the beat rule instead.
+ */
+export function readingFloor(text, kind) {
+  if (kind === "reveal") return READING.revealFloor;
+  const { H, W } = readingCounts(text ?? "");
+  const rate = READING.secondsPerHangulSyllable * H + W / READING.wordsPerSecond;
+  if (kind === "word") return Math.max(READING.wordFloor, rate);
+  if (!text || !text.trim()) return 0;
+  return Math.max(H > 0 ? READING.lineFloorHangul : READING.lineFloorLatin, rate);
+}
+
+/** Wrap text to lines no wider than `maxWidth`, breaking only at whitespace (eojeol boundaries). */
+export function wrapByWidth(text, maxWidth, measure) {
+  const words = eojeol(text);
+  const lines = [];
+  let line = "";
+  for (const word of words) {
+    const candidate = line ? `${line} ${word}` : word;
+    if (!line || measure(candidate) <= maxWidth) line = candidate;
+    else {
+      lines.push(line);
+      line = word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines;
+}

package/plugins/litclaude/skills/lit-typographic-motion/engine/core/timeline.mjs

@@ -0,0 +1,142 @@
+// Timeline model (MO-A-06, MO-A-09..16, MO-A-41a). Builds the canonical timeline[] from a
+// normalized brief: every shot's hold comes from the reading floor at the generator margin, cuts
+// are snapped forward to the beat grid (never shortening a hold), and a shot always holds at least
+// two beats. The same anchor-and-snap method works for the Tier-1 BPM grid and a Tier-2 beat grid.
+import { TIMELINE, READING, GATE } from "./constants.mjs";
+import { readingFloor, readingCounts, textScript, eojeol, smart } from "./text.mjs";
+
+/** Beat times (seconds) for a constant BPM, long enough to cover `untilSec`. */
+export function bpmGrid(bpm, untilSec) {
+  const step = 60 / bpm;
+  const beats = [];
+  for (let i = 0; i * step <= untilSec + step * 4; i++) beats.push(i * step);
+  return beats;
+}
+
+/** Extend a detected beat grid past its last beat with the median interval. */
+export function extendGrid(grid, untilSec) {
+  const beats = [...grid].sort((a, b) => a - b);
+  if (beats.length < 2) return bpmGrid(TIMELINE.defaultBpm, untilSec);
+  const gaps = beats.slice(1).map((b, i) => b - beats[i]).sort((a, b) => a - b);
+  const median = gaps[Math.floor(gaps.length / 2)];
+  while (beats[beats.length - 1] < untilSec + median * 4) beats.push(beats[beats.length - 1] + median);
+  if (beats[0] > 0) beats.unshift(0);
+  return beats;
+}
+
+const frameTime = (seconds, fps) => Math.round(seconds * fps) / fps;
+
+/** First beat at or after `t` (within half a frame). */
+function beatAtOrAfter(grid, t, fps) {
+  const eps = 0.5 / fps;
+  return grid.find((b) => b >= t - eps) ?? grid[grid.length - 1];
+}
+
+function localBeat(grid, t) {
+  for (let i = 1; i < grid.length; i++) if (grid[i] > t) return grid[i] - grid[i - 1];
+  return grid.length > 1 ? grid[grid.length - 1] - grid[grid.length - 2] : 60 / TIMELINE.defaultBpm;
+}
+
+/** The text a viewer reads in a shot, and the reveal steps inside it (each an eojeol or item). */
+export function shotReading(shot) {
+  switch (shot.scene) {
+    case "title-slam":
+    case "end-card":
+      return { kind: "line", text: [shot.text, shot.sub].filter(Boolean).join(" "), reveals: [] };
+    case "karaoke-line":
+      return { kind: "line", text: shot.text, reveals: eojeol(shot.text) };
+    case "kinetic-list":
+      return { kind: "scene", text: [shot.heading, ...(shot.items ?? [])].filter(Boolean).join(" "), reveals: [...(shot.items ?? [])] };
+    case "number-counter":
+      return { kind: "scene", text: [shot.label, shot.display].filter(Boolean).join(" "), reveals: [] };
+    case "signature":
+      return { kind: "line", text: shot.text, reveals: [] };
+    default:
+      return { kind: shot.text ? "line" : "scene", text: shot.text ?? "", reveals: shot.reveals ?? [] };
+  }
+}
+
+// Reveals take this share of a shot, so the finished line keeps the rest of the hold.
+const REVEAL_SHARE = 0.6;
+
+/**
+ * Build the timeline. `shots` are normalized brief shots (text already through smart()).
+ * Returns { timeline, shots, durationSec, beats } where shots carry start/end and their reveals.
+ */
+export function buildTimeline({ shots, fps = TIMELINE.defaultFps, bpm = TIMELINE.defaultBpm, beatGrid = null }) {
+  const margin = TIMELINE.generatorMargin;
+  const estimate = shots.reduce((sum, shot) => sum + 8 + (shot.hold ?? 0), 0) + 10;
+  const grid = beatGrid ? extendGrid(beatGrid, estimate) : bpmGrid(bpm, estimate);
+  const counters = new Map();
+  const timeline = [];
+  const placed = [];
+  let cursor = 0;
+  for (const shot of shots) {
+    const shotIndex = counters.get(shot.scene) ?? 0;
+    counters.set(shot.scene, shotIndex + 1);
+    const id = shotIndex === 0 ? shot.scene : `${shot.scene}-${shotIndex}`;
+    const reading = shotReading(shot);
+    const start = cursor;
+    const beat = localBeat(grid, start);
+    const floor = readingFloor(reading.text, reading.kind);
+    const revealStep = margin * READING.revealFloor;
+    const revealSpan = reading.reveals.length * revealStep;
+    let hold = Math.max(
+      margin * floor,
+      TIMELINE.minSceneBeats * beat,
+      reading.reveals.length ? revealSpan / REVEAL_SHARE : 0,
+      shot.hold ?? 0,
+    );
+    // A cps cross-check failure is fixed by holding longer, never by cutting text.
+    const { C } = readingCounts(reading.text ?? "");
+    if (C / hold > READING.maxCharsPerSecond) hold = (C / READING.maxCharsPerSecond) * margin;
+    const snappedEnd = beatAtOrAfter(grid, start + hold, fps);
+    const end = frameTime(snappedEnd, fps);
+    const beatSec = beatAtOrAfter(grid, start, fps);
+    timeline.push({
+      id, sceneId: shot.scene, shotIndex, start, end, holdSec: +(end - start).toFixed(6), kind: reading.kind,
+      text: reading.text, script: textScript(reading.text || " "), beatSec: +beatSec.toFixed(6),
+    });
+    const reveals = [];
+    if (reading.reveals.length) {
+      const step = Math.max(revealStep, ((end - start) * REVEAL_SHARE) / reading.reveals.length);
+      reading.reveals.forEach((text, k) => {
+        const rStart = frameTime(start + k * step, fps);
+        const rEnd = k === reading.reveals.length - 1 ? end : frameTime(start + (k + 1) * step, fps);
+        const entry = {
+          id: `${id}/r${k}`, sceneId: shot.scene, shotIndex, start: rStart, end: rEnd, holdSec: +(rEnd - rStart).toFixed(6),
+          kind: "reveal", text, script: textScript(text), beatSec: +nearestBeat(grid, rStart).toFixed(6),
+        };
+        reveals.push(entry);
+        timeline.push(entry);
+      });
+    }
+    placed.push({ ...shot, id, shotIndex, start, end, reveals, reading });
+    cursor = end;
+  }
+  let durationSec = cursor;
+  if (durationSec < GATE.minDurationSec && placed.length) {
+    const last = placed[placed.length - 1];
+    const end = frameTime(beatAtOrAfter(grid, GATE.minDurationSec, fps), fps);
+    last.end = end;
+    const entry = timeline.find((e) => e.id === last.id);
+    entry.end = end;
+    entry.holdSec = +(end - entry.start).toFixed(6);
+    if (last.reveals.length) {
+      const lastReveal = timeline.find((e) => e.id === last.reveals[last.reveals.length - 1].id);
+      lastReveal.end = end;
+      lastReveal.holdSec = +(end - lastReveal.start).toFixed(6);
+    }
+    durationSec = end;
+  }
+  return { timeline, shots: placed, durationSec, beats: grid.filter((b) => b <= durationSec + 1e-9) };
+}
+
+function nearestBeat(grid, t) {
+  let best = grid[0];
+  for (const b of grid) if (Math.abs(b - t) < Math.abs(best - t)) best = b;
+  return best;
+}
+
+/** Normalize a display string: typographic punctuation for display voices, plain for machine. */
+export const displayText = (text, voice = "display") => (voice === "machine" ? text : smart(text));

package/plugins/litclaude/skills/lit-typographic-motion/engine/core/util.mjs

@@ -0,0 +1,167 @@
+// Pure math, easing and seeded-randomness helpers shared by the page engine and the Node side.
+// Adapted from mexicat/pdoom-video app/src/engine/util.ts (MIT, see ../NOTICE). Every function is a
+// deterministic function of its arguments: nothing here may read a clock or an unseeded RNG
+// (MO-A-23), because the determinism gate hashes frames rendered by two separate processes.
+
+export const clamp = (x, a = 0, b = 1) => (x < a ? a : x > b ? b : x);
+export const lerp = (a, b, t) => a + (b - a) * t;
+export const invLerp = (a, b, x) => (a === b ? 0 : (x - a) / (b - a));
+export const remap = (x, a, b, c, d, clamped = true) => {
+  const t = invLerp(a, b, x);
+  return lerp(c, d, clamped ? clamp(t) : t);
+};
+export const smoothstep = (a, b, x) => {
+  const t = clamp((x - a) / (b - a));
+  return t * t * (3 - 2 * t);
+};
+export const fract = (x) => x - Math.floor(x);
+export const mod = (x, m) => ((x % m) + m) % m;
+export const TAU = Math.PI * 2;
+
+// Cubic bezier easing, solved by a fixed 40-step bisection so the value never depends on a
+// convergence tolerance.
+function bezier(x1, y1, x2, y2) {
+  const coord = (t, a, b) => 3 * a * t * (1 - t) ** 2 + 3 * b * t * t * (1 - t) + t ** 3;
+  return (x) => {
+    if (x <= 0) return 0;
+    if (x >= 1) return 1;
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 40; i++) {
+      const mid = (lo + hi) / 2;
+      if (coord(mid, x1, x2) < x) lo = mid;
+      else hi = mid;
+    }
+    return coord((lo + hi) / 2, y1, y2);
+  };
+}
+
+// The named easing set (MO-A-08). Scenes pick from these names; ad hoc curves are not allowed.
+export const ease = Object.freeze({
+  linear: (t) => t,
+  outQuad: (t) => 1 - (1 - t) * (1 - t),
+  inOutQuad: (t) => (t < 0.5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2),
+  outCubic: (t) => 1 - (1 - t) ** 3,
+  inOutCubic: (t) => (t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2),
+  outExpo: (t) => (t >= 1 ? 1 : 1 - 2 ** (-10 * t)),
+  // Film tokens from the preset bibles (MO-B-01..03).
+  slam: bezier(0.16, 1, 0.3, 1),
+  drift: bezier(0.37, 0, 0.63, 1),
+  surgePunch: bezier(0.16, 1, 0.3, 1),
+});
+
+/** Eased progress of x through [a, b], clamped. */
+export const prog = (x, a, b, fn = ease.linear) => fn(clamp((x - a) / (b - a)));
+
+/**
+ * Piecewise interpolation through keyframes `[[time, value, easeName], ...]`; the ease on key i
+ * shapes the segment that ends at key i. Only names from `ease` are accepted.
+ */
+export function keys(t, ks) {
+  if (ks.length === 0) return 0;
+  if (t <= ks[0][0]) return ks[0][1];
+  for (let i = 1; i < ks.length; i++) {
+    const [time, value, name = "inOutCubic"] = ks[i];
+    if (t <= time) {
+      const [pt, pv] = ks[i - 1];
+      const fn = ease[name];
+      if (!fn) throw new Error(`unknown ease: ${name}`);
+      return lerp(pv, value, fn((t - pt) / (time - pt)));
+    }
+  }
+  return ks[ks.length - 1][1];
+}
+
+/** Damped spring response to a step at time 0 (the rare deliberate overshoot, MO-A-08). */
+export const springStep = (t, freq = 4, damping = 0.35) => {
+  if (t <= 0) return 0;
+  const w = TAU * freq;
+  return 1 - Math.exp(-damping * w * t) * Math.cos(w * Math.sqrt(1 - damping * damping) * t);
+};
+
+/** Exponential decay after an event at t0 (1 at t0, half-life hl). */
+export const pulse = (t, t0, hl = 0.12) => (t < t0 ? 0 : 0.5 ** ((t - t0) / hl));
+
+// ---- seeded randomness (MO-SH-01, MO-A-23) ----
+
+/** FNV-1a 32-bit over the UTF-8 bytes of `text`; offset basis 0x811c9dc5, prime 0x01000193. */
+export function fnv1a32(text) {
+  let hash = 0x811c9dc5;
+  for (const byte of new TextEncoder().encode(text)) {
+    hash ^= byte;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash >>> 0;
+}
+
+/** MO-SH-01: the one seed formula for every pass in every product. */
+export const passSeed = (runSeed, sceneId, shotIndex, pass) => fnv1a32(`${runSeed}:${sceneId}:${shotIndex}:${pass}`);
+
+/** mulberry32 PRNG in unsigned 32-bit arithmetic. Returns a function yielding [0, 1). */
+export function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/** Stateless hash of numbers to [0, 1). */
+export function hash(...xs) {
+  let h = 2166136261 >>> 0;
+  for (const x of xs) {
+    h ^= Math.floor(x * 1000003) | 0;
+    h = Math.imul(h, 16777619);
+    h ^= h >>> 13;
+    h = Math.imul(h, 0x5bd1e995);
+    h ^= h >>> 15;
+  }
+  return (h >>> 0) / 4294967296;
+}
+
+const quintic = (t) => t * t * t * (t * (t * 6 - 15) + 10);
+export function noise1(x, seed = 0) {
+  const i = Math.floor(x);
+  return lerp(hash(i, seed) * 2 - 1, hash(i + 1, seed) * 2 - 1, quintic(x - i));
+}
+
+// ---- colour ----
+
+export const srgbToLinear = (s) => (s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4);
+export const linearToSrgb = (l) => (l <= 0.0031308 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055);
+
+export function hexToRgb(hex) {
+  const n = Number.parseInt(hex.replace("#", ""), 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+export const hexToLinear = (hex) => hexToRgb(hex).map((v) => srgbToLinear(v / 255));
+
+/** WCAG relative luminance of an sRGB hex colour. */
+export function relativeLuminance(hex) {
+  const [r, g, b] = hexToLinear(hex);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+export const contrastRatio = (la, lb) => (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+
+/** HSL hue (degrees) and saturation (0..1) of 0..255 sRGB values. */
+export function hsl(r, g, b) {
+  const [rn, gn, bn] = [r / 255, g / 255, b / 255];
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const l = (max + min) / 2;
+  const d = max - min;
+  if (d === 0) return { h: 0, s: 0, l };
+  const s = d / (1 - Math.abs(2 * l - 1));
+  let h;
+  if (max === rn) h = ((gn - bn) / d) % 6;
+  else if (max === gn) h = (bn - rn) / d + 2;
+  else h = (rn - gn) / d + 4;
+  return { h: mod(h * 60, 360), s, l };
+}
+export const hueDistance = (a, b) => {
+  const d = Math.abs(mod(a, 360) - mod(b, 360));
+  return Math.min(d, 360 - d);
+};

package/plugins/litclaude/skills/lit-typographic-motion/engine/core/voices.mjs

@@ -0,0 +1,19 @@
+// The one mapping from (voice, script run) to a font key, shared by the page type kit and the
+// Node glyph-coverage pre-flight so both resolve the same file. Hangul runs never get a Latin
+// width instance or a synthetic weight: only the voice's Hangul face, or the lit-pptx 400/700 pair
+// when the voice declares weight steps (MO-A-33).
+export function runFontKey(voices, voice, script, { widthPct = 100, weight } = {}) {
+  const v = voices[voice];
+  if (!v) throw new Error(`unknown voice: ${voice}`);
+  if (script === "hangul") {
+    if (weight !== undefined && v.weightSteps) return weight >= 700 ? v.weightSteps[1] : v.weightSteps[0];
+    return v.hangul;
+  }
+  if (v.latin.startsWith("archivo-")) {
+    const base = Number(v.latin.split("-")[2]);
+    const widths = v.latinWidths ?? [100];
+    const nearest = widths.reduce((best, x) => (Math.abs(x - widthPct) < Math.abs(best - widthPct) ? x : best), widths[0]);
+    return `archivo-${nearest}-${weight ?? base}`;
+  }
+  return v.latin;
+}