miriad-viz 0.3.5 → 0.4.0

package/dist-cli/chunk-3NPPXJ6N.js

@@ -0,0 +1,50 @@
+// src/types/pacing.ts
+import { z } from "zod";
+var PacingLineSchema = z.object({
+  /** Line ID — must match script.json line ID */
+  id: z.string().min(1),
+  /** Text from script (read-only, for context while editing pacing) */
+  text: z.string().min(1),
+  /** Audio clip duration in seconds (measured from file, read-only) */
+  clipDuration: z.number().positive(),
+  /** Silence after this line in seconds (overrides defaultPauseSec) */
+  pauseAfter: z.number().nonnegative().optional(),
+  /** Viz speed multiplier DURING this clip's audio. >1 = faster, <1 = slower */
+  vizSpeed: z.number().positive().optional(),
+  /** Viz speed multiplier DURING the pause after this clip (defaults to defaultVizSpeed) */
+  gapVizSpeed: z.number().positive().optional(),
+  /** Agent's reasoning for pacing choices (human reads during review) */
+  note: z.string().optional()
+});
+var PacingFileSchema = z.object({
+  /** Schema version — always 1 for now */
+  version: z.literal(1),
+  /** Seconds of viz playback before first narration line */
+  leadInSec: z.number().nonnegative().optional(),
+  /** Seconds of viz playback after last narration line */
+  tailOutSec: z.number().nonnegative().optional(),
+  /** Default pause between lines in seconds (used when pauseAfter not set) */
+  defaultPauseSec: z.number().nonnegative(),
+  /** Default viz speed multiplier (used when vizSpeed/gapVizSpeed not set) */
+  defaultVizSpeed: z.number().positive(),
+  /** Ordered list of pacing lines — must match script.json order */
+  lines: z.array(PacingLineSchema).min(1)
+}).superRefine((data, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.lines.length; i++) {
+    const id = data.lines[i].id;
+    if (ids.has(id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Duplicate line ID: "${id}" (line index ${i})`,
+        path: ["lines", i, "id"]
+      });
+    }
+    ids.add(id);
+  }
+});
+
+export {
+  PacingLineSchema,
+  PacingFileSchema
+};

package/dist-cli/chunk-BD2KEZI4.js

@@ -0,0 +1,38 @@
+// src/types/script.ts
+import { z } from "zod";
+var ScriptLineSchema = z.object({
+  /** Unique identifier for this line (e.g., 'narrator-01', 'lead-03') */
+  id: z.string().min(1),
+  /** Who speaks this line (e.g., 'narrator', 'lead', 'snorre') */
+  speaker: z.string().min(1),
+  /** The spoken text */
+  text: z.string().min(1),
+  /** Rendering style: narrator voice (cursive) or agent quote (normal) */
+  style: z.enum(["narrator", "quote"]),
+  /** Optional phase this line belongs to (for grouping in the viz) */
+  phaseId: z.string().optional()
+});
+var ScriptFileSchema = z.object({
+  /** Schema version — always 1 for now */
+  version: z.literal(1),
+  /** Ordered list of script lines */
+  lines: z.array(ScriptLineSchema).min(1)
+}).superRefine((data, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.lines.length; i++) {
+    const id = data.lines[i].id;
+    if (ids.has(id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Duplicate line ID: "${id}" (line index ${i})`,
+        path: ["lines", i, "id"]
+      });
+    }
+    ids.add(id);
+  }
+});
+
+export {
+  ScriptLineSchema,
+  ScriptFileSchema
+};

package/dist-cli/chunk-SKRQW7PY.js

@@ -0,0 +1,58 @@
+// src/types/timing.ts
+import { z } from "zod";
+var TimedLineSchema = z.object({
+  /** Line ID — matches script.json and pacing.json */
+  id: z.string().min(1),
+  /** Speaker identifier (e.g., 'narrator', 'lead', 'snorre') */
+  speaker: z.string().min(1),
+  /** The spoken text */
+  text: z.string().min(1),
+  /** Rendering style: narrator voice (cursive) or agent quote (normal) */
+  style: z.enum(["narrator", "quote"]),
+  /** Wall-clock start time in seconds from video start */
+  startSec: z.number().nonnegative(),
+  /** Audio clip duration in seconds */
+  durationSec: z.number().positive(),
+  /** Pause after this line in seconds (resolved from defaults) */
+  pauseAfterSec: z.number().nonnegative(),
+  /** Audio file path relative to audio directory (e.g., 'narrator-01.mp3') */
+  audioFile: z.string().min(1),
+  /** Viz progress at clip start [0, 1] */
+  progressStart: z.number().min(0).max(1),
+  /** Viz progress at clip end [0, 1] */
+  progressEnd: z.number().min(0).max(1),
+  /** Viz speed multiplier during this clip */
+  vizSpeed: z.number().positive(),
+  /** Viz speed multiplier during the pause after this clip */
+  gapVizSpeed: z.number().positive(),
+  /** Phase this line belongs to (optional) */
+  phase: z.string().optional()
+}).refine((line) => line.progressStart <= line.progressEnd, {
+  message: "progressStart must be <= progressEnd",
+  path: ["progressStart"]
+});
+var TimingFileSchema = z.object({
+  /** Schema version — always 1 for now */
+  version: z.literal(1),
+  /** Total video duration in seconds */
+  totalDurationSec: z.number().positive(),
+  /** Ordered list of timed lines — fully resolved, all fields required */
+  lines: z.array(TimedLineSchema).min(1)
+}).superRefine((data, ctx) => {
+  const ids = /* @__PURE__ */ new Set();
+  for (let i = 0; i < data.lines.length; i++) {
+    const id = data.lines[i].id;
+    if (ids.has(id)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Duplicate line ID: "${id}" (line index ${i})`,
+        path: ["lines", i, "id"]
+      });
+    }
+    ids.add(id);
+  }
+});
+
+export {
+  TimingFileSchema
+};

package/dist-cli/{chunk-KY56F5QU.js → chunk-X2MHAVAE.js}

@@ -1,25 +1,26 @@
 // src/cli/guided/types.ts
-var STEPS = [
+var STEPS_V2 = [
   "init",
   "extract",
-  "curate",
-  "transform",
-  "preview",
-  "audio",
+  "script",
+  "voices",
+  "viz-timing",
+  "sound-design",
   "render"
 ];
+var STEPS = STEPS_V2;
 function createProgressFile(project) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
-    version: 1,
+    version: 2,
     project,
     steps: {
       init: { status: "complete", completedAt: now },
       extract: { status: "pending" },
-      curate: { status: "pending" },
-      transform: { status: "pending" },
-      preview: { status: "pending" },
-      audio: { status: "pending" },
+      script: { status: "pending" },
+      voices: { status: "pending" },
+      "viz-timing": { status: "pending" },
+      "sound-design": { status: "pending" },
       render: { status: "pending" }
     },
     lastUpdated: now
@@ -33,6 +34,34 @@ function getNextStep(progress) {
   }
   return null;
 }
+function migrateV1toV2(v1) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const init = v1.steps.init ?? { status: "pending" };
+  const extract = v1.steps.extract ?? { status: "pending" };
+  const render = v1.steps.render ?? { status: "pending" };
+  const script = v1.steps.curate ?? { status: "pending" };
+  const voices = v1.steps.audio ?? { status: "pending" };
+  const transformComplete = v1.steps.transform?.status === "complete";
+  const previewComplete = v1.steps.preview?.status === "complete";
+  const bothComplete = transformComplete && previewComplete;
+  const vizTiming = bothComplete ? { status: "complete", completedAt: v1.steps.transform?.completedAt ?? now } : { status: "pending" };
+  const soundDesign = bothComplete ? { status: "complete", completedAt: v1.steps.preview?.completedAt ?? now } : { status: "pending" };
+  return {
+    version: 2,
+    project: v1.project,
+    extractConfig: v1.extractConfig,
+    steps: {
+      init,
+      extract,
+      script,
+      voices,
+      "viz-timing": vizTiming,
+      "sound-design": soundDesign,
+      render
+    },
+    lastUpdated: now
+  };
+}
 var STEP_CONFIG = {
   init: {
     mode: "inline",
@@ -45,30 +74,27 @@ var STEP_CONFIG = {
     logFile: "extract.log",
     outputFiles: ["data/git-commits.json", "data/chat-activity.json"]
   },
-  curate: {
+  script: {
     mode: "inline",
-    label: "Curate editorial content",
+    label: "Write narrative script",
     creative: true,
-    outputFiles: [
-      "data/retro-page-data.json",
-      "data/retro-page-quotes.json",
-      "data/timeline-events.json"
-    ]
+    outputFiles: ["data/script.json"]
   },
-  transform: {
+  voices: {
     mode: "inline",
-    label: "Transform to viz-data",
-    outputFiles: ["output/viz-data.json"]
+    label: "Generate voices (TTS)",
+    creative: true,
+    outputFiles: []
   },
-  preview: {
+  "viz-timing": {
     mode: "inline",
-    label: "Preview visualization",
+    label: "Set visualization timing",
     creative: true,
-    outputFiles: ["viewer/public/data/viz-data.json"]
+    outputFiles: ["output/timing.json"]
   },
-  audio: {
+  "sound-design": {
     mode: "inline",
-    label: "Generate audio (ElevenLabs)",
+    label: "Sound design (SFX + music)",
     creative: true,
     outputFiles: []
   },
@@ -108,10 +134,16 @@ function readProgress(dir) {
   if (!existsSync(path)) return null;
   try {
     const raw = readFileSync(path, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.version !== 1) {
-      throw new Error(`Unsupported progress file version: ${data.version}`);
+    const raw_data = JSON.parse(raw);
+    if (raw_data.version === 1) {
+      const migrated = migrateV1toV2(raw_data);
+      writeProgress(dir, migrated);
+      return migrated;
+    }
+    if (raw_data.version !== 2) {
+      throw new Error(`Unsupported progress file version: ${raw_data.version}`);
     }
+    const data = raw_data;
     if (migrateProgressSteps(data)) {
       writeProgress(dir, data);
     }

package/dist-cli/{curate-CN2LX2QE.js → curate-7VM5QLE2.js}

@@ -1,15 +1,15 @@
-import {
-  inferRole
-} from "./chunk-HFGJKQTB.js";
 import {
   extractMentions,
   filterByDateRange
 } from "./chunk-R7QITZ76.js";
+import {
+  inferRole
+} from "./chunk-HFGJKQTB.js";
 import {
   markComplete,
   markInProgress,
   writeProgress
-} from "./chunk-KY56F5QU.js";
+} from "./chunk-X2MHAVAE.js";
 
 // src/cli/guided/steps/curate.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist-cli/{extract-ER32ZVS5.js → extract-7SPUMODE.js}

@@ -11,7 +11,7 @@ import {
   markError,
   markInProgress,
   writeProgress
-} from "./chunk-KY56F5QU.js";
+} from "./chunk-X2MHAVAE.js";
 
 // src/cli/guided/steps/extract.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist-cli/from-pacing-chain-J22MLDQP.js

@@ -0,0 +1,197 @@
+import {
+  TimingFileSchema
+} from "./chunk-SKRQW7PY.js";
+import {
+  PacingFileSchema
+} from "./chunk-3NPPXJ6N.js";
+import {
+  ScriptFileSchema
+} from "./chunk-BD2KEZI4.js";
+
+// src/cli/from-pacing-chain.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+
+// src/cli/generate-timing.ts
+function generateTiming(script, pacing) {
+  if (script.lines.length !== pacing.lines.length) {
+    throw new Error(
+      `Line count mismatch: script has ${script.lines.length} lines, pacing has ${pacing.lines.length}`
+    );
+  }
+  for (let i = 0; i < script.lines.length; i++) {
+    if (script.lines[i].id !== pacing.lines[i].id) {
+      throw new Error(
+        `Line ID mismatch at index ${i}: script has "${script.lines[i].id}", pacing has "${pacing.lines[i].id}"`
+      );
+    }
+  }
+  const leadIn = pacing.leadInSec ?? 0;
+  const tailOut = pacing.tailOutSec ?? 0;
+  const defaultPause = pacing.defaultPauseSec;
+  const defaultSpeed = pacing.defaultVizSpeed;
+  const resolved = [];
+  let wallClock = leadIn;
+  for (let i = 0; i < pacing.lines.length; i++) {
+    const pl = pacing.lines[i];
+    const sl = script.lines[i];
+    const pauseAfter = pl.pauseAfter ?? defaultPause;
+    const vizSpeed = pl.vizSpeed ?? defaultSpeed;
+    const gapVizSpeed = pl.gapVizSpeed ?? defaultSpeed;
+    resolved.push({
+      id: sl.id,
+      speaker: sl.speaker,
+      text: sl.text,
+      style: sl.style,
+      phase: sl.phaseId,
+      clipDuration: pl.clipDuration,
+      pauseAfter,
+      vizSpeed,
+      gapVizSpeed,
+      startSec: wallClock
+    });
+    wallClock += pl.clipDuration + pauseAfter;
+  }
+  const totalDurationSec = wallClock + tailOut;
+  let totalProjectTime = 0;
+  totalProjectTime += leadIn * defaultSpeed;
+  for (const line of resolved) {
+    totalProjectTime += line.clipDuration * line.vizSpeed;
+    totalProjectTime += line.pauseAfter * line.gapVizSpeed;
+  }
+  totalProjectTime += tailOut * defaultSpeed;
+  let accumulatedProjectTime = leadIn * defaultSpeed;
+  const timedLines = resolved.map((line) => {
+    const clipProjectTime = line.clipDuration * line.vizSpeed;
+    const gapProjectTime = line.pauseAfter * line.gapVizSpeed;
+    const progressStart = totalProjectTime > 0 ? accumulatedProjectTime / totalProjectTime : 0;
+    accumulatedProjectTime += clipProjectTime;
+    const progressEnd = totalProjectTime > 0 ? accumulatedProjectTime / totalProjectTime : 0;
+    accumulatedProjectTime += gapProjectTime;
+    return {
+      id: line.id,
+      speaker: line.speaker,
+      text: line.text,
+      style: line.style,
+      startSec: line.startSec,
+      durationSec: line.clipDuration,
+      pauseAfterSec: line.pauseAfter,
+      audioFile: `${line.id}.mp3`,
+      progressStart,
+      progressEnd,
+      vizSpeed: line.vizSpeed,
+      gapVizSpeed: line.gapVizSpeed,
+      phase: line.phase
+    };
+  });
+  return {
+    version: 1,
+    totalDurationSec,
+    lines: timedLines
+  };
+}
+function formatTimingPreview(timing, pacing) {
+  const rows = [];
+  const header = [
+    pad("Line ID", 18),
+    pad("Speaker", 12),
+    pad("Duration", 10),
+    pad("Pause", 8),
+    pad("VizSpeed", 10),
+    pad("Screen Time", 12)
+  ].join("| ");
+  rows.push(header);
+  rows.push("-".repeat(header.length));
+  for (const line of timing.lines) {
+    const screenTime = line.durationSec + line.pauseAfterSec;
+    rows.push(
+      [
+        pad(line.id, 18),
+        pad(line.speaker, 12),
+        pad(`${line.durationSec.toFixed(1)}s`, 10),
+        pad(`${line.pauseAfterSec.toFixed(1)}s`, 8),
+        pad(`${line.vizSpeed.toFixed(1)}x`, 10),
+        pad(`${screenTime.toFixed(1)}s`, 12)
+      ].join("| ")
+    );
+  }
+  rows.push("-".repeat(header.length));
+  const extras = [];
+  if (pacing?.leadInSec) extras.push(`lead-in: ${pacing.leadInSec.toFixed(1)}s`);
+  if (pacing?.tailOutSec) extras.push(`tail-out: ${pacing.tailOutSec.toFixed(1)}s`);
+  const extrasStr = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+  rows.push(`TOTAL: ${timing.totalDurationSec.toFixed(1)}s${extrasStr}`);
+  return rows.join("\n");
+}
+function pad(str, width) {
+  return str.padEnd(width);
+}
+
+// src/cli/from-pacing-chain.ts
+function runFromPacingChain(dataDir) {
+  const scriptPath = resolve(dataDir, "script.json");
+  const pacingPath = resolve(dataDir, "pacing.json");
+  const timingPath = resolve(dataDir, "timing.json");
+  if (!existsSync(scriptPath)) {
+    return {
+      success: false,
+      error: `script.json not found at ${scriptPath}. Write the script first (Step 2).`
+    };
+  }
+  let script;
+  try {
+    const raw = JSON.parse(readFileSync(scriptPath, "utf-8"));
+    script = ScriptFileSchema.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      error: `Invalid script.json: ${message}`
+    };
+  }
+  if (!existsSync(pacingPath)) {
+    return {
+      success: false,
+      error: `pacing.json not found at ${pacingPath}. Run 'npx miriad-viz scaffold-pacing' first.`
+    };
+  }
+  let pacing;
+  try {
+    const raw = JSON.parse(readFileSync(pacingPath, "utf-8"));
+    pacing = PacingFileSchema.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      error: `Invalid pacing.json: ${message}`
+    };
+  }
+  let timing;
+  try {
+    timing = generateTiming(script, pacing);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      error: `Timing generation failed: ${message}`
+    };
+  }
+  const validated = TimingFileSchema.safeParse(timing);
+  if (!validated.success) {
+    return {
+      success: false,
+      error: `Generated timing.json failed validation: ${validated.error.message}`
+    };
+  }
+  writeFileSync(timingPath, `${JSON.stringify(timing, null, 2)}
+`);
+  const previewTable = formatTimingPreview(timing, pacing);
+  return {
+    success: true,
+    timingPath,
+    previewTable
+  };
+}
+export {
+  runFromPacingChain
+};