starry-slides 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1119 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_SLIDE_HEIGHT,
+  DEFAULT_SLIDE_WIDTH,
+  SELECTOR_ATTR,
+  SLIDE_ROOT_ATTR,
+  createSingleHtmlExportDocument,
+  parseDimension,
+  planHtmlExportSlides,
+  planPdfExport
+} from "../chunk-J7W4Y7WJ.js";
+
+// src/cli/index.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/core/verify-deck.ts
+import fs from "fs";
+import path from "path";
+import { JSDOM, VirtualConsole } from "jsdom";
+function createVerifyIssue(severity, code, message, details) {
+  const slideFile = typeof details?.slideFile === "string" ? details.slideFile : void 0;
+  const selector = typeof details?.selector === "string" ? details.selector : void 0;
+  return {
+    severity,
+    code,
+    message,
+    ...slideFile ? { slideFile } : {},
+    ...selector ? { selector } : {},
+    ...details ? { details } : {}
+  };
+}
+function issue(severity, code, message, details) {
+  return createVerifyIssue(severity, code, message, details);
+}
+function collectHtmlFiles(targetPath) {
+  const stat = fs.statSync(targetPath);
+  if (stat.isFile()) {
+    return targetPath.endsWith(".html") ? [targetPath] : [];
+  }
+  const files = [];
+  for (const entry of fs.readdirSync(targetPath, { withFileTypes: true })) {
+    const entryPath = path.join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectHtmlFiles(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".html")) {
+      files.push(entryPath);
+    }
+  }
+  return files.sort();
+}
+function parseManifest(manifestPath) {
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      error instanceof Error ? `invalid manifest.json: ${error.message}` : "invalid manifest.json"
+    );
+  }
+}
+function validateSlideHtml(_filePath, slideFile, html) {
+  const dom = new JSDOM(html, { virtualConsole: new VirtualConsole() });
+  const { document } = dom.window;
+  const issues = [];
+  const roots = Array.from(document.querySelectorAll(`[${SLIDE_ROOT_ATTR}]`));
+  if (roots.length === 0) {
+    issues.push(
+      issue("error", "structure.missing-root", "missing required slide root", {
+        slideFile
+      })
+    );
+  }
+  if (roots.length > 1) {
+    issues.push(
+      issue("error", "structure.multiple-roots", "found multiple slide roots", {
+        slideFile
+      })
+    );
+  }
+  const root = roots[0] ?? null;
+  if (root) {
+    if (!root.getAttribute("data-slide-width")) {
+      issues.push(
+        issue(
+          "warning",
+          "structure.missing-width",
+          "missing data-slide-width, default 1920 will be assumed",
+          {
+            slideFile
+          }
+        )
+      );
+    }
+    if (!root.getAttribute("data-slide-height")) {
+      issues.push(
+        issue(
+          "warning",
+          "structure.missing-height",
+          "missing data-slide-height, default 1080 will be assumed",
+          { slideFile }
+        )
+      );
+    }
+  }
+  const editableNodes = Array.from(document.querySelectorAll("[data-editable]"));
+  if (editableNodes.length === 0) {
+    issues.push(
+      issue("warning", "structure.empty-slide", "slide contains no editable nodes", {
+        slideFile
+      })
+    );
+  }
+  for (const node of editableNodes) {
+    const editableType = node.getAttribute("data-editable") ?? "";
+    if (!["text", "image", "block"].includes(editableType)) {
+      issues.push(
+        issue(
+          "error",
+          "structure.invalid-editable",
+          `invalid data-editable value "${editableType}" on <${node.tagName.toLowerCase()}>`,
+          {
+            slideFile,
+            selector: node.getAttribute(SELECTOR_ATTR) ?? void 0
+          }
+        )
+      );
+    }
+    if (node.getAttribute("data-group") === "true" && editableType !== "block") {
+      issues.push(
+        issue(
+          "error",
+          "structure.invalid-group",
+          'data-group="true" is only allowed on block editables',
+          {
+            slideFile,
+            selector: node.getAttribute(SELECTOR_ATTR) ?? void 0
+          }
+        )
+      );
+    }
+  }
+  return issues;
+}
+function allowsOverflow(node) {
+  return Boolean(node.closest('[data-allow-overflow="true"]'));
+}
+function validateStaticOverflow(_filePath, slideFile, html) {
+  const dom = new JSDOM(html, { virtualConsole: new VirtualConsole() });
+  const { document } = dom.window;
+  const issues = [];
+  const candidates = [
+    document.querySelector(`[${SLIDE_ROOT_ATTR}]`),
+    ...Array.from(document.querySelectorAll("[data-editable]"))
+  ].filter((node) => Boolean(node));
+  for (const node of candidates) {
+    if (allowsOverflow(node)) {
+      continue;
+    }
+    const overflow = node.style.overflow.trim().toLowerCase();
+    const overflowX = node.style.overflowX.trim().toLowerCase();
+    const overflowY = node.style.overflowY.trim().toLowerCase();
+    const hasExplicitOverflow = ["auto", "scroll"].includes(overflow) || ["auto", "scroll"].includes(overflowX) || ["auto", "scroll"].includes(overflowY);
+    if (!hasExplicitOverflow) {
+      continue;
+    }
+    issues.push(
+      issue("error", "overflow.static", "explicit scrolling overflow is not allowed", {
+        slideFile,
+        selector: node.getAttribute(SELECTOR_ATTR) ?? void 0
+      })
+    );
+  }
+  return issues;
+}
+function loadVerifyDeckSource(deckPath) {
+  const deck = path.resolve(process.cwd(), deckPath);
+  const manifestPath = path.join(deck, "manifest.json");
+  const issues = [];
+  if (!fs.existsSync(deck)) {
+    return {
+      deck,
+      manifestPath,
+      manifest: null,
+      slideFiles: [],
+      issues: [issue("error", "structure.missing-deck", "deck path does not exist")]
+    };
+  }
+  if (!fs.existsSync(manifestPath)) {
+    return {
+      deck,
+      manifestPath,
+      manifest: null,
+      slideFiles: [],
+      issues: [
+        issue("error", "structure.missing-manifest", "deck package is missing manifest.json")
+      ]
+    };
+  }
+  let manifest = null;
+  try {
+    manifest = parseManifest(manifestPath);
+  } catch (error) {
+    return {
+      deck,
+      manifestPath,
+      manifest: null,
+      slideFiles: [],
+      issues: [
+        issue(
+          "error",
+          "structure.invalid-manifest",
+          error instanceof Error ? error.message : "invalid manifest.json"
+        )
+      ]
+    };
+  }
+  const slideFiles = [];
+  const manifestSlidePaths = /* @__PURE__ */ new Set();
+  if (!Array.isArray(manifest?.slides) || !manifest?.slides?.length) {
+    issues.push(
+      issue("error", "structure.empty-manifest", "manifest.json must include at least one slide")
+    );
+  } else {
+    for (const [index, slide] of manifest.slides.entries()) {
+      if ("hidden" in slide && typeof slide.hidden !== "boolean") {
+        issues.push(
+          issue(
+            "error",
+            "structure.invalid-slide-hidden",
+            `manifest slide ${index + 1} hidden must be a boolean when present`,
+            {
+              slideIndex: index,
+              ...typeof slide.file === "string" ? { slideFile: slide.file } : {}
+            }
+          )
+        );
+      }
+      if (typeof slide.file !== "string" || !slide.file.trim()) {
+        issues.push(
+          issue(
+            "error",
+            "structure.missing-slide-file",
+            `manifest slide ${index + 1} is missing file`,
+            { slideIndex: index }
+          )
+        );
+        continue;
+      }
+      const slidePath = path.resolve(deck, slide.file);
+      if (slidePath !== deck && !slidePath.startsWith(`${deck}${path.sep}`)) {
+        issues.push(
+          issue(
+            "error",
+            "structure.slide-escape",
+            `manifest slide escapes deck directory: ${slide.file}`,
+            {
+              slideFile: slide.file
+            }
+          )
+        );
+        continue;
+      }
+      if (!fs.existsSync(slidePath)) {
+        issues.push(
+          issue(
+            "error",
+            "structure.missing-slide",
+            `manifest slide file does not exist: ${slide.file}`,
+            {
+              slideFile: slide.file
+            }
+          )
+        );
+        continue;
+      }
+      slideFiles.push(slide.file);
+      manifestSlidePaths.add(slidePath);
+      const html = fs.readFileSync(slidePath, "utf8");
+      issues.push(...validateSlideHtml(slidePath, slide.file, html));
+      issues.push(...validateStaticOverflow(slidePath, slide.file, html));
+    }
+  }
+  for (const filePath of collectHtmlFiles(deck)) {
+    if (manifestSlidePaths.has(filePath)) {
+      continue;
+    }
+    const slideFile = path.relative(deck, filePath);
+    const html = fs.readFileSync(filePath, "utf8");
+    issues.push(...validateSlideHtml(filePath, slideFile, html));
+  }
+  return {
+    deck,
+    manifestPath,
+    manifest,
+    slideFiles,
+    issues
+  };
+}
+function createVerifyResult({
+  deck,
+  mode,
+  checks,
+  issues
+}) {
+  const errorCount = issues.filter((item) => item.severity === "error").length;
+  const warningCount = issues.filter((item) => item.severity === "warning").length;
+  return {
+    ok: errorCount === 0,
+    deck,
+    mode,
+    checks,
+    issues,
+    summary: {
+      errorCount,
+      warningCount
+    }
+  };
+}
+function verifyDeck(deckPath, options = {}) {
+  const source = loadVerifyDeckSource(deckPath);
+  const mode = options.mode ?? "static";
+  const renderedIssues = mode === "complete" ? options.renderedIssues ?? [] : [];
+  const issues = [...source.issues, ...renderedIssues];
+  return createVerifyResult({
+    deck: source.deck,
+    mode,
+    checks: mode === "complete" ? ["structure", "static-overflow", "rendered-overflow"] : ["structure", "static-overflow"],
+    issues
+  });
+}
+
+// src/node/deck-source.ts
+import path2 from "path";
+function resolveDeckPath(deckPath) {
+  if (deckPath?.trim()) {
+    return path2.resolve(process.cwd(), deckPath);
+  }
+  return path2.resolve(import.meta.dirname, "../../sample-slides");
+}
+
+// src/node/html-export.ts
+import fs3 from "fs";
+import path4 from "path";
+
+// src/node/view-renderer.ts
+import fs2 from "fs";
+import { createRequire } from "module";
+import path3 from "path";
+import { pathToFileURL } from "url";
+function getManifestSlides(deckPath) {
+  const source = loadVerifyDeckSource(deckPath);
+  const slidesByFile = new Map(
+    source.manifest?.slides?.filter(
+      (slide) => typeof slide.file === "string"
+    ).map((slide, index) => [
+      slide.file,
+      {
+        index,
+        file: slide.file,
+        title: typeof slide.title === "string" ? slide.title : void 0,
+        hidden: slide.hidden === true,
+        filePath: path3.resolve(source.deck, slide.file)
+      }
+    ]) ?? []
+  );
+  return source.slideFiles.flatMap((file) => {
+    const slide = slidesByFile.get(file);
+    return slide && fs2.existsSync(slide.filePath) ? [slide] : [];
+  });
+}
+async function verifyRenderedOverflow(deckPath) {
+  const slides = getManifestSlides(deckPath);
+  if (slides.length === 0) {
+    return [];
+  }
+  const chromium = await loadChromium();
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const issues = [];
+    const page = await browser.newPage();
+    for (const slide of slides) {
+      await loadSlide(page, slide.filePath);
+      const measurements = await measureOverflow(page);
+      for (const measurement of measurements) {
+        issues.push(
+          createVerifyIssue("error", measurement.code, measurement.message, {
+            slideFile: slide.file,
+            selector: measurement.selector,
+            ...measurement.details
+          })
+        );
+      }
+    }
+    return issues;
+  } finally {
+    await browser.close();
+  }
+}
+async function renderPreviewManifest({
+  deckPath,
+  slideFile,
+  outDir
+}) {
+  const deck = path3.resolve(process.cwd(), deckPath);
+  const slides = getManifestSlides(deck);
+  const selectedSlides = slideFile ? slides.filter((slide) => slide.file === slideFile) : slides;
+  if (slideFile && selectedSlides.length === 0) {
+    throw new Error(`--slide must match a manifest slide file exactly: ${slideFile}`);
+  }
+  const outputDir = outDir ? path3.resolve(process.cwd(), outDir) : path3.join(deck, ".starry-slides", "view");
+  clearPreviewOutput(outputDir);
+  const chromium = await loadChromium();
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    const renders = [];
+    for (const slide of selectedSlides) {
+      const { width, height } = await loadSlide(page, slide.filePath);
+      const file = `${previewFileStem(slide.file)}.png`;
+      const imagePath = path3.join(outputDir, file);
+      await page.screenshot({
+        path: imagePath,
+        clip: { x: 0, y: 0, width, height }
+      });
+      renders.push({
+        index: slide.index,
+        slideFile: slide.file,
+        ...slide.title ? { title: slide.title } : {},
+        file,
+        path: imagePath,
+        width,
+        height,
+        scale: 1
+      });
+    }
+    return {
+      deck,
+      mode: slideFile ? "single" : "all",
+      outputDir,
+      slides: renders
+    };
+  } finally {
+    await browser.close();
+  }
+}
+async function loadSlide(page, filePath) {
+  await page.goto(pathToFileURL(filePath).href, { waitUntil: "load" });
+  const root = page.locator('[data-slide-root="true"]');
+  const size = {
+    width: Number(await root.getAttribute("data-slide-width") || 1920),
+    height: Number(await root.getAttribute("data-slide-height") || 1080)
+  };
+  await page.setViewportSize(size);
+  await page.evaluate("document.fonts ? document.fonts.ready : Promise.resolve()");
+  return size;
+}
+async function measureOverflow(page) {
+  return page.evaluate(`(() => {
+    const root = document.querySelector('[data-slide-root="true"]');
+    if (!root) {
+      return [];
+    }
+
+    const roundRect = (rect) => ({
+      left: Math.round(rect.left * 100) / 100,
+      top: Math.round(rect.top * 100) / 100,
+      right: Math.round(rect.right * 100) / 100,
+      bottom: Math.round(rect.bottom * 100) / 100,
+      width: Math.round(rect.width * 100) / 100,
+      height: Math.round(rect.height * 100) / 100,
+    });
+    const selectorFor = (node) =>
+      node.getAttribute("data-editor-id")
+        ? '[data-editor-id="' + node.getAttribute("data-editor-id") + '"]'
+        : node.getAttribute("data-editable")
+          ? node.tagName.toLowerCase() + '[data-editable="' + node.getAttribute("data-editable") + '"]'
+          : node.tagName.toLowerCase();
+    const hasAllowedOverflow = (node) =>
+      Boolean(node.closest('[data-allow-overflow="true"]'));
+    const rootRect = root.getBoundingClientRect();
+    const measurements = [];
+    const tolerance = 1;
+
+    if (!hasAllowedOverflow(root)) {
+      const rootOverflowX = root.scrollWidth - root.clientWidth;
+      const rootOverflowY = root.scrollHeight - root.clientHeight;
+      if (rootOverflowX > tolerance || rootOverflowY > tolerance) {
+        measurements.push({
+          code: "overflow.slide",
+          selector: selectorFor(root),
+          message: "slide root has rendered overflow",
+          details: {
+            rootScrollWidth: root.scrollWidth,
+            rootClientWidth: root.clientWidth,
+            rootScrollHeight: root.scrollHeight,
+            rootClientHeight: root.clientHeight,
+          },
+        });
+      }
+    }
+
+    const body = document.body;
+    if (body && !hasAllowedOverflow(body) && !hasAllowedOverflow(root)) {
+      const viewportWidth = document.documentElement.clientWidth;
+      const viewportHeight = document.documentElement.clientHeight;
+      const bodyOverflowX = Math.max(
+        document.documentElement.scrollWidth,
+        body.scrollWidth
+      ) - viewportWidth;
+      const bodyOverflowY = Math.max(
+        document.documentElement.scrollHeight,
+        body.scrollHeight
+      ) - viewportHeight;
+
+      if (bodyOverflowX > tolerance || bodyOverflowY > tolerance) {
+        measurements.push({
+          code: "overflow.slide",
+          selector: "body",
+          message: "document body has rendered overflow",
+          details: {
+            bodyScrollWidth: body.scrollWidth,
+            bodyScrollHeight: body.scrollHeight,
+            documentScrollWidth: document.documentElement.scrollWidth,
+            documentScrollHeight: document.documentElement.scrollHeight,
+            viewportWidth,
+            viewportHeight,
+          },
+        });
+      }
+    }
+
+    for (const node of Array.from(document.querySelectorAll("[data-editable]"))) {
+      if (hasAllowedOverflow(node)) {
+        continue;
+      }
+
+      const rect = node.getBoundingClientRect();
+      if (
+        rect.left < rootRect.left - tolerance ||
+        rect.top < rootRect.top - tolerance ||
+        rect.right > rootRect.right + tolerance ||
+        rect.bottom > rootRect.bottom + tolerance
+      ) {
+        measurements.push({
+          code: "overflow.element-bounds",
+          selector: selectorFor(node),
+          message: "editable element renders outside slide bounds",
+          details: {
+            elementRect: roundRect(rect),
+            slideRect: roundRect(rootRect),
+          },
+        });
+      }
+
+      const overflowX = node.scrollWidth - node.clientWidth;
+      const overflowY = node.scrollHeight - node.clientHeight;
+      if (hasConstrainedContentBox(node) && (overflowX > tolerance || overflowY > tolerance)) {
+        measurements.push({
+          code: "overflow.element-content",
+          selector: selectorFor(node),
+          message: "editable element content has rendered overflow",
+          details: {
+            elementRect: roundRect(rect),
+            scrollWidth: node.scrollWidth,
+            clientWidth: node.clientWidth,
+            scrollHeight: node.scrollHeight,
+            clientHeight: node.clientHeight,
+          },
+        });
+      }
+    }
+
+    return measurements;
+
+    function hasConstrainedContentBox(node) {
+      const style = window.getComputedStyle(node);
+      const overflowValues = [
+        style.overflow,
+        style.overflowX,
+        style.overflowY,
+      ];
+      const clipsOverflow = overflowValues.some((value) =>
+        ["hidden", "clip", "auto", "scroll"].includes(value)
+      );
+      const hasExplicitBox =
+        style.position === "absolute" ||
+        style.position === "fixed" ||
+        style.display === "block" ||
+        style.display === "inline-block" ||
+        style.display === "inline-flex" ||
+        style.display === "flex" ||
+        style.display === "grid" ||
+        style.maxWidth !== "none" ||
+        style.maxHeight !== "none" ||
+        node.style.width ||
+        node.style.height ||
+        node.style.maxWidth ||
+        node.style.maxHeight;
+
+      return clipsOverflow && hasExplicitBox;
+    }
+  })()`);
+}
+async function loadChromium() {
+  const require2 = createRequire(import.meta.url);
+  const playwright = require2("@playwright/test");
+  return playwright.chromium;
+}
+function clearPreviewOutput(outputDir) {
+  fs2.rmSync(outputDir, { recursive: true, force: true });
+  fs2.mkdirSync(outputDir, { recursive: true });
+}
+function previewFileStem(slideFile) {
+  const safeName = slideFile.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/\.html?$/i, "");
+  let hash = 0;
+  for (let index = 0; index < slideFile.length; index += 1) {
+    hash = hash * 31 + slideFile.charCodeAt(index) >>> 0;
+  }
+  return `${safeName}-${hash.toString(16).padStart(8, "0")}`;
+}
+
+// src/node/html-export.ts
+async function exportHtml({
+  deckPath,
+  outFile
+}) {
+  const deck = path4.resolve(process.cwd(), deckPath);
+  const outputPath = path4.resolve(process.cwd(), outFile);
+  const manifestSlides = getManifestSlides(deck);
+  const slides = manifestSlides.map((slide) => ({
+    file: slide.file,
+    ...slide.title ? { title: slide.title } : {},
+    ...slide.hidden ? { hidden: slide.hidden } : {},
+    htmlSource: fs3.readFileSync(slide.filePath, "utf8")
+  }));
+  const html = createSingleHtmlExportDocument({
+    title: path4.basename(deck),
+    slides
+  });
+  const exportedSlides = planHtmlExportSlides(slides);
+  fs3.mkdirSync(path4.dirname(outputPath), { recursive: true });
+  fs3.writeFileSync(outputPath, html, "utf8");
+  return {
+    deck,
+    mode: "all",
+    outFile: outputPath,
+    path: outputPath,
+    slides: exportedSlides.map((slide) => {
+      const manifestSlide = manifestSlides.find((item) => item.file === slide.file);
+      return {
+        index: manifestSlide?.index ?? 0,
+        slideFile: slide.file,
+        ...slide.title ? { title: slide.title } : {}
+      };
+    })
+  };
+}
+
+// src/node/open-browser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+
+// src/node/pdf-export.ts
+import fs4 from "fs";
+import { createRequire as createRequire2 } from "module";
+import os from "os";
+import path5 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { JSDOM as JSDOM2, VirtualConsole as VirtualConsole2 } from "jsdom";
+async function exportPdf({
+  deckPath,
+  outFile,
+  selection
+}) {
+  const deck = path5.resolve(process.cwd(), deckPath);
+  const outputPath = path5.resolve(process.cwd(), outFile);
+  const manifestSlides = getManifestSlides(deck);
+  const plan = planPdfExport({ slides: manifestSlides, selection });
+  const selectedSlides = resolveSelectedSlides(
+    manifestSlides,
+    plan.slides.map((slide) => slide.file)
+  );
+  if (selectedSlides.length === 0) {
+    throw new Error("PDF export requires at least one manifest slide.");
+  }
+  const sizedSlides = selectedSlides.map((slide) => ({
+    ...slide,
+    ...readSlideSize(slide.filePath)
+  }));
+  const [firstSlide] = sizedSlides;
+  const mismatchedSlide = sizedSlides.find(
+    (slide) => slide.width !== firstSlide.width || slide.height !== firstSlide.height
+  );
+  if (mismatchedSlide) {
+    throw new Error(
+      `PDF export requires selected slides to share one size; ${mismatchedSlide.file} is ${mismatchedSlide.width}x${mismatchedSlide.height}, expected ${firstSlide.width}x${firstSlide.height}.`
+    );
+  }
+  const tempDir = fs4.mkdtempSync(path5.join(os.tmpdir(), "starry-slides-pdf-"));
+  const printFile = path5.join(tempDir, "print.html");
+  try {
+    fs4.writeFileSync(
+      printFile,
+      createPrintDocument({
+        slides: sizedSlides,
+        width: firstSlide.width,
+        height: firstSlide.height
+      }),
+      "utf8"
+    );
+    fs4.mkdirSync(path5.dirname(outputPath), { recursive: true });
+    const chromium = await loadChromium2();
+    const browser = await chromium.launch({ headless: true });
+    try {
+      const page = await browser.newPage();
+      await page.goto(pathToFileURL2(printFile).href, { waitUntil: "load" });
+      await page.evaluate("document.fonts ? document.fonts.ready : Promise.resolve()");
+      await page.pdf({
+        path: outputPath,
+        width: `${firstSlide.width}px`,
+        height: `${firstSlide.height}px`,
+        margin: { top: "0", right: "0", bottom: "0", left: "0" },
+        printBackground: true,
+        preferCSSPageSize: true
+      });
+    } finally {
+      await browser.close();
+    }
+  } finally {
+    fs4.rmSync(tempDir, { recursive: true, force: true });
+  }
+  return {
+    deck,
+    mode: plan.mode,
+    outFile: outputPath,
+    path: outputPath,
+    slides: sizedSlides.map((slide) => ({
+      index: slide.index,
+      slideFile: slide.file,
+      ...slide.title ? { title: slide.title } : {},
+      width: slide.width,
+      height: slide.height
+    }))
+  };
+}
+function resolveSelectedSlides(slides, selectedFiles) {
+  const slideByFile = new Map(slides.map((slide) => [slide.file, slide]));
+  return selectedFiles.map((file) => {
+    const slide = slideByFile.get(file);
+    if (!slide) {
+      throw new Error(`PDF export could not resolve selected slide file: ${file}`);
+    }
+    return slide;
+  });
+}
+function readSlideSize(filePath) {
+  const dom = new JSDOM2(fs4.readFileSync(filePath, "utf8"), {
+    virtualConsole: new VirtualConsole2()
+  });
+  const root = dom.window.document.querySelector(`[${SLIDE_ROOT_ATTR}]`);
+  return {
+    width: parseDimension(root?.getAttribute("data-slide-width") ?? null, DEFAULT_SLIDE_WIDTH),
+    height: parseDimension(root?.getAttribute("data-slide-height") ?? null, DEFAULT_SLIDE_HEIGHT)
+  };
+}
+function createPrintDocument({
+  slides,
+  width,
+  height
+}) {
+  return `<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <style>
+      @page { size: ${width}px ${height}px; margin: 0; }
+      html, body { margin: 0; padding: 0; width: ${width}px; background: white; }
+      iframe {
+        display: block;
+        width: ${width}px;
+        height: ${height}px;
+        border: 0;
+        margin: 0;
+        padding: 0;
+        break-after: page;
+        page-break-after: always;
+      }
+      iframe:last-child {
+        break-after: auto;
+        page-break-after: auto;
+      }
+    </style>
+  </head>
+  <body>
+    ${slides.map(
+    (slide) => `<iframe title="${escapeAttribute(slide.title ?? slide.file)}" src="${pathToFileURL2(slide.filePath).href}"></iframe>`
+  ).join("\n    ")}
+  </body>
+</html>`;
+}
+async function loadChromium2() {
+  const require2 = createRequire2(import.meta.url);
+  const playwright = require2("@playwright/test");
+  return playwright.chromium;
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/node/ports.ts
+import net from "net";
+async function findAvailablePort(preferredPort = 5173) {
+  for (let port = preferredPort; port < preferredPort + 100; port += 1) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port found near ${preferredPort}.`);
+}
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => {
+      resolve(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+
+// src/cli/index.ts
+var COMMANDS = /* @__PURE__ */ new Set(["open", "verify", "view", "export", "add-skill", "help", "--help", "-h"]);
+function usage() {
+  return `Usage:
+  starry-slides [deck]
+  starry-slides open [deck]
+  starry-slides verify [deck]
+  starry-slides verify [deck] --static
+  starry-slides view [deck] --slide <manifest-file>
+  starry-slides view [deck] --all
+  starry-slides view [deck] --all --out-dir <directory>
+  starry-slides export pdf [deck] --out <file>
+  starry-slides export pdf [deck] --all --out <file>
+  starry-slides export pdf [deck] --slide <manifest-file> --out <file>
+  starry-slides export pdf [deck] --slides <manifest-file>[,<manifest-file>...] --out <file>
+  starry-slides export html [deck] --out <file>
+  starry-slides add-skill`;
+}
+function parseArgs(argv) {
+  const [first, ...rest] = argv;
+  const command = normalizeCommand(first);
+  const remaining = command === "open" && first && !COMMANDS.has(first) ? [first, ...rest] : rest;
+  let deckPath;
+  let staticVerify = false;
+  let viewMode;
+  let exportFormat;
+  let exportMode;
+  let slideFile;
+  let slideFiles;
+  let outDir;
+  let outFile;
+  if (command === "export") {
+    const format = remaining.shift();
+    if (format !== "pdf" && format !== "html") {
+      throw new Error("export requires a format: pdf or html");
+    }
+    exportFormat = format;
+  }
+  for (let index = 0; index < remaining.length; index += 1) {
+    const arg = remaining[index];
+    if (!arg) {
+      continue;
+    }
+    if (arg === "--static") {
+      staticVerify = true;
+      continue;
+    }
+    if (arg === "--all") {
+      viewMode = "all";
+      exportMode = "all";
+      continue;
+    }
+    if (arg === "--slide") {
+      const value = remaining[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--slide requires a manifest slide file value");
+      }
+      viewMode = "slide";
+      exportMode = "slide";
+      slideFile = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--slides") {
+      const value = remaining[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--slides requires at least one manifest slide file value");
+      }
+      exportMode = "slides";
+      slideFiles = value.split(",").map((item) => item.trim()).filter(Boolean);
+      index += 1;
+      continue;
+    }
+    if (arg === "--out-dir") {
+      const value = remaining[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--out-dir requires a directory path");
+      }
+      outDir = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--out") {
+      const value = remaining[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--out requires a file path");
+      }
+      outFile = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    if (deckPath) {
+      throw new Error(`Unexpected extra argument: ${arg}`);
+    }
+    deckPath = arg;
+  }
+  return {
+    command,
+    deckPath,
+    staticVerify,
+    viewMode,
+    exportFormat,
+    exportMode,
+    slideFile,
+    slideFiles,
+    outDir,
+    outFile
+  };
+}
+function normalizeCommand(first) {
+  if (!first) {
+    return "open";
+  }
+  if (first === "help" || first === "--help" || first === "-h") {
+    return "help";
+  }
+  if (first === "open" || first === "verify" || first === "view" || first === "export" || first === "add-skill") {
+    return first;
+  }
+  return "open";
+}
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function runStaticVerify(deckPath) {
+  return verifyDeck(deckPath, { mode: "static" });
+}
+async function runCompleteVerify(deckPath) {
+  const staticResult = verifyDeck(deckPath, { mode: "static" });
+  if (!staticResult.ok) {
+    return createVerifyResult({
+      deck: staticResult.deck,
+      mode: "complete",
+      checks: ["structure", "static-overflow", "rendered-overflow"],
+      issues: staticResult.issues
+    });
+  }
+  const renderedIssues = await verifyRenderedOverflow(deckPath);
+  return verifyDeck(deckPath, {
+    mode: "complete",
+    renderedIssues
+  });
+}
+async function runVerify(deckPath, mode) {
+  const result = mode === "static" ? await runStaticVerify(deckPath) : await runCompleteVerify(deckPath);
+  writeJson(result);
+  return result.ok;
+}
+async function runView(deckPath, parsed) {
+  if (parsed.staticVerify) {
+    throw new Error("view always runs Static Verify; do not pass --static");
+  }
+  if (parsed.viewMode === "slide" && !parsed.slideFile) {
+    throw new Error("--slide requires a manifest slide file value");
+  }
+  if (!parsed.viewMode) {
+    throw new Error("view requires either --slide <manifest-file> or --all");
+  }
+  const staticResult = await runStaticVerify(deckPath);
+  if (!staticResult.ok) {
+    writeJson(staticResult);
+    process.exitCode = 1;
+    return;
+  }
+  const manifest = await renderPreviewManifest({
+    deckPath,
+    slideFile: parsed.viewMode === "slide" ? parsed.slideFile : void 0,
+    outDir: parsed.outDir
+  });
+  writeJson(manifest);
+}
+async function runExport(deckPath, parsed) {
+  if (parsed.exportFormat !== "pdf" && parsed.exportFormat !== "html") {
+    throw new Error("export requires a format: pdf or html");
+  }
+  if (parsed.staticVerify) {
+    throw new Error(
+      `export ${parsed.exportFormat} runs Static Verify internally; do not pass --static`
+    );
+  }
+  if (!parsed.outFile) {
+    throw new Error(`export ${parsed.exportFormat} requires --out <file>`);
+  }
+  const staticResult = await runStaticVerify(deckPath);
+  if (!staticResult.ok) {
+    writeJson(staticResult);
+    process.exitCode = 1;
+    return;
+  }
+  if (parsed.exportFormat === "html") {
+    if (parsed.exportMode && parsed.exportMode !== "all") {
+      throw new Error("export html currently supports full-deck export only");
+    }
+    const result2 = await exportHtml({
+      deckPath,
+      outFile: parsed.outFile
+    });
+    writeJson(result2);
+    return;
+  }
+  const result = await exportPdf({
+    deckPath,
+    outFile: parsed.outFile,
+    selection: parsed.exportMode === "slide" ? { mode: "slide", slideFile: parsed.slideFile } : parsed.exportMode === "slides" ? { mode: "slides", slideFiles: parsed.slideFiles } : { mode: "all" }
+  });
+  writeJson(result);
+}
+async function runOpen(deckPath) {
+  const result = await runCompleteVerify(deckPath);
+  if (!result.ok) {
+    writeJson(result);
+    process.exitCode = 1;
+    return;
+  }
+  const port = await findAvailablePort(Number(process.env.PORT ?? 5173));
+  const url = `http://127.0.0.1:${port}/`;
+  if (process.env.STARRY_SLIDES_TEST_STUB_OPEN === "1") {
+    console.error(`Opening Starry Slides at ${url}`);
+    console.error(`Editor startup stub: STARRY_SLIDES_DECK_DIR=${deckPath}`);
+    return;
+  }
+  const child = spawn2("vite", ["--host", "127.0.0.1", "--port", String(port), "--strictPort"], {
+    env: {
+      ...process.env,
+      STARRY_SLIDES_DECK_DIR: deckPath
+    },
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.on(signal, () => {
+      child.kill(signal);
+    });
+  }
+  console.error(`Opening Starry Slides at ${url}`);
+  setTimeout(() => openBrowser(url), 750);
+}
+async function main() {
+  const parsed = parseArgs(process.argv.slice(2));
+  if (parsed.command === "help") {
+    console.log(usage());
+    return;
+  }
+  if (parsed.command === "add-skill") {
+    console.error("add-skill is not implemented yet.");
+    return;
+  }
+  const deckPath = resolveDeckPath(parsed.deckPath);
+  if (parsed.command === "verify") {
+    const ok = await runVerify(deckPath, parsed.staticVerify ? "static" : "complete");
+    if (!ok) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (parsed.command === "view") {
+    await runView(deckPath, parsed);
+    return;
+  }
+  if (parsed.command === "export") {
+    await runExport(deckPath, parsed);
+    return;
+  }
+  await runOpen(deckPath);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});