hazo_ui 2.17.0 → 3.1.0

package/dist/test-harness/index.js

@@ -0,0 +1,984 @@
+import React, { createContext, useState, useRef, useCallback, useContext } from 'react';
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { optional_import } from 'hazo_core';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+function SidebarLayout({
+  sidebar,
+  children
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "cls_sidebar_layout flex h-screen w-full overflow-hidden bg-gray-50", children: [
+    /* @__PURE__ */ jsx("aside", { className: "cls_sidebar_aside flex-none w-60 h-full flex flex-col bg-white border-r border-gray-200 overflow-y-auto", children: sidebar }),
+    /* @__PURE__ */ jsx("main", { className: "cls_sidebar_main flex-1 h-full overflow-y-auto", children })
+  ] });
+}
+function ActiveLink({
+  item,
+  current_path
+}) {
+  const is_active = item.href === "/" ? current_path === "/" : current_path === item.href || current_path.startsWith(item.href + "/");
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      href: item.href,
+      className: cn(
+        "flex items-center gap-2.5 rounded-md px-3 py-2 text-sm font-medium transition-colors",
+        is_active ? "bg-blue-50 text-blue-700" : "text-gray-600 hover:bg-gray-100 hover:text-gray-900"
+      ),
+      children: [
+        item.icon && /* @__PURE__ */ jsx("span", { className: cn("flex-none text-base", is_active ? "text-blue-600" : "text-gray-400"), children: item.icon }),
+        item.label
+      ]
+    }
+  );
+}
+function AppSidebar({
+  pkg,
+  navItems
+}) {
+  const [collapsed, set_collapsed] = useState(false);
+  const [current_path, set_current_path] = useState("/");
+  React.useEffect(() => {
+    function update_path() {
+      set_current_path(window.location.pathname);
+    }
+    update_path();
+    window.addEventListener("popstate", update_path);
+    return () => window.removeEventListener("popstate", update_path);
+  }, []);
+  if (collapsed) {
+    return /* @__PURE__ */ jsxs("div", { className: "cls_app_sidebar_collapsed flex flex-col items-center py-3 gap-2 w-12 bg-white border-r border-gray-200 h-full", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => set_collapsed(false),
+          className: "p-1.5 rounded hover:bg-gray-100 text-gray-500",
+          "aria-label": "Expand sidebar",
+          children: "\u25B6"
+        }
+      ),
+      navItems.map((item) => /* @__PURE__ */ jsx(
+        "a",
+        {
+          href: item.href,
+          className: "p-1.5 rounded hover:bg-gray-100 text-gray-500 text-base",
+          title: item.label,
+          children: item.icon ?? item.label.slice(0, 1)
+        },
+        item.href
+      ))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "cls_app_sidebar flex flex-col h-full", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-4 py-3 border-b border-gray-100", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-semibold text-sm text-gray-800 truncate", children: pkg }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => set_collapsed(true),
+          className: "flex-none p-1 rounded hover:bg-gray-100 text-gray-400 hover:text-gray-600",
+          "aria-label": "Collapse sidebar",
+          children: "\u25C0"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("nav", { className: "flex-1 overflow-y-auto px-2 py-2 space-y-0.5", children: navItems.map((item) => /* @__PURE__ */ jsx(ActiveLink, { item, current_path }, item.href)) }),
+    /* @__PURE__ */ jsx("div", { className: "px-4 py-3 border-t border-gray-100", children: /* @__PURE__ */ jsx("p", { className: "text-xs text-gray-400", children: "Press ? for shortcuts" }) })
+  ] });
+}
+
+// src/test-harness/scenarios/api.ts
+var registry = /* @__PURE__ */ new Map();
+function parse_caller_path(stack) {
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    const match = line.match(/\(([^)]+)\)/) || line.match(/at\s+(\/[^\s:]+)/);
+    if (!match) continue;
+    const raw = match[1] ?? match[0];
+    const path_part = raw.split(":")[0];
+    if (!path_part) continue;
+    if (path_part.includes("node:") || path_part.includes("test-harness/scenarios/api") || path_part.includes("<anonymous>")) {
+      continue;
+    }
+    return path_part;
+  }
+  return void 0;
+}
+function registerScenario(id, opts) {
+  const stack = new Error().stack;
+  const filePath = parse_caller_path(stack);
+  registry.set(id, {
+    id,
+    name: opts.name,
+    pkg: opts.pkg,
+    filePath,
+    cases: opts.cases
+  });
+}
+function getRegistry() {
+  return registry;
+}
+function clearRegistry() {
+  registry.clear();
+}
+var AutoTestContext = createContext(null);
+function build_initial_state() {
+  const registry2 = getRegistry();
+  const map = /* @__PURE__ */ new Map();
+  for (const [id, scenario] of registry2) {
+    map.set(id, {
+      id,
+      name: scenario.name,
+      status: "pending",
+      cases: scenario.cases.map((c) => ({
+        name: c.name,
+        status: "pending"
+      }))
+    });
+  }
+  return map;
+}
+function AutoTestProvider({
+  pkg: _pkg,
+  children
+}) {
+  const [scenarios, set_scenarios] = useState(
+    () => build_initial_state()
+  );
+  const scenarios_ref = useRef(scenarios);
+  scenarios_ref.current = scenarios;
+  const update_scenario = useCallback(
+    (id, updater) => {
+      set_scenarios((prev) => {
+        const next = new Map(prev);
+        const existing = next.get(id);
+        if (existing) {
+          next.set(id, updater(existing));
+        }
+        return next;
+      });
+    },
+    []
+  );
+  const runScenario = useCallback(
+    async (id) => {
+      const registry2 = getRegistry();
+      const scenario = registry2.get(id);
+      if (!scenario) return;
+      update_scenario(id, (prev) => ({
+        ...prev,
+        status: "running",
+        cases: prev.cases.map((c) => ({ ...c, status: "pending" }))
+      }));
+      let all_passed = true;
+      for (let i = 0; i < scenario.cases.length; i++) {
+        const case_def = scenario.cases[i];
+        if (!case_def) continue;
+        update_scenario(id, (prev) => {
+          const updated_cases = [...prev.cases];
+          updated_cases[i] = { ...updated_cases[i], status: "running" };
+          return { ...prev, cases: updated_cases };
+        });
+        const start_ts = Date.now();
+        let result_status = "passed";
+        let error;
+        let expected;
+        let actual;
+        try {
+          await case_def.run();
+        } catch (err) {
+          result_status = "failed";
+          all_passed = false;
+          error = err instanceof Error ? err : new Error(String(err));
+          if (error && "expected" in error) expected = error.expected;
+          if (error && "actual" in error) actual = error.actual;
+        }
+        const duration_ms = Date.now() - start_ts;
+        update_scenario(id, (prev) => {
+          const updated_cases = [...prev.cases];
+          updated_cases[i] = {
+            ...updated_cases[i],
+            scenarioId: id,
+            status: result_status,
+            durationMs: duration_ms,
+            error,
+            expected,
+            actual
+          };
+          return { ...prev, cases: updated_cases };
+        });
+      }
+      update_scenario(id, (prev) => ({
+        ...prev,
+        status: all_passed ? "passed" : "failed"
+      }));
+    },
+    [update_scenario]
+  );
+  const runAll = useCallback(async () => {
+    const ids = Array.from(getRegistry().keys());
+    for (const id of ids) {
+      await runScenario(id);
+    }
+  }, [runScenario]);
+  const reset = useCallback(() => {
+    set_scenarios(build_initial_state());
+  }, []);
+  const value = {
+    scenarios,
+    runScenario,
+    runAll,
+    reset
+  };
+  return /* @__PURE__ */ jsx(AutoTestContext.Provider, { value, children });
+}
+function useAutoTest() {
+  const ctx = useContext(AutoTestContext);
+  if (!ctx) {
+    throw new Error("useAutoTest must be used within an <AutoTestProvider>");
+  }
+  return ctx;
+}
+
+// src/test-harness/scenarios/assertions.ts
+function capture_call_site(stack) {
+  if (!stack) return void 0;
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    const match = line.match(/\(([^)]+)\)/) || line.match(/at\s+(\/[^\s]+)/);
+    if (!match) continue;
+    const raw = match[1] ?? match[0];
+    if (raw.includes("test-harness/scenarios/assertions") || raw.includes("node:")) {
+      continue;
+    }
+    return raw;
+  }
+  return void 0;
+}
+var HazoAssertionError = class extends Error {
+  constructor(message, expected, actual, callSite) {
+    super(message);
+    __publicField(this, "expected");
+    __publicField(this, "actual");
+    __publicField(this, "callSite");
+    this.name = "HazoAssertionError";
+    this.expected = expected;
+    this.actual = actual;
+    this.callSite = callSite;
+  }
+};
+function assertEqual(actual, expected) {
+  const callSite = capture_call_site(new Error().stack);
+  const a_str = JSON.stringify(actual);
+  const e_str = JSON.stringify(expected);
+  if (a_str !== e_str) {
+    throw new HazoAssertionError(
+      `assertEqual failed: expected ${e_str}, got ${a_str}`,
+      expected,
+      actual,
+      callSite
+    );
+  }
+}
+function assertThrows(fn, ErrorClass) {
+  const callSite = capture_call_site(new Error().stack);
+  let thrown = void 0;
+  let did_throw = false;
+  try {
+    fn();
+  } catch (err) {
+    thrown = err;
+    did_throw = true;
+  }
+  if (!did_throw) {
+    throw new HazoAssertionError(
+      `assertThrows failed: expected function to throw but it returned without throwing`,
+      ErrorClass ? ErrorClass.name : "Error",
+      "no throw",
+      callSite
+    );
+  }
+  if (ErrorClass && !(thrown instanceof ErrorClass)) {
+    const actual_name = thrown instanceof Error ? thrown.constructor.name : String(thrown);
+    throw new HazoAssertionError(
+      `assertThrows failed: expected ${ErrorClass.name} but got ${actual_name}`,
+      ErrorClass.name,
+      actual_name,
+      callSite
+    );
+  }
+}
+async function assertResolves(promise) {
+  const callSite = capture_call_site(new Error().stack);
+  try {
+    await promise;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new HazoAssertionError(
+      `assertResolves failed: promise rejected with "${msg}"`,
+      "resolved",
+      `rejected: ${msg}`,
+      callSite
+    );
+  }
+}
+async function assertRejects(promise, ErrorClass) {
+  const callSite = capture_call_site(new Error().stack);
+  let thrown = void 0;
+  let did_reject = false;
+  try {
+    await promise;
+  } catch (err) {
+    thrown = err;
+    did_reject = true;
+  }
+  if (!did_reject) {
+    throw new HazoAssertionError(
+      `assertRejects failed: expected promise to reject but it resolved`,
+      ErrorClass ? ErrorClass.name : "rejection",
+      "resolved",
+      callSite
+    );
+  }
+  if (ErrorClass && !(thrown instanceof ErrorClass)) {
+    const actual_name = thrown instanceof Error ? thrown.constructor.name : String(thrown);
+    throw new HazoAssertionError(
+      `assertRejects failed: expected ${ErrorClass.name} but got ${actual_name}`,
+      ErrorClass.name,
+      actual_name,
+      callSite
+    );
+  }
+}
+function assertMatch(str, pattern) {
+  const callSite = capture_call_site(new Error().stack);
+  if (!pattern.test(str)) {
+    throw new HazoAssertionError(
+      `assertMatch failed: "${str}" did not match ${pattern}`,
+      pattern.toString(),
+      str,
+      callSite
+    );
+  }
+}
+function assertIncludes(arr, value) {
+  const callSite = capture_call_site(new Error().stack);
+  const value_str = JSON.stringify(value);
+  const found = arr.some((item) => JSON.stringify(item) === value_str);
+  if (!found) {
+    throw new HazoAssertionError(
+      `assertIncludes failed: array does not contain ${value_str}`,
+      value,
+      arr,
+      callSite
+    );
+  }
+}
+
+// src/test-harness/scenarios/format.ts
+var SECRET_PATTERNS = [
+  /AKIA[0-9A-Z]{16}/,
+  /-----BEGIN.*PRIVATE KEY/,
+  /eyJ[a-zA-Z0-9_-]+\.eyJ/
+];
+function redact_secrets(value) {
+  let result = value;
+  for (const pattern of SECRET_PATTERNS) {
+    result = result.replace(new RegExp(pattern.source, pattern.flags + "g"), "<redacted>");
+  }
+  return result;
+}
+function parse_stack_frames(stack) {
+  if (!stack) return [];
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const line of lines.slice(1)) {
+    const m = line.match(/at\s+(?:\S+\s+)?\(([^)]+):(\d+):(\d+)\)/) || line.match(/at\s+(\/[^\s:]+):(\d+):(\d+)/);
+    if (!m) continue;
+    const file = m[1];
+    const ln = parseInt(m[2], 10);
+    const col = parseInt(m[3], 10);
+    if (file && ln) {
+      frames.push({ file, line: ln, col });
+    }
+  }
+  return frames;
+}
+function find_src_frame(frames) {
+  const src_frames = frames.filter(
+    (f) => f.file.includes("/src/") && !f.file.includes("test-harness")
+  );
+  return src_frames[src_frames.length - 1];
+}
+function read_file_lines(file_path) {
+  try {
+    const fs = __require("fs");
+    const content = fs.readFileSync(file_path, "utf-8");
+    return content.split("\n");
+  } catch {
+    return null;
+  }
+}
+function extract_context_lines(lines, target_line, context, mark_text) {
+  const start = Math.max(0, target_line - context - 1);
+  const end = Math.min(lines.length - 1, target_line + context - 1);
+  const result = [];
+  for (let i = start; i <= end; i++) {
+    const line_num = i + 1;
+    const line_content = lines[i] ?? "";
+    if (line_num === target_line) {
+      result.push(`${line_content}  ${mark_text}`);
+    } else {
+      result.push(line_content);
+    }
+  }
+  return result.join("\n");
+}
+function compute_diff(expected, actual) {
+  if (typeof expected === "object" && expected !== null && typeof actual === "object" && actual !== null) {
+    const e_obj = expected;
+    const a_obj = actual;
+    const all_keys = /* @__PURE__ */ new Set([...Object.keys(e_obj), ...Object.keys(a_obj)]);
+    const lines = [];
+    for (const key of all_keys) {
+      const e_val = JSON.stringify(e_obj[key]);
+      const a_val = JSON.stringify(a_obj[key]);
+      if (e_val === a_val) {
+        lines.push(`  ${key}: ${e_val}`);
+      } else if (key in e_obj && !(key in a_obj)) {
+        lines.push(`- ${key}: ${e_val}`);
+      } else if (!(key in e_obj) && key in a_obj) {
+        lines.push(`+ ${key}: ${a_val}`);
+      } else {
+        lines.push(`- ${key}: ${e_val}`);
+        lines.push(`+ ${key}: ${a_val}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  if (typeof expected === "string" && typeof actual === "string") {
+    const e_lines = expected.split("\n");
+    const a_lines = actual.split("\n");
+    const lines = [];
+    const max = Math.max(e_lines.length, a_lines.length);
+    for (let i = 0; i < max; i++) {
+      const e_line = e_lines[i];
+      const a_line = a_lines[i];
+      if (e_line === a_line) {
+        lines.push(`  ${e_line ?? ""}`);
+      } else {
+        if (e_line !== void 0) lines.push(`- ${e_line}`);
+        if (a_line !== void 0) lines.push(`+ ${a_line}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  return `- ${JSON.stringify(expected)}
++ ${JSON.stringify(actual)}`;
+}
+function build_task_footer(fc, src_frame, assertion_type) {
+  const loc = src_frame ? `\`${src_frame.file}:${src_frame.line}\`` : "the source code";
+  const scenario = fc.scenarioId;
+  const pkg = fc.pkg;
+  let body;
+  if (assertion_type === "assertEqual") {
+    body = `The test expects ${JSON.stringify(fc.expected)}; the code returned ${JSON.stringify(fc.actual)}. The suspect line in ${loc} returns the wrong value. Fix and re-run the \`${scenario}\` scenario.`;
+  } else if (assertion_type.startsWith("assertThrows")) {
+    const msg = fc.error.message ?? "";
+    if (msg.includes("returned without throwing")) {
+      body = `The test expects this call to throw ${JSON.stringify(fc.expected)} but it returned ${JSON.stringify(fc.actual)} without throwing. Add the missing error case in ${loc}.`;
+    } else {
+      body = `Expected ${JSON.stringify(fc.expected)} but got ${JSON.stringify(fc.actual)}. The error type/code in ${loc} is wrong.`;
+    }
+  } else if (assertion_type === "assertResolves") {
+    body = `The test expects the promise to resolve but it rejected. Check ${loc} for the rejection source.`;
+  } else if (assertion_type === "assertRejects") {
+    if (fc.actual === "resolved") {
+      body = `The test expects the promise to reject but it resolved without error. Add the missing rejection case in ${loc}.`;
+    } else {
+      body = `Expected a rejection of type ${JSON.stringify(fc.expected)} but got ${JSON.stringify(fc.actual)}. Fix the error type in ${loc}.`;
+    }
+  } else {
+    body = `The assertion in ${loc} failed. Check the values and fix the implementation.`;
+  }
+  return `## TASK
+
+${body}
+
+Verify your fix by re-running:
+\`\`\`bash
+cd ${pkg}/test-app && npm run dev   # then Run scenario in the test-app
+\`\`\`
+
+Or via the autotest runner: click "Run" next to the \`${scenario}\` scenario.`;
+}
+async function formatAsClaudePrompt(fc, opts = {}) {
+  const {
+    includeRingBuffer = true,
+    includeCodeContext = true,
+    maxRingBufferEntries = 15
+  } = opts;
+  const sections = [];
+  const cid = fc.correlationId ?? "n/a";
+  const duration_str = fc.durationMs != null ? `${fc.durationMs}ms` : "n/a";
+  const scenario_loc = fc.scenarioFilePath ? ` (\`${fc.scenarioFilePath}\`)` : "";
+  sections.push(
+    `# Failed: ${fc.pkg} / ${fc.scenarioId} / "${fc.caseName}"
+
+**Package:** ${fc.pkg}
+**Scenario:** ${fc.scenarioId}${scenario_loc}
+**Case:** "${fc.caseName}"
+**Correlation ID:** ${cid}
+**Duration:** ${duration_str}
+**Failed at:** ${fc.failedAt.toISOString()}`
+  );
+  sections.push(`## What went wrong
+
+${fc.error.message}`);
+  const has_assertion = fc.error instanceof HazoAssertionError;
+  const expected = has_assertion ? fc.error.expected : fc.expected;
+  const actual = has_assertion ? fc.error.actual : fc.actual;
+  let exp_actual_section = `## Expected
+
+${JSON.stringify(expected, null, 2)}
+
+## Actual
+
+${JSON.stringify(actual, null, 2)}
+
+## Diff (computed)
+
+\`\`\`
+${compute_diff(expected, actual)}
+\`\`\``;
+  sections.push(exp_actual_section);
+  if (includeCodeContext) {
+    let test_code_section = "## Test code\n\n";
+    const call_site = fc.error instanceof HazoAssertionError ? fc.error.callSite : void 0;
+    if (fc.scenarioFilePath && call_site) {
+      const call_site_parts = call_site.split(":");
+      const line_num = parseInt(call_site_parts[call_site_parts.length - 2] ?? "0", 10);
+      const file_lines = read_file_lines(fc.scenarioFilePath);
+      if (file_lines && line_num > 0) {
+        const start = Math.max(0, line_num - 5 - 1);
+        const end = Math.min(file_lines.length - 1, line_num + 5 - 1);
+        const context = extract_context_lines(file_lines, line_num, 5, "// \u2190 failed here");
+        test_code_section += `\`${fc.scenarioFilePath}:${start + 1}-${end + 1}\`
+
+\`\`\`ts
+${context}
+\`\`\``;
+      } else {
+        test_code_section += `\`${fc.scenarioFilePath}\`
+
+source unavailable`;
+      }
+    } else if (fc.scenarioFilePath) {
+      test_code_section += `\`${fc.scenarioFilePath}\`
+
+source unavailable (no call-site captured)`;
+    } else {
+      test_code_section += "source unavailable";
+    }
+    sections.push(test_code_section);
+  }
+  if (includeCodeContext) {
+    let code_section = "## Code under test\n\n";
+    const frames = parse_stack_frames(fc.error.stack);
+    const src_frame = find_src_frame(frames);
+    if (src_frame) {
+      const src_lines = read_file_lines(src_frame.file);
+      if (src_lines) {
+        const start = Math.max(0, src_frame.line - 8 - 1);
+        const end = Math.min(src_lines.length - 1, src_frame.line + 7 - 1);
+        const context = extract_context_lines(src_lines, src_frame.line, 8, "// \u2190 suspect line");
+        code_section += `\`${src_frame.file}:${start + 1}-${end + 1}\`
+
+\`\`\`ts
+${context}
+\`\`\``;
+        const all_src = frames.filter(
+          (f) => f.file.includes("/src/") && !f.file.includes("test-harness")
+        );
+        if (all_src.length > 1) {
+          code_section += "\n\n**Stack (in-package frames):**\n" + all_src.map((f) => `- \`${f.file}:${f.line}\``).join("\n");
+        }
+      } else {
+        code_section += `\`${src_frame.file}:${src_frame.line}\`
+
+source unavailable`;
+      }
+    } else {
+      code_section += "source unavailable";
+    }
+    sections.push(code_section);
+  }
+  const chain_lines = [];
+  let current = fc.error;
+  let depth = 0;
+  const include_stack = process.env.NODE_ENV !== "production" || process.env.HAZO_INCLUDE_STACK === "1";
+  while (current instanceof Error && depth < 10) {
+    const prefix = depth === 0 ? "Top" : "caused by";
+    let entry = `- ${prefix}: \`${current.constructor.name}: ${current.message}\``;
+    if (include_stack && current.stack) {
+      entry += `
+  \`\`\`
+  ${current.stack.split("\n").slice(0, 4).join("\n  ")}
+  \`\`\``;
+    }
+    chain_lines.push(entry);
+    current = current.cause;
+    depth++;
+  }
+  if (chain_lines.length === 0) {
+    chain_lines.push("- (no error captured)");
+  } else if (!(current instanceof Error) && depth > 0 && current === void 0) {
+    chain_lines.push("- (No `cause`)");
+  }
+  sections.push(`## Error chain
+
+${chain_lines.join("\n")}`);
+  const node_env = redact_secrets(process.env.NODE_ENV ?? "undefined");
+  const hazo_env = redact_secrets(process.env.HAZO_ENV ?? "unset");
+  const node_ver = process.version ?? "unknown";
+  const ctx_lines = [
+    `- Node: ${node_ver}`,
+    `- NODE_ENV: ${node_env}`,
+    `- HAZO_ENV: ${hazo_env}`
+  ];
+  if (fc.adapter) ctx_lines.push(`- Adapter: ${fc.adapter}`);
+  if (fc.relevantConfig && Object.keys(fc.relevantConfig).length > 0) {
+    ctx_lines.push("- Relevant config:");
+    for (const [k, v] of Object.entries(fc.relevantConfig)) {
+      ctx_lines.push(`  - \`${k} = "${redact_secrets(v)}"\``);
+    }
+  }
+  sections.push(`## Context at test run
+
+${ctx_lines.join("\n")}`);
+  if (includeRingBuffer) {
+    let ring_section = `## Ring buffer (last ${maxRingBufferEntries} events on this correlation ID)
+
+`;
+    try {
+      const hazo_logs = await optional_import("hazo_logs");
+      const get_ring = hazo_logs?.["getRingBuffer"];
+      if (!hazo_logs || typeof get_ring !== "function") {
+        ring_section += "ring buffer not available (hazo_logs >= 2.0.0 required)";
+      } else if (fc.correlationId) {
+        const entries = get_ring(fc.correlationId, maxRingBufferEntries);
+        if (!entries || entries.length === 0) {
+          ring_section += "no buffered events";
+        } else {
+          ring_section += "```\n" + entries.map((e) => JSON.stringify(e)).join("\n") + "\n```";
+        }
+      } else {
+        ring_section += "no correlation ID \u2014 ring buffer not queried";
+      }
+    } catch {
+      ring_section += "ring buffer not available (hazo_logs >= 2.0.0 required)";
+    }
+    sections.push(ring_section);
+  }
+  const frames_for_task = parse_stack_frames(fc.error.stack);
+  const src_frame_for_task = find_src_frame(frames_for_task);
+  let assertion_type = "unknown";
+  if (fc.error instanceof HazoAssertionError) {
+    const msg = fc.error.message;
+    if (msg.startsWith("assertEqual")) assertion_type = "assertEqual";
+    else if (msg.startsWith("assertThrows")) assertion_type = "assertThrows";
+    else if (msg.startsWith("assertResolves")) assertion_type = "assertResolves";
+    else if (msg.startsWith("assertRejects")) assertion_type = "assertRejects";
+    else if (msg.startsWith("assertMatch")) assertion_type = "assertMatch";
+    else if (msg.startsWith("assertIncludes")) assertion_type = "assertIncludes";
+  }
+  sections.push(build_task_footer(fc, src_frame_for_task, assertion_type));
+  return sections.join("\n\n---\n\n");
+}
+async function build_copy_all_text(failed_cases) {
+  const registry2 = getRegistry();
+  const scenario_ids = Array.from(registry2.keys());
+  const failed_with_context = [];
+  for (const cr of failed_cases) {
+    if (!cr.error) continue;
+    const scenario_id = cr.scenarioId ?? scenario_ids.find(
+      (sid) => registry2.get(sid)?.cases.some((c) => c.name === cr.name)
+    );
+    if (!scenario_id) continue;
+    const scenario = registry2.get(scenario_id);
+    if (!scenario) continue;
+    failed_with_context.push({
+      fc: {
+        pkg: scenario.pkg,
+        scenarioId: scenario_id,
+        caseName: cr.name,
+        failedAt: /* @__PURE__ */ new Date(),
+        error: cr.error,
+        durationMs: cr.durationMs,
+        scenarioFilePath: scenario.filePath,
+        expected: cr.expected,
+        actual: cr.actual
+      },
+      scenario_id
+    });
+  }
+  if (failed_with_context.length === 0) return "";
+  const unique_scenarios = new Set(failed_with_context.map((x) => x.scenario_id));
+  const toc_lines = failed_with_context.map(
+    ({ fc }, i) => `${i + 1}. \`${fc.pkg} / ${fc.scenarioId} / "${fc.caseName}"\``
+  );
+  const header = `# Test failures (${failed_with_context.length} case${failed_with_context.length === 1 ? "" : "s"} failed across ${unique_scenarios.size} scenario${unique_scenarios.size === 1 ? "" : "s"})
+
+## Failed cases
+
+` + toc_lines.join("\n");
+  const blocks = await Promise.all(
+    failed_with_context.map(({ fc }) => formatAsClaudePrompt(fc))
+  );
+  return [header, ...blocks].join("\n\n---\n\n");
+}
+function CopyAllFailuresButton({
+  failedCases
+}) {
+  const [state, set_state] = useState("idle");
+  async function handle_click() {
+    set_state("copying");
+    try {
+      const text = await build_copy_all_text(failedCases);
+      if (!text) {
+        set_state("idle");
+        return;
+      }
+      await navigator.clipboard.writeText(text);
+      set_state("copied");
+      setTimeout(() => set_state("idle"), 2500);
+    } catch {
+      set_state("error");
+      setTimeout(() => set_state("idle"), 2500);
+    }
+  }
+  const label_map = {
+    idle: `Copy ${failedCases.length} failure${failedCases.length === 1 ? "" : "s"}`,
+    copying: "Copying...",
+    copied: "Copied!",
+    error: "Failed to copy"
+  };
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: handle_click,
+      disabled: state === "copying" || failedCases.length === 0,
+      className: cn(
+        "px-3 py-1.5 rounded text-xs font-medium transition-colors border",
+        state === "copied" ? "bg-green-50 border-green-300 text-green-700" : state === "error" ? "bg-red-50 border-red-300 text-red-700" : "bg-orange-50 border-orange-300 text-orange-700 hover:bg-orange-100"
+      ),
+      children: label_map[state]
+    }
+  );
+}
+function StatusBadge({ status }) {
+  const map = {
+    pending: "bg-gray-100 text-gray-500",
+    running: "bg-blue-100 text-blue-600 animate-pulse",
+    passed: "bg-green-100 text-green-700",
+    failed: "bg-red-100 text-red-700"
+  };
+  const label_map = {
+    pending: "pending",
+    running: "running",
+    passed: "passed",
+    failed: "failed"
+  };
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: cn(
+        "inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium",
+        map[status] ?? map["pending"]
+      ),
+      children: label_map[status] ?? status
+    }
+  );
+}
+function StatusIcon({ status }) {
+  if (status === "passed") return /* @__PURE__ */ jsx("span", { className: "text-green-600 font-bold", children: "\u2713" });
+  if (status === "failed") return /* @__PURE__ */ jsx("span", { className: "text-red-600 font-bold", children: "\u2717" });
+  if (status === "running") return /* @__PURE__ */ jsx("span", { className: "text-blue-500", children: "\u27F3" });
+  return /* @__PURE__ */ jsx("span", { className: "text-gray-400", children: "\u25CB" });
+}
+function CopySinglePromptButton({
+  scenario_id,
+  case_result,
+  pkg
+}) {
+  const [copied, set_copied] = useState(false);
+  async function handle_copy() {
+    const scenario = getRegistry().get(scenario_id);
+    if (!case_result.error) return;
+    const fc = {
+      pkg,
+      scenarioId: scenario_id,
+      caseName: case_result.name,
+      failedAt: /* @__PURE__ */ new Date(),
+      error: case_result.error,
+      durationMs: case_result.durationMs,
+      scenarioFilePath: scenario?.filePath,
+      expected: case_result.expected,
+      actual: case_result.actual
+    };
+    const text = await formatAsClaudePrompt(fc);
+    await navigator.clipboard.writeText(text);
+    set_copied(true);
+    setTimeout(() => set_copied(false), 2e3);
+  }
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      onClick: handle_copy,
+      className: "ml-2 text-xs text-blue-600 hover:text-blue-800 underline",
+      children: copied ? "Copied!" : "Copy prompt"
+    }
+  );
+}
+function ScenarioRow({
+  scenario,
+  pkg
+}) {
+  const { runScenario } = useAutoTest();
+  const [expanded, set_expanded] = useState(false);
+  const is_running = scenario.status === "running";
+  return /* @__PURE__ */ jsxs("div", { className: "border border-gray-200 rounded-lg overflow-hidden", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-4 py-3 bg-gray-50", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => set_expanded((v) => !v),
+            className: "text-gray-500 hover:text-gray-700 text-sm font-mono",
+            "aria-label": expanded ? "Collapse cases" : "Expand cases",
+            children: expanded ? "\u25BE" : "\u25B8"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "font-medium text-sm text-gray-800", children: scenario.name }),
+        /* @__PURE__ */ jsx(StatusBadge, { status: scenario.status }),
+        /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-400", children: [
+          scenario.cases.filter((c) => c.status === "passed").length,
+          "/",
+          scenario.cases.length,
+          " passed"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          disabled: is_running,
+          onClick: () => runScenario(scenario.id),
+          className: cn(
+            "px-3 py-1 rounded text-xs font-medium transition-colors",
+            is_running ? "bg-gray-100 text-gray-400 cursor-not-allowed" : "bg-blue-600 text-white hover:bg-blue-700 cursor-pointer"
+          ),
+          children: is_running ? "Running..." : "Run"
+        }
+      )
+    ] }),
+    expanded && /* @__PURE__ */ jsx("div", { className: "divide-y divide-gray-100", children: scenario.cases.map((c, i) => /* @__PURE__ */ jsxs("div", { className: "px-6 py-2", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 text-sm", children: [
+        /* @__PURE__ */ jsx(StatusIcon, { status: c.status }),
+        /* @__PURE__ */ jsx("span", { className: cn(
+          "flex-1",
+          c.status === "failed" ? "text-red-700" : "text-gray-700"
+        ), children: c.name }),
+        c.durationMs != null && /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-400", children: [
+          c.durationMs,
+          "ms"
+        ] }),
+        c.status === "failed" && c.error && /* @__PURE__ */ jsx(
+          CopySinglePromptButton,
+          {
+            scenario_id: scenario.id,
+            case_result: c,
+            pkg
+          }
+        )
+      ] }),
+      c.status === "failed" && c.error && /* @__PURE__ */ jsx("div", { className: "mt-1 ml-5 text-xs text-red-600 bg-red-50 rounded px-2 py-1 font-mono", children: c.error.message })
+    ] }, i)) })
+  ] });
+}
+function AutoTestRunner() {
+  const { scenarios, runAll, reset } = useAutoTest();
+  const registry2 = getRegistry();
+  const first_scenario = Array.from(registry2.values())[0];
+  const pkg = first_scenario?.pkg ?? "unknown";
+  const scenario_list = Array.from(scenarios.values());
+  const any_running = scenario_list.some((s) => s.status === "running");
+  const total_cases = scenario_list.reduce((acc, s) => acc + s.cases.length, 0);
+  const passed_cases = scenario_list.reduce(
+    (acc, s) => acc + s.cases.filter((c) => c.status === "passed").length,
+    0
+  );
+  const failed_cases_flat = scenario_list.flatMap(
+    (s) => s.cases.filter((c) => c.status === "failed")
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "cls_auto_test_runner p-4 space-y-4", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("h2", { className: "text-base font-semibold text-gray-800", children: "Test Scenarios" }),
+        total_cases > 0 && /* @__PURE__ */ jsxs("p", { className: "text-xs text-gray-500 mt-0.5", children: [
+          passed_cases,
+          "/",
+          total_cases,
+          " cases passed",
+          failed_cases_flat.length > 0 && /* @__PURE__ */ jsxs("span", { className: "text-red-600 ml-2", children: [
+            "\xB7 ",
+            failed_cases_flat.length,
+            " failed"
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+        failed_cases_flat.length > 0 && /* @__PURE__ */ jsx(CopyAllFailuresButton, { failedCases: failed_cases_flat }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: reset,
+            disabled: any_running,
+            className: "px-3 py-1.5 rounded text-xs font-medium border border-gray-300 text-gray-600 hover:bg-gray-50 disabled:opacity-50",
+            children: "Reset"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: runAll,
+            disabled: any_running,
+            className: cn(
+              "px-4 py-1.5 rounded text-xs font-medium transition-colors",
+              any_running ? "bg-gray-100 text-gray-400 cursor-not-allowed" : "bg-green-600 text-white hover:bg-green-700 cursor-pointer"
+            ),
+            children: any_running ? "Running..." : "Run All"
+          }
+        )
+      ] })
+    ] }),
+    scenario_list.length === 0 ? /* @__PURE__ */ jsx("div", { className: "text-sm text-gray-500 italic py-8 text-center", children: "No scenarios registered. Import your scenario files to populate this runner." }) : /* @__PURE__ */ jsx("div", { className: "space-y-2", children: scenario_list.map((s) => /* @__PURE__ */ jsx(ScenarioRow, { scenario: s, pkg }, s.id)) })
+  ] });
+}
+
+export { AppSidebar, AutoTestProvider, AutoTestRunner, CopyAllFailuresButton, HazoAssertionError, SidebarLayout, assertEqual, assertIncludes, assertMatch, assertRejects, assertResolves, assertThrows, clearRegistry, formatAsClaudePrompt, getRegistry, registerScenario, useAutoTest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map