@rtrentjones/greenlight 0.2.4

package/dist/chunk-6N7MD6FR.js

@@ -0,0 +1,75 @@
+import {
+  msg,
+  report
+} from "./chunk-QFKE5JKC.js";
+
+// ../packages/verify/src/eval.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+function resultText(res) {
+  const r = res;
+  if (r.structuredContent !== void 0) return JSON.stringify(r.structuredContent);
+  if (Array.isArray(r.content)) {
+    return r.content.map((c) => c.type === "text" ? c.text ?? "" : JSON.stringify(c)).join("\n");
+  }
+  return JSON.stringify(res);
+}
+function llmJudge(model) {
+  return async ({ rubric, result }) => {
+    if (!process.env.ANTHROPIC_API_KEY) throw new Error("ANTHROPIC_API_KEY not set");
+    const sdkName = "@anthropic-ai/sdk";
+    const Anthropic = (await import(sdkName)).default;
+    const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    const resp = await client.messages.create({
+      model,
+      max_tokens: 512,
+      system: 'You are a strict evaluation judge. Score how well RESULT satisfies RUBRIC on a 1\u20135 scale (5 = fully satisfies). Reply ONLY with JSON: {"score": <1-5>, "pass": <bool>, "reason": "<short>"}.',
+      messages: [{ role: "user", content: `RUBRIC:
+${rubric}
+
+RESULT:
+${result}` }]
+    });
+    const text = resp.content.find((b) => b.type === "text")?.text ?? "";
+    const json = text.match(/\{[\s\S]*\}/);
+    if (!json) throw new Error(`judge returned no JSON: ${text.slice(0, 120)}`);
+    const parsed = JSON.parse(json[0]);
+    return { score: Number(parsed.score) || 0, pass: Boolean(parsed.pass), reason: parsed.reason };
+  };
+}
+async function verifyEval(baseUrl, spec, judge) {
+  const score = judge ?? llmJudge(spec.model ?? "claude-sonnet-4-6");
+  const checks = [];
+  const client = new Client({ name: "greenlight-verify", version: "0.0.0" });
+  const transport = new StreamableHTTPClientTransport(new URL(baseUrl));
+  try {
+    await client.connect(transport);
+  } catch (e) {
+    return report("eval", baseUrl, [{ name: "initialize handshake", pass: false, detail: msg(e) }]);
+  }
+  try {
+    for (const c of spec.cases) {
+      const min = c.minScore ?? 4;
+      try {
+        const res = await client.callTool({ name: c.tool, arguments: c.args ?? {} });
+        const verdict = await score({ rubric: c.rubric, result: resultText(res) });
+        const pass = verdict.pass && verdict.score >= min;
+        checks.push({
+          name: `eval: ${c.name}`,
+          pass,
+          detail: `score ${verdict.score}/5 (min ${min})${verdict.reason ? ` \u2014 ${verdict.reason}` : ""}`
+        });
+      } catch (e) {
+        checks.push({ name: `eval: ${c.name}`, pass: false, detail: msg(e) });
+      }
+    }
+  } finally {
+    await client.close();
+  }
+  return report("eval", baseUrl, checks);
+}
+
+export {
+  llmJudge,
+  verifyEval
+};

package/dist/chunk-KFKYLGFX.js

@@ -0,0 +1,271 @@
+import {
+  msg,
+  report
+} from "./chunk-QFKE5JKC.js";
+
+// ../packages/shared/src/defineConfig.ts
+function defineConfig(config) {
+  return config;
+}
+
+// ../packages/shared/src/load.ts
+import { createJiti } from "jiti";
+
+// ../packages/shared/src/schema.ts
+import { z } from "zod";
+var LaneEnum = z.enum(["astro", "next", "mcp"]);
+var TargetEnum = z.enum(["workers", "vercel", "oci"]);
+var DataEnum = z.enum(["none", "d1", "kv", "supabase"]);
+var AuthEnum = z.enum(["none", "bearer", "oauth"]);
+var AccessEnum = z.enum(["public", "private"]);
+var EnvEnum = z.enum(["preview", "beta", "prod"]);
+var MATRIX = {
+  astro: { targets: ["workers"], data: ["none", "d1", "kv"] },
+  next: { targets: ["vercel"], data: ["none", "supabase"] },
+  mcp: { targets: ["workers", "oci"], data: ["none"] }
+};
+var ToolSchema = z.object({
+  name: z.string().regex(/^[a-z][a-z0-9-]*$/, "tool name must be kebab-case starting with a letter"),
+  lane: LaneEnum,
+  target: TargetEnum,
+  data: DataEnum,
+  auth: AuthEnum.default("none"),
+  access: AccessEnum.default("public"),
+  envs: z.array(EnvEnum).nonempty("a tool needs at least one env"),
+  adopted: z.boolean().default(false),
+  // Directory the tool builds/deploys from. Defaults to tools/<name>; a standalone
+  // (poly-repo) tool sets '.' (the repo root).
+  dir: z.string().optional(),
+  // The tool's code lives in another repo — this entry is a registry pointer only,
+  // not built/deployed here (greenlight-v1.md §15.5 poly-repo).
+  external: z.boolean().default(false)
+}).superRefine((tool, ctx) => {
+  const rule = MATRIX[tool.lane];
+  if (!rule.targets.includes(tool.target)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["target"],
+      message: `lane "${tool.lane}" does not support target "${tool.target}" (allowed: ${rule.targets.join(", ")})`
+    });
+  }
+  if (!rule.data.includes(tool.data)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["data"],
+      message: `lane "${tool.lane}" does not support data "${tool.data}" (allowed: ${rule.data.join(", ")})`
+    });
+  }
+  if (tool.access === "private" && tool.auth === "none") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["auth"],
+      message: 'private tools must set auth to "bearer" or "oauth", never "none"'
+    });
+  }
+});
+var BlogSchema = z.object({
+  lane: z.literal("astro"),
+  target: z.literal("workers"),
+  data: z.enum(["none", "d1", "kv"])
+});
+var AlertsSchema = z.object({
+  sink: z.enum(["github-issue", "email"])
+});
+var ConfigSchema = z.object({
+  domain: z.string().min(1, "domain is required"),
+  alerts: AlertsSchema,
+  // Optional: a tool-only repo (a poly-repo consumer) has no blog.
+  blog: BlogSchema.optional(),
+  tools: z.array(ToolSchema).default([])
+});
+
+// ../packages/shared/src/load.ts
+async function loadConfig(path) {
+  const jiti = createJiti(import.meta.url);
+  const mod = await jiti.import(path);
+  const raw = "default" in mod ? mod.default : mod;
+  const result = ConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const details = result.error.issues.map((issue) => `  \u2022 ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+    throw new Error(`Invalid Greenlight manifest at ${path}:
+${details}`);
+  }
+  return result.data;
+}
+
+// ../packages/shared/src/url.ts
+function resolveUrl({ domain, name, env, mcp }) {
+  if (env === "preview") {
+    throw new Error(
+      "preview URLs are per-target and not deterministic \u2014 get them from the adapter (deploy result / adapter.url), not resolveUrl()."
+    );
+  }
+  const host = name === void 0 ? env === "beta" ? `beta.${domain}` : domain : env === "beta" ? `beta.${name}.${domain}` : `${name}.${domain}`;
+  return `https://${host}${mcp ? "/mcp" : ""}`;
+}
+
+// ../packages/verify/src/index.ts
+import { setTimeout as sleep } from "timers/promises";
+
+// ../packages/verify/src/api.ts
+var trimSlash = (s) => s.replace(/\/+$/, "");
+async function checkRoute(base, c) {
+  const name = `GET ${c.path}`;
+  try {
+    const res = await fetch(base + c.path, { redirect: "manual" });
+    const reasons = [];
+    if (c.status !== void 0 && res.status !== c.status) {
+      reasons.push(`status ${res.status} != ${c.status}`);
+    }
+    if (c.contains !== void 0) {
+      const body = await res.text();
+      if (!body.includes(c.contains)) reasons.push(`body missing "${c.contains}"`);
+    }
+    if (c.header) {
+      const v = res.headers.get(c.header.name);
+      if (v === null) reasons.push(`header ${c.header.name} absent`);
+      else if (c.header.value !== void 0 && v !== c.header.value) {
+        reasons.push(`header ${c.header.name}="${v}" != "${c.header.value}"`);
+      }
+    }
+    return { name, pass: reasons.length === 0, detail: reasons.join("; ") || void 0 };
+  } catch (e) {
+    return { name, pass: false, detail: msg(e) };
+  }
+}
+async function checkXml(base, candidates, label, marker) {
+  for (const path of candidates) {
+    try {
+      const res = await fetch(base + path, { redirect: "manual" });
+      if (res.status === 200) {
+        const body = await res.text();
+        const ok = marker.test(body);
+        return {
+          name: `${label} (${path})`,
+          pass: ok,
+          detail: ok ? void 0 : `200 but content did not look like ${label}`
+        };
+      }
+    } catch {
+    }
+  }
+  return { name: label, pass: false, detail: `none of ${candidates.join(", ")} returned 200` };
+}
+async function checkInternalLinks(base, max = 25) {
+  try {
+    const res = await fetch(`${base}/`, { redirect: "manual" });
+    const html = await res.text();
+    const hrefs = /* @__PURE__ */ new Set();
+    for (const m of html.matchAll(/href="(\/[^"#?]*)"/g)) {
+      const href = m[1];
+      if (href && !href.startsWith("//")) hrefs.add(href);
+      if (hrefs.size >= max) break;
+    }
+    const broken = [];
+    for (const href of hrefs) {
+      try {
+        const r = await fetch(base + href, { redirect: "manual" });
+        if (r.status >= 400) broken.push(`${href} (${r.status})`);
+      } catch {
+        broken.push(`${href} (unreachable)`);
+      }
+    }
+    return {
+      name: `no broken internal links (${hrefs.size} checked)`,
+      pass: broken.length === 0,
+      detail: broken.length ? `broken: ${broken.join(", ")}` : void 0
+    };
+  } catch (e) {
+    return { name: "no broken internal links", pass: false, detail: msg(e) };
+  }
+}
+async function verifyApi(baseUrl, spec) {
+  const base = trimSlash(baseUrl);
+  const checks = [];
+  for (const c of spec.checks ?? []) checks.push(await checkRoute(base, c));
+  if (spec.rssValid) {
+    checks.push(
+      await checkXml(base, ["/rss.xml", "/feed.xml", "/index.xml"], "rss", /<(rss|feed)[\s>]/i)
+    );
+  }
+  if (spec.sitemapValid) {
+    checks.push(
+      await checkXml(
+        base,
+        ["/sitemap.xml", "/sitemap-index.xml"],
+        "sitemap",
+        /<(urlset|sitemapindex)[\s>]/i
+      )
+    );
+  }
+  if (spec.noBrokenInternalLinks) checks.push(await checkInternalLinks(base));
+  return report("api", baseUrl, checks);
+}
+
+// ../packages/verify/src/index.ts
+function defineVerify(spec) {
+  return spec;
+}
+async function waitForReachable(url, timeoutMs) {
+  if (timeoutMs <= 0) return true;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    try {
+      await fetch(url, { signal: AbortSignal.timeout(5e3) });
+      return true;
+    } catch {
+      if (Date.now() >= deadline) return false;
+      await sleep(2e3);
+    }
+  }
+}
+async function verify(baseUrl, spec, opts) {
+  if (opts?.reachableTimeoutMs) await waitForReachable(baseUrl, opts.reachableTimeoutMs);
+  switch (spec.mode) {
+    case "api":
+      return verifyApi(baseUrl, spec);
+    case "mcp": {
+      const { verifyMcp: verifyMcp2 } = await import("./mcp-KU7WKB5K.js");
+      return verifyMcp2(baseUrl, spec);
+    }
+    case "playwright": {
+      const { verifyPlaywright: verifyPlaywright2 } = await import("./playwright-CGTTHGIL.js");
+      return verifyPlaywright2(baseUrl, spec);
+    }
+    case "test": {
+      const { verifyTest: verifyTest2 } = await import("./test-7GMOU7I5.js");
+      return verifyTest2(spec, opts?.toolDir ?? process.cwd());
+    }
+    case "agent-web": {
+      const { verifyAgentWeb: verifyAgentWeb2 } = await import("./agent-web-I4LXW4SR.js");
+      return verifyAgentWeb2(baseUrl, spec);
+    }
+    case "eval": {
+      const { verifyEval: verifyEval2 } = await import("./eval-LLQPOEQX.js");
+      return verifyEval2(baseUrl, spec);
+    }
+  }
+}
+async function verifyAll(baseUrl, specs, opts) {
+  const reports = [];
+  let waited = false;
+  for (const spec of specs) {
+    const perSpec = waited ? { ...opts, reachableTimeoutMs: 0 } : opts;
+    reports.push(await verify(baseUrl, spec, perSpec));
+    waited = true;
+  }
+  return reports;
+}
+function allPass(reports) {
+  return reports.length > 0 && reports.every((r) => r.pass);
+}
+
+export {
+  ConfigSchema,
+  defineConfig,
+  loadConfig,
+  resolveUrl,
+  defineVerify,
+  verifyAll,
+  allPass
+};

package/dist/chunk-KP3Y6WRU.js

@@ -0,0 +1,45 @@
+import {
+  msg,
+  report
+} from "./chunk-QFKE5JKC.js";
+
+// ../packages/verify/src/test.ts
+import { spawnSync } from "child_process";
+function summarize(output) {
+  const lines = output.split("\n");
+  const hit = lines.find((l) => /Tests?\s+\d+\s+(passed|failed)|Tests:|# (pass|fail)\b/.test(l));
+  if (hit) return hit.trim();
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const l = lines[i];
+    if (l?.trim()) return l.trim();
+  }
+  return void 0;
+}
+function verifyTest(spec, defaultCwd) {
+  const command = spec.command ?? "pnpm test";
+  const cwd = spec.cwd ?? defaultCwd;
+  const where = `${command} (${cwd})`;
+  try {
+    const res = spawnSync(command, {
+      cwd,
+      shell: true,
+      encoding: "utf8",
+      timeout: spec.timeoutMs ?? 6e5,
+      maxBuffer: 64 * 1024 * 1024
+    });
+    if (res.error) {
+      return report("test", where, [{ name: command, pass: false, detail: msg(res.error) }]);
+    }
+    const out = `${res.stdout ?? ""}${res.stderr ?? ""}`;
+    const summary = summarize(out);
+    const pass = res.status === 0;
+    const detail = pass ? summary : `exit ${res.status ?? "signal"}${summary ? ` \u2014 ${summary}` : ""}`;
+    return report("test", where, [{ name: command, pass, detail }]);
+  } catch (e) {
+    return report("test", where, [{ name: command, pass: false, detail: msg(e) }]);
+  }
+}
+
+export {
+  verifyTest
+};

package/dist/chunk-QFKE5JKC.js

@@ -0,0 +1,12 @@
+// ../packages/verify/src/types.ts
+function msg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function report(mode, url, checks) {
+  return { pass: checks.length > 0 && checks.every((c) => c.pass), mode, url, checks };
+}
+
+export {
+  msg,
+  report
+};

package/dist/chunk-UXHHLEYO.js

@@ -0,0 +1,231 @@
+import {
+  msg,
+  report
+} from "./chunk-QFKE5JKC.js";
+
+// ../packages/verify/src/agent-web.ts
+var TOOLS = [
+  {
+    name: "browser_snapshot",
+    description: "Get the current URL and the accessibility tree of the page.",
+    input_schema: { type: "object", properties: {} }
+  },
+  {
+    name: "browser_click",
+    description: "Click an element identified by its ARIA role and accessible name.",
+    input_schema: {
+      type: "object",
+      properties: { role: { type: "string" }, name: { type: "string" } },
+      required: ["role", "name"]
+    }
+  },
+  {
+    name: "browser_type",
+    description: "Type text into a field by role + accessible name; submit=true presses Enter.",
+    input_schema: {
+      type: "object",
+      properties: {
+        role: { type: "string" },
+        name: { type: "string" },
+        text: { type: "string" },
+        submit: { type: "boolean" }
+      },
+      required: ["role", "name", "text"]
+    }
+  },
+  {
+    name: "browser_navigate",
+    description: 'Navigate to a path on the same site (e.g. "/login").',
+    input_schema: {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"]
+    }
+  },
+  {
+    name: "browser_finish",
+    description: "Finish the task. success=false if you could not complete it.",
+    input_schema: {
+      type: "object",
+      properties: { success: { type: "boolean" }, summary: { type: "string" } },
+      required: ["success"]
+    }
+  }
+];
+var SYSTEM = "You are a QA agent validating a deployed web app. Use the browser tools to accomplish the given task, then call browser_finish. Identify elements by the ARIA role + accessible name shown in the snapshot. Start by calling browser_snapshot. Be efficient \u2014 no more steps than needed.";
+async function execTool(page, base, name, input) {
+  try {
+    switch (name) {
+      case "browser_snapshot": {
+        const tree = await page.locator("body").ariaSnapshot();
+        return `URL: ${page.url()}
+${tree}`.slice(0, 6e3);
+      }
+      case "browser_click": {
+        await page.getByRole(input.role, { name: String(input.name) }).first().click({ timeout: 5e3 });
+        return `clicked ${input.role} "${input.name}"`;
+      }
+      case "browser_type": {
+        const el = page.getByRole(input.role, { name: String(input.name) }).first();
+        await el.fill(String(input.text), { timeout: 5e3 });
+        if (input.submit) await el.press("Enter");
+        return `typed into ${input.role} "${input.name}"${input.submit ? " + submitted" : ""}`;
+      }
+      case "browser_navigate": {
+        await page.goto(base + String(input.path), { waitUntil: "domcontentloaded" });
+        return `navigated to ${input.path}`;
+      }
+      case "browser_finish":
+        return "finished";
+      default:
+        return `unknown tool ${name}`;
+    }
+  } catch (e) {
+    return `error: ${msg(e)}`;
+  }
+}
+async function evalAsserts(page, asserts) {
+  const checks = [];
+  let text = "";
+  if (asserts.some((a) => a.textContains)) {
+    try {
+      text = await page.locator("body").innerText({ timeout: 3e3 });
+    } catch {
+      text = "";
+    }
+  }
+  for (const a of asserts) {
+    if (a.urlContains !== void 0) {
+      const ok = page.url().includes(a.urlContains);
+      checks.push({
+        name: `url contains "${a.urlContains}"`,
+        pass: ok,
+        detail: ok ? void 0 : page.url()
+      });
+    }
+    if (a.textContains !== void 0) {
+      const ok = text.includes(a.textContains);
+      checks.push({ name: `text contains "${a.textContains}"`, pass: ok });
+    }
+    if (a.selector !== void 0) {
+      let count = 0;
+      try {
+        count = await page.locator(a.selector).count();
+      } catch {
+      }
+      checks.push({ name: `selector ${a.selector}`, pass: count > 0 });
+    }
+  }
+  return checks;
+}
+async function runScenario(client, page, base, spec, scenario) {
+  const tag = `[${scenario.name}]`;
+  await page.goto(base + (scenario.start ?? "/"), { waitUntil: "domcontentloaded" });
+  const messages = [{ role: "user", content: `Task: ${scenario.task}` }];
+  const maxSteps = spec.maxSteps ?? 12;
+  let finish = null;
+  for (let step = 0; step < maxSteps && !finish; step++) {
+    const resp = await client.messages.create({
+      model: spec.model ?? "claude-sonnet-4-6",
+      max_tokens: 1024,
+      system: SYSTEM,
+      tools: TOOLS,
+      messages
+    });
+    const blocks = resp.content;
+    messages.push({ role: "assistant", content: blocks });
+    const toolUses = blocks.filter((b) => b.type === "tool_use");
+    if (toolUses.length === 0) break;
+    const results = [];
+    for (const tu of toolUses) {
+      const out = await execTool(page, base, tu.name, tu.input);
+      if (tu.name === "browser_finish") {
+        finish = tu.input;
+      }
+      results.push({ type: "tool_result", tool_use_id: tu.id, content: out });
+    }
+    messages.push({ role: "user", content: results });
+  }
+  const checks = [];
+  if (!finish) {
+    checks.push({
+      name: `${tag} completed`,
+      pass: false,
+      detail: "agent did not finish in maxSteps"
+    });
+  } else if (finish.success === false) {
+    checks.push({ name: `${tag} agent succeeded`, pass: false, detail: finish.summary });
+  }
+  for (const c of await evalAsserts(page, scenario.asserts ?? [])) {
+    checks.push({ ...c, name: `${tag} ${c.name}` });
+  }
+  if (checks.length === 0) checks.push({ name: `${tag} agent succeeded`, pass: true });
+  return checks;
+}
+async function verifyAgentWeb(baseUrl, spec) {
+  const base = baseUrl.replace(/\/+$/, "");
+  if (!process.env.ANTHROPIC_API_KEY) {
+    return report("agent-web", baseUrl, [
+      {
+        name: "ANTHROPIC_API_KEY set",
+        pass: false,
+        detail: "set ANTHROPIC_API_KEY to run agent-web"
+      }
+    ]);
+  }
+  let chromium;
+  let Anthropic;
+  try {
+    ({ chromium } = await import("playwright"));
+  } catch {
+    return report("agent-web", baseUrl, [
+      {
+        name: "playwright available",
+        pass: false,
+        detail: "pnpm add playwright && playwright install chromium"
+      }
+    ]);
+  }
+  try {
+    const sdkName = "@anthropic-ai/sdk";
+    const sdk = await import(sdkName);
+    Anthropic = sdk.default;
+  } catch {
+    return report("agent-web", baseUrl, [
+      { name: "@anthropic-ai/sdk available", pass: false, detail: "pnpm add @anthropic-ai/sdk" }
+    ]);
+  }
+  const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+  let browser;
+  try {
+    browser = await chromium.launch({ headless: !spec.headed });
+  } catch (e) {
+    return report("agent-web", baseUrl, [
+      {
+        name: "launch browser",
+        pass: false,
+        detail: `${msg(e)} (try \`playwright install chromium\`)`
+      }
+    ]);
+  }
+  const checks = [];
+  try {
+    for (const scenario of spec.scenarios) {
+      const page = await browser.newPage();
+      try {
+        checks.push(...await runScenario(client, page, base, spec, scenario));
+      } catch (e) {
+        checks.push({ name: `[${scenario.name}]`, pass: false, detail: msg(e) });
+      } finally {
+        await page.close();
+      }
+    }
+  } finally {
+    await browser.close();
+  }
+  return report("agent-web", baseUrl, checks);
+}
+
+export {
+  verifyAgentWeb
+};

package/dist/chunk-WFZTRXBF.js

@@ -0,0 +1,61 @@
+import {
+  msg,
+  report
+} from "./chunk-QFKE5JKC.js";
+
+// ../packages/verify/src/playwright.ts
+async function verifyPlaywright(baseUrl, spec) {
+  let chromium;
+  try {
+    ({ chromium } = await import("playwright"));
+  } catch {
+    return report("playwright", baseUrl, [
+      {
+        name: "playwright available",
+        pass: false,
+        detail: "playwright not installed \u2014 run `pnpm add playwright && pnpm exec playwright install chromium`"
+      }
+    ]);
+  }
+  const base = baseUrl.replace(/\/+$/, "");
+  const checks = [];
+  let browser;
+  try {
+    browser = await chromium.launch();
+  } catch (e) {
+    return report("playwright", baseUrl, [
+      {
+        name: "launch browser",
+        pass: false,
+        detail: `${msg(e)} (try \`playwright install chromium\`)`
+      }
+    ]);
+  }
+  try {
+    for (const path of spec.renders) {
+      const page = await browser.newPage();
+      try {
+        const res = await page.goto(base + path, { waitUntil: "domcontentloaded" });
+        const ok = res?.ok() ?? false;
+        const aria = await page.locator("body").ariaSnapshot();
+        const nonEmpty = aria.trim().length > 0;
+        checks.push({
+          name: `renders ${path}`,
+          pass: ok && nonEmpty,
+          detail: !ok ? `status ${res?.status() ?? "none"}` : nonEmpty ? void 0 : "empty accessibility tree"
+        });
+      } catch (e) {
+        checks.push({ name: `renders ${path}`, pass: false, detail: msg(e) });
+      } finally {
+        await page.close();
+      }
+    }
+  } finally {
+    await browser.close();
+  }
+  return report("playwright", baseUrl, checks);
+}
+
+export {
+  verifyPlaywright
+};