pdf-presenter 1.0.0

package/dist/pdf-presenter.js

@@ -0,0 +1,760 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync as existsSync6, readFileSync } from "fs";
+import { basename as basename3, relative as relative2 } from "path";
+import { Command, Option } from "commander";
+import open from "open";
+
+// src/generate-notes.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { basename, relative } from "path";
+
+// src/utils.ts
+import { createServer } from "net";
+import { extname, resolve } from "path";
+import { existsSync, statSync } from "fs";
+function resolvePdfPath(input) {
+  const abs = resolve(input);
+  if (!existsSync(abs)) {
+    throw new Error(`File not found: ${input}`);
+  }
+  if (!statSync(abs).isFile()) {
+    throw new Error(`Not a file: ${input}`);
+  }
+  if (extname(abs).toLowerCase() !== ".pdf") {
+    throw new Error(`Not a PDF file: ${input}`);
+  }
+  return abs;
+}
+function notesPathFor(pdfPath) {
+  return pdfPath.replace(/\.pdf$/i, ".notes.json");
+}
+async function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortFree(port)) return port;
+  }
+  throw new Error(
+    `Could not find a free port (tried ${startPort}..${startPort + maxAttempts - 1})`
+  );
+}
+function isPortFree(port) {
+  return new Promise((resolveP) => {
+    const srv = createServer();
+    srv.once("error", () => resolveP(false));
+    srv.once("listening", () => {
+      srv.close(() => resolveP(true));
+    });
+    srv.listen(port, "127.0.0.1");
+  });
+}
+
+// src/generate-notes.ts
+var HINT_MAX = 80;
+async function generateNotesTemplate(pdfPath, options) {
+  const notesPath = notesPathFor(pdfPath);
+  if (existsSync2(notesPath) && !options.force) {
+    const rel = relative(process.cwd(), notesPath) || basename(notesPath);
+    const err = new Error(
+      `${rel} already exists. Use --force to overwrite.`
+    );
+    err.code = "NOTES_EXISTS";
+    throw err;
+  }
+  const pdfjsLib = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const data = new Uint8Array(await readFile(pdfPath));
+  const pdf = await pdfjsLib.getDocument({
+    data,
+    isEvalSupported: false,
+    useSystemFonts: true
+  }).promise;
+  const totalSlides = pdf.numPages;
+  if (totalSlides === 0) {
+    throw new Error("PDF has no pages");
+  }
+  const notes = {};
+  for (let i = 1; i <= totalSlides; i++) {
+    const page = await pdf.getPage(i);
+    const text = await page.getTextContent();
+    const joined = text.items.map((item) => "str" in item ? item.str : "").join(" ").replace(/\s+/g, " ").trim();
+    const hint = joined.slice(0, HINT_MAX).trim();
+    notes[String(i)] = { hint, note: "" };
+  }
+  await pdf.cleanup();
+  await pdf.destroy();
+  const out = {
+    meta: {
+      pdf: basename(pdfPath),
+      totalSlides,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      generator: "pdf-presenter"
+    },
+    notes
+  };
+  await writeFile(notesPath, JSON.stringify(out, null, 2) + "\n", "utf8");
+  return { notesPath, totalSlides };
+}
+
+// src/server.ts
+import { createServer as createServer2 } from "http";
+
+// src/server/http-utils.ts
+import { createReadStream, statSync as statSync2 } from "fs";
+import { extname as extname2 } from "path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".woff2": "font/woff2"
+};
+var EMPTY_NOTES = JSON.stringify(
+  { meta: { totalSlides: 0, generator: "pdf-presenter" }, notes: {} },
+  null,
+  2
+);
+var MAX_JSON_BODY = 1e6;
+var MAX_RECORDING_BODY = 500 * 1024 * 1024;
+function send(res, status, body, contentType = "text/plain; charset=utf-8", extraHeaders = {}) {
+  res.writeHead(status, {
+    "Content-Type": contentType,
+    "Cache-Control": "no-store",
+    ...extraHeaders
+  });
+  res.end(body);
+}
+function notFound(res) {
+  send(res, 404, "Not Found");
+}
+function streamFile(res, filePath, contentType) {
+  try {
+    const st = statSync2(filePath);
+    res.writeHead(200, {
+      "Content-Type": contentType,
+      "Content-Length": String(st.size),
+      "Cache-Control": "no-store"
+    });
+    const stream = createReadStream(filePath);
+    stream.on("error", () => {
+      if (!res.headersSent) notFound(res);
+      else res.end();
+    });
+    stream.pipe(res);
+  } catch {
+    notFound(res);
+  }
+}
+function contentTypeFor(filePath) {
+  return MIME[extname2(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function isSafeFilename(name) {
+  if (name.length === 0 || name.length > 255) return false;
+  if (name.includes("/") || name.includes("\\") || name.includes("\0")) return false;
+  if (name === "." || name === "..") return false;
+  return true;
+}
+async function readJsonBody(req) {
+  return new Promise((resolveP, rejectP) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_JSON_BODY) {
+        rejectP(new Error("Request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        resolveP(raw.length === 0 ? {} : JSON.parse(raw));
+      } catch (err) {
+        rejectP(err);
+      }
+    });
+    req.on("error", rejectP);
+  });
+}
+async function readBinaryBody(req) {
+  return new Promise((resolveP, rejectP) => {
+    let size = 0;
+    const chunks = [];
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > MAX_RECORDING_BODY) {
+        rejectP(new Error("recording exceeds 500 MB limit"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolveP(Buffer.concat(chunks)));
+    req.on("error", rejectP);
+  });
+}
+
+// src/server/paths.ts
+import { existsSync as existsSync3 } from "fs";
+import { createRequire } from "module";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+function resolveUiDir(callerUrl) {
+  const here = dirname(fileURLToPath(callerUrl));
+  const candidates = [
+    resolve2(here, "../src/ui"),
+    // published layout: dist/ → ../src/ui
+    resolve2(here, "./ui")
+    // dev: src/ → ./ui
+  ];
+  for (const c of candidates) {
+    if (existsSync3(c)) return c;
+  }
+  throw new Error(
+    `Could not locate UI assets (looked in: ${candidates.join(", ")})`
+  );
+}
+function resolvePdfjsDir(callerUrl) {
+  const require2 = createRequire(callerUrl);
+  const pkgJson = require2.resolve("pdfjs-dist/package.json");
+  return dirname(pkgJson);
+}
+
+// src/server/html-render.ts
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2, join } from "path";
+async function renderHtml(uiDir, file, config) {
+  const raw = await readFile2(join(uiDir, file), "utf8");
+  const meta = {
+    pdfUrl: "/slides.pdf",
+    notesUrl: "/notes.json",
+    pdfName: basename2(config.pdfPath),
+    timerMinutes: config.timerMinutes ?? null
+  };
+  return raw.replace(
+    "<!--PDF_PRESENTER_CONFIG-->",
+    `<script id="pdf-presenter-config" type="application/json">${JSON.stringify(meta)}</script>`
+  );
+}
+
+// src/server/notes-store.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3, writeFile as writeFile2, rename } from "fs/promises";
+function validateNotesDoc(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { ok: false, error: "body must be a JSON object" };
+  }
+  const obj = raw;
+  if (obj.notes === void 0 || obj.notes === null) {
+    return { ok: false, error: "missing 'notes' field" };
+  }
+  if (typeof obj.notes !== "object" || Array.isArray(obj.notes)) {
+    return { ok: false, error: "'notes' must be an object" };
+  }
+  const notes = {};
+  for (const [key, value] of Object.entries(obj.notes)) {
+    const n = Number.parseInt(key, 10);
+    if (!Number.isInteger(n) || n < 1 || String(n) !== key) {
+      return { ok: false, error: `invalid slide key: ${JSON.stringify(key)}` };
+    }
+    if (!value || typeof value !== "object") {
+      return { ok: false, error: `slide ${key} entry must be an object` };
+    }
+    const entry = value;
+    if (entry.hint !== void 0 && typeof entry.hint !== "string") {
+      return { ok: false, error: `slide ${key} hint must be a string` };
+    }
+    if (entry.note !== void 0 && typeof entry.note !== "string") {
+      return { ok: false, error: `slide ${key} note must be a string` };
+    }
+    notes[key] = {
+      hint: typeof entry.hint === "string" ? entry.hint : "",
+      note: typeof entry.note === "string" ? entry.note : ""
+    };
+  }
+  const meta = obj.meta && typeof obj.meta === "object" && !Array.isArray(obj.meta) ? obj.meta : {};
+  return { ok: true, doc: { meta, notes } };
+}
+async function loadNotesDoc(notesPath) {
+  if (!existsSync4(notesPath)) {
+    return {
+      meta: { generator: "pdf-presenter" },
+      notes: {}
+    };
+  }
+  const raw = await readFile3(notesPath, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      meta: parsed.meta ?? { generator: "pdf-presenter" },
+      notes: parsed.notes ?? {}
+    };
+  } catch {
+    return {
+      meta: { generator: "pdf-presenter" },
+      notes: {}
+    };
+  }
+}
+async function writeNotesDoc(notesPath, doc) {
+  const body = JSON.stringify(doc, null, 2) + "\n";
+  const tmp = `${notesPath}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile2(tmp, body, "utf8");
+  await rename(tmp, notesPath);
+}
+function createNotesUpdater(notesPath) {
+  let chain = Promise.resolve();
+  return (updater) => {
+    const next = chain.then(async () => {
+      const current = await loadNotesDoc(notesPath);
+      const updated = await updater(current);
+      await writeNotesDoc(notesPath, updated);
+      return updated;
+    });
+    chain = next.catch(() => void 0);
+    return next;
+  };
+}
+
+// src/server/routes/notes.ts
+async function handleNotesRoutes(req, res, url, deps) {
+  const pathname = url.pathname;
+  const method = req.method ?? "GET";
+  const { updateNotes } = deps;
+  if (pathname === "/api/notes-file" && (method === "PUT" || method === "POST")) {
+    const body = await readJsonBody(req);
+    const validation = validateNotesDoc(body);
+    if (!validation.ok) {
+      send(res, 400, JSON.stringify({ error: validation.error }), MIME[".json"]);
+      return "handled";
+    }
+    const incoming = validation.doc;
+    await updateNotes(() => ({
+      meta: {
+        ...incoming.meta,
+        generator: incoming.meta.generator ?? "pdf-presenter",
+        lastEditedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      notes: incoming.notes
+    }));
+    send(
+      res,
+      200,
+      JSON.stringify({
+        ok: true,
+        slideCount: Object.keys(incoming.notes).length
+      }),
+      MIME[".json"]
+    );
+    return "handled";
+  }
+  if (pathname === "/api/notes" && (method === "PUT" || method === "POST")) {
+    const body = await readJsonBody(req);
+    const slideRaw = body.slide;
+    const note = body.note;
+    const slideNum = typeof slideRaw === "number" ? slideRaw : typeof slideRaw === "string" ? Number.parseInt(slideRaw, 10) : NaN;
+    if (!Number.isInteger(slideNum) || slideNum < 1) {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "slide must be a positive integer" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    if (typeof note !== "string") {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "note must be a string" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    const key = String(slideNum);
+    await updateNotes((doc) => {
+      const existing = doc.notes[key] ?? {};
+      const nextNotes = {
+        ...doc.notes,
+        [key]: { hint: existing.hint ?? "", note }
+      };
+      const nextMeta = {
+        generator: "pdf-presenter",
+        ...doc.meta,
+        lastEditedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return { meta: nextMeta, notes: nextNotes };
+    });
+    send(res, 200, JSON.stringify({ ok: true, slide: slideNum }), MIME[".json"]);
+    return "handled";
+  }
+  return "pass";
+}
+
+// src/server/routes/recording.ts
+import { writeFile as writeFile3, mkdir } from "fs/promises";
+import { dirname as dirname2, join as join2 } from "path";
+async function handleRecordingRoutes(req, res, url, deps) {
+  const pathname = url.pathname;
+  const method = req.method ?? "GET";
+  if (pathname === "/api/recording-meta" && method === "POST") {
+    const filenameParam = url.searchParams.get("filename");
+    if (!filenameParam) {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "filename query param required" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    if (!isSafeFilename(filenameParam)) {
+      send(res, 400, JSON.stringify({ error: "invalid filename" }), MIME[".json"]);
+      return "handled";
+    }
+    let body;
+    try {
+      body = await readJsonBody(req);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      send(res, 400, JSON.stringify({ error: msg }), MIME[".json"]);
+      return "handled";
+    }
+    if (!body || typeof body !== "object") {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "body must be a JSON object" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    const outDir = join2(dirname2(deps.pdfPath), "recordings");
+    await mkdir(outDir, { recursive: true });
+    const outPath = join2(outDir, filenameParam);
+    const text = JSON.stringify(body, null, 2) + "\n";
+    await writeFile3(outPath, text, "utf8");
+    send(
+      res,
+      200,
+      JSON.stringify({
+        ok: true,
+        path: outPath,
+        bytes: Buffer.byteLength(text)
+      }),
+      MIME[".json"]
+    );
+    return "handled";
+  }
+  if (pathname === "/api/recording" && method === "POST") {
+    const filenameParam = url.searchParams.get("filename");
+    if (!filenameParam) {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "filename query param required" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    if (!isSafeFilename(filenameParam)) {
+      send(res, 400, JSON.stringify({ error: "invalid filename" }), MIME[".json"]);
+      return "handled";
+    }
+    let bytes;
+    try {
+      bytes = await readBinaryBody(req);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      send(res, 413, JSON.stringify({ error: msg }), MIME[".json"]);
+      return "handled";
+    }
+    if (bytes.length === 0) {
+      send(
+        res,
+        400,
+        JSON.stringify({ error: "empty recording body" }),
+        MIME[".json"]
+      );
+      return "handled";
+    }
+    const outDir = join2(dirname2(deps.pdfPath), "recordings");
+    await mkdir(outDir, { recursive: true });
+    const outPath = join2(outDir, filenameParam);
+    await writeFile3(outPath, bytes);
+    send(
+      res,
+      200,
+      JSON.stringify({ ok: true, path: outPath, bytes: bytes.length }),
+      MIME[".json"]
+    );
+    return "handled";
+  }
+  return "pass";
+}
+
+// src/server/routes/static.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve3 } from "path";
+async function handleStaticRoutes(req, res, url, deps) {
+  const pathname = url.pathname;
+  const method = req.method ?? "GET";
+  if (method !== "GET" && method !== "HEAD") return "pass";
+  if (pathname === "/" || pathname === "/audience") {
+    send(res, 200, deps.audienceHtml, MIME[".html"]);
+    return "handled";
+  }
+  if (pathname === "/presenter") {
+    send(res, 200, deps.presenterHtml, MIME[".html"]);
+    return "handled";
+  }
+  if (pathname === "/slides.pdf") {
+    streamFile(res, deps.pdfPath, "application/pdf");
+    return "handled";
+  }
+  if (pathname === "/notes.json") {
+    if (existsSync5(deps.notesPath)) {
+      streamFile(res, deps.notesPath, MIME[".json"]);
+    } else {
+      send(res, 200, EMPTY_NOTES, MIME[".json"]);
+    }
+    return "handled";
+  }
+  if (pathname.startsWith("/assets/pdfjs/")) {
+    const rel = pathname.slice("/assets/pdfjs/".length);
+    const safe = resolve3(deps.pdfjsDir, rel);
+    if (!safe.startsWith(deps.pdfjsDir + "/") && safe !== deps.pdfjsDir) {
+      send(res, 403, "Forbidden");
+      return "handled";
+    }
+    if (!existsSync5(safe)) {
+      notFound(res);
+      return "handled";
+    }
+    streamFile(res, safe, contentTypeFor(safe));
+    return "handled";
+  }
+  if (pathname.startsWith("/assets/")) {
+    const rel = pathname.slice("/assets/".length);
+    const safe = resolve3(deps.uiDir, rel);
+    if (!safe.startsWith(deps.uiDir + "/") && safe !== deps.uiDir) {
+      send(res, 403, "Forbidden");
+      return "handled";
+    }
+    if (!existsSync5(safe)) {
+      notFound(res);
+      return "handled";
+    }
+    streamFile(res, safe, contentTypeFor(safe));
+    return "handled";
+  }
+  return "pass";
+}
+
+// src/server.ts
+async function startServer(config) {
+  const uiDir = resolveUiDir(import.meta.url);
+  const pdfjsDir = resolvePdfjsDir(import.meta.url);
+  const audienceHtml = await renderHtml(uiDir, "audience.html", config);
+  const presenterHtml = await renderHtml(uiDir, "presenter.html", config);
+  const updateNotes = createNotesUpdater(config.notesPath);
+  const handler = async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${config.port}`);
+    try {
+      if (await handleRecordingRoutes(req, res, url, {
+        pdfPath: config.pdfPath
+      }) === "handled")
+        return;
+      if (await handleNotesRoutes(req, res, url, {
+        notesPath: config.notesPath,
+        updateNotes
+      }) === "handled")
+        return;
+      if (await handleStaticRoutes(req, res, url, {
+        audienceHtml,
+        presenterHtml,
+        pdfPath: config.pdfPath,
+        notesPath: config.notesPath,
+        uiDir,
+        pdfjsDir
+      }) === "handled")
+        return;
+      notFound(res);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!res.headersSent) send(res, 500, `Internal Server Error: ${msg}`);
+      else res.end();
+    }
+  };
+  const server = createServer2((req, res) => {
+    handler(req, res).catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+      }
+      res.end(`Internal Server Error: ${msg}`);
+    });
+  });
+  await new Promise((resolveP, rejectP) => {
+    server.once("error", rejectP);
+    server.listen(config.port, "127.0.0.1", () => {
+      server.off("error", rejectP);
+      resolveP();
+    });
+  });
+  return {
+    port: config.port,
+    stop: () => new Promise((resolveP, rejectP) => {
+      server.close((err) => err ? rejectP(err) : resolveP());
+    })
+  };
+}
+
+// src/cli.ts
+var VERSION = "1.0.0";
+async function runCli(argv) {
+  const program = new Command();
+  program.name("pdf-presenter").description(
+    "Serve a PDF as browser slides with a full presenter mode (notes, next preview, timer)."
+  ).version(VERSION, "-v, --version").argument("<file>", "Path to the PDF file").addOption(new Option("-p, --port <port>", "Server port").default("3000")).option("--no-open", "Don't auto-open browser").option("--presenter", "Open directly in presenter mode", false).option("-n, --notes <path>", "Path to notes JSON file").option("-t, --timer <minutes>", "Countdown timer in minutes").option(
+    "-gn, --generate-presenter-note-template",
+    "Generate a notes template JSON next to the PDF",
+    false
+  ).option("--force", "Overwrite existing notes file when used with -gn", false).action(async (file, options) => {
+    try {
+      const pdfPath = resolvePdfPath(file);
+      if (options.generatePresenterNoteTemplate) {
+        await runGenerate(pdfPath, { force: !!options.force });
+        return;
+      }
+      await runServe(pdfPath, options);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`
+Error: ${msg}
+`);
+      process.exit(1);
+    }
+  });
+  program.showHelpAfterError();
+  await program.parseAsync(argv);
+}
+async function runGenerate(pdfPath, opts) {
+  try {
+    const result = await generateNotesTemplate(pdfPath, opts);
+    const rel = relative2(process.cwd(), result.notesPath) || basename3(result.notesPath);
+    process.stdout.write(
+      `
+\u2705 Generated ${rel} (${result.totalSlides} slides)
+
+   Edit the "note" fields in the JSON file, then run:
+     pdf-presenter ${relative2(process.cwd(), pdfPath) || basename3(pdfPath)}
+
+`
+    );
+  } catch (err) {
+    const code = err.code;
+    if (code === "NOTES_EXISTS") {
+      process.stderr.write(`
+\u26A0 ${err.message}
+
+`);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+async function runServe(pdfPath, options) {
+  const startPort = Number.parseInt(options.port, 10);
+  if (!Number.isFinite(startPort) || startPort <= 0) {
+    throw new Error(`Invalid --port value: ${options.port}`);
+  }
+  const notesPath = options.notes ? resolveMaybeExisting(options.notes) : notesPathFor(pdfPath);
+  let timerMinutes;
+  if (options.timer !== void 0) {
+    const t = Number.parseFloat(options.timer);
+    if (!Number.isFinite(t) || t <= 0) {
+      throw new Error(`Invalid --timer value: ${options.timer}`);
+    }
+    timerMinutes = t;
+  }
+  const port = await findAvailablePort(startPort);
+  const server = await startServer({ pdfPath, notesPath, port, timerMinutes });
+  const notesInfo = describeNotes(notesPath);
+  const url = `http://localhost:${port}`;
+  const presenterUrl = `${url}/presenter`;
+  process.stdout.write(
+    `
+\u{1F3AF} pdf-presenter v${VERSION}
+
+   Audience:   ${url}
+   Presenter:  ${presenterUrl}
+
+   PDF:   ${basename3(pdfPath)}
+   Notes: ${notesInfo}
+` + (timerMinutes !== void 0 ? `   Timer: ${formatMinutes(timerMinutes)}
+` : "") + `
+   Press Ctrl+C to stop.
+
+`
+  );
+  if (options.open) {
+    const target = options.presenter ? presenterUrl : url;
+    open(target).catch(() => {
+    });
+  }
+  const shutdown = async (signal) => {
+    process.stdout.write(`
+Received ${signal}, shutting down...
+`);
+    try {
+      await server.stop();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+}
+function resolveMaybeExisting(path) {
+  return path;
+}
+function describeNotes(notesPath) {
+  if (!existsSync6(notesPath)) {
+    return `${basename3(notesPath)} (not found \u2014 using empty notes)`;
+  }
+  try {
+    const raw = readFileSync(notesPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const total = parsed.meta?.totalSlides ?? 0;
+    const filled = Object.values(parsed.notes ?? {}).filter(
+      (e) => typeof e.note === "string" && e.note.trim() !== ""
+    ).length;
+    const suffix = total > 0 ? ` (${filled}/${total} slides have notes)` : "";
+    return `${basename3(notesPath)}${suffix}`;
+  } catch {
+    return `${basename3(notesPath)} (invalid JSON \u2014 using empty notes)`;
+  }
+}
+function formatMinutes(minutes) {
+  const total = Math.round(minutes * 60);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+}
+
+// bin/pdf-presenter.ts
+runCli(process.argv).catch((err) => {
+  const msg = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`
+Fatal: ${msg}
+`);
+  process.exit(1);
+});