@hajimism/dek 0.1.0

package/src/cli/format.ts

@@ -0,0 +1,156 @@
+import { isAbsolute, relative } from "node:path";
+import type { Diagnostic } from "../core/diagnostic.ts";
+import { type ErrorFields, errorFields } from "../core/error.ts";
+import type { LiveEvent } from "../core/live-protocol.ts";
+import { ansi, displayWidth, padEndWidth, padStartWidth } from "./tty.ts";
+
+function formatLocation(location: { path?: string; line?: number; column?: number }): string {
+  if (location.path !== undefined && location.line !== undefined) {
+    const column = location.column === undefined ? "" : `:${location.column}`;
+    return `${location.path}:${location.line}${column}`;
+  }
+  if (location.path !== undefined) {
+    return location.path;
+  }
+  if (location.line !== undefined) {
+    return String(location.line);
+  }
+  return "";
+}
+
+export function formatDiagnostics(
+  diagnostics: Diagnostic[],
+  opts?: { color?: boolean; cwd?: string },
+): string {
+  if (diagnostics.length === 0) {
+    return "no diagnostics";
+  }
+  const c = ansi(opts?.color === true);
+  const lines = diagnostics.flatMap((diagnostic) => {
+    const where = formatLocation({
+      ...diagnostic,
+      ...(diagnostic.path !== undefined ? { path: displayPath(diagnostic.path, opts?.cwd) } : {}),
+    });
+    const prefix = where ? `${c.cyan(where)}: ` : "";
+    const label = diagnostic.severity === "warning" ? ` ${c.yellow("warning:")}` : "";
+    const line = `${prefix}${c.yellow(diagnostic.id)}${label} ${diagnostic.message}`;
+    return diagnostic.hint ? [line, `  ${c.yellow("help:")} ${diagnostic.hint}`] : [line];
+  });
+  return lines.join("\n");
+}
+
+export type FormattedError = ErrorFields;
+
+/** A path as the reader should type it: relative to `cwd` when one is given. */
+export function displayPath(path: string, cwd?: string): string {
+  if (cwd === undefined || !isAbsolute(path)) {
+    return path;
+  }
+  return relative(cwd, path) || ".";
+}
+
+export function formatError(error: unknown, opts?: { cwd?: string }): FormattedError {
+  const fields = errorFields(error);
+  return fields.path === undefined
+    ? fields
+    : { ...fields, path: displayPath(fields.path, opts?.cwd) };
+}
+
+export function formatErrorText(error: unknown, opts?: { color?: boolean; cwd?: string }): string {
+  const formatted = formatError(error, opts);
+  const c = ansi(opts?.color === true);
+  const parts = [`${c.bold(c.red("error:"))} ${formatted.message}`];
+  if (formatted.path) {
+    const loc =
+      formatted.line !== undefined ? `${formatted.path}:${formatted.line}` : formatted.path;
+    parts.push(` ${c.cyan("-->")} ${loc}`);
+  }
+  if (formatted.hint) {
+    parts.push(`  ${c.yellow("help:")} ${formatted.hint}`);
+  }
+  return parts.join("\n");
+}
+
+export function formatTable(
+  headers: string[],
+  rows: string[][],
+  align?: Array<"left" | "right">,
+): string {
+  const widths = headers.map((header, index) =>
+    Math.max(displayWidth(header), ...rows.map((row) => displayWidth(row[index] ?? ""))),
+  );
+  const pad = (cell: string, index: number): string => {
+    const width = widths[index] ?? 0;
+    return (align?.[index] ?? "left") === "right"
+      ? padStartWidth(cell, width)
+      : padEndWidth(cell, width);
+  };
+  const line = (cells: string[]): string => cells.map((cell, index) => pad(cell, index)).join("  ");
+  return [line(headers), ...rows.map((row) => line(row))].join("\n");
+}
+
+export function formatCreated(
+  created: string[],
+  updated: string[] = [],
+  removed: string[] = [],
+): string {
+  const count = created.length + updated.length + removed.length;
+  const header = `synced ${count} ${count === 1 ? "file" : "files"}`;
+  const lines = [
+    ...created,
+    ...updated.map((path) => `${path} (updated)`),
+    ...removed.map((path) => `${path} (removed)`),
+  ];
+  return [header, ...lines.map((line) => `  ${line}`)].join("\n");
+}
+
+/**
+ * A dev server event as the terminal shows it. `deck` names the deck on each line that starts an
+ * entry, for a server that serves several; lines that continue one stay indented under it.
+ */
+export function formatDevEvent(
+  event: LiveEvent,
+  opts?: { cwd?: string; deck?: string },
+): string | null {
+  const text = formatLiveEvent(event, opts?.cwd);
+  const deck = opts?.deck;
+  if (text === null || deck === undefined) {
+    return text;
+  }
+  return text
+    .split("\n")
+    .map((line) => (/^\s/.test(line) ? line : `[${deck}] ${line}`))
+    .join("\n");
+}
+
+function formatLiveEvent(event: LiveEvent, cwd: string | undefined): string | null {
+  switch (event.type) {
+    case "reload-slide":
+      return `reload-slide ${event.slug}`;
+    case "reload-theme":
+      return "reload-theme";
+    case "reload-script":
+      return `reload-script ${event.slugs.join(", ")}`;
+    case "sync":
+      if ((event.removed?.length ?? 0) > 0 && event.created.length === 0) {
+        const count = event.removed?.length ?? 0;
+        return `removed ${count} ${count === 1 ? "file" : "files"}`;
+      }
+      return formatCreated(event.created, event.updated, event.removed);
+    case "diagnostics":
+      return event.diagnostics.length === 0 ? null : formatDiagnostics(event.diagnostics, { cwd });
+    case "timeline":
+      return "timeline";
+  }
+}
+
+export function writeDevEvent(
+  event: LiveEvent,
+  stream: { write(chunk: string): unknown },
+  opts?: { cwd?: string; deck?: string },
+): void {
+  const text = formatDevEvent(event, opts);
+  if (text) {
+    stream.write(`${text}\n`);
+  }
+}

package/src/cli/goto.ts

@@ -0,0 +1,96 @@
+import { DekError } from "../core/error.ts";
+import { deckRoutePath } from "../runtime/routes.ts";
+import { isPidAlive, readDevServerLock } from "../server/lock.ts";
+import { type DeckTarget, requireSection } from "./scope.ts";
+
+export type NavResult = {
+  slug: string;
+  slideIndex: number;
+  beatIndex: number;
+  /** The pages that show the deck; with none, the position is where the next one lands. */
+  viewers: number;
+};
+
+export async function gotoCommand(target: DeckTarget, slug: string): Promise<NavResult> {
+  requireSection(target.deck, slug);
+  return requestDevServer(target, {
+    method: "POST",
+    path: "goto",
+    body: { slug },
+  });
+}
+
+export async function currentCommand(target: DeckTarget): Promise<NavResult> {
+  return requestDevServer(target, { method: "GET", path: "current" });
+}
+
+async function requestDevServer(
+  { project, deck }: DeckTarget,
+  request: { method: "GET" | "POST"; path: "goto" | "current"; body?: { slug: string } },
+): Promise<NavResult> {
+  const deckName = deck.name;
+  const lock = readDevServerLock(project.root);
+  if (!lock || !isPidAlive(lock.pid)) {
+    throw new DekError("dev server is not running", { hint: "run `dekc`" });
+  }
+
+  // Under /decks/<name> whether or not the server is scoped to this deck; a scoped one takes both.
+  const url = new URL(deckRoutePath(deckName, { kind: request.path }), lock.url);
+  const headers: Record<string, string> = {};
+  if (request.body) {
+    headers["content-type"] = "application/json";
+  }
+  if (lock.password) {
+    headers.authorization = `Basic ${btoa(`:${lock.password}`)}`;
+  }
+  const response = await fetch(url, {
+    method: request.method,
+    headers: Object.keys(headers).length > 0 ? headers : undefined,
+    body: request.body ? JSON.stringify(request.body) : undefined,
+  });
+  // Only the nav routes answer JSON; a 404, 401, or 405 from the server itself is plain text.
+  if (!response.headers.get("content-type")?.includes("application/json")) {
+    throw refusal(response.status, lock, deckName, request.path);
+  }
+  const json = (await response.json()) as {
+    ok?: boolean;
+    slug?: string;
+    slideIndex?: number;
+    beatIndex?: number;
+    viewers?: number;
+    error?: { message?: string };
+  };
+  if (!response.ok || json.ok === false || json.slug === undefined) {
+    throw new DekError(json.error?.message ?? `dev server ${request.path} failed`, {
+      hint: "run `dekc`",
+    });
+  }
+  return {
+    slug: json.slug,
+    slideIndex: json.slideIndex ?? 0,
+    beatIndex: json.beatIndex ?? 0,
+    viewers: json.viewers ?? 0,
+  };
+}
+
+/** Why the server turned the request away before a nav route saw it. */
+function refusal(
+  status: number,
+  lock: { url: string; deck?: string },
+  deckName: string,
+  path: string,
+): DekError {
+  if (status === 404 && lock.deck !== undefined && lock.deck !== deckName) {
+    return new DekError(`the running dev server serves deck "${lock.deck}", not "${deckName}"`, {
+      hint: `pass --deck ${lock.deck}, or stop the server at ${lock.url} and run \`dekc ${deckName}\``,
+    });
+  }
+  if (status === 401) {
+    return new DekError(`the dev server at ${lock.url} refused the password in .dek/server.json`, {
+      hint: "restart it: stop `dekc` and run it again",
+    });
+  }
+  return new DekError(`dev server ${path} failed with HTTP ${status}`, {
+    hint: `restart the server at ${lock.url}: stop \`dek\` and run it again`,
+  });
+}

package/src/cli/init.ts

@@ -0,0 +1,136 @@
+import { existsSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { parseCss, publishedTokens } from "../core/css.ts";
+import { deckPaths } from "../core/deck-paths.ts";
+import { DekError } from "../core/error.ts";
+import { REQUIRED_TOKENS } from "../core/lint/tokens.ts";
+import { walkUp } from "../core/optional.ts";
+import { DECK_NAME_HINT, isDeckName } from "../core/path.ts";
+import { readTextIfExists } from "../core/resolve.ts";
+import {
+  defaultTsconfig,
+  dekFilePaths,
+  type FileChanges,
+  syncDeck,
+  writeDekFiles,
+} from "../core/sync.ts";
+import {
+  applyPlan,
+  checkFileSlots,
+  deckPlan,
+  defaultGitignore,
+  defaultRumdl,
+  defaultTheme,
+  defaultToml,
+  nextSteps,
+  type PlannedPath,
+  playwrightStep,
+  shellQuote,
+} from "./files.ts";
+
+export type InitResult = {
+  root: string;
+  /** Paths init wrote. */
+  created: string[];
+  /** dek's own files, already there, that init brought up to date. */
+  updated: string[];
+  /** Files that were already there and differ from what init would write; left as they are. */
+  kept: string[];
+  /** The commands to run next, from the directory init ran in. */
+  next: string[];
+  /** The Playwright install, when the project lacks it: `dekc shot`, `dekc pdf`, and `--visual` need it. */
+  playwright?: string;
+  /**
+   * The tokens a kept theme.css lacks of the ones every deck needs, when it lacks any. Each deck
+   * copies the project theme, so its lint would report them all on its first run.
+   */
+  missingTokens?: string[];
+};
+
+/**
+ * Plans the whole project, checks it, then writes only what is missing. Run
+ * again, it fills in what is gone and keeps everything else, edits included.
+ */
+export function initCommand(options: { cwd: string; dir?: string; deck?: string }): InitResult {
+  const root = resolve(options.cwd, options.dir ?? ".");
+  if (options.deck !== undefined && !isDeckName(options.deck)) {
+    throw new DekError(`invalid deck name "${options.deck}"`, {
+      hint: DECK_NAME_HINT,
+    });
+  }
+  checkTarget(root);
+  checkFileSlots(dekFilePaths(root));
+
+  const { created, kept } = applyPlan(projectPlan(root, options.deck));
+  const deckDir = options.deck ? join(root, "decks", options.deck) : undefined;
+  // A starter script init just wrote gets its skeletons as sync writes them; a script that was
+  // already there is the author's, and so is whether it parses.
+  const started = deckDir !== undefined && created.includes(deckPaths(deckDir).script);
+  const dekFiles = started ? syncDeckFiles(deckDir, created) : writeDekFiles(root);
+  created.push(...dekFiles.created);
+  const playwright = playwrightStep(root);
+  const missingTokens = kept.includes(join(root, "theme.css")) ? missingThemeTokens(root) : [];
+  return {
+    root,
+    created,
+    updated: dekFiles.updated,
+    kept,
+    next: nextSteps(options.cwd, root, deckDir),
+    ...(playwright ? { playwright } : {}),
+    ...(missingTokens.length > 0 ? { missingTokens } : {}),
+  };
+}
+
+/** The tokens every deck needs that the project's theme.css does not publish on `.slide`. */
+function missingThemeTokens(root: string): string[] {
+  const published = new Set(
+    publishedTokens(parseCss(readTextIfExists(join(root, "theme.css")) ?? "")).map(
+      (token) => token.name,
+    ),
+  );
+  return REQUIRED_TOKENS.filter((name) => !published.has(name));
+}
+
+function syncDeckFiles(deckDir: string, created: string[]): FileChanges {
+  const synced = syncDeck(deckDir);
+  created.push(...synced.created);
+  return synced.dekFiles;
+}
+
+/** Everything init writes but `.dek/` and AGENTS.md, in the order a reader meets it. */
+function projectPlan(root: string, deck: string | undefined): PlannedPath[] {
+  const themePath = join(root, "theme.css");
+  // A first deck is drawn in the theme that will be there: the one kept, or dek's.
+  const theme = readTextIfExists(themePath) ?? defaultTheme();
+  return [
+    { path: join(root, "dek.toml"), contents: defaultToml() },
+    { path: themePath, contents: defaultTheme() },
+    { path: join(root, ".rumdl.toml"), contents: defaultRumdl() },
+    { path: join(root, ".gitignore"), contents: defaultGitignore() },
+    { path: join(root, "tsconfig.json"), contents: defaultTsconfig() },
+    { path: join(root, "assets") },
+    { path: join(root, "decks") },
+    ...(deck ? deckPlan(root, deck, theme) : []),
+  ];
+}
+
+/**
+ * The target is a directory, or nothing yet, and no project already holds it:
+ * a project inside another would be a second root the outer one cannot see,
+ * and its decks belong under the outer project's decks/ instead.
+ */
+function checkTarget(root: string): void {
+  if (existsSync(root) && !statSync(root).isDirectory()) {
+    throw new DekError("not a directory", { path: root, hint: "pass a directory to init" });
+  }
+  const outer = walkUp(root, (dir) => {
+    const config = join(dir, "dek.toml");
+    return existsSync(config) && statSync(config).isFile() ? dir : undefined;
+  });
+  if (outer !== undefined && outer !== root) {
+    throw new DekError(`already inside the dek project at ${outer}`, {
+      path: join(outer, "dek.toml"),
+      hint: `add a deck to that project with \`dekc new ${shellQuote(basename(root))}\`, or run init outside it`,
+    });
+  }
+}

package/src/cli/keep-alive.ts

@@ -0,0 +1,72 @@
+import type { DevServer } from "../server/dev.ts";
+import { writeDevEvent } from "./format.ts";
+
+/** How often the server checks that whoever started it is still there. */
+const PARENT_POLL_MS = 1_000;
+
+/** How long a stop waits for the server to close before the process exits anyway. */
+const SHUTDOWN_GRACE_MS = 2_000;
+
+/**
+ * Serve until told to stop: Ctrl-C, a kill, a closed terminal, or the process that started the
+ * server going away, so a test run or an editor that dies without cleaning up leaves no server
+ * holding a port.
+ */
+export async function keepDevServer(server: DevServer): Promise<void> {
+  const stop = stopOnce(
+    () => server.close(),
+    (code) => process.exit(code),
+  );
+  for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"] as const) {
+    process.on(signal, stop);
+  }
+  onOrphaned(stop);
+  // A server scoped to one deck has nothing to tell apart; one that serves several names each.
+  server.events.listen((event) =>
+    writeDevEvent(event, process.stderr, {
+      cwd: process.cwd(),
+      ...(server.deckDir === undefined ? { deck: event.deck } : {}),
+    }),
+  );
+  await new Promise<void>(() => {
+    /* keep the process alive until stopped */
+  });
+}
+
+/** A stop that closes once however often it is asked, and exits even if the close never ends. */
+export function stopOnce(
+  close: () => Promise<void>,
+  exit: (code: number) => void,
+  graceMs = SHUTDOWN_GRACE_MS,
+): () => void {
+  let stopping = false;
+  return () => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    setTimeout(() => exit(0), graceMs).unref();
+    void close().finally(() => exit(0));
+  };
+}
+
+/**
+ * Call `fn` once this process is reparented, which is how Unix says the parent died: a SIGKILL
+ * leaves it no chance to stop its children. A process started with no parent of its own to lose
+ * (already under init) is never orphaned.
+ */
+export function onOrphaned(
+  fn: () => void,
+  options: { ppid?: () => number; intervalMs?: number } = {},
+): () => void {
+  const ppid = options.ppid ?? (() => process.ppid);
+  const parent = ppid();
+  const timer = setInterval(() => {
+    if (ppid() !== parent) {
+      clearInterval(timer);
+      fn();
+    }
+  }, options.intervalMs ?? PARENT_POLL_MS);
+  timer.unref();
+  return () => clearInterval(timer);
+}

package/src/cli/lint.ts

@@ -0,0 +1,84 @@
+import { existsSync } from "node:fs";
+import { relative } from "node:path";
+import type { Diagnostic } from "../core/diagnostic.ts";
+import { lintDeck, lintProject, unreadableScriptDiagnostics } from "../core/lint.ts";
+import { playwrightMissingError } from "../core/playwright.ts";
+import { resolveRumdlBin, runRumdl } from "../core/rumdl.ts";
+import { mergeSarif, type SarifLog } from "../core/sarif.ts";
+import { syncDeck } from "../core/sync.ts";
+import { lintVisualDeck } from "../core/visual.ts";
+import { type SkippedCheck, skippedChecks, visualSkipped } from "./result.ts";
+import type { DecksTarget } from "./scope.ts";
+
+export type LintCliResult = {
+  diagnostics: Diagnostic[];
+  /** Checks that did not run, each with why and how to run it, so an empty list is not a pass. */
+  skipped?: SkippedCheck[];
+  rumdlSarif?: SarifLog;
+};
+
+/** `cwd` is where a skipped rumdl's hint says to run it from. */
+export async function lintCommand(
+  { project, decks, failed = [] }: DecksTarget,
+  options: { cwd: string; fix?: boolean; visual?: boolean },
+): Promise<LintCliResult> {
+  // dek.toml's findings once, then each deck's.
+  const diagnostics: Diagnostic[] = [
+    ...lintProject(project),
+    ...failed.flatMap(unreadableScriptDiagnostics),
+  ];
+  let rumdlSkip: SkippedCheck | undefined;
+  let rumdlSarif: SarifLog | undefined;
+
+  for (const deck of decks) {
+    if (options.fix) {
+      syncDeck({ project, deck });
+    }
+    diagnostics.push(...lintDeck({ project, deck }));
+    const markdown = await runRumdl(deck.scriptPath);
+    diagnostics.push(...markdown.diagnostics);
+    if (markdown.skipped) {
+      rumdlSkip ??= rumdlSkipped(deck.scriptPath, options.cwd);
+    }
+    if (markdown.sarif) {
+      rumdlSarif = rumdlSarif ? mergeSarif(rumdlSarif, markdown.sarif) : markdown.sarif;
+    }
+    if (options.visual) {
+      const visual = await lintVisualDeck({ project, deck });
+      if (visual === null) {
+        throw playwrightMissingError();
+      }
+      diagnostics.push(...visual);
+    }
+  }
+
+  return {
+    diagnostics,
+    ...skippedChecks([
+      ...(rumdlSkip ? [rumdlSkip] : []),
+      ...(options.visual
+        ? []
+        : [
+            visualSkipped("dekc lint --visual", {
+              reason: "overflow and contrast are measured only with --visual",
+            }),
+          ]),
+    ]),
+    ...(rumdlSarif ? { rumdlSarif } : {}),
+  };
+}
+
+const RUMDL_INSTALL = "bun add -d rumdl; or put rumdl on PATH, or set DEK_RUMDL to its path";
+
+/** Why rumdl gave no result: dek looks for it on PATH, in node_modules/.bin, and at DEK_RUMDL. */
+function rumdlSkipped(scriptPath: string, cwd: string): SkippedCheck {
+  const bin = resolveRumdlBin();
+  if (bin === undefined || !existsSync(bin)) {
+    return { check: "rumdl", reason: "rumdl is not installed", hint: RUMDL_INSTALL };
+  }
+  return {
+    check: "rumdl",
+    reason: "rumdl ran but gave no result",
+    hint: `run \`${bin} check ${relative(cwd, scriptPath) || scriptPath}\` to see why`,
+  };
+}

package/src/cli/ls.ts

@@ -0,0 +1,119 @@
+import { type DekConfig, loadConfig } from "../core/config.ts";
+import type { Diagnostic } from "../core/diagnostic.ts";
+import { lintDeck, lintProject } from "../core/lint.ts";
+import { listSlides, type Project, type ProjectDeck } from "../core/resolve.ts";
+import { slideVideoSeconds, timelineSeconds } from "../core/timeline.ts";
+import { sectionTiming } from "../core/timing.ts";
+import { tryLoadCachedTimeline } from "../core/voice.ts";
+import { type SkippedCheck, skippedChecks } from "./result.ts";
+import type { DecksTarget, RefInfo } from "./scope.ts";
+
+export type LsListResult = {
+  kind: "list";
+  root: string;
+  /** The project's own findings (dek.toml), once: no deck's row repeats them. */
+  diagnostics: Diagnostic[];
+  decks: Array<{
+    name: string;
+    title: string;
+    sections: number;
+    slides: number;
+    diagnostics: Diagnostic[];
+  }>;
+  failed: Array<{ name: string }>;
+};
+
+type LsSectionRow = {
+  slug: string;
+  title: string;
+  beats: number;
+  estimateSeconds: number;
+  budgetSeconds?: number;
+  videoSeconds?: number;
+};
+
+export type LsDeckResult = {
+  kind: "deck";
+  name: string;
+  title: string;
+  event?: string;
+  date?: string;
+  duration?: string;
+  estimateSeconds: number;
+  videoSeconds?: number;
+  sections: LsSectionRow[];
+  diagnostics: Diagnostic[];
+  /** Lint is skipped for a ref: it is not yours to fix, so an empty list is not a pass. */
+  skipped?: SkippedCheck[];
+  /** Set when the deck is a ref. */
+  ref?: RefInfo;
+};
+
+/** The one deck in scope, a ref included, or else every deck of the project. */
+export function lsCommand(target: DecksTarget): LsListResult | LsDeckResult {
+  const { project, deck, ref } = target;
+  if (deck && ref) {
+    return {
+      ...formatDeck(deck, loadConfig(project.configPath), project, { lint: false }),
+      ...skippedChecks([
+        { check: "lint", reason: "a ref is read-only; its problems are not yours to fix" },
+      ]),
+      ref,
+    };
+  }
+  if (deck) {
+    return formatDeck(deck, loadConfig(project.configPath), project);
+  }
+  return {
+    kind: "list",
+    root: project.root,
+    diagnostics: lintProject(project),
+    decks: project.decks.map((entry) => summarizeDeck(entry, project)),
+    failed: project.failed.map((entry) => ({ name: entry.name })),
+  };
+}
+
+function summarizeDeck(deck: ProjectDeck, project: Project): LsListResult["decks"][number] {
+  return {
+    name: deck.name,
+    title: deck.deck.title,
+    sections: deck.deck.sections.length,
+    slides: listSlides(deck.dir).length,
+    diagnostics: lintDeck({ project, deck }),
+  };
+}
+
+function formatDeck(
+  deck: ProjectDeck,
+  config: DekConfig,
+  project: Project,
+  options: { lint: boolean } = { lint: true },
+): LsDeckResult {
+  const timing = sectionTiming(deck.deck.sections, deck.deck.duration, config);
+  const estimateTotal = timing.reduce((sum, row) => sum + row.estimateSeconds, 0);
+  const timeline = tryLoadCachedTimeline(deck.dir);
+
+  return {
+    kind: "deck",
+    name: deck.name,
+    title: deck.deck.title,
+    ...(deck.deck.event ? { event: deck.deck.event } : {}),
+    ...(deck.deck.date ? { date: deck.deck.date } : {}),
+    ...(deck.deck.duration ? { duration: deck.deck.duration } : {}),
+    estimateSeconds: estimateTotal,
+    ...(timeline ? { videoSeconds: timelineSeconds(timeline) } : {}),
+    sections: deck.deck.sections.map((section, index) => {
+      const row = timing[index];
+      const videoSeconds = timeline ? slideVideoSeconds(timeline, index) : undefined;
+      return {
+        slug: section.slug,
+        title: section.title,
+        beats: section.beats.length,
+        estimateSeconds: row?.estimateSeconds ?? 0,
+        ...(row?.budgetSeconds !== undefined ? { budgetSeconds: row.budgetSeconds } : {}),
+        ...(videoSeconds !== undefined ? { videoSeconds } : {}),
+      };
+    }),
+    diagnostics: options.lint ? lintDeck({ project, deck }) : [],
+  };
+}