@glossarist/concept-browser 0.7.115 → 0.7.116

package/scripts/migrate-v1-to-v3.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+// scripts/migrate-v1-to-v3.ts
+import fs from "fs";
+import path from "path";
+function isV1PartitiveRelation(rel) {
+  return rel && Array.isArray(rel.parts);
+}
+function migrateRelation(rel) {
+  if (!isV1PartitiveRelation(rel)) return null;
+  return {
+    comprehensive: rel.comprehensive,
+    completeness: rel.enumeration === "open" ? "partial" : rel.enumeration === "closed" || rel.enumeration == null ? "complete" : rel.enumeration,
+    partitives: (rel.parts ?? []).map((p) => ({
+      ref: p,
+      certainty: "confirmed"
+    })),
+    ...rel.content ? { content: rel.content } : {}
+  };
+}
+function migrateConceptData(data) {
+  if (!data?.partitive_relations?.length) return null;
+  const migrated = data.partitive_relations.map(migrateRelation).filter((r) => r !== null);
+  if (migrated.length === 0) return null;
+  return { ...data, partitive_relations: migrated };
+}
+function isAlreadyMigrated(content) {
+  return Boolean(content?.data?.partitive_relations?.some?.((rel) => Array.isArray(rel.partitives)));
+}
+function walkFiles(input) {
+  const stat = fs.statSync(input);
+  if (stat.isFile()) return [input];
+  const out = [];
+  for (const entry of fs.readdirSync(input, { withFileTypes: true })) {
+    const full = path.join(input, entry.name);
+    if (entry.isDirectory()) out.push(...walkFiles(full));
+    else if (entry.isFile() && /\.(ya?ml)$/i.test(entry.name)) out.push(full);
+  }
+  return out;
+}
+async function loadYamlModule() {
+  try {
+    return await import("js-yaml");
+  } catch {
+    return null;
+  }
+}
+function outputPath(input, file, outRoot) {
+  const stat = fs.statSync(input);
+  if (stat.isFile()) return outRoot;
+  const rel = path.relative(input, file);
+  return path.join(outRoot, rel);
+}
+async function migrateFile(input, file, options, yaml) {
+  const raw = fs.readFileSync(file, "utf8");
+  const parsed = yaml ? yaml.load(raw) : JSON.parse(raw);
+  if (!parsed?.data) return { changed: false };
+  if (isAlreadyMigrated(parsed)) return { changed: false, skipped: true };
+  const migrated = migrateConceptData(parsed.data);
+  if (!migrated) return { changed: false };
+  parsed.data = { ...parsed.data, ...migrated };
+  const out = outputPath(input, file, options.out);
+  fs.mkdirSync(path.dirname(out), { recursive: true });
+  const outText = yaml ? yaml.dump(parsed) : JSON.stringify(parsed, null, 2);
+  if (!options.dryRun) fs.writeFileSync(out, outText);
+  return { changed: true, out, in: file };
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const opts = { in: null, out: null, dryRun: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--in") opts.in = args[++i];
+    else if (a === "--out") opts.out = args[++i];
+    else if (a === "--dry-run") opts.dryRun = true;
+    else if (!opts.in) opts.in = a;
+    else if (!opts.out) opts.out = a;
+  }
+  if (!opts.in) {
+    console.error("Usage: node scripts/migrate-v1-to-v3.mjs --in <dir|file> [--out <dir|file>] [--dry-run]");
+    process.exit(1);
+  }
+  if (!opts.out) opts.out = opts.dryRun ? opts.in : `${opts.in}.v3`;
+  const yaml = await loadYamlModule();
+  if (!yaml) {
+    console.error("js-yaml is required; install via npm install js-yaml");
+    process.exit(1);
+  }
+  const files = walkFiles(opts.in);
+  let changed = 0, skipped = 0, total = 0;
+  for (const f of files) {
+    total++;
+    const res = await migrateFile(opts.in, f, opts, yaml);
+    if (res.changed) {
+      changed++;
+      console.log(`\u2713 ${res.in} \u2192 ${res.out}`);
+    } else if (res.skipped) {
+      skipped++;
+    }
+  }
+  console.log(`
+${changed} migrated, ${skipped} skipped (already v3), ${total - changed - skipped} unchanged.`);
+  if (opts.dryRun) console.log("(dry-run \u2014 no files written)");
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  isAlreadyMigrated,
+  isV1PartitiveRelation,
+  migrateConceptData,
+  migrateRelation
+};

package/scripts/normalize-yaml.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+// scripts/normalize-yaml.ts
+import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative, extname, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+var YAML_EXTS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+function walk(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    if (SKIP_DIRS.has(entry)) continue;
+    const full = join(dir, entry);
+    const st = statSync(full);
+    if (st.isDirectory()) {
+      out.push(...walk(full));
+    } else if (YAML_EXTS.has(extname(entry))) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function normalizeYaml({ root = ROOT, check = false, paths = [] } = {}) {
+  const searchDirs = paths.length > 0 ? paths.map((p) => join(root, p)) : [join(root, ".datasets")];
+  const files = [];
+  for (const dir of searchDirs) {
+    try {
+      statSync(dir);
+    } catch {
+      continue;
+    }
+    files.push(...walk(dir));
+  }
+  files.sort();
+  let checked = 0;
+  let nonNfc = 0;
+  const fixed = [];
+  for (const file of files) {
+    const original = readFileSync(file, "utf8");
+    checked++;
+    if (!isNfc(original)) {
+      nonNfc++;
+      if (!check) {
+        writeFileSync(file, original.normalize("NFC"), "utf8");
+        fixed.push(relative(root, file));
+      } else {
+        fixed.push(relative(root, file));
+      }
+    }
+  }
+  return { checked, nonNfc, fixed, check };
+}
+function isNfc(s) {
+  return s === s.normalize("NFC");
+}
+function main() {
+  const args = process.argv.slice(2);
+  const check = args.includes("--check");
+  const paths = args.filter((a) => !a.startsWith("-") && a !== "normalize");
+  const { checked, nonNfc, fixed } = normalizeYaml({ check, paths });
+  if (check) {
+    if (nonNfc === 0) {
+      process.stdout.write(`NFC OK: ${checked} file(s) checked, all normalized
+`);
+      return;
+    }
+    process.stderr.write(`NFC check failed: ${nonNfc} of ${checked} file(s) are not NFC-normalized
+
+`);
+    for (const f of fixed) {
+      process.stderr.write(`  ${f}
+`);
+    }
+    process.exit(1);
+  } else {
+    if (nonNfc === 0) {
+      process.stdout.write(`NFC OK: ${checked} file(s) checked, all already normalized
+`);
+      return;
+    }
+    process.stdout.write(`Normalized ${nonNfc} of ${checked} file(s)
+`);
+    for (const f of fixed) {
+      process.stdout.write(`  ${f}
+`);
+    }
+  }
+}
+var isDirectEntry = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectEntry) {
+  main();
+}
+export {
+  normalizeYaml
+};

package/scripts/process-about-pages.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+// scripts/process-about-pages.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { join, basename, extname, resolve as resolve2 } from "node:path";
+import { cwd } from "node:process";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/load-site-config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var projectRoot = resolve(__dirname, "..");
+var SNAKE_TO_CAMEL = {
+  // Site-level
+  uri_base: "uriBase",
+  base_path: "basePath",
+  ui_languages: "uiLanguages",
+  dataset_groups: "datasetGroups",
+  dataset_translations: "datasetTranslations",
+  primary_color: "primaryColor",
+  dark_color: "darkColor",
+  owner_name: "ownerName",
+  owner_url: "ownerUrl",
+  powered_by: "poweredBy",
+  footer_nav: "footerNav",
+  footer_logo: "footerLogo",
+  news_dir: "newsDir",
+  // Dataset-level
+  gcr_package: "gcrPackage",
+  source_repo: "sourceRepo",
+  local_path: "localPath",
+  local_light: "localLight",
+  local_dark: "localDark",
+  uri_aliases: "uriAliases",
+  language_order: "languageOrder",
+  ref_aliases: "refAliases",
+  urn_aliases: "urnAliases",
+  existing_site_url: "existingSiteUrl",
+  edition_status: "editionStatus",
+  dataset_uri: "datasetUri",
+  schema_version: "schemaVersion"
+};
+function normalizeKey(key) {
+  if (typeof key !== "string") return key;
+  if (Object.prototype.hasOwnProperty.call(SNAKE_TO_CAMEL, key)) {
+    return SNAKE_TO_CAMEL[key];
+  }
+  if (key.includes("_") && /^[a-z][a-z0-9_]*$/.test(key)) {
+    return key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+  }
+  return key;
+}
+function normalizeObject(obj) {
+  if (Array.isArray(obj)) return obj.map(normalizeObject);
+  if (obj && typeof obj === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[normalizeKey(k)] = normalizeObject(v);
+    }
+    return out;
+  }
+  return obj;
+}
+function findConfigFile(args = []) {
+  if (process.env.SITE_CONFIG) {
+    return resolve(process.env.SITE_CONFIG);
+  }
+  for (const dir of [process.cwd(), projectRoot]) {
+    const p = resolve(dir, "site-config.yml");
+    if (existsSync(p)) return p;
+  }
+  throw new Error("No site config found. Set SITE_CONFIG or create site-config.yml");
+}
+function loadSiteConfig(args = []) {
+  const configPath = findConfigFile(args);
+  const raw = yaml.load(readFileSync(configPath, "utf-8"));
+  const config = normalizeObject(raw);
+  return { config, configPath };
+}
+
+// scripts/process-about-pages.ts
+function loadSiteConfigForAbout() {
+  try {
+    const { config } = loadSiteConfig([]);
+    return config;
+  } catch {
+    return null;
+  }
+}
+function roots() {
+  const ROOT = cwd();
+  return {
+    ROOT,
+    PUBLIC_PAGES: join(ROOT, "public", "pages"),
+    DATASETS_DIR: join(ROOT, ".datasets"),
+    GROUPS_CONTENT_DIR: join(ROOT, "site-content", "groups")
+  };
+}
+function renderMarkdown(text) {
+  const lines = text.split("\n");
+  const html = [];
+  let inList = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      continue;
+    }
+    if (/^#{1}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h1>${inline(trimmed.replace(/^#\s/, ""))}</h1>`);
+    } else if (/^#{2}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h2>${inline(trimmed.replace(/^##\s/, ""))}</h2>`);
+    } else if (/^#{3}\s/.test(trimmed)) {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<h3>${inline(trimmed.replace(/^###\s/, ""))}</h3>`);
+    } else if (/^[-*]\s/.test(trimmed)) {
+      if (!inList) {
+        html.push("<ul>");
+        inList = true;
+      }
+      html.push(`<li>${inline(trimmed.replace(/^[-*]\s/, ""))}</li>`);
+    } else {
+      if (inList) {
+        html.push("</ul>");
+        inList = false;
+      }
+      html.push(`<p>${inline(trimmed)}</p>`);
+    }
+  }
+  if (inList) html.push("</ul>");
+  return html.join("\n");
+}
+function inline(text) {
+  return text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\*(.+?)\*/g, "<em>$1</em>").replace(/\[(.+?)\]\((.+?)\)/g, '<a href="$2">$1</a>').replace(/`(.+?)`/g, "<code>$1</code>");
+}
+function processAboutDir(sourceDir, outputPrefix, publicPagesDir) {
+  if (!existsSync2(sourceDir)) return 0;
+  let count = 0;
+  for (const file of readdirSync(sourceDir)) {
+    const fullPath = join(sourceDir, file);
+    if (!statSync(fullPath).isFile()) continue;
+    const ext = extname(file);
+    if (ext !== ".md" && ext !== ".adoc" && ext !== ".html") continue;
+    const base = basename(file, ext);
+    const langMatch = base.match(/^about\.(\w+)$/);
+    const lang = langMatch ? langMatch[1] : "eng";
+    const outputName = lang === "eng" ? `${outputPrefix}.json` : `${outputPrefix}.${lang}.json`;
+    const raw = readFileSync2(fullPath, "utf8");
+    let html;
+    let title;
+    if (ext === ".html") {
+      html = raw;
+      const titleMatch = raw.match(/<h1[^>]*>(.+?)<\/h1>/);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else if (ext === ".md") {
+      html = renderMarkdown(raw);
+      const titleMatch = raw.match(/^#\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    } else {
+      html = `<p>${raw.split("\n").filter((l) => l.trim() && !l.startsWith("=")).join("</p>\n<p>")}</p>`;
+      const titleMatch = raw.match(/^=\s+(.+)$/m);
+      title = titleMatch ? titleMatch[1] : "About";
+    }
+    const output = { title, html };
+    mkdirSync(publicPagesDir, { recursive: true });
+    writeFileSync(join(publicPagesDir, outputName), JSON.stringify(output));
+    count++;
+    console.log(`  Compiled: ${file} \u2192 public/pages/${outputName}`);
+  }
+  return count;
+}
+function main() {
+  const { ROOT, PUBLIC_PAGES, DATASETS_DIR, GROUPS_CONTENT_DIR } = roots();
+  mkdirSync(PUBLIC_PAGES, { recursive: true });
+  let total = 0;
+  const siteConfig = loadSiteConfigForAbout();
+  const localPathMap = /* @__PURE__ */ new Map();
+  for (const ds of siteConfig?.datasets || []) {
+    if (ds.id && ds.localPath) {
+      localPathMap.set(ds.id, resolve2(ROOT, ds.localPath));
+    }
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  if (existsSync2(DATASETS_DIR)) {
+    for (const dsId of readdirSync(DATASETS_DIR)) {
+      seenIds.add(dsId);
+      const aboutDir = join(DATASETS_DIR, dsId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing dataset: ${dsId}`);
+        total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  for (const [dsId, dsPath] of localPathMap) {
+    if (seenIds.has(dsId)) continue;
+    const aboutDir = join(dsPath, "about");
+    if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+      console.log(`Processing dataset (localPath): ${dsId}`);
+      total += processAboutDir(aboutDir, `dataset-${dsId}-about`, PUBLIC_PAGES);
+    }
+  }
+  if (existsSync2(GROUPS_CONTENT_DIR)) {
+    for (const groupId of readdirSync(GROUPS_CONTENT_DIR)) {
+      const aboutDir = join(GROUPS_CONTENT_DIR, groupId, "about");
+      if (existsSync2(aboutDir) && statSync(aboutDir).isDirectory()) {
+        console.log(`Processing group: ${groupId}`);
+        total += processAboutDir(aboutDir, `group-${groupId}-about`, PUBLIC_PAGES);
+      }
+    }
+  }
+  console.log(total > 0 ? `
+Compiled ${total} about page(s).` : "\nNo about pages found.");
+}
+var isDirectInvocation = process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath2(import.meta.url));
+if (isDirectInvocation) {
+  main();
+}
+export {
+  loadSiteConfigForAbout,
+  main,
+  processAboutDir,
+  renderMarkdown,
+  roots
+};

package/scripts/smoke.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+// scripts/smoke.ts
+import { chromium } from "playwright";
+import { createServer } from "http";
+import { statSync, createReadStream } from "fs";
+import { extname, join, normalize, resolve as pathResolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+var DIST = pathResolve(__dirname, "..", "dist");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  "": "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",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".map": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8"
+};
+function serveDist(root) {
+  return new Promise((resolve) => {
+    const server = createServer((req, res) => {
+      try {
+        const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+        let filePath = join(root, urlPath);
+        if (!extname(filePath)) {
+          if (statSafe(filePath)?.isFile()) {
+            return sendFile(res, filePath);
+          }
+          const candidates = [
+            filePath + ".html",
+            join(filePath, "index.html"),
+            join(root, "200.html"),
+            join(root, "index.html")
+          ];
+          for (const c of candidates) {
+            if (statSafe(c)?.isFile()) {
+              return sendFile(res, c);
+            }
+          }
+          res.writeHead(404);
+          return res.end("Not found");
+        }
+        if (statSafe(filePath)?.isFile()) {
+          return sendFile(res, filePath);
+        }
+        res.writeHead(404);
+        return res.end("Not found");
+      } catch (e) {
+        res.writeHead(500);
+        res.end(String(e ?? "server error"));
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      resolve({ server, origin: `http://127.0.0.1:${port}` });
+    });
+  });
+}
+function statSafe(p) {
+  try {
+    return statSync(p);
+  } catch {
+    return null;
+  }
+}
+function sendFile(res, filePath) {
+  const safe = normalize(filePath);
+  const ct = MIME[extname(safe)] ?? "application/octet-stream";
+  res.writeHead(200, { "Content-Type": ct });
+  createReadStream(safe).pipe(res);
+}
+var PAGE_PATHS = [
+  "/",
+  "/learn/",
+  "/learn/relationships/",
+  "/learn/designations/",
+  "/learn/statuses/"
+];
+var CONSUMER_DATA_FILES = [
+  "/datasets.json",
+  "/site-config.json",
+  "/data/cross-ref-index.json"
+];
+function isConsumerDataFile(url) {
+  try {
+    const u = new URL(url);
+    return CONSUMER_DATA_FILES.some((f) => u.pathname === f || u.pathname.startsWith("/data/"));
+  } catch {
+    return false;
+  }
+}
+async function probePage(browser, origin, path) {
+  const url = new URL(path, origin).toString();
+  const page = await browser.newPage();
+  const errors = [];
+  const failedRequests = [];
+  page.on("pageerror", (e) => {
+    errors.push({ kind: "pageerror", message: e.message, stack: e.stack ?? "" });
+  });
+  page.on("console", (msg) => {
+    if (msg.type() !== "error") return;
+    const text = msg.text();
+    if (/Failed to load resource/i.test(text)) return;
+    if (/fonts\.g(oogle|static)\.com/.test(text)) return;
+    errors.push({ kind: "console.error", message: text });
+  });
+  page.on("requestfailed", (req) => {
+    const u = req.url();
+    if (u.startsWith(origin) && !isConsumerDataFile(u)) {
+      failedRequests.push({ url: u, failure: req.failure()?.errorText ?? "failed" });
+    }
+  });
+  page.on("response", (resp) => {
+    const u = resp.url();
+    if (u.startsWith(origin) && resp.status() >= 400 && !isConsumerDataFile(u)) {
+      failedRequests.push({ url: u, status: resp.status() });
+    }
+  });
+  try {
+    const resp = await page.goto(url, { waitUntil: "networkidle", timeout: 15e3 });
+    if (resp && resp.status() >= 400) {
+      return { path, url, status: resp.status(), bodyLen: 0, errors, failedRequests, skipped: path !== "/" };
+    }
+    await page.waitForTimeout(500);
+    const bodyLen = await page.evaluate(() => document.body?.innerText?.length ?? 0);
+    return { path, url, status: resp?.status() ?? 0, bodyLen, errors, failedRequests, skipped: false };
+  } catch (e) {
+    errors.push({ kind: "navigation", message: String(e) });
+    return { path, url, status: 0, bodyLen: 0, errors, failedRequests, skipped: false };
+  } finally {
+    await page.close();
+  }
+}
+function formatFindings(results) {
+  const lines = [];
+  for (const r of results) {
+    if (r.skipped) {
+      lines.push(`
+  ${r.path}  (HTTP ${r.status} \u2014 skipped, not in this build)`);
+      continue;
+    }
+    if (r.errors.length === 0 && r.failedRequests.length === 0 && r.bodyLen > 0) continue;
+    lines.push(`
+  ${r.path}  (HTTP ${r.status}, body ${r.bodyLen} chars)`);
+    for (const e of r.errors) {
+      lines.push(`    [${e.kind}] ${e.message}`);
+    }
+    for (const f of r.failedRequests) {
+      lines.push(`    [request] ${f.status ?? f.failure}  ${f.url}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function ensureDist() {
+  if (!statSafe(DIST)?.isDirectory()) {
+    console.error(`smoke: dist/ not found at ${DIST}`);
+    console.error(`       run \`npm run build\` first, or use \`npm run build:full\`.`);
+    process.exit(2);
+  }
+  if (!statSafe(join(DIST, "index.html"))?.isFile()) {
+    console.error(`smoke: dist/index.html missing \u2014 build did not complete.`);
+    process.exit(2);
+  }
+}
+async function main() {
+  await ensureDist();
+  const { server, origin } = await serveDist(DIST);
+  let exitCode = 0;
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const results = [];
+    for (const path of PAGE_PATHS) {
+      const r = await probePage(browser, origin, path);
+      results.push(r);
+    }
+    const anyFail = results.some(
+      (r) => !r.skipped && (r.errors.length > 0 || r.failedRequests.length > 0 || r.bodyLen === 0)
+    );
+    const findings = formatFindings(results);
+    if (anyFail) {
+      exitCode = 1;
+      console.error(`
+  FAIL  smoke test found problems:${findings}
+`);
+    } else {
+      const skipped = results.filter((r) => r.skipped).length;
+      console.log(`
+  OK    smoke test passed (${results.length - skipped} pages, ${skipped} skipped, 0 errors).`);
+    }
+  } finally {
+    await browser.close();
+    server.close();
+  }
+  process.exit(exitCode);
+}
+main().catch((e) => {
+  console.error("smoke: fatal error", e);
+  process.exit(1);
+});