@treeseed/sdk 0.10.28 → 0.12.4

package/dist/scenes/seed.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedSceneSeedOptions, TreeseedSceneSeedReport } from './types.js';
+export declare function planOrApplyTreeseedSceneSeed(input: TreeseedSceneSeedOptions): Promise<TreeseedSceneSeedReport>;

package/dist/scenes/seed.js

@@ -0,0 +1,83 @@
+import { pathToFileURL } from "node:url";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { MarketClient, resolveMarketProfile, resolveMarketSession } from "../market-client.js";
+import { loadAndPlanSeed } from "../seeds/index.js";
+import { findNearestTreeseedRoot } from "../workflow-support.js";
+import { sceneErrorDiagnostic } from "./diagnostics.js";
+function redacted(value) {
+  if (Array.isArray(value)) return value.map(redacted);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = /token|secret|key|password/iu.test(key) ? "<redacted>" : redacted(entry);
+    }
+    return out;
+  }
+  return value;
+}
+async function loadLocalSeedRunner(projectRoot) {
+  const applyModulePath = resolve(projectRoot, "src", "lib", "market", "seeds", "apply.js");
+  if (!existsSync(applyModulePath)) return null;
+  const module = await import(pathToFileURL(applyModulePath).href);
+  return module.applyLocalSeedViaApiFromCli ?? module.applyLocalSeedFromCli ?? null;
+}
+async function planOrApplyTreeseedSceneSeed(input) {
+  const setup = input.scene.setup.seed;
+  if (!setup?.name) {
+    return { ok: true, requested: false, seedName: null, mode: "none", environments: [], plan: null, result: null, diagnostics: [] };
+  }
+  const environments = setup.environments.length > 0 ? setup.environments : [input.environment];
+  const mode = setup.apply ? "apply" : "plan";
+  const planned = loadAndPlanSeed({
+    projectRoot: input.projectRoot,
+    seedName: setup.name,
+    environments: environments.join(","),
+    mode
+  });
+  const diagnostics = [...planned.diagnostics.map((entry) => ({
+    severity: entry.severity,
+    code: entry.code.startsWith("scene.") ? entry.code : `seed.${entry.code}`,
+    message: entry.message,
+    path: entry.path ? `setup.seed.${entry.path}` : "setup.seed"
+  }))];
+  if (!planned.plan) {
+    diagnostics.push(sceneErrorDiagnostic("scene.seed_plan_failed", `Seed "${setup.name}" could not be planned.`, "setup.seed"));
+    return { ok: false, requested: true, seedName: setup.name, mode, environments, plan: null, result: null, diagnostics };
+  }
+  if (!setup.apply) {
+    return { ok: !diagnostics.some((entry) => entry.severity === "error"), requested: true, seedName: setup.name, mode: "plan", environments, plan: planned.plan, result: null, diagnostics };
+  }
+  try {
+    if (environments.some((environment) => environment !== "local")) {
+      const profile = resolveMarketProfile(input.scene.setup.auth?.profile ?? null);
+      const authRoot = findNearestTreeseedRoot(input.projectRoot) ?? input.projectRoot;
+      const session = resolveMarketSession(authRoot, profile.id);
+      if (!session?.accessToken) {
+        throw sceneErrorDiagnostic("scene.auth_required", `Not logged in to market "${profile.id}". Run treeseed auth:login --market ${profile.id}.`, "setup.auth");
+      }
+      const client = new MarketClient({ profile, accessToken: session.accessToken, userAgent: "treeseed-scene" });
+      const result = await client.applySeed(setup.name, { environments });
+      return { ok: true, requested: true, seedName: setup.name, mode: "apply", environments, plan: planned.plan, result: redacted(result), diagnostics };
+    }
+    const runner = await loadLocalSeedRunner(input.projectRoot);
+    if (!runner) {
+      diagnostics.push(sceneErrorDiagnostic("scene.seed_apply_failed", "Local seed apply service is not available in this project.", "setup.seed"));
+      return { ok: false, requested: true, seedName: setup.name, mode: "apply", environments, plan: planned.plan, result: null, diagnostics };
+    }
+    const applied = await runner({
+      projectRoot: input.projectRoot,
+      seedName: setup.name,
+      environments: environments.join(","),
+      plan: planned.plan,
+      env: input.env
+    });
+    return { ok: true, requested: true, seedName: setup.name, mode: "apply", environments, plan: applied.plan ?? planned.plan, result: redacted(applied.result ?? applied), diagnostics };
+  } catch (error) {
+    const diagnostic = error && typeof error === "object" && "code" in error ? error : sceneErrorDiagnostic("scene.seed_apply_failed", error instanceof Error ? error.message : String(error ?? "Seed apply failed."), "setup.seed");
+    return { ok: false, requested: true, seedName: setup.name, mode: "apply", environments, plan: planned.plan, result: null, diagnostics: [...diagnostics, diagnostic] };
+  }
+}
+export {
+  planOrApplyTreeseedSceneSeed
+};

package/dist/scenes/segments.d.ts

@@ -0,0 +1,15 @@
+import type { TreeseedSceneChapter, TreeseedSceneManifest, TreeseedSceneRunChapterReport, TreeseedSceneRunSegmentReport, TreeseedSceneRunStatus, TreeseedSceneRunStepReport, TreeseedSceneTimelineEvent } from './types.js';
+export declare function deriveTreeseedSceneStepChapters(scene: TreeseedSceneManifest): Map<string, TreeseedSceneChapter>;
+export declare function createTreeseedSceneChapterReports(scene: TreeseedSceneManifest): TreeseedSceneRunChapterReport[];
+export declare function createTreeseedSceneSegment(input: {
+    segmentsRoot: string;
+    chapterId: string;
+    index: number;
+    startedAt?: string;
+}): TreeseedSceneRunSegmentReport;
+export declare function finishTreeseedSceneSegment(segment: TreeseedSceneRunSegmentReport, status: TreeseedSceneRunStatus): TreeseedSceneRunSegmentReport;
+export declare function writeTreeseedSceneSegmentArtifacts(input: {
+    segment: TreeseedSceneRunSegmentReport;
+    steps: TreeseedSceneRunStepReport[];
+    timeline: TreeseedSceneTimelineEvent[];
+}): void;

package/dist/scenes/segments.js

@@ -0,0 +1,79 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function duration(startedAt, finishedAt) {
+  return finishedAt ? Math.max(0, Date.parse(finishedAt) - Date.parse(startedAt)) : 0;
+}
+function deriveTreeseedSceneStepChapters(scene) {
+  const starts = new Map(scene.chapters.map((chapter) => [chapter.startsAt, chapter]));
+  const defaultChapter = { id: "default", title: "Default", startsAt: scene.workflow[0]?.id ?? "default" };
+  let current = scene.chapters.length > 0 && starts.has(scene.workflow[0]?.id ?? "") ? starts.get(scene.workflow[0].id) : defaultChapter;
+  const result = /* @__PURE__ */ new Map();
+  for (const step of scene.workflow) {
+    current = starts.get(step.id) ?? current;
+    result.set(step.id, current);
+  }
+  return result;
+}
+function createTreeseedSceneChapterReports(scene) {
+  const stepChapters = deriveTreeseedSceneStepChapters(scene);
+  const reports = /* @__PURE__ */ new Map();
+  for (const step of scene.workflow) {
+    const chapter = stepChapters.get(step.id);
+    if (!reports.has(chapter.id)) {
+      reports.set(chapter.id, {
+        id: chapter.id,
+        title: chapter.title,
+        startedAt: iso(),
+        finishedAt: null,
+        durationMs: 0,
+        status: "passed",
+        stepIds: [],
+        segmentIds: []
+      });
+    }
+    reports.get(chapter.id).stepIds.push(step.id);
+  }
+  return [...reports.values()];
+}
+function createTreeseedSceneSegment(input) {
+  const id = `${input.chapterId}-segment-${String(input.index).padStart(3, "0")}`;
+  const root = join(input.segmentsRoot, input.chapterId, id);
+  mkdirSync(root, { recursive: true });
+  return {
+    id,
+    chapterId: input.chapterId,
+    startedAt: input.startedAt ?? iso(),
+    finishedAt: null,
+    durationMs: 0,
+    status: "passed",
+    stepIds: [],
+    timelinePath: join(root, "timeline.json"),
+    stepsPath: join(root, "steps.json"),
+    segmentPath: join(root, "segment.json"),
+    videoRefs: []
+  };
+}
+function finishTreeseedSceneSegment(segment, status) {
+  segment.finishedAt = iso();
+  segment.durationMs = duration(segment.startedAt, segment.finishedAt);
+  segment.status = status;
+  return segment;
+}
+function writeTreeseedSceneSegmentArtifacts(input) {
+  writeFileSync(input.segment.segmentPath, `${JSON.stringify(input.segment, null, 2)}
+`, "utf8");
+  writeFileSync(input.segment.stepsPath, `${JSON.stringify(input.steps, null, 2)}
+`, "utf8");
+  writeFileSync(input.segment.timelinePath, `${JSON.stringify(input.timeline, null, 2)}
+`, "utf8");
+}
+export {
+  createTreeseedSceneChapterReports,
+  createTreeseedSceneSegment,
+  deriveTreeseedSceneStepChapters,
+  finishTreeseedSceneSegment,
+  writeTreeseedSceneSegmentArtifacts
+};

package/dist/scenes/selectors.d.ts

@@ -0,0 +1,3 @@
+import type { TreeseedSceneLocator, TreeseedScenePage, TreeseedSceneSelector } from './types.js';
+export declare function describeTreeseedSceneSelector(selector: TreeseedSceneSelector): string;
+export declare function resolveTreeseedSceneLocator(page: TreeseedScenePage, selector: TreeseedSceneSelector): TreeseedSceneLocator;

package/dist/scenes/selectors.js

@@ -0,0 +1,21 @@
+function escapeAttribute(value) {
+  return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+}
+function describeTreeseedSceneSelector(selector) {
+  if ("scene" in selector) return `data-scene=${selector.scene}`;
+  if ("testId" in selector) return `data-testid=${selector.testId}`;
+  if ("role" in selector) return selector.name ? `role=${selector.role} name=${selector.name}` : `role=${selector.role}`;
+  if ("text" in selector) return `text=${selector.text}`;
+  return `css=${selector.css}`;
+}
+function resolveTreeseedSceneLocator(page, selector) {
+  if ("scene" in selector) return page.locator(`[data-scene="${escapeAttribute(selector.scene)}"]`);
+  if ("testId" in selector) return page.getByTestId(selector.testId);
+  if ("role" in selector) return page.getByRole(selector.role, selector.name ? { name: selector.name } : void 0);
+  if ("text" in selector) return page.getByText(selector.text);
+  return page.locator(selector.css);
+}
+export {
+  describeTreeseedSceneSelector,
+  resolveTreeseedSceneLocator
+};

package/dist/scenes/timeline.d.ts

@@ -0,0 +1,11 @@
+import type { TreeseedSceneTimelineEvent } from './types.js';
+export type TreeseedSceneTimelineWriter = {
+    events: TreeseedSceneTimelineEvent[];
+    push(type: TreeseedSceneTimelineEvent['type'], data: Record<string, unknown>, stepId?: string): TreeseedSceneTimelineEvent;
+};
+export declare function createTreeseedSceneTimeline(input: {
+    sceneId: string;
+    runId: string;
+    startedAtMs: number;
+    now?: () => Date;
+}): TreeseedSceneTimelineWriter;

package/dist/scenes/timeline.js

@@ -0,0 +1,26 @@
+function createTreeseedSceneTimeline(input) {
+  const events = [];
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  let sequence = 0;
+  return {
+    events,
+    push(type, data, stepId) {
+      const timestamp = now();
+      const event = {
+        id: `${input.runId}-${String(sequence += 1).padStart(5, "0")}`,
+        type,
+        sceneId: input.sceneId,
+        runId: input.runId,
+        ...stepId ? { stepId } : {},
+        timestamp: timestamp.toISOString(),
+        offsetMs: Math.max(0, timestamp.getTime() - input.startedAtMs),
+        data
+      };
+      events.push(event);
+      return event;
+    }
+  };
+}
+export {
+  createTreeseedSceneTimeline
+};

package/dist/scenes/timeouts.d.ts

@@ -0,0 +1,6 @@
+import type { TreeseedSceneDiagnostic } from './types.js';
+export declare function withTreeseedSceneTimeout<T>(input: {
+    promise: Promise<T>;
+    timeoutMs: number | null;
+    diagnostic: TreeseedSceneDiagnostic;
+}): Promise<T>;

package/dist/scenes/timeouts.js

@@ -0,0 +1,17 @@
+async function withTreeseedSceneTimeout(input) {
+  if (!input.timeoutMs || input.timeoutMs <= 0) return input.promise;
+  let timeout;
+  try {
+    return await Promise.race([
+      input.promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(input.diagnostic), input.timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+export {
+  withTreeseedSceneTimeout
+};

package/dist/scenes/training-captions.d.ts

@@ -0,0 +1,14 @@
+import type { TreeseedSceneCaptionCue, TreeseedSceneManifest, TreeseedSceneRunReport, TreeseedSceneTimelineEvent } from './types.js';
+export declare function stepOffset(input: {
+    stepId: string;
+    timeline: TreeseedSceneTimelineEvent[];
+    prefer?: 'start' | 'end';
+    fallbackMs?: number;
+}): number;
+export declare function buildTreeseedSceneCaptionCues(input: {
+    scene: TreeseedSceneManifest;
+    run: TreeseedSceneRunReport;
+    timeline: TreeseedSceneTimelineEvent[];
+}): TreeseedSceneCaptionCue[];
+export declare function formatTreeseedSceneCaptionsVtt(cues: TreeseedSceneCaptionCue[]): string;
+export declare function formatTreeseedSceneCaptionsSrt(cues: TreeseedSceneCaptionCue[]): string;

package/dist/scenes/training-captions.js

@@ -0,0 +1,98 @@
+function clampText(value) {
+  return value.replace(/\s+/gu, " ").trim();
+}
+function formatTimestamp(ms, separator) {
+  const totalMs = Math.max(0, Math.round(ms));
+  const hours = Math.floor(totalMs / 36e5);
+  const minutes = Math.floor(totalMs % 36e5 / 6e4);
+  const seconds = Math.floor(totalMs % 6e4 / 1e3);
+  const millis = totalMs % 1e3;
+  return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}${separator}${String(millis).padStart(3, "0")}`;
+}
+function stepOffset(input) {
+  const preferredType = input.prefer === "end" ? "step.end" : "step.start";
+  const preferred = input.timeline.find((event) => event.stepId === input.stepId && event.type === preferredType);
+  if (preferred) return preferred.offsetMs;
+  const any = input.timeline.find((event) => event.stepId === input.stepId);
+  return any?.offsetMs ?? input.fallbackMs ?? 0;
+}
+function chapterForStep(run, stepId) {
+  return (run.chapters ?? []).find((chapter) => chapter.stepIds.includes(stepId)) ?? null;
+}
+function boundedCue(input) {
+  const startMs = Math.max(0, Math.round(input.startMs));
+  const requestedEnd = input.endMs && input.endMs > startMs ? input.endMs : startMs + input.maxCueMs;
+  const endMs = Math.max(startMs + 1e3, Math.min(Math.round(requestedEnd), startMs + input.maxCueMs));
+  return {
+    id: input.id,
+    startMs,
+    endMs,
+    text: clampText(input.text),
+    ...input.stepId ? { stepId: input.stepId } : {},
+    ...input.chapterId ? { chapterId: input.chapterId } : {}
+  };
+}
+function buildTreeseedSceneCaptionCues(input) {
+  const maxCueMs = Math.max(1e3, Math.round(input.scene.training.captions.maxCueSeconds * 1e3));
+  const cues = [];
+  for (const chapter of input.run.chapters ?? []) {
+    const firstStep = chapter.stepIds[0];
+    const startMs = firstStep ? stepOffset({ stepId: firstStep, timeline: input.timeline }) : 0;
+    cues.push(boundedCue({ id: `chapter-${chapter.id}`, startMs, maxCueMs, text: `Chapter: ${chapter.title}`, chapterId: chapter.id }));
+  }
+  input.run.steps.forEach((step, index) => {
+    const chapter = chapterForStep(input.run, step.id);
+    const startMs = stepOffset({ stepId: step.id, timeline: input.timeline, fallbackMs: index * 4e3 });
+    const endMs = stepOffset({ stepId: step.id, timeline: input.timeline, prefer: "end", fallbackMs: startMs + maxCueMs });
+    cues.push(boundedCue({ id: `step-${step.id}`, startMs, endMs, maxCueMs, text: step.title, stepId: step.id, chapterId: chapter?.id ?? null }));
+  });
+  for (const overlay of input.scene.overlays ?? []) {
+    if (!overlay.text) continue;
+    const startMs = stepOffset({ stepId: overlay.at, timeline: input.timeline });
+    const chapter = chapterForStep(input.run, overlay.at);
+    cues.push(boundedCue({ id: `overlay-${overlay.id}`, startMs, maxCueMs, text: overlay.text, stepId: overlay.at, chapterId: chapter?.id ?? null }));
+  }
+  for (const diagram of input.scene.diagrams ?? []) {
+    const title = typeof diagram.props?.title === "string" ? diagram.props.title : diagram.id;
+    const startMs = stepOffset({ stepId: diagram.at, timeline: input.timeline });
+    const chapter = chapterForStep(input.run, diagram.at);
+    cues.push(boundedCue({ id: `diagram-${diagram.id}`, startMs, maxCueMs, text: `Diagram: ${title}`, stepId: diagram.at, chapterId: chapter?.id ?? null }));
+  }
+  const failedStep = input.run.failedStep ? input.run.steps.find((step) => step.id === input.run.failedStep) : null;
+  if (failedStep?.error && input.scene.training.narration.includeDiagnostics) {
+    const startMs = stepOffset({ stepId: failedStep.id, timeline: input.timeline });
+    const chapter = chapterForStep(input.run, failedStep.id);
+    cues.push(boundedCue({ id: `diagnostic-${failedStep.id}`, startMs, maxCueMs, text: `${failedStep.error.code}: ${failedStep.error.message}`, stepId: failedStep.id, chapterId: chapter?.id ?? null }));
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const cue of cues.filter((cue2) => cue2.text.length > 0)) byId.set(cue.id, cue);
+  return [...byId.values()].sort((a, b) => a.startMs - b.startMs || a.id.localeCompare(b.id));
+}
+function formatTreeseedSceneCaptionsVtt(cues) {
+  const lines = ["WEBVTT", ""];
+  for (const cue of cues) {
+    lines.push(cue.id);
+    lines.push(`${formatTimestamp(cue.startMs, ".")} --> ${formatTimestamp(cue.endMs, ".")}`);
+    lines.push(cue.text);
+    lines.push("");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+function formatTreeseedSceneCaptionsSrt(cues) {
+  const lines = [];
+  cues.forEach((cue, index) => {
+    lines.push(String(index + 1));
+    lines.push(`${formatTimestamp(cue.startMs, ",")} --> ${formatTimestamp(cue.endMs, ",")}`);
+    lines.push(cue.text);
+    lines.push("");
+  });
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+export {
+  buildTreeseedSceneCaptionCues,
+  formatTreeseedSceneCaptionsSrt,
+  formatTreeseedSceneCaptionsVtt,
+  stepOffset
+};

package/dist/scenes/training-report.d.ts

@@ -0,0 +1,10 @@
+import type { TreeseedSceneDiagnostic, TreeseedSceneManifest, TreeseedSceneTrainingOutputPaths, TreeseedSceneTrainingOutputs } from './types.js';
+export declare function writeTreeseedSceneTrainingOutputs(input: {
+    runRoot: string;
+    scene: TreeseedSceneManifest;
+    outputs: TreeseedSceneTrainingOutputs;
+}): TreeseedSceneTrainingOutputPaths;
+export declare function appendTreeseedSceneTrainingOutputPaths(input: {
+    runPath: string;
+    paths: TreeseedSceneTrainingOutputPaths;
+}): TreeseedSceneDiagnostic[];

package/dist/scenes/training-report.js

@@ -0,0 +1,78 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { sceneWarningDiagnostic } from "./diagnostics.js";
+import { formatTreeseedSceneCaptionsSrt, formatTreeseedSceneCaptionsVtt } from "./training-captions.js";
+import {
+  formatTreeseedSceneGlossaryMarkdown,
+  formatTreeseedSceneNarrationMarkdown,
+  formatTreeseedSceneTranscriptMarkdown
+} from "./training-transcript.js";
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function writeText(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, value, "utf8");
+}
+function writeTreeseedSceneTrainingOutputs(input) {
+  const trainingRoot = join(input.runRoot, "training");
+  const paths = {
+    trainingRoot,
+    inputPath: join(trainingRoot, "input.json"),
+    reportPath: join(trainingRoot, "report.json"),
+    captionsVttPath: input.scene.training.enabled && input.scene.training.captions.enabled && input.scene.training.captions.formats.includes("vtt") ? join(trainingRoot, "captions.vtt") : null,
+    captionsSrtPath: input.scene.training.enabled && input.scene.training.captions.enabled && input.scene.training.captions.formats.includes("srt") ? join(trainingRoot, "captions.srt") : null,
+    transcriptJsonPath: input.scene.training.enabled && input.scene.training.transcript.enabled && input.scene.training.transcript.formats.includes("json") ? join(trainingRoot, "transcript.json") : null,
+    transcriptMarkdownPath: input.scene.training.enabled && input.scene.training.transcript.enabled && input.scene.training.transcript.formats.includes("markdown") ? join(trainingRoot, "transcript.md") : null,
+    narrationJsonPath: input.scene.training.enabled && input.scene.training.narration.enabled ? join(trainingRoot, "narration.json") : null,
+    narrationMarkdownPath: input.scene.training.enabled && input.scene.training.narration.enabled ? join(trainingRoot, "narration.md") : null,
+    glossaryJsonPath: input.scene.training.enabled && input.scene.training.glossary.enabled ? join(trainingRoot, "glossary.json") : null,
+    glossaryMarkdownPath: input.scene.training.enabled && input.scene.training.glossary.enabled ? join(trainingRoot, "glossary.md") : null,
+    chapterClipsPath: input.scene.training.enabled && input.scene.training.chapterClips.enabled ? join(trainingRoot, "chapter-clips.json") : null
+  };
+  writeJson(paths.inputPath, input.outputs);
+  writeJson(paths.reportPath, {
+    ok: true,
+    phase: 8,
+    sceneId: input.outputs.sceneId,
+    runId: input.outputs.runId,
+    generatedAt: input.outputs.generatedAt,
+    counts: {
+      captions: input.outputs.captions.length,
+      transcript: input.outputs.transcript.length,
+      narration: input.outputs.narration.length,
+      glossary: input.outputs.glossary.length,
+      chapterClips: input.outputs.chapterClips.length
+    },
+    paths
+  });
+  if (paths.captionsVttPath) writeText(paths.captionsVttPath, formatTreeseedSceneCaptionsVtt(input.outputs.captions));
+  if (paths.captionsSrtPath) writeText(paths.captionsSrtPath, formatTreeseedSceneCaptionsSrt(input.outputs.captions));
+  if (paths.transcriptJsonPath) writeJson(paths.transcriptJsonPath, input.outputs.transcript);
+  if (paths.transcriptMarkdownPath) writeText(paths.transcriptMarkdownPath, formatTreeseedSceneTranscriptMarkdown(input.outputs.transcript));
+  if (paths.narrationJsonPath) writeJson(paths.narrationJsonPath, input.outputs.narration);
+  if (paths.narrationMarkdownPath) writeText(paths.narrationMarkdownPath, formatTreeseedSceneNarrationMarkdown(input.outputs.narration));
+  if (paths.glossaryJsonPath) writeJson(paths.glossaryJsonPath, input.outputs.glossary);
+  if (paths.glossaryMarkdownPath) writeText(paths.glossaryMarkdownPath, formatTreeseedSceneGlossaryMarkdown(input.outputs.glossary));
+  if (paths.chapterClipsPath) writeJson(paths.chapterClipsPath, input.outputs.chapterClips);
+  return paths;
+}
+function appendTreeseedSceneTrainingOutputPaths(input) {
+  try {
+    const run = JSON.parse(readFileSync(input.runPath, "utf8"));
+    writeJson(input.runPath, {
+      ...run,
+      trainingOutputPaths: input.paths,
+      logs: run.logs ? { ...run.logs, training: input.paths.trainingRoot } : run.logs
+    });
+    return [];
+  } catch (error) {
+    return [sceneWarningDiagnostic("scene.training_run_update_failed", `Training outputs were written but run.json could not be updated. ${error instanceof Error ? error.message : String(error ?? "")}`.trim(), "run.json")];
+  }
+}
+export {
+  appendTreeseedSceneTrainingOutputPaths,
+  writeTreeseedSceneTrainingOutputs
+};

package/dist/scenes/training-transcript.d.ts

@@ -0,0 +1,24 @@
+import type { TreeseedSceneChapterClipManifest, TreeseedSceneGlossaryTerm, TreeseedSceneManifest, TreeseedSceneNarrationScriptEntry, TreeseedSceneRunReport, TreeseedSceneTimelineEvent, TreeseedSceneTrainingNarrationStyle, TreeseedSceneTranscriptEntry } from './types.js';
+export declare function buildTreeseedSceneTranscriptEntries(input: {
+    scene: TreeseedSceneManifest;
+    run: TreeseedSceneRunReport;
+    timeline: TreeseedSceneTimelineEvent[];
+}): TreeseedSceneTranscriptEntry[];
+export declare function buildTreeseedSceneNarrationEntries(input: {
+    scene: TreeseedSceneManifest;
+    run: TreeseedSceneRunReport;
+    transcript: TreeseedSceneTranscriptEntry[];
+    style: TreeseedSceneTrainingNarrationStyle;
+}): TreeseedSceneNarrationScriptEntry[];
+export declare function buildTreeseedSceneGlossary(input: {
+    scene: TreeseedSceneManifest;
+    transcript: TreeseedSceneTranscriptEntry[];
+}): TreeseedSceneGlossaryTerm[];
+export declare function buildTreeseedSceneChapterClips(input: {
+    scene: TreeseedSceneManifest;
+    run: TreeseedSceneRunReport;
+    timeline: TreeseedSceneTimelineEvent[];
+}): TreeseedSceneChapterClipManifest[];
+export declare function formatTreeseedSceneTranscriptMarkdown(entries: TreeseedSceneTranscriptEntry[]): string;
+export declare function formatTreeseedSceneNarrationMarkdown(entries: TreeseedSceneNarrationScriptEntry[]): string;
+export declare function formatTreeseedSceneGlossaryMarkdown(terms: TreeseedSceneGlossaryTerm[]): string;