haltija 1.1.21 → 1.2.3

package/dist/test.js

@@ -0,0 +1,847 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/client.ts
+class DevChannelClient {
+  baseUrl;
+  constructor(serverUrl = "http://localhost:8700") {
+    this.baseUrl = serverUrl;
+  }
+  async status() {
+    const res = await fetch(`${this.baseUrl}/status`);
+    return res.json();
+  }
+  async send(channel, action, payload) {
+    const res = await fetch(`${this.baseUrl}/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel, action, payload })
+    });
+    return res.json();
+  }
+  async request(channel, action, payload, timeout = 5000) {
+    const res = await fetch(`${this.baseUrl}/request`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ channel, action, payload, timeout })
+    });
+    return res.json();
+  }
+  async query(selector) {
+    const res = await fetch(`${this.baseUrl}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, all: false })
+    });
+    const response = await res.json();
+    return response.success ? response.data : null;
+  }
+  async queryAll(selector) {
+    const res = await fetch(`${this.baseUrl}/query`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, all: true })
+    });
+    const response = await res.json();
+    return response.success ? response.data : [];
+  }
+  async getConsole(since = 0) {
+    const res = await fetch(`${this.baseUrl}/console?since=${since}`);
+    const response = await res.json();
+    return response.success ? response.data : [];
+  }
+  async clearConsole() {
+    await this.request("console", "clear", {});
+  }
+  async eval(code) {
+    const res = await fetch(`${this.baseUrl}/eval`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ code })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Eval failed");
+    }
+    return response.data;
+  }
+  async click(selector, options) {
+    const res = await fetch(`${this.baseUrl}/click`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, options })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || `Click failed on ${selector}`);
+    }
+  }
+  async type(selector, text) {
+    const res = await fetch(`${this.baseUrl}/type`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ selector, text })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || `Type failed on ${selector}`);
+    }
+  }
+  async dispatch(event) {
+    const response = await this.request("events", "dispatch", event);
+    if (!response.success) {
+      throw new Error(response.error || "Dispatch failed");
+    }
+  }
+  async focus(selector) {
+    await this.dispatch({ selector, event: "focus" });
+  }
+  async blur(selector) {
+    await this.dispatch({ selector, event: "blur" });
+  }
+  async press(key, modifiers) {
+    await this.dispatch({
+      selector: "body",
+      event: "keydown",
+      options: {
+        key,
+        altKey: modifiers?.alt,
+        ctrlKey: modifiers?.ctrl,
+        metaKey: modifiers?.meta,
+        shiftKey: modifiers?.shift
+      }
+    });
+  }
+  async refresh(hard = false) {
+    const res = await fetch(`${this.baseUrl}/refresh`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ hard })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Refresh failed");
+    }
+  }
+  async navigate(url) {
+    const res = await fetch(`${this.baseUrl}/navigate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ url })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Navigate failed");
+    }
+  }
+  async getLocation() {
+    const res = await fetch(`${this.baseUrl}/location`);
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Get location failed");
+    }
+    return response.data;
+  }
+  async startRecording(name) {
+    const res = await fetch(`${this.baseUrl}/recording/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Start recording failed");
+    }
+    return response.data.sessionId;
+  }
+  async stopRecording() {
+    const res = await fetch(`${this.baseUrl}/recording/stop`, {
+      method: "POST"
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Stop recording failed");
+    }
+    return response.data;
+  }
+  async replayRecording(session, speed = 1) {
+    const response = await this.request("recording", "replay", { session, speed });
+    if (!response.success) {
+      throw new Error(response.error || "Replay failed");
+    }
+  }
+  async publishBuild(event) {
+    await fetch(`${this.baseUrl}/build`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(event)
+    });
+  }
+  async watchEvents(options) {
+    const response = await this.request("events", "watch", options);
+    if (!response.success) {
+      throw new Error(response.error || "Watch failed");
+    }
+    return response.data.watchId;
+  }
+  async unwatchEvents(watchId) {
+    const response = await this.request("events", "unwatch", { watchId });
+    if (!response.success) {
+      throw new Error(response.error || "Unwatch failed");
+    }
+  }
+  async watchMutations(options) {
+    const res = await fetch(`${this.baseUrl}/mutations/watch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(options || {})
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Watch mutations failed");
+    }
+  }
+  async unwatchMutations() {
+    const res = await fetch(`${this.baseUrl}/mutations/unwatch`, {
+      method: "POST"
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Unwatch mutations failed");
+    }
+  }
+  async getMutationStatus() {
+    const res = await fetch(`${this.baseUrl}/mutations/status`);
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Get mutation status failed");
+    }
+    return response.data;
+  }
+  async getMessages(since = 0) {
+    const res = await fetch(`${this.baseUrl}/messages?since=${since}`);
+    return res.json();
+  }
+  async getInteractiveElements() {
+    const [buttons, links, inputs] = await Promise.all([
+      this.queryAll("button"),
+      this.queryAll("a[href]"),
+      this.queryAll("input, textarea, select")
+    ]);
+    return {
+      buttons: buttons.map((el) => ({
+        selector: el.id ? `#${el.id}` : `button`,
+        text: el.innerText?.slice(0, 50) || ""
+      })),
+      links: links.map((el) => ({
+        selector: el.id ? `#${el.id}` : `a[href="${el.attributes?.href}"]`,
+        text: el.innerText?.slice(0, 50) || "",
+        href: el.attributes?.href || ""
+      })),
+      inputs: inputs.map((el) => ({
+        selector: el.id ? `#${el.id}` : `${el.tagName}[name="${el.attributes?.name}"]`,
+        type: el.attributes?.type,
+        name: el.attributes?.name,
+        placeholder: el.attributes?.placeholder
+      }))
+    };
+  }
+  async getCustomElements() {
+    return this.eval(`
+      Array.from(document.querySelectorAll('*'))
+        .filter(el => el.tagName.includes('-'))
+        .reduce((acc, el) => {
+          const tag = el.tagName.toLowerCase()
+          if (!acc[tag]) acc[tag] = { count: 0, examples: [] }
+          acc[tag].count++
+          if (acc[tag].examples.length < 3) {
+            acc[tag].examples.push({
+              id: el.id || null,
+              classes: el.className?.split?.(' ')?.slice(0, 3) || [],
+              text: el.textContent?.slice(0, 50)
+            })
+          }
+          return acc
+        }, {})
+    `);
+  }
+  async doAndWait(action, options) {
+    const timeout = options?.timeout || 2000;
+    const debounce = options?.debounce || 100;
+    await this.watchMutations({ debounce });
+    const startTime = Date.now();
+    await action();
+    let mutations = [];
+    let lastMutationTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const messages = await this.getMessages(startTime);
+      const newMutations = messages.filter((m) => m.channel === "mutations" && m.action === "batch");
+      if (newMutations.length > mutations.length) {
+        mutations = newMutations;
+        lastMutationTime = Date.now();
+      } else if (mutations.length > 0 && Date.now() - lastMutationTime > debounce * 2) {
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    await this.unwatchMutations();
+    return {
+      mutations,
+      duration: Date.now() - startTime
+    };
+  }
+  async validateTest(test) {
+    const res = await fetch(`${this.baseUrl}/test/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(test)
+    });
+    return res.json();
+  }
+  async runTest(test, options) {
+    const res = await fetch(`${this.baseUrl}/test/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ test, ...options })
+    });
+    const result = await res.json();
+    return {
+      test,
+      passed: result.passed,
+      startTime: Date.now() - result.duration,
+      endTime: Date.now(),
+      steps: result.steps,
+      error: result.steps.find((s) => !s.passed)?.error
+    };
+  }
+  async runTestSuite(tests, options) {
+    const res = await fetch(`${this.baseUrl}/test/suite`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tests, ...options })
+    });
+    return res.json();
+  }
+  async loadTest(source) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      const res = await fetch(source);
+      return res.json();
+    }
+    return JSON.parse(source);
+  }
+  formatTestResult(result) {
+    const lines = [];
+    const icon = result.passed ? "\u2713" : "\u2717";
+    const status = result.passed ? "PASSED" : "FAILED";
+    lines.push(`${icon} ${result.test.name} - ${status}`);
+    lines.push(`  Duration: ${result.endTime - result.startTime}ms`);
+    lines.push("");
+    for (const step of result.steps) {
+      const stepIcon = step.passed ? "  \u2713" : "  \u2717";
+      const desc = step.description || `Step ${step.index + 1}`;
+      lines.push(`${stepIcon} ${desc}`);
+      if (!step.passed && step.error) {
+        lines.push(`      Error: ${step.error}`);
+        if (step.purpose) {
+          lines.push(`      Purpose: ${step.purpose}`);
+        }
+        if (step.context) {
+          lines.push(`      Context: ${JSON.stringify(step.context)}`);
+        }
+      }
+    }
+    return lines.join(`
+`);
+  }
+}
+var devChannel = new DevChannelClient;
+
+// src/test.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+
+// src/test-formatters.ts
+function formatTestGitHub(result, test, testFile) {
+  const lines = [];
+  for (const step of result.steps.filter((s) => !s.passed)) {
+    const annotation = buildAnnotation(step, test, testFile);
+    lines.push(annotation);
+  }
+  lines.push("");
+  lines.push("---SUMMARY---");
+  lines.push(buildTestSummary(result, test));
+  return lines.join(`
+`);
+}
+function formatSuiteGitHub(result, tests, testFiles) {
+  const lines = [];
+  result.results.forEach((testResult, i) => {
+    const test = tests[i];
+    const testFile = testFiles?.[i];
+    for (const step of testResult.steps.filter((s) => !s.passed)) {
+      lines.push(buildAnnotation(step, test, testFile));
+    }
+  });
+  lines.push("");
+  lines.push("---SUMMARY---");
+  lines.push(buildSuiteSummary(result, tests));
+  return lines.join(`
+`);
+}
+function buildAnnotation(step, test, testFile) {
+  const title = buildFailureTitle(step, test);
+  const message = buildFailureMessage(step);
+  const file = testFile ? `file=${testFile},` : "";
+  return `::error ${file}title=${escapeAnnotation(title)}::${escapeAnnotation(message)}`;
+}
+function buildFailureTitle(step, test) {
+  const stepDesc = step.description || `Step ${step.index + 1}`;
+  const purpose = step.purpose ? ` (${step.purpose})` : "";
+  return `${stepDesc}${purpose}`;
+}
+function buildFailureMessage(step) {
+  const parts = [];
+  const reason = step.context?.reason || step.error || "Unknown error";
+  parts.push(reason);
+  if (step.context?.buttonsOnPage?.length) {
+    parts.push(`Page shows: ${step.context.buttonsOnPage.join(", ")}`);
+  }
+  if (step.context?.actual !== undefined && step.context?.expected !== undefined) {
+    parts.push(`Expected "${step.context.expected}", got "${step.context.actual}"`);
+  }
+  if (step.context?.suggestion) {
+    parts.push(step.context.suggestion);
+  }
+  return parts.join(". ");
+}
+function buildTestSummary(result, test) {
+  const icon = result.passed ? "\u2705" : "\u274C";
+  const lines = [];
+  lines.push(`## ${icon} ${test.name}`);
+  lines.push("");
+  if (test.description) {
+    lines.push(`> ${test.description}`);
+    lines.push("");
+  }
+  if (!result.passed) {
+    const failed = result.steps.filter((s) => !s.passed);
+    for (const step of failed) {
+      lines.push(`### Step ${step.index + 1}: ${step.description || "Unknown step"}`);
+      lines.push("");
+      if (step.purpose) {
+        lines.push(`**Tried to:** ${step.purpose}`);
+      }
+      lines.push(`**What happened:** ${step.context?.reason || step.error || "Unknown error"}`);
+      if (step.context?.buttonsOnPage?.length) {
+        lines.push(`**What's on the page:** ${step.context.buttonsOnPage.join(", ")}`);
+      }
+      if (step.context?.actual !== undefined) {
+        lines.push(`**Expected:** ${step.context.expected}`);
+        lines.push(`**Actual:** ${step.context.actual}`);
+      }
+      if (step.context?.suggestion) {
+        lines.push(`**Likely cause:** ${step.context.suggestion}`);
+      }
+      if (step.step.planRef) {
+        lines.push(`**Plan:** ${step.step.planRef}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Duration | ${result.duration}ms |`);
+  lines.push(`| Steps | ${result.summary.passed}/${result.summary.total} passed |`);
+  if (result.patience) {
+    const p = result.patience;
+    lines.push(`| Patience | ${p.remaining}/${p.allowed} remaining (${p.failures} failures, streak limit ${p.streak}) |`);
+    lines.push(`| Final Timeout | ${p.finalTimeoutMs}ms |`);
+  }
+  if (result.snapshotId) {
+    lines.push(`| Snapshot | ${result.snapshotId} |`);
+  }
+  return lines.join(`
+`);
+}
+function buildSuiteSummary(result, tests) {
+  const icon = result.summary.failed === 0 ? "\u2705" : "\u274C";
+  const lines = [];
+  lines.push(`## ${icon} Test Suite Results`);
+  lines.push("");
+  lines.push(`**${result.summary.passed}/${result.summary.total} tests passed** in ${result.duration}ms`);
+  lines.push("");
+  lines.push("| Test | Status | Duration | Issue |");
+  lines.push("|------|--------|----------|-------|");
+  result.results.forEach((testResult, i) => {
+    const test = tests[i];
+    const status = testResult.passed ? "\u2705" : "\u274C";
+    const issue = testResult.passed ? "" : testResult.steps.find((s) => !s.passed)?.description || "Unknown";
+    lines.push(`| ${test.name} | ${status} | ${testResult.duration}ms | ${issue} |`);
+  });
+  lines.push("");
+  const failedResults = result.results.filter((r) => !r.passed);
+  if (failedResults.length > 0) {
+    lines.push("---");
+    lines.push("");
+    for (let i = 0;i < result.results.length; i++) {
+      if (!result.results[i].passed) {
+        lines.push(buildTestSummary(result.results[i], tests[i]));
+        lines.push("");
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+function formatTestHuman(result, test) {
+  const lines = [];
+  const icon = result.passed ? "\u2713" : "\u2717";
+  const color = result.passed ? "\x1B[32m" : "\x1B[31m";
+  const reset = "\x1B[0m";
+  lines.push(`${color}${icon} ${test.name}${reset} (${result.duration}ms)`);
+  if (!result.passed) {
+    const failed = result.steps.filter((s) => !s.passed);
+    for (const step of failed) {
+      lines.push("");
+      lines.push(`  ${color}Step ${step.index + 1}:${reset} ${step.description || "Unknown step"}`);
+      if (step.purpose) {
+        lines.push(`  Tried to: ${step.purpose}`);
+      }
+      lines.push(`  ${color}Error:${reset} ${step.context?.reason || step.error || "Unknown error"}`);
+      if (step.context?.buttonsOnPage?.length) {
+        lines.push(`  Page shows: ${step.context.buttonsOnPage.join(", ")}`);
+      }
+      if (step.context?.actual !== undefined) {
+        lines.push(`  Expected: ${step.context.expected}`);
+        lines.push(`  Actual: ${step.context.actual}`);
+      }
+      if (step.context?.suggestion) {
+        lines.push(`  ${color}Likely:${reset} ${step.context.suggestion}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push(`  ${result.summary.passed}/${result.summary.total} steps passed`);
+  if (result.patience) {
+    const p = result.patience;
+    const pColor = p.remaining > 0 ? "\x1B[33m" : "\x1B[31m";
+    lines.push(`  ${pColor}Patience:${reset} ${p.remaining}/${p.allowed} remaining, ${p.failures} failures, timeout ${p.finalTimeoutMs}ms`);
+  }
+  return lines.join(`
+`);
+}
+function formatSuiteHuman(result, tests) {
+  const lines = [];
+  const icon = result.summary.failed === 0 ? "\u2713" : "\u2717";
+  const color = result.summary.failed === 0 ? "\x1B[32m" : "\x1B[31m";
+  const reset = "\x1B[0m";
+  lines.push(`${color}${icon} Test Suite${reset} (${result.duration}ms)`);
+  lines.push(`  ${result.summary.passed}/${result.summary.total} tests passed`);
+  lines.push("");
+  result.results.forEach((testResult, i) => {
+    lines.push(formatTestHuman(testResult, tests[i]));
+    lines.push("");
+  });
+  return lines.join(`
+`);
+}
+function escapeAnnotation(str) {
+  return str.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A").replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+function inferSuggestion(step, pageContext) {
+  const desc = step.description?.toLocaleLowerCase() || "";
+  const buttons = pageContext.buttonsOnPage || [];
+  const englishWords = ["submit", "cancel", "ok", "save", "delete", "confirm", "next", "back", "continue"];
+  const hasEnglishInDesc = englishWords.some((w) => desc.includes(w));
+  const hasNonEnglishButtons = buttons.some((b) => {
+    const lower = b.toLocaleLowerCase();
+    return !englishWords.includes(lower) && /[\u00E0\u00E1\u00E2\u00E3\u00E4\u00E5\u00E6\u00E7\u00E8\u00E9\u00EA\u00EB\u00EC\u00ED\u00EE\u00EF\u00F0\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u00F8\u00F9\u00FA\u00FB\u00FC\u00FD\u00FE\u00FF]/.test(lower);
+  });
+  if (hasEnglishInDesc && hasNonEnglishButtons) {
+    return "Page may be in a different locale than expected";
+  }
+  if (buttons.length === 0) {
+    return "No interactive elements found - page may not have loaded or element is conditionally rendered";
+  }
+  const selectorText = step.description?.match(/["']([^"']+)["']/)?.[1]?.toLocaleLowerCase();
+  if (selectorText && buttons.length > 0) {
+    const similar = buttons.find((b) => {
+      const lower = b.toLocaleLowerCase();
+      return lower.includes(selectorText.slice(0, 3)) || selectorText.includes(lower.slice(0, 3));
+    });
+    if (similar) {
+      return `Button may have been renamed - found "${similar}" which looks similar`;
+    }
+  }
+  return;
+}
+
+// src/test.ts
+class HaltijaTestError extends Error {
+  results;
+  summary;
+  constructor(message, results, summary) {
+    super(message);
+    this.name = "HaltijaTestError";
+    this.results = results;
+    this.summary = summary;
+  }
+}
+function substituteVars(text, vars = {}) {
+  return text.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+    const trimmed = varName.trim();
+    if (trimmed.startsWith("GEN."))
+      return match;
+    if (trimmed in vars)
+      return vars[trimmed];
+    if (trimmed in process.env)
+      return process.env[trimmed];
+    return match;
+  });
+}
+function loadTestFile(filePath, vars) {
+  const content = readFileSync(filePath, "utf-8");
+  const processed = vars ? substituteVars(content, vars) : content;
+  const parsed = JSON.parse(processed);
+  if (Array.isArray(parsed.tests)) {
+    return parsed.tests;
+  }
+  return [parsed];
+}
+function expandTestDir(dir) {
+  const absDir = resolve(dir);
+  const stat = statSync(absDir);
+  if (!stat.isDirectory()) {
+    return [absDir];
+  }
+  return readdirSync(absDir).filter((f) => f.endsWith(".json")).sort().map((f) => join(absDir, f));
+}
+
+class HaltijaTestClient {
+  client;
+  baseUrl;
+  constructor(serverUrl = "http://localhost:8700") {
+    this.baseUrl = serverUrl;
+    this.client = new DevChannelClient(serverUrl);
+  }
+  async waitForServer(timeoutMs = 15000) {
+    const start = Date.now();
+    const pollInterval = 500;
+    while (Date.now() - start < timeoutMs) {
+      try {
+        const res = await fetch(`${this.baseUrl}/status`);
+        if (res.ok)
+          return;
+      } catch {}
+      await new Promise((r) => setTimeout(r, pollInterval));
+    }
+    throw new Error(`Haltija server not reachable at ${this.baseUrl} after ${timeoutMs}ms`);
+  }
+  async status() {
+    return this.client.status();
+  }
+  async windows() {
+    const res = await fetch(`${this.baseUrl}/windows`);
+    return res.json();
+  }
+  async query(selector) {
+    return this.client.query(selector);
+  }
+  async queryAll(selector) {
+    return this.client.queryAll(selector);
+  }
+  async click(selector, options) {
+    return this.client.click(selector, options);
+  }
+  async type(selector, text) {
+    return this.client.type(selector, text);
+  }
+  async press(key, modifiers) {
+    return this.client.press(key, modifiers);
+  }
+  async focus(selector) {
+    return this.client.focus(selector);
+  }
+  async blur(selector) {
+    return this.client.blur(selector);
+  }
+  async navigate(url) {
+    return this.client.navigate(url);
+  }
+  async refresh(hard = false) {
+    return this.client.refresh(hard);
+  }
+  async getLocation() {
+    return this.client.getLocation();
+  }
+  async eval(code) {
+    return this.client.eval(code);
+  }
+  async getConsole(since = 0) {
+    return this.client.getConsole(since);
+  }
+  async screenshot(options = {}) {
+    const res = await fetch(`${this.baseUrl}/screenshot`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ file: true, ...options })
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Screenshot failed");
+    }
+    return response.data;
+  }
+  async tree(options = {}) {
+    const res = await fetch(`${this.baseUrl}/tree`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(options)
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Tree failed");
+    }
+    return response.data;
+  }
+  async runFile(filePath, options = {}) {
+    const tests = loadTestFile(resolve(filePath), options.vars);
+    const { vars, ...serverOptions } = options;
+    if (tests.length > 1) {
+      const res2 = await fetch(`${this.baseUrl}/test/suite`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tests, ...serverOptions })
+      });
+      const text2 = await res2.text();
+      let suiteResult;
+      try {
+        suiteResult = JSON.parse(text2);
+      } catch {
+        throw new Error(`Suite endpoint returned invalid JSON (status ${res2.status}): ${text2.slice(0, 200)}`);
+      }
+      const combined = {
+        test: tests[0]?.name || filePath,
+        passed: suiteResult.summary.failed === 0,
+        duration: suiteResult.duration,
+        steps: suiteResult.results.flatMap((r) => r.steps || []),
+        summary: {
+          total: suiteResult.summary.total,
+          executed: suiteResult.summary.executed ?? suiteResult.summary.total,
+          passed: suiteResult.summary.passed,
+          failed: suiteResult.summary.failed
+        }
+      };
+      if (!combined.passed) {
+        const formatted = formatSuiteHuman(suiteResult, tests);
+        throw new HaltijaTestError(`Suite file "${filePath}" failed: ${suiteResult.summary.failed}/${suiteResult.summary.total} tests failed
+
+${formatted}`, suiteResult, suiteResult.summary);
+      }
+      return combined;
+    }
+    const test = tests[0];
+    const res = await fetch(`${this.baseUrl}/test/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ test, ...serverOptions })
+    });
+    const text = await res.text();
+    let result;
+    try {
+      result = JSON.parse(text);
+    } catch {
+      throw new Error(`Test run endpoint returned invalid JSON (status ${res.status}): ${text.slice(0, 200)}`);
+    }
+    if (!result.passed) {
+      const formatted = formatTestHuman(result, test);
+      throw new HaltijaTestError(`Test "${test.name}" failed: ${result.summary.failed}/${result.summary.total} steps failed
+
+${formatted}`, result, result.summary);
+    }
+    return result;
+  }
+  async suite(dir, options = {}) {
+    const files = expandTestDir(resolve(dir));
+    if (files.length === 0) {
+      throw new Error(`No .json test files found in ${dir}`);
+    }
+    const tests = files.flatMap((f) => loadTestFile(f, options.vars));
+    const { vars, ...serverOptions } = options;
+    const res = await fetch(`${this.baseUrl}/test/suite`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ tests, ...serverOptions })
+    });
+    const text = await res.text();
+    let result;
+    try {
+      result = JSON.parse(text);
+    } catch {
+      throw new Error(`Suite endpoint returned invalid JSON (status ${res.status}): ${text.slice(0, 200)}`);
+    }
+    if (result.summary.failed > 0) {
+      const formatted = formatSuiteHuman(result, tests);
+      throw new HaltijaTestError(`Suite failed: ${result.summary.failed}/${result.summary.total} tests failed
+
+${formatted}`, result, result.summary);
+    }
+    return result;
+  }
+  async watchMutations(options) {
+    return this.client.watchMutations(options);
+  }
+  async unwatchMutations() {
+    return this.client.unwatchMutations();
+  }
+  async watchEvents(options = {}) {
+    const res = await fetch(`${this.baseUrl}/events/watch`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(options)
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Watch events failed");
+    }
+  }
+  async unwatchEvents() {
+    const res = await fetch(`${this.baseUrl}/events/unwatch`, {
+      method: "POST"
+    });
+    const response = await res.json();
+    if (!response.success) {
+      throw new Error(response.error || "Unwatch events failed");
+    }
+  }
+  async getEvents() {
+    const res = await fetch(`${this.baseUrl}/events`);
+    const response = await res.json();
+    return response.success ? response.data : [];
+  }
+}
+var hj = new HaltijaTestClient;
+function createTestClient(serverUrl) {
+  return new HaltijaTestClient(serverUrl);
+}
+export {
+  hj,
+  createTestClient,
+  HaltijaTestError,
+  HaltijaTestClient
+};