@open-press/cli 1.0.0 → 1.1.0

package/template/core/engine/runtime/config.mjs

@@ -1,172 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { normalizePageGeometry } from "./page-geometry.mjs";
-
-const DEFAULT_CONFIG = {
-  title: "OpenPress Document",
-  subtitle: "",
-  organization: "",
-  workspaceLabel: "",
-  documentDir: ".",
-  sourceDir: "content",
-  mediaDir: "media",
-  themeDir: "theme",
-  designDoc: "design.md",
-  componentsDir: "components",
-  publicDir: "public/openpress",
-  outputDir: "dist",
-  captionNumbering: {
-    figure: "Figure",
-    table: "Table",
-    separator: " ",
-  },
-  pdf: {
-    filename: "document.pdf",
-  },
-  deploy: {
-    adapter: "cloudflare-pages",
-    source: ".deploy/openpress",
-    projectName: null,
-    commitDirty: false,
-    requiresConfirmation: true,
-  },
-  page: null,
-};
-
-// 1.0 contract: the only user-writable config lives in package.json
-// under the "openpress" field. The engine reads it synchronously so
-// the deploy command can resolve its adapter before any React render.
-//
-// Everything else is convention (path layout) or declared on
-// <Press> / <Workspace> JSX props (document metadata).
-export async function loadConfig(root = ".") {
-  const workspaceRoot = path.resolve(root);
-  const packageOpenpress = await readPackageOpenpressField(workspaceRoot);
-  return normalizeConfig(workspaceRoot, packageOpenpress ?? {});
-}
-
-async function readPackageOpenpressField(workspaceRoot) {
-  const pkgPath = path.join(workspaceRoot, "package.json");
-  try {
-    const raw = await fs.readFile(pkgPath, "utf8");
-    const parsed = JSON.parse(raw);
-    const field = parsed?.openpress;
-    return (field && typeof field === "object" && !Array.isArray(field)) ? field : null;
-  } catch (error) {
-    if (error?.code === "ENOENT") return null;
-    if (error instanceof SyntaxError) {
-      throw new Error(`Malformed package.json at ${pkgPath}: ${error.message}`);
-    }
-    throw error;
-  }
-}
-
-// Convention-only fields. The user can't override these — they're part
-// of OpenPress's product surface. If you don't like the layout, your
-// project isn't an OpenPress workspace.
-const CONVENTION = {
-  documentDir: "press",
-  sourceDir: "chapters",
-  mediaDir: "media",
-  themeDir: "theme",
-  componentsDir: "components",
-  designDoc: "design.md",
-  publicDir: "public/openpress",
-  outputDir: "dist-react",
-};
-
-export function normalizeConfig(root, userConfig = {}, configPath = path.join(root, "package.json")) {
-  const config = {
-    root: path.resolve(root),
-    configPath,
-    // Document metadata defaults — actual values are merged in by
-    // loadReactDocumentEntry from <Press> / <Workspace> JSX props.
-    title: DEFAULT_CONFIG.title,
-    subtitle: "",
-    organization: "",
-    workspaceLabel: "",
-    // Paths — fixed conventions, not user-configurable.
-    documentDir: CONVENTION.documentDir,
-    sourceDir: CONVENTION.sourceDir,
-    mediaDir: CONVENTION.mediaDir,
-    themeDir: CONVENTION.themeDir,
-    designDoc: CONVENTION.designDoc,
-    componentsDir: CONVENTION.componentsDir,
-    publicDir: CONVENTION.publicDir,
-    outputDir: CONVENTION.outputDir,
-    captionNumbering: captionNumberingValue(userConfig.captionNumbering, DEFAULT_CONFIG.captionNumbering),
-    page: normalizePageGeometry(userConfig.page ?? DEFAULT_CONFIG.page),
-    pdf: {
-      filename: fileNameValue(userConfig.pdf?.filename, DEFAULT_CONFIG.pdf.filename),
-    },
-    deploy: {
-      adapter: stringValue(userConfig.deploy?.adapter, DEFAULT_CONFIG.deploy.adapter),
-      source: relativePathValue(userConfig.deploy?.source, DEFAULT_CONFIG.deploy.source),
-      projectName: optionalStringValue(userConfig.deploy?.projectName, DEFAULT_CONFIG.deploy.projectName),
-      commitDirty: booleanValue(userConfig.deploy?.commitDirty, DEFAULT_CONFIG.deploy.commitDirty),
-      requiresConfirmation: booleanValue(userConfig.deploy?.requiresConfirmation, DEFAULT_CONFIG.deploy.requiresConfirmation),
-    },
-  };
-
-  const documentRoot = config.documentDir === "." ? config.root : path.join(config.root, config.documentDir);
-  config.paths = {
-    documentRoot,
-    sourceDir: path.join(documentRoot, config.sourceDir),
-    mediaDir: path.join(documentRoot, config.mediaDir),
-    themeDir: path.join(documentRoot, config.themeDir),
-    designDoc: path.join(documentRoot, config.designDoc),
-    componentsDir: path.join(documentRoot, config.componentsDir),
-    publicDir: path.join(config.root, config.publicDir),
-    outputDir: path.join(config.root, config.outputDir),
-    pdf: path.join(config.root, config.outputDir, config.pdf.filename),
-    deploySource: path.join(config.root, config.deploy.source),
-    deployMetadata: path.join(config.root, config.deploy.source, "openpress", "deploy.json"),
-  };
-
-  return config;
-}
-
-export function publicPdfHref(config) {
-  return `/${config.pdf.filename}`;
-}
-
-function stringValue(value, fallback) {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-
-function optionalStringValue(value, fallback) {
-  if (value === null) return null;
-  if (typeof value === "string" && value.trim()) return value.trim();
-  return fallback;
-}
-
-function captionNumberingValue(value, fallback) {
-  const input = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-  return {
-    figure: optionalStringValue(input.figure, fallback.figure) ?? fallback.figure,
-    table: optionalStringValue(input.table, fallback.table) ?? fallback.table,
-    separator: typeof input.separator === "string" ? input.separator : fallback.separator,
-  };
-}
-
-function booleanValue(value, fallback) {
-  return typeof value === "boolean" ? value : fallback;
-}
-
-function fileNameValue(value, fallback) {
-  const fileName = stringValue(value, fallback);
-  if (fileName.includes("/") || fileName.includes("\\") || fileName === "." || fileName === "..") {
-    throw new Error(`OpenPress config pdf.filename must be a file name, got: ${fileName}`);
-  }
-  return fileName;
-}
-
-function relativePathValue(value, fallback) {
-  const raw = stringValue(value, fallback).replaceAll("\\", "/");
-  if (path.isAbsolute(raw)) throw new Error(`OpenPress config paths must be relative, got: ${raw}`);
-  const normalized = path.posix.normalize(raw).replace(/^\.\//, "");
-  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
-    throw new Error(`OpenPress config path escapes workspace: ${raw}`);
-  }
-  return normalized;
-}

package/template/core/engine/runtime/file-utils.mjs

@@ -1,114 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { loadConfig } from "./config.mjs";
-import { readKatexCss } from "../output/katex-assets.mjs";
-
-const CONTENT_CSS_LAYERS = [
-  "base/page-contract.css",
-  "base/typography.css",
-  "page-surfaces/cover.css",
-  { path: "page-surfaces/chapter-opener.css", optional: true },
-  "page-surfaces/back-cover.css",
-  "page-surfaces/toc.css",
-  { path: "page-surfaces", type: "directory", exclude: ["cover.css", "chapter-opener.css", "back-cover.css", "toc.css"] },
-  "shell/reader-controls.css",
-  "base/print.css",
-];
-
-export async function copyDirectory(src, dst) {
-  await fs.rm(dst, { recursive: true, force: true });
-  await fs.mkdir(path.dirname(dst), { recursive: true });
-  await fs.cp(src, dst, { recursive: true });
-}
-
-export async function writeContentCss(root, targetDir, config) {
-  config ??= await loadConfig(root);
-  const css = await buildContentCss(root, config);
-  await fs.mkdir(targetDir, { recursive: true });
-  await fs.writeFile(path.join(targetDir, "content.css"), css, "utf8");
-}
-
-export async function buildContentCss(root, config) {
-  config ??= await loadConfig(root);
-  const contentAssetsDir = config.paths.themeDir;
-  const parts = [];
-  for (const layer of CONTENT_CSS_LAYERS) {
-    if (typeof layer !== "string" && layer.type === "directory") {
-      await appendCssDirectory(parts, path.join(contentAssetsDir, layer.path), layer.path, {
-        exclude: new Set(layer.exclude ?? []),
-      });
-      continue;
-    }
-    const relativePath = typeof layer === "string" ? layer : layer.path;
-    const cssPath = path.join(contentAssetsDir, relativePath);
-    let css;
-    try {
-      css = await fs.readFile(cssPath, "utf8");
-    } catch (error) {
-      if (typeof layer !== "string" && layer.optional && error.code === "ENOENT") continue;
-      throw error;
-    }
-    parts.push(`/* === ${relativePath} === */\n`);
-    parts.push(css.trimEnd());
-    parts.push("\n\n");
-  }
-  parts.push("/* === engine/katex.css === */\n");
-  parts.push((await readKatexCss()).trimEnd());
-  parts.push("\n\n");
-  return parts.join("");
-}
-
-export async function writeComponentsCss(root, targetDir, config) {
-  config ??= await loadConfig(root);
-  const css = await buildComponentsCss(root, config);
-  await fs.mkdir(targetDir, { recursive: true });
-  await fs.writeFile(path.join(targetDir, "components.css"), css, "utf8");
-}
-
-export async function buildComponentsCss(root, config) {
-  config ??= await loadConfig(root);
-  const parts = [];
-  await appendCssDirectory(parts, path.join(config.paths.themeDir, "patterns"), "theme/patterns");
-  await appendComponentScopedCss(parts, config.paths.componentsDir);
-  return parts.join("");
-}
-
-async function appendCssDirectory(parts, directory, labelPrefix, options = {}) {
-  let entries;
-  try {
-    entries = await fs.readdir(directory);
-  } catch {
-    return;
-  }
-  for (const name of entries.filter((entry) => entry.endsWith(".css")).sort()) {
-    if (options.exclude?.has(name)) continue;
-    parts.push(`/* === ${labelPrefix}/${name} === */\n`);
-    parts.push((await fs.readFile(path.join(directory, name), "utf8")).trimEnd());
-    parts.push("\n\n");
-  }
-}
-
-async function appendComponentScopedCss(parts, componentsDir) {
-  let entries;
-  try {
-    entries = await fs.readdir(componentsDir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-    const cssPath = path.join(componentsDir, entry.name, "style.css");
-    let css;
-    try {
-      css = await fs.readFile(cssPath, "utf8");
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        continue;
-      }
-      throw error;
-    }
-    parts.push(`/* === components/${entry.name}/style.css === */\n`);
-    parts.push(css.trimEnd());
-    parts.push("\n\n");
-  }
-}

package/template/core/engine/runtime/file-walk.mjs

@@ -1,22 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-export async function walkFiles(directory, visit) {
-  let entries;
-  try {
-    entries = await fs.readdir(directory, { withFileTypes: true });
-  } catch (error) {
-    if (error?.code === "ENOENT") return;
-    throw error;
-  }
-
-  for (const entry of entries) {
-    if (entry.name.startsWith(".")) continue;
-    const absolutePath = path.join(directory, entry.name);
-    if (entry.isDirectory()) {
-      await walkFiles(absolutePath, visit);
-    } else if (entry.isFile()) {
-      await visit(absolutePath);
-    }
-  }
-}

package/template/core/engine/runtime/inspection.mjs

@@ -1,328 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { evaluateUrlWithChrome, stopChildProcess } from "../output/chrome-pdf.mjs";
-import { buildReactStatic, startStaticServer } from "../commands/_shared.mjs";
-import { walkFiles } from "./file-walk.mjs";
-import { createIssue, createIssueReport } from "./issue-report.mjs";
-import { collectActiveContentFiles, resolveActiveSourceWorkspace } from "./source-workspace.mjs";
-
-const MEDIA_EXTENSIONS = new Set([".avif", ".gif", ".jpeg", ".jpg", ".png", ".svg", ".webp"]);
-const SOURCE_EXTENSIONS = new Set([".css", ".html", ".js", ".json", ".md", ".mjs", ".ts", ".tsx"]);
-
-export async function inspectWorkspace({ root, config, options = {}, recurse = null }) {
-  const checked = [];
-  const issues = [];
-
-  const sourceScan = await collectInspectionSources(config);
-  checked.push(sourceScan.checkedName);
-  sourceScan.contentFiles.forEach((file) => {
-    if (!file.text.trim()) {
-      issues.push(createIssue({
-        level: "warning",
-        code: "react-source.empty-file",
-        message: `${sourceScan.contentLabel} \`${file.relativePath}\` is empty.`,
-        path: file.absolutePath,
-      }));
-    }
-  });
-
-  checked.push("media");
-  const mediaFiles = await readMediaFiles(sourceScan.config.paths.mediaDir);
-  const sourceText = sourceScan.sourceFiles.map((file) => file.text).join("\n");
-  const unusedMedia = mediaFiles.filter((file) => !sourceText.includes(file.name) && !sourceText.includes(file.relativePath));
-  unusedMedia.forEach((file) => {
-    issues.push(createIssue({
-      level: "warning",
-      code: "media.unused",
-      message: `Media asset \`${file.relativePath}\` is not referenced by document sources.`,
-      path: file.absolutePath,
-      detail: {
-        file: file.name,
-        relativePath: file.relativePath,
-      },
-    }));
-  });
-
-  checked.push("components");
-  const componentUsage = sourceScan.componentUsage;
-
-  const summary = {
-    ...sourceScan.summary,
-    mediaFiles: mediaFiles.length,
-    unusedMedia: unusedMedia.length,
-    componentUsage,
-  };
-
-  checked.push("overflow");
-  const renderCode = await buildReactStatic({
-    root,
-    noBuild: options.noBuild,
-    recurse,
-    silent: options.json,
-  });
-  if (renderCode !== 0) {
-    issues.push(createIssue({
-      level: "error",
-      code: "inspect.render",
-      message: `React render failed before overflow inspection (exit code ${renderCode}).`,
-      path: config.configPath,
-    }));
-    return createIssueReport({
-      kind: "inspection",
-      checked,
-      issues,
-      summary,
-      okMessage: "OpenPress inspection OK",
-    });
-  }
-
-  const overflowMeasurements = await inspectRenderedOverflow({
-    root,
-    config,
-    host: options.host ?? "127.0.0.1",
-    port: options.port ?? "5186",
-  });
-  issues.push(...overflowIssuesFromMeasurements(overflowMeasurements));
-  summary.pages = overflowMeasurements.length;
-  summary.overflowPages = overflowMeasurements.filter((page) => (page.overflows ?? []).length > 0).length;
-
-  return createIssueReport({
-    kind: "inspection",
-    checked,
-    issues,
-    summary,
-    okMessage: "OpenPress inspection OK",
-  });
-}
-
-export async function collectInspectionSources(config) {
-  const sourceWorkspace = await resolveActiveSourceWorkspace(config);
-  const sourceConfig = sourceWorkspace.config;
-  const contentFiles = await collectActiveContentFiles(sourceWorkspace);
-  const sourceFiles = [
-    ...contentFiles,
-    ...await readSourceFiles(sourceConfig.paths.componentsDir),
-    ...await readSingleFile(sourceConfig.paths.designDoc),
-  ];
-  const componentUsage = summarizeComponentUsage(contentFiles);
-
-  return {
-    sourceKind: sourceWorkspace.kind,
-    checkedName: sourceWorkspace.checkedName,
-    contentLabel: sourceWorkspace.contentLabel,
-    config: sourceConfig,
-    contentFiles,
-    sourceFiles,
-    componentUsage,
-    summary: {
-      sourceKind: sourceWorkspace.kind,
-      sourceFiles: contentFiles.length,
-      mdxFiles: contentFiles.length,
-    },
-  };
-}
-
-export async function inspectRenderedOverflow({ root, config, host = "127.0.0.1", port = "5186" }) {
-  const server = await startStaticServer(root, config, host, port);
-  try {
-    return await evaluateUrlWithChrome({
-      root,
-      url: `http://${host}:${port}/?print=1`,
-      debuggingPortBase: 9900,
-      debuggingPortRange: 600,
-      profilePrefix: "chrome-inspect",
-      emulatedMedia: "print",
-      evaluate: waitForInspectionReady,
-    });
-  } finally {
-    await stopChildProcess(server);
-  }
-}
-
-export async function waitForInspectionReady(client) {
-  const deadline = Date.now() + 30000;
-  while (Date.now() < deadline) {
-    const result = await client.send("Runtime.evaluate", {
-      returnByValue: true,
-      awaitPromise: true,
-      expression: inspectionExpression(),
-    });
-    const value = result.result?.value;
-    if (Array.isArray(value)) return value;
-    await delay(100);
-  }
-  throw new Error("Timed out waiting for OpenPress pagination before inspection.");
-}
-
-export function overflowIssuesFromMeasurements(measurements) {
-  return measurements.flatMap((page) => {
-    const pageLabel = String(page.pageNumber).padStart(2, "0");
-    return (page.overflows ?? []).map((overflow) => createIssue({
-      level: "warning",
-      code: `overflow.${overflow.code}`,
-      message: `Page ${pageLabel} exceeds ${humanOverflowTarget(overflow.code)} by ${Math.ceil(overflow.overflowPx)}px.`,
-      path: page.source?.path,
-      detail: {
-        pageNumber: page.pageNumber,
-        title: page.title,
-        sourceFile: page.source?.file,
-        selector: overflow.selector,
-        tagName: overflow.tagName,
-        text: overflow.text,
-        overflowPx: Math.ceil(overflow.overflowPx),
-      },
-    }));
-  });
-}
-
-async function readSourceFiles(directory, extension = null) {
-  const files = [];
-  await walkFiles(directory, async (absolutePath) => {
-    if (extension && path.extname(absolutePath) !== extension) return;
-    if (!SOURCE_EXTENSIONS.has(path.extname(absolutePath))) return;
-    files.push({
-      absolutePath,
-      relativePath: path.relative(directory, absolutePath).replaceAll("\\", "/"),
-      text: await fs.readFile(absolutePath, "utf8"),
-    });
-  });
-  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  return files;
-}
-
-async function readSingleFile(absolutePath) {
-  try {
-    const text = await fs.readFile(absolutePath, "utf8");
-    return [{
-      absolutePath,
-      relativePath: path.basename(absolutePath),
-      text,
-    }];
-  } catch (error) {
-    if (error?.code === "ENOENT") return [];
-    throw error;
-  }
-}
-
-async function readMediaFiles(directory) {
-  const files = [];
-  await walkFiles(directory, async (absolutePath) => {
-    if (!MEDIA_EXTENSIONS.has(path.extname(absolutePath).toLowerCase())) return;
-    files.push({
-      absolutePath,
-      name: path.basename(absolutePath),
-      relativePath: path.relative(directory, absolutePath).replaceAll("\\", "/"),
-    });
-  });
-  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  return files;
-}
-
-function summarizeComponentUsage(contentFiles) {
-  const usages = new Map();
-  for (const file of contentFiles) {
-    for (const match of file.text.matchAll(/<([A-Z][A-Za-z0-9]*)\b/g)) {
-      const name = match[1];
-      const current = usages.get(name) ?? { name, count: 0, files: [] };
-      current.count += 1;
-      if (!current.files.includes(file.relativePath)) current.files.push(file.relativePath);
-      usages.set(name, current);
-    }
-  }
-  return Array.from(usages.values()).sort((a, b) => a.name.localeCompare(b.name));
-}
-
-function humanOverflowTarget(code) {
-  if (code === "page-body") return "page body";
-  if (code === "page-frame") return "page frame";
-  return code.replaceAll("-", " ");
-}
-
-function inspectionExpression() {
-  return `Promise.resolve().then(async () => {
-    const root = document.querySelector('[data-openpress-print-document="true"]');
-    if (!root || root.querySelectorAll('.openpress-html-page').length === 0) return null;
-
-    await document.fonts?.ready;
-    await Promise.all(Array.from(document.images).map(async (img) => {
-      if (!img.complete) {
-        await new Promise((resolve) => {
-          const settle = () => {
-            img.removeEventListener('load', settle);
-            img.removeEventListener('error', settle);
-            resolve();
-          };
-          img.addEventListener('load', settle, { once: true });
-          img.addEventListener('error', settle, { once: true });
-        });
-      }
-      await img.decode?.().catch(() => undefined);
-    }));
-    await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
-
-    const textFor = (element) => (element?.textContent || '').replace(/\\s+/g, ' ').trim().slice(0, 120);
-    const overflowAmount = (outer, inner) => {
-      if (!outer || !inner) return 0;
-      const outerRect = outer.getBoundingClientRect();
-      const innerRect = inner.getBoundingClientRect();
-      return Math.max(0, innerRect.bottom - outerRect.bottom, innerRect.right - outerRect.right);
-    };
-    const contentBottomOverflow = (body) => {
-      if (!body) return 0;
-      const bodyRect = body.getBoundingClientRect();
-      const contentBottom = Array.from(body.children).reduce((bottom, child) => {
-        if (getComputedStyle(child).display === 'none') return bottom;
-        const marginBottom = Number.parseFloat(getComputedStyle(child).marginBottom) || 0;
-        return Math.max(bottom, child.getBoundingClientRect().bottom + marginBottom);
-      }, bodyRect.top);
-      return Math.max(0, contentBottom - bodyRect.bottom);
-    };
-    const addElementOverflow = (overflows, code, selector, container, element) => {
-      const px = overflowAmount(container, element);
-      if (px <= 1) return;
-      overflows.push({
-        code,
-        selector,
-        overflowPx: Math.ceil(px),
-        tagName: element.tagName,
-        text: textFor(element),
-      });
-    };
-
-    const wrappers = Array.from(document.querySelectorAll('.openpress-public-page > .openpress-html-page'));
-    if (wrappers.length === 0) return null;
-    return wrappers.map((wrapper, index) => {
-      const page = wrapper.querySelector('.reader-page') || wrapper;
-      const frame = page.querySelector('.page-frame') || page;
-      const body = page.querySelector('.page-body') || frame;
-      const sourcePath = wrapper.getAttribute('data-source-path') || undefined;
-      const sourceFile = wrapper.getAttribute('data-source-file') || sourcePath?.split('/').pop();
-      const overflows = [];
-      const bodyOverflow = contentBottomOverflow(body);
-      if (bodyOverflow > 1) {
-        overflows.push({
-          code: 'page-body',
-          selector: '.page-body',
-          overflowPx: Math.ceil(bodyOverflow),
-          tagName: body.tagName,
-          text: textFor(body),
-        });
-      }
-      addElementOverflow(overflows, 'page-frame', '.page-frame', page, frame);
-      body.querySelectorAll('table, img, pre, figure, [data-openpress-component]').forEach((element) => {
-        const tag = element.tagName.toLowerCase();
-        addElementOverflow(overflows, tag, tag, body, element);
-      });
-      return {
-        pageNumber: index + 1,
-        title: page.getAttribute('data-page-title') || wrapper.getAttribute('aria-label') || '',
-        source: sourcePath ? { file: sourceFile, path: sourcePath } : undefined,
-        overflows,
-      };
-    });
-  })`;
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/template/core/engine/runtime/issue-report.mjs

@@ -1,44 +0,0 @@
-export function createIssue({ level = "warning", code, message, path = null, detail = undefined }) {
-  return {
-    level,
-    code,
-    message,
-    ...(path ? { path } : {}),
-    ...(detail !== undefined ? { detail } : {}),
-  };
-}
-
-export function createIssueReport({ kind, checked = [], issues = [], summary = undefined, okMessage = undefined }) {
-  const report = {
-    kind,
-    ok: issues.every((issue) => issue.level !== "error"),
-    checked,
-    issues,
-    ...(summary !== undefined ? { summary } : {}),
-  };
-  return {
-    ...report,
-    format() {
-      return formatIssueReport(report, { okMessage });
-    },
-  };
-}
-
-export function exitCodeForIssueReport(report) {
-  return report.ok ? 0 : 1;
-}
-
-export function formatIssueReport(report, { okMessage } = {}) {
-  if (report.issues.length === 0) return okMessage ?? `${capitalize(report.kind)} OK`;
-  return report.issues.map(formatIssue).join("\n");
-}
-
-function formatIssue(issue) {
-  const suffix = issue.path ? ` (${issue.path})` : "";
-  return `[${issue.level}] ${issue.code}: ${issue.message}${suffix}`;
-}
-
-function capitalize(value) {
-  const text = String(value ?? "");
-  return text ? `${text.charAt(0).toUpperCase()}${text.slice(1)}` : "Report";
-}