assuremind 1.0.0

package/dist/index.js

@@ -0,0 +1,1628 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AssuremindError: () => AssuremindError,
+  ConfigError: () => ConfigError,
+  ExecutionError: () => ExecutionError,
+  HealingError: () => HealingError,
+  ProviderError: () => ProviderError,
+  StorageError: () => StorageError,
+  ValidationError: () => ValidationError,
+  acceptHealingEvent: () => acceptHealingEvent,
+  appendPendingEvent: () => appendPendingEvent,
+  clearEnvCache: () => clearEnvCache,
+  configExists: () => configExists,
+  createCase: () => createCase,
+  createChildLogger: () => createChildLogger,
+  createSuite: () => createSuite,
+  defineConfig: () => defineConfig,
+  deleteCase: () => deleteCase,
+  deleteGlobalVariable: () => deleteGlobalVariable,
+  deleteResult: () => deleteResult,
+  deleteSuite: () => deleteSuite,
+  formatError: () => formatError,
+  generateCacheKey: () => generateCacheKey,
+  getCasePath: () => getCasePath,
+  getHealingStats: () => getHealingStats,
+  isAssuremindError: () => isAssuremindError,
+  listCasePaths: () => listCasePaths,
+  listCases: () => listCases,
+  listHealingReportIds: () => listHealingReportIds,
+  listResultIds: () => listResultIds,
+  listResults: () => listResults,
+  listSuiteDirs: () => listSuiteDirs,
+  listSuites: () => listSuites,
+  listSuitesWithCounts: () => listSuitesWithCounts,
+  listVariableFiles: () => listVariableFiles,
+  logger: () => logger,
+  normalizeUrl: () => normalizeUrl,
+  pruneResolvedEvents: () => pruneResolvedEvents,
+  readCase: () => readCase,
+  readConfig: () => readConfig,
+  readEnvVariables: () => readEnvVariables,
+  readGlobalVariables: () => readGlobalVariables,
+  readHealingReport: () => readHealingReport,
+  readPendingEvents: () => readPendingEvents,
+  readResult: () => readResult,
+  readSuite: () => readSuite,
+  readVariables: () => readVariables,
+  redactSecrets: () => redactSecrets,
+  rejectHealingEvent: () => rejectHealingEvent,
+  resolveVariables: () => resolveVariables,
+  sanitizeGeneratedCode: () => sanitizeGeneratedCode,
+  screenshotsDir: () => screenshotsDir,
+  setGlobalVariable: () => setGlobalVariable,
+  sha256: () => sha256,
+  toSlug: () => toSlug,
+  tracesDir: () => tracesDir,
+  tryGetEnv: () => tryGetEnv,
+  updateCase: () => updateCase,
+  updateConfig: () => updateConfig,
+  updateSuite: () => updateSuite,
+  validateConfig: () => validateConfig,
+  validateEnv: () => validateEnv,
+  videosDir: () => videosDir,
+  writeCase: () => writeCase,
+  writeConfig: () => writeConfig,
+  writeHealingReport: () => writeHealingReport,
+  writeResult: () => writeResult,
+  writeSuite: () => writeSuite,
+  writeVariables: () => writeVariables
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types/config.ts
+var import_zod = require("zod");
+var ScreenshotModeSchema = import_zod.z.enum(["off", "on", "only-on-failure"]);
+var VideoModeSchema = import_zod.z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
+var TraceModeSchema = import_zod.z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
+var BrowserNameSchema = import_zod.z.enum(["chromium", "firefox", "webkit"]);
+var PageLoadStrategySchema = import_zod.z.enum(["commit", "domcontentloaded", "load", "networkidle"]);
+var EnvironmentSchema = import_zod.z.enum(["dev", "stage", "test", "prod"]);
+var EnvironmentUrlsSchema = import_zod.z.object({
+  dev: import_zod.z.string().url().or(import_zod.z.literal("")).default(""),
+  stage: import_zod.z.string().url().or(import_zod.z.literal("")).default(""),
+  test: import_zod.z.string().url().or(import_zod.z.literal("")).default(""),
+  prod: import_zod.z.string().url().or(import_zod.z.literal("")).default("")
+});
+var HealingConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean(),
+  maxLevel: import_zod.z.number().int().min(1).max(6),
+  dailyBudget: import_zod.z.number().positive(),
+  autoPR: import_zod.z.boolean()
+});
+var ReportingConfigSchema = import_zod.z.object({
+  allure: import_zod.z.boolean(),
+  html: import_zod.z.boolean(),
+  json: import_zod.z.boolean()
+});
+var ViewportSchema = import_zod.z.object({
+  width: import_zod.z.number().int().positive(),
+  height: import_zod.z.number().int().positive()
+});
+var EnvironmentProfileSchema = import_zod.z.object({
+  name: import_zod.z.string().min(1),
+  environment: EnvironmentSchema,
+  baseUrl: import_zod.z.string().url(),
+  browsers: import_zod.z.array(BrowserNameSchema).min(1),
+  headless: import_zod.z.boolean().optional()
+});
+var AutotestConfigSchema = import_zod.z.object({
+  baseUrl: import_zod.z.string().url(),
+  environment: EnvironmentSchema.default("stage"),
+  environmentUrls: EnvironmentUrlsSchema.default({
+    dev: "",
+    stage: "",
+    test: "",
+    prod: ""
+  }),
+  browsers: import_zod.z.array(BrowserNameSchema).min(1),
+  headless: import_zod.z.boolean(),
+  viewport: ViewportSchema.default({ width: 1280, height: 720 }),
+  timeout: import_zod.z.number().int().positive(),
+  retries: import_zod.z.number().int().min(0),
+  parallel: import_zod.z.number().int().positive(),
+  pageLoad: PageLoadStrategySchema.default("domcontentloaded"),
+  screenshot: ScreenshotModeSchema,
+  video: VideoModeSchema,
+  trace: TraceModeSchema,
+  healing: HealingConfigSchema,
+  reporting: ReportingConfigSchema,
+  studioPort: import_zod.z.number().int().min(1024).max(65535),
+  profiles: import_zod.z.array(EnvironmentProfileSchema).default([]),
+  activeProfile: import_zod.z.string().optional(),
+  /** Playwright device descriptor name for emulation (e.g. 'iPhone 15 Pro'). */
+  device: import_zod.z.string().optional()
+});
+var DEFAULT_CONFIG = {
+  baseUrl: "http://localhost:3000",
+  environment: "stage",
+  environmentUrls: {
+    dev: "",
+    stage: "http://localhost:3000",
+    test: "",
+    prod: ""
+  },
+  browsers: ["chromium"],
+  headless: true,
+  viewport: { width: 1280, height: 720 },
+  timeout: 3e4,
+  retries: 1,
+  parallel: 1,
+  pageLoad: "domcontentloaded",
+  screenshot: "only-on-failure",
+  video: "off",
+  trace: "on-first-retry",
+  healing: {
+    enabled: true,
+    maxLevel: 5,
+    dailyBudget: 5,
+    autoPR: false
+  },
+  reporting: {
+    allure: true,
+    html: true,
+    json: true
+  },
+  studioPort: 4400,
+  profiles: []
+};
+
+// src/storage/suite-store.ts
+var import_path2 = __toESM(require("path"));
+var import_fs_extra3 = __toESM(require("fs-extra"));
+var import_uuid = require("uuid");
+
+// src/types/suite.ts
+var import_zod2 = require("zod");
+var TestStepSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  order: import_zod2.z.number().int().positive(),
+  instruction: import_zod2.z.string().min(1),
+  generatedCode: import_zod2.z.string(),
+  strategy: import_zod2.z.enum(["template", "cache", "batch", "fast", "primary"]),
+  stepType: import_zod2.z.enum(["ui", "api", "mock"]).default("ui"),
+  lastHealed: import_zod2.z.string().nullable(),
+  timeout: import_zod2.z.number().int().positive().optional(),
+  retries: import_zod2.z.number().int().min(0).optional(),
+  mockUrl: import_zod2.z.string().optional(),
+  mockResponse: import_zod2.z.string().optional(),
+  mockStatus: import_zod2.z.number().int().optional(),
+  runAudit: import_zod2.z.boolean().optional()
+  // Mark this step as a Lighthouse audit checkpoint
+});
+var DataSourceSchema = import_zod2.z.object({
+  type: import_zod2.z.enum(["inline", "json-file", "csv-file"]),
+  path: import_zod2.z.string().optional(),
+  data: import_zod2.z.array(import_zod2.z.record(import_zod2.z.string())).optional()
+}).optional();
+var CaseHookStepSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  instruction: import_zod2.z.string(),
+  generatedCode: import_zod2.z.string().default(""),
+  order: import_zod2.z.number().int().default(0)
+});
+var CaseHooksSchema = import_zod2.z.object({
+  before: import_zod2.z.array(CaseHookStepSchema).default([]),
+  after: import_zod2.z.array(CaseHookStepSchema).default([])
+}).default({ before: [], after: [] });
+var TestCaseSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  name: import_zod2.z.string().min(1),
+  description: import_zod2.z.string(),
+  tags: import_zod2.z.array(import_zod2.z.string()),
+  priority: import_zod2.z.enum(["critical", "high", "medium", "low"]),
+  timeout: import_zod2.z.number().int().positive().optional(),
+  dataSource: DataSourceSchema,
+  steps: import_zod2.z.array(TestStepSchema),
+  caseHooks: CaseHooksSchema,
+  lighthouseCategories: import_zod2.z.array(import_zod2.z.enum(["performance", "accessibility", "seo"])).default(["performance", "accessibility", "seo"]),
+  createdAt: import_zod2.z.string().datetime(),
+  updatedAt: import_zod2.z.string().datetime()
+});
+var TestSuiteSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1),
+  name: import_zod2.z.string().min(1),
+  description: import_zod2.z.string(),
+  tags: import_zod2.z.array(import_zod2.z.string()),
+  type: import_zod2.z.enum(["ui", "api", "audit", "performance"]).default("ui"),
+  timeout: import_zod2.z.number().int().positive().optional(),
+  createdAt: import_zod2.z.string().datetime(),
+  updatedAt: import_zod2.z.string().datetime()
+});
+var HookTypeEnum = import_zod2.z.enum(["before_all", "before_each", "after_each", "after_all"]);
+var SuiteHooksSchema = import_zod2.z.object({
+  before_all: import_zod2.z.array(TestStepSchema).default([]),
+  before_each: import_zod2.z.array(TestStepSchema).default([]),
+  after_each: import_zod2.z.array(TestStepSchema).default([]),
+  after_all: import_zod2.z.array(TestStepSchema).default([])
+});
+
+// src/utils/errors.ts
+var AssuremindError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "AssuremindError";
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ProviderError = class extends AssuremindError {
+  provider;
+  constructor(message, provider, code = "PROVIDER_ERROR") {
+    super(message, code);
+    this.name = "ProviderError";
+    this.provider = provider;
+  }
+};
+var ExecutionError = class extends AssuremindError {
+  stepId;
+  constructor(message, stepId, code = "EXECUTION_ERROR") {
+    super(message, code);
+    this.name = "ExecutionError";
+    this.stepId = stepId;
+  }
+};
+var ConfigError = class extends AssuremindError {
+  constructor(message, code = "CONFIG_ERROR") {
+    super(message, code);
+    this.name = "ConfigError";
+  }
+};
+var ValidationError = class extends AssuremindError {
+  field;
+  constructor(message, field, code = "VALIDATION_ERROR") {
+    super(message, code);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+};
+var HealingError = class extends AssuremindError {
+  level;
+  constructor(message, level, code = "HEALING_ERROR") {
+    super(message, code);
+    this.name = "HealingError";
+    this.level = level;
+  }
+};
+var StorageError = class extends AssuremindError {
+  path;
+  constructor(message, path8, code = "STORAGE_ERROR") {
+    super(message, code);
+    this.name = "StorageError";
+    this.path = path8;
+  }
+};
+function isAssuremindError(error) {
+  return error instanceof AssuremindError;
+}
+function formatError(error) {
+  if (error instanceof AssuremindError) {
+    return `[${error.code}] ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/utils/logger.ts
+var import_pino = __toESM(require("pino"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var isDevelopment = process.env["NODE_ENV"] !== "production";
+var transport = isDevelopment ? {
+  target: "pino-pretty",
+  options: {
+    colorize: true,
+    translateTime: "HH:MM:ss",
+    ignore: "pid,hostname",
+    messageFormat: "[assuremind] {msg}"
+  }
+} : void 0;
+var logger = (0, import_pino.default)(
+  {
+    level: process.env["LOG_LEVEL"] ?? "info",
+    base: { name: "assuremind" }
+  },
+  transport ? import_pino.default.transport(transport) : void 0
+);
+function createChildLogger(component) {
+  return logger.child({ component });
+}
+
+// src/utils/sanitize.ts
+function stripCodeFences(raw) {
+  const fencePattern = /^```(?:typescript|javascript|ts|js)?\n?([\s\S]*?)```\s*$/m;
+  const match = raw.match(fencePattern);
+  if (match?.[1] !== void 0) {
+    return match[1].trim();
+  }
+  return raw.trim();
+}
+var FORBIDDEN_PATTERNS = [
+  /\brequire\s*\(/,
+  /\bimport\s*\(/,
+  /\bprocess\b/,
+  /\bchild_process\b/,
+  /\bexec\s*\(/,
+  /\bspawn\s*\(/,
+  /\beval\s*\(/,
+  /\bFunction\s*\(/,
+  /\b__dirname\b/,
+  /\b__filename\b/,
+  /\bglobal\b/,
+  /\bwindow\.location\.href\s*=/,
+  /\bdocument\.cookie\b/,
+  /\blocalStorage\b/,
+  /\bsessionStorage\b/,
+  /\bIndexedDB\b/,
+  /\bXMLHttpRequest\b/,
+  /\bfetch\s*\(/,
+  /\bWebSocket\s*\(/
+];
+function validateGeneratedCode(code) {
+  for (const pattern of FORBIDDEN_PATTERNS) {
+    if (pattern.test(code)) {
+      throw new ValidationError(
+        `Generated code contains forbidden pattern: ${pattern.source}. This may be a prompt injection attempt. Please regenerate the step.`,
+        "generatedCode",
+        "UNSAFE_CODE"
+      );
+    }
+  }
+}
+function fixAntiPatterns(code) {
+  let result = code;
+  result = result.replace(
+    /\.or\((?:[^()]*|\([^()]*\))*\)(?:\.(?:first|last)\(\))?/g,
+    ""
+  );
+  result = result.replace(/\.(?:first|last)\(\)(?=\.\w)/g, "");
+  return result;
+}
+function sanitizeGeneratedCode(raw) {
+  const stripped = stripCodeFences(raw);
+  if (!stripped) {
+    throw new ValidationError(
+      "AI returned an empty code response. Please try regenerating.",
+      "generatedCode",
+      "EMPTY_CODE"
+    );
+  }
+  const fixed = fixAntiPatterns(stripped);
+  validateGeneratedCode(fixed);
+  return fixed;
+}
+function toSlug(input) {
+  return input.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function redactSecrets(text, secrets) {
+  let result = text;
+  for (const secret of secrets) {
+    if (secret.length > 0) {
+      result = result.replaceAll(secret, "[REDACTED]");
+    }
+  }
+  return result;
+}
+
+// src/storage/utils.ts
+var import_path = __toESM(require("path"));
+var import_fs_extra2 = __toESM(require("fs-extra"));
+async function atomicWriteJson(filePath, data) {
+  const dir = import_path.default.dirname(filePath);
+  await import_fs_extra2.default.ensureDir(dir);
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    await import_fs_extra2.default.writeJson(tmpPath, data, { spaces: 2 });
+    await import_fs_extra2.default.rename(tmpPath, filePath);
+  } catch (err) {
+    await import_fs_extra2.default.remove(tmpPath).catch(() => void 0);
+    throw new StorageError(
+      `Failed to write file "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
+      filePath,
+      "WRITE_FAILED"
+    );
+  }
+}
+async function readJson(filePath) {
+  try {
+    return await import_fs_extra2.default.readJson(filePath);
+  } catch (err) {
+    throw new StorageError(
+      `Failed to read JSON file "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
+      filePath,
+      "READ_FAILED"
+    );
+  }
+}
+async function atomicWriteText(filePath, content) {
+  const dir = import_path.default.dirname(filePath);
+  await import_fs_extra2.default.ensureDir(dir);
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    await import_fs_extra2.default.writeFile(tmpPath, content, "utf8");
+    await import_fs_extra2.default.rename(tmpPath, filePath);
+  } catch (err) {
+    await import_fs_extra2.default.remove(tmpPath).catch(() => void 0);
+    throw new StorageError(
+      `Failed to write file "${filePath}": ${err instanceof Error ? err.message : String(err)}`,
+      filePath,
+      "WRITE_FAILED"
+    );
+  }
+}
+
+// src/storage/suite-store.ts
+var logger2 = createChildLogger("suite-store");
+var SUITE_FILE = "suite.json";
+async function readSuite(suiteDir) {
+  const filePath = import_path2.default.join(suiteDir, SUITE_FILE);
+  if (!await import_fs_extra3.default.pathExists(filePath)) {
+    throw new StorageError(
+      `Suite file not found at "${filePath}". Ensure the suite directory exists and contains a suite.json file.`,
+      filePath,
+      "SUITE_NOT_FOUND"
+    );
+  }
+  const raw = await readJson(filePath);
+  const result = TestSuiteSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid suite.json at "${filePath}":
+${issues}`,
+      "suite",
+      "INVALID_SUITE"
+    );
+  }
+  const rawObj = raw;
+  if (!rawObj.type) {
+    const parentDir = import_path2.default.basename(import_path2.default.dirname(suiteDir));
+    if (parentDir === "api") result.data.type = "api";
+    else if (parentDir === "audit") result.data.type = "audit";
+    else if (parentDir === "performance") result.data.type = "audit";
+    else result.data.type = "ui";
+  }
+  return result.data;
+}
+async function writeSuite(suiteDir, suite) {
+  await import_fs_extra3.default.ensureDir(suiteDir);
+  const filePath = import_path2.default.join(suiteDir, SUITE_FILE);
+  const result = TestSuiteSchema.safeParse(suite);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid suite to "${filePath}":
+${issues}`,
+      "suite",
+      "INVALID_SUITE"
+    );
+  }
+  await atomicWriteJson(filePath, result.data);
+  logger2.debug({ suiteId: suite.id, path: filePath }, "Suite written");
+}
+async function createSuite(testsDir, suite) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const suiteType = suite.type ?? "ui";
+  const newSuite = {
+    ...suite,
+    type: suiteType,
+    id: (0, import_uuid.v4)(),
+    createdAt: now,
+    updatedAt: now
+  };
+  const targetDir = import_path2.default.join(testsDir, suiteType);
+  const suiteDir = import_path2.default.join(targetDir, toSlug(newSuite.name));
+  if (await import_fs_extra3.default.pathExists(import_path2.default.join(suiteDir, SUITE_FILE))) {
+    throw new StorageError(
+      `Suite directory already exists at "${suiteDir}". Choose a different name or delete the existing suite first.`,
+      suiteDir,
+      "SUITE_ALREADY_EXISTS"
+    );
+  }
+  await writeSuite(suiteDir, newSuite);
+  logger2.info({ suiteId: newSuite.id, path: suiteDir }, "Suite created");
+  return { suiteDir, suiteId: newSuite.id };
+}
+async function updateSuite(suiteDir, updates) {
+  const existing = await readSuite(suiteDir);
+  const updated = {
+    ...existing,
+    ...updates,
+    id: existing.id,
+    createdAt: existing.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeSuite(suiteDir, updated);
+  return updated;
+}
+async function deleteSuite(suiteDir) {
+  if (!await import_fs_extra3.default.pathExists(suiteDir)) {
+    throw new StorageError(
+      `Suite directory not found at "${suiteDir}".`,
+      suiteDir,
+      "SUITE_NOT_FOUND"
+    );
+  }
+  await import_fs_extra3.default.remove(suiteDir);
+  logger2.info({ path: suiteDir }, "Suite deleted");
+}
+async function listSuiteDirs(testsDir) {
+  const suiteDirs = [];
+  const searchDirs = [
+    import_path2.default.join(testsDir, "ui"),
+    import_path2.default.join(testsDir, "api"),
+    import_path2.default.join(testsDir, "audit"),
+    import_path2.default.join(testsDir, "performance"),
+    // legacy: keep scanning for backward compat
+    testsDir
+    // legacy: suites at root level
+  ];
+  for (const baseDir of searchDirs) {
+    if (!await import_fs_extra3.default.pathExists(baseDir)) continue;
+    const entries = await import_fs_extra3.default.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (baseDir === testsDir && (entry.name === "ui" || entry.name === "api" || entry.name === "audit" || entry.name === "performance")) continue;
+      const suiteFile = import_path2.default.join(baseDir, entry.name, SUITE_FILE);
+      if (await import_fs_extra3.default.pathExists(suiteFile)) {
+        suiteDirs.push(import_path2.default.join(baseDir, entry.name));
+      }
+    }
+  }
+  return suiteDirs;
+}
+async function listSuites(testsDir) {
+  const dirs = await listSuiteDirs(testsDir);
+  const suites = [];
+  for (const dir of dirs) {
+    try {
+      suites.push(await readSuite(dir));
+    } catch (err) {
+      logger2.warn({ path: dir, err }, "Failed to read suite \u2014 skipping");
+    }
+  }
+  return suites;
+}
+async function listSuitesWithCounts(testsDir) {
+  const dirs = await listSuiteDirs(testsDir);
+  const suites = [];
+  for (const dir of dirs) {
+    try {
+      const suite = await readSuite(dir);
+      const entries = await import_fs_extra3.default.readdir(dir, { withFileTypes: true });
+      const caseCount = entries.filter((e) => e.isFile() && e.name.endsWith(".test.json")).length;
+      suites.push({ ...suite, caseCount });
+    } catch (err) {
+      logger2.warn({ path: dir, err }, "Failed to read suite \u2014 skipping");
+    }
+  }
+  return suites;
+}
+
+// src/storage/case-store.ts
+var import_path3 = __toESM(require("path"));
+var import_fs_extra4 = __toESM(require("fs-extra"));
+var import_uuid2 = require("uuid");
+var logger3 = createChildLogger("case-store");
+var CASE_EXTENSION = ".test.json";
+async function readCase(casePath) {
+  if (!await import_fs_extra4.default.pathExists(casePath)) {
+    throw new StorageError(
+      `Test case file not found at "${casePath}".`,
+      casePath,
+      "CASE_NOT_FOUND"
+    );
+  }
+  const raw = await readJson(casePath);
+  const result = TestCaseSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid test case file at "${casePath}":
+${issues}`,
+      "case",
+      "INVALID_CASE"
+    );
+  }
+  return result.data;
+}
+async function writeCase(casePath, testCase) {
+  const result = TestCaseSchema.safeParse(testCase);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid test case to "${casePath}":
+${issues}`,
+      "case",
+      "INVALID_CASE"
+    );
+  }
+  await atomicWriteJson(casePath, result.data);
+  logger3.debug({ caseId: testCase.id, path: casePath }, "Test case written");
+}
+async function createCase(suiteDir, testCase) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newCase = {
+    ...testCase,
+    id: (0, import_uuid2.v4)(),
+    createdAt: now,
+    updatedAt: now
+  };
+  const casePath = import_path3.default.join(suiteDir, `${toSlug(newCase.name)}${CASE_EXTENSION}`);
+  await writeCase(casePath, newCase);
+  logger3.info({ caseId: newCase.id, path: casePath }, "Test case created");
+  return casePath;
+}
+async function updateCase(casePath, updates) {
+  const existing = await readCase(casePath);
+  const updated = {
+    ...existing,
+    ...updates,
+    id: existing.id,
+    createdAt: existing.createdAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeCase(casePath, updated);
+  return updated;
+}
+async function deleteCase(casePath) {
+  if (!await import_fs_extra4.default.pathExists(casePath)) {
+    throw new StorageError(
+      `Test case file not found at "${casePath}".`,
+      casePath,
+      "CASE_NOT_FOUND"
+    );
+  }
+  await import_fs_extra4.default.remove(casePath);
+  logger3.info({ path: casePath }, "Test case deleted");
+}
+async function listCasePaths(suiteDir) {
+  if (!await import_fs_extra4.default.pathExists(suiteDir)) return [];
+  const entries = await import_fs_extra4.default.readdir(suiteDir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(CASE_EXTENSION)).map((e) => import_path3.default.join(suiteDir, e.name));
+}
+async function listCases(suiteDir) {
+  const paths = await listCasePaths(suiteDir);
+  const cases = [];
+  for (const casePath of paths) {
+    try {
+      cases.push(await readCase(casePath));
+    } catch (err) {
+      logger3.warn({ path: casePath, err }, "Failed to read test case \u2014 skipping");
+    }
+  }
+  return cases.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getCasePath(suiteDir, caseName) {
+  return import_path3.default.join(suiteDir, `${toSlug(caseName)}${CASE_EXTENSION}`);
+}
+
+// src/storage/variable-store.ts
+var import_path4 = __toESM(require("path"));
+var import_fs_extra5 = __toESM(require("fs-extra"));
+
+// src/types/variable.ts
+var import_zod3 = require("zod");
+var SecretVariableSchema = import_zod3.z.object({
+  value: import_zod3.z.string(),
+  secret: import_zod3.z.literal(true)
+});
+var VariableValueSchema = import_zod3.z.union([import_zod3.z.string(), SecretVariableSchema]);
+var VariableStoreSchema = import_zod3.z.record(import_zod3.z.string(), VariableValueSchema);
+function isSecretVariable(value) {
+  return typeof value === "object" && value.secret === true;
+}
+function resolveVariableValue(value) {
+  if (isSecretVariable(value)) {
+    return value.value;
+  }
+  return value;
+}
+
+// src/storage/variable-store.ts
+var logger4 = createChildLogger("variable-store");
+var VARIABLES_DIR = "variables";
+var GLOBAL_FILE = "global.json";
+function envFileName(env) {
+  return `${env}.env.json`;
+}
+async function readVariables(filePath) {
+  if (!await import_fs_extra5.default.pathExists(filePath)) {
+    return {};
+  }
+  const raw = await readJson(filePath);
+  const result = VariableStoreSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid variables file at "${filePath}":
+${issues}`,
+      "variables",
+      "INVALID_VARIABLES"
+    );
+  }
+  return result.data;
+}
+async function writeVariables(filePath, store) {
+  const result = VariableStoreSchema.safeParse(store);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid variables to "${filePath}":
+${issues}`,
+      "variables",
+      "INVALID_VARIABLES"
+    );
+  }
+  await atomicWriteJson(filePath, result.data);
+  logger4.debug({ path: filePath }, "Variables written");
+}
+async function readGlobalVariables(rootDir) {
+  const filePath = import_path4.default.join(rootDir, VARIABLES_DIR, GLOBAL_FILE);
+  return readVariables(filePath);
+}
+async function readEnvVariables(rootDir, env) {
+  const filePath = import_path4.default.join(rootDir, VARIABLES_DIR, envFileName(env));
+  return readVariables(filePath);
+}
+async function resolveVariables(rootDir, env) {
+  const global = await readGlobalVariables(rootDir);
+  const envSpecific = env ? await readEnvVariables(rootDir, env) : {};
+  const merged = { ...global, ...envSpecific };
+  const resolved = {};
+  for (const [key, value] of Object.entries(merged)) {
+    resolved[key] = resolveVariableValue(value);
+  }
+  return resolved;
+}
+async function setGlobalVariable(rootDir, key, value) {
+  const filePath = import_path4.default.join(rootDir, VARIABLES_DIR, GLOBAL_FILE);
+  await import_fs_extra5.default.ensureDir(import_path4.default.dirname(filePath));
+  const existing = await readVariables(filePath);
+  existing[key] = value;
+  await writeVariables(filePath, existing);
+}
+async function deleteGlobalVariable(rootDir, key) {
+  const filePath = import_path4.default.join(rootDir, VARIABLES_DIR, GLOBAL_FILE);
+  const existing = await readVariables(filePath);
+  if (!(key in existing)) {
+    throw new StorageError(
+      `Variable "${key}" not found in global variables.`,
+      filePath,
+      "VARIABLE_NOT_FOUND"
+    );
+  }
+  delete existing[key];
+  await writeVariables(filePath, existing);
+}
+async function listVariableFiles(rootDir) {
+  const dir = import_path4.default.join(rootDir, VARIABLES_DIR);
+  if (!await import_fs_extra5.default.pathExists(dir)) return [];
+  const entries = await import_fs_extra5.default.readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => import_path4.default.join(dir, e.name));
+}
+
+// src/storage/config-store.ts
+var import_path5 = __toESM(require("path"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
+var logger5 = createChildLogger("config-store");
+var CONFIG_JSON = "autotest.config.json";
+var CONFIG_TS = "autotest.config.ts";
+async function readConfig(rootDir) {
+  const jsonPath = import_path5.default.join(rootDir, CONFIG_JSON);
+  if (!await import_fs_extra6.default.pathExists(jsonPath)) {
+    logger5.debug({ rootDir }, "No autotest.config.json found \u2014 using defaults");
+    return DEFAULT_CONFIG;
+  }
+  const raw = await readJson(jsonPath);
+  const result = AutotestConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid autotest.config.json at "${jsonPath}":
+${issues}
+
+How to fix: Run "npx assuremind init" to reset to defaults, or manually correct the file using autotest.config.ts as reference.`,
+      "config",
+      "INVALID_CONFIG"
+    );
+  }
+  return result.data;
+}
+async function writeConfig(rootDir, config) {
+  const result = AutotestConfigSchema.safeParse(config);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid config:
+${issues}`,
+      "config",
+      "INVALID_CONFIG"
+    );
+  }
+  const jsonPath = import_path5.default.join(rootDir, CONFIG_JSON);
+  await atomicWriteJson(jsonPath, result.data);
+  const tsPath = import_path5.default.join(rootDir, CONFIG_TS);
+  await atomicWriteText(tsPath, generateConfigTs(result.data));
+  logger5.info({ rootDir }, "Config saved");
+}
+async function updateConfig(rootDir, updates) {
+  const current = await readConfig(rootDir);
+  const merged = {
+    ...current,
+    ...updates,
+    healing: { ...current.healing, ...updates.healing ?? {} },
+    reporting: { ...current.reporting, ...updates.reporting ?? {} },
+    environmentUrls: { ...current.environmentUrls, ...updates.environmentUrls ?? {} }
+  };
+  await writeConfig(rootDir, merged);
+  return merged;
+}
+async function configExists(rootDir) {
+  const jsonPath = import_path5.default.join(rootDir, CONFIG_JSON);
+  const tsPath = import_path5.default.join(rootDir, CONFIG_TS);
+  return await import_fs_extra6.default.pathExists(jsonPath) || await import_fs_extra6.default.pathExists(tsPath);
+}
+async function validateConfig(rootDir) {
+  const config = await readConfig(rootDir);
+  if (!config.baseUrl) {
+    throw new ConfigError(
+      'baseUrl is required in autotest.config.ts. Set it to your application URL, e.g. "http://localhost:3000".',
+      "CONFIG_BASE_URL_MISSING"
+    );
+  }
+  logger5.debug({ config }, "Config validated successfully");
+}
+function generateConfigTs(config) {
+  return `import { defineConfig } from 'assuremind';
+
+export default defineConfig({
+  baseUrl: '${config.baseUrl}',
+  browsers: ${JSON.stringify(config.browsers)},
+  headless: ${config.headless},
+  timeout: ${config.timeout},
+  retries: ${config.retries},
+  parallel: ${config.parallel},
+  screenshot: '${config.screenshot}',
+  video: '${config.video}',
+  trace: '${config.trace}',
+  healing: {
+    enabled: ${config.healing.enabled},
+    maxLevel: ${config.healing.maxLevel},
+    dailyBudget: ${config.healing.dailyBudget},
+    autoPR: ${config.healing.autoPR},
+  },
+  reporting: {
+    allure: ${config.reporting.allure},
+    html: ${config.reporting.html},
+    json: ${config.reporting.json},
+  },
+  studioPort: ${config.studioPort},
+});
+`;
+}
+
+// src/storage/result-store.ts
+var import_path6 = __toESM(require("path"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
+
+// src/types/run.ts
+var import_zod4 = require("zod");
+var RunStatusSchema = import_zod4.z.enum(["pending", "running", "passed", "failed", "skipped"]);
+var ApiRequestSchema = import_zod4.z.object({
+  method: import_zod4.z.string(),
+  url: import_zod4.z.string(),
+  headers: import_zod4.z.record(import_zod4.z.string()).optional(),
+  body: import_zod4.z.string().optional()
+}).optional();
+var ApiResponseSchema = import_zod4.z.object({
+  status: import_zod4.z.number(),
+  statusText: import_zod4.z.string(),
+  headers: import_zod4.z.record(import_zod4.z.string()).optional(),
+  body: import_zod4.z.string().optional(),
+  duration: import_zod4.z.number()
+}).optional();
+var optionalNum = import_zod4.z.number().nullish().transform((v) => v ?? void 0);
+var AuditItemSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  title: import_zod4.z.string(),
+  passed: import_zod4.z.boolean(),
+  // true  = score === 1
+  partial: import_zod4.z.boolean().optional(),
+  // true  = 0 < score < 1 (needs work)
+  na: import_zod4.z.boolean().optional()
+  // true  = score === null (not applicable)
+});
+var PageLoadMetricSchema = import_zod4.z.object({
+  url: import_zod4.z.string(),
+  stepIndex: import_zod4.z.number().int(),
+  stepInstruction: import_zod4.z.string(),
+  score: optionalNum,
+  // Performance score 0-100 (pre-multiplied in runner)
+  a11yScore: optionalNum,
+  // Accessibility score 0-100 (pre-multiplied in runner)
+  seoScore: optionalNum,
+  // SEO score 0-100 (pre-multiplied in runner)
+  fcp: optionalNum,
+  // First Contentful Paint (ms)
+  lcp: optionalNum,
+  // Largest Contentful Paint (ms)
+  cls: optionalNum,
+  // Cumulative Layout Shift (score)
+  ttfb: optionalNum,
+  // Time to First Byte (ms)
+  tbt: optionalNum,
+  // Total Blocking Time (ms)
+  si: optionalNum,
+  // Speed Index (ms)
+  tti: optionalNum,
+  // Time to Interactive (ms)
+  inp: optionalNum,
+  // Interaction to Next Paint (ms)
+  // Individual audit items for Accessibility and SEO categories
+  a11yAudits: import_zod4.z.array(AuditItemSchema).optional(),
+  seoAudits: import_zod4.z.array(AuditItemSchema).optional(),
+  lighthouseError: import_zod4.z.string().optional()
+});
+var StepResultSchema = import_zod4.z.object({
+  stepId: import_zod4.z.string(),
+  instruction: import_zod4.z.string(),
+  status: RunStatusSchema,
+  code: import_zod4.z.string(),
+  error: import_zod4.z.string().optional(),
+  duration: import_zod4.z.number(),
+  screenshotPath: import_zod4.z.string().optional(),
+  healed: import_zod4.z.boolean().optional(),
+  healedCode: import_zod4.z.string().optional(),
+  stepType: import_zod4.z.enum(["ui", "api", "mock"]).optional(),
+  apiRequest: ApiRequestSchema,
+  apiResponse: ApiResponseSchema,
+  navigatedToUrl: import_zod4.z.string().optional(),
+  auditUrl: import_zod4.z.string().optional()
+  // URL captured when step has runAudit=true (may not have navigated)
+});
+var TestCaseResultSchema = import_zod4.z.object({
+  caseId: import_zod4.z.string(),
+  caseName: import_zod4.z.string(),
+  status: RunStatusSchema,
+  steps: import_zod4.z.array(StepResultSchema),
+  duration: import_zod4.z.number(),
+  browser: import_zod4.z.string(),
+  /** Playwright device descriptor used for this case (undefined = no emulation). */
+  device: import_zod4.z.string().optional(),
+  startedAt: import_zod4.z.string().datetime(),
+  finishedAt: import_zod4.z.string().datetime(),
+  videoPath: import_zod4.z.string().optional(),
+  tracePath: import_zod4.z.string().optional(),
+  dataRowIndex: import_zod4.z.number().int().optional(),
+  dataRow: import_zod4.z.record(import_zod4.z.string()).optional(),
+  pageLoads: import_zod4.z.array(PageLoadMetricSchema).default([])
+});
+var SuiteResultSchema = import_zod4.z.object({
+  suiteId: import_zod4.z.string(),
+  suiteName: import_zod4.z.string(),
+  suiteType: import_zod4.z.enum(["ui", "api", "audit", "performance"]).optional(),
+  status: RunStatusSchema,
+  cases: import_zod4.z.array(TestCaseResultSchema),
+  duration: import_zod4.z.number(),
+  browser: import_zod4.z.string(),
+  startedAt: import_zod4.z.string().datetime(),
+  finishedAt: import_zod4.z.string().datetime()
+});
+var RunResultSchema = import_zod4.z.object({
+  runId: import_zod4.z.string(),
+  status: RunStatusSchema,
+  environment: import_zod4.z.string().optional(),
+  suites: import_zod4.z.array(SuiteResultSchema),
+  duration: import_zod4.z.number(),
+  startedAt: import_zod4.z.string().datetime(),
+  finishedAt: import_zod4.z.string().datetime(),
+  totalTests: import_zod4.z.number().int(),
+  passed: import_zod4.z.number().int(),
+  failed: import_zod4.z.number().int(),
+  skipped: import_zod4.z.number().int(),
+  logFilePath: import_zod4.z.string().optional()
+});
+
+// src/storage/result-store.ts
+var logger6 = createChildLogger("result-store");
+var RESULTS_DIR = "results";
+var RUNS_DIR = "runs";
+function runFilePath(resultsDir, runId) {
+  return import_path6.default.join(resultsDir, RUNS_DIR, `${runId}.json`);
+}
+async function writeResult(rootDir, result) {
+  const schema = RunResultSchema.safeParse(result);
+  if (!schema.success) {
+    const issues = schema.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid run result:
+${issues}`,
+      "result",
+      "INVALID_RESULT"
+    );
+  }
+  const filePath = runFilePath(import_path6.default.join(rootDir, RESULTS_DIR), result.runId);
+  await atomicWriteJson(filePath, schema.data);
+  logger6.info({ runId: result.runId, status: result.status }, "Run result saved");
+}
+async function readResult(rootDir, runId) {
+  const filePath = runFilePath(import_path6.default.join(rootDir, RESULTS_DIR), runId);
+  if (!await import_fs_extra7.default.pathExists(filePath)) {
+    throw new StorageError(
+      `Run result not found for runId "${runId}".`,
+      filePath,
+      "RESULT_NOT_FOUND"
+    );
+  }
+  const raw = await readJson(filePath);
+  const result = RunResultSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid run result at "${filePath}":
+${issues}`,
+      "result",
+      "INVALID_RESULT"
+    );
+  }
+  return result.data;
+}
+async function listResultIds(rootDir) {
+  const runsDir = import_path6.default.join(rootDir, RESULTS_DIR, RUNS_DIR);
+  if (!await import_fs_extra7.default.pathExists(runsDir)) return [];
+  const entries = await import_fs_extra7.default.readdir(runsDir, { withFileTypes: true });
+  const ids = entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => e.name.replace(".json", ""));
+  const withStats = await Promise.all(
+    ids.map(async (id) => {
+      const stat = await import_fs_extra7.default.stat(import_path6.default.join(runsDir, `${id}.json`));
+      return { id, mtime: stat.mtimeMs };
+    })
+  );
+  return withStats.sort((a, b) => b.mtime - a.mtime).map((x) => x.id);
+}
+async function listResults(rootDir, limit = 20) {
+  const ids = await listResultIds(rootDir);
+  const results = [];
+  for (const id of ids.slice(0, limit)) {
+    try {
+      const result = await readResult(rootDir, id);
+      results.push({
+        runId: result.runId,
+        status: result.status,
+        environment: result.environment,
+        startedAt: result.startedAt,
+        finishedAt: result.finishedAt,
+        totalTests: result.totalTests,
+        passed: result.passed,
+        failed: result.failed,
+        skipped: result.skipped,
+        duration: result.duration,
+        suiteIds: result.suites.map((s) => s.suiteId)
+      });
+    } catch (err) {
+      logger6.warn({ runId: id, err }, "Failed to read run result \u2014 skipping");
+    }
+  }
+  return results;
+}
+async function deleteResult(rootDir, runId) {
+  const filePath = runFilePath(import_path6.default.join(rootDir, RESULTS_DIR), runId);
+  if (!await import_fs_extra7.default.pathExists(filePath)) {
+    throw new StorageError(
+      `Run result not found for runId "${runId}".`,
+      filePath,
+      "RESULT_NOT_FOUND"
+    );
+  }
+  await import_fs_extra7.default.remove(filePath);
+  logger6.info({ runId }, "Run result deleted");
+}
+function screenshotsDir(rootDir) {
+  return import_path6.default.join(rootDir, RESULTS_DIR, "screenshots");
+}
+function videosDir(rootDir) {
+  return import_path6.default.join(rootDir, RESULTS_DIR, "videos");
+}
+function tracesDir(rootDir) {
+  return import_path6.default.join(rootDir, RESULTS_DIR, "traces");
+}
+
+// src/storage/healing-store.ts
+var import_path7 = __toESM(require("path"));
+var import_fs_extra8 = __toESM(require("fs-extra"));
+
+// src/types/healing.ts
+var import_zod5 = require("zod");
+var HealingStatusSchema = import_zod5.z.enum(["pending", "accepted", "rejected"]);
+var HealingStrategySchema = import_zod5.z.enum([
+  "retry",
+  "regenerate",
+  "multi-selector",
+  "visual",
+  "decompose",
+  "manual"
+]);
+var HealingEventSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  runId: import_zod5.z.string(),
+  suiteId: import_zod5.z.string(),
+  caseId: import_zod5.z.string(),
+  stepId: import_zod5.z.string(),
+  stepInstruction: import_zod5.z.string(),
+  failedCode: import_zod5.z.string(),
+  healedCode: import_zod5.z.string(),
+  error: import_zod5.z.string(),
+  strategy: HealingStrategySchema,
+  level: import_zod5.z.number().int().min(1).max(6),
+  status: HealingStatusSchema,
+  pageUrl: import_zod5.z.string(),
+  timestamp: import_zod5.z.string().datetime(),
+  acceptedAt: import_zod5.z.string().datetime().optional(),
+  rejectedAt: import_zod5.z.string().datetime().optional()
+});
+var HealingReportSchema = import_zod5.z.object({
+  runId: import_zod5.z.string(),
+  generatedAt: import_zod5.z.string().datetime(),
+  totalHeals: import_zod5.z.number().int(),
+  accepted: import_zod5.z.number().int(),
+  rejected: import_zod5.z.number().int(),
+  pending: import_zod5.z.number().int(),
+  events: import_zod5.z.array(HealingEventSchema)
+});
+
+// src/storage/healing-store.ts
+var logger7 = createChildLogger("healing-store");
+var HEALING_DIR = import_path7.default.join("results", "healing");
+var PENDING_FILE = "pending.json";
+var REPORT_PREFIX = "healing-report-";
+function reportFilePath(healingDir, runId) {
+  return import_path7.default.join(healingDir, `${REPORT_PREFIX}${runId}.json`);
+}
+function pendingFilePath(healingDir) {
+  return import_path7.default.join(healingDir, PENDING_FILE);
+}
+async function writeHealingReport(rootDir, report) {
+  const schema = HealingReportSchema.safeParse(report);
+  if (!schema.success) {
+    const issues = schema.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Cannot write invalid healing report:
+${issues}`,
+      "healingReport",
+      "INVALID_HEALING_REPORT"
+    );
+  }
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  const filePath = reportFilePath(healingDir, report.runId);
+  await atomicWriteJson(filePath, schema.data);
+  logger7.info({ runId: report.runId, totalHeals: report.totalHeals }, "Healing report saved");
+}
+async function readHealingReport(rootDir, runId) {
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  const filePath = reportFilePath(healingDir, runId);
+  if (!await import_fs_extra8.default.pathExists(filePath)) {
+    throw new StorageError(
+      `Healing report not found for runId "${runId}".`,
+      filePath,
+      "HEALING_REPORT_NOT_FOUND"
+    );
+  }
+  const raw = await readJson(filePath);
+  const result = HealingReportSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ValidationError(
+      `Invalid healing report at "${filePath}":
+${issues}`,
+      "healingReport",
+      "INVALID_HEALING_REPORT"
+    );
+  }
+  return result.data;
+}
+async function readPendingEvents(rootDir) {
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  const filePath = pendingFilePath(healingDir);
+  if (!await import_fs_extra8.default.pathExists(filePath)) return [];
+  const raw = await readJson(filePath);
+  const result = HealingEventSchema.array().safeParse(raw);
+  if (!result.success) {
+    logger7.warn({ path: filePath }, "Pending healing file is malformed \u2014 resetting");
+    return [];
+  }
+  return result.data;
+}
+var MAX_HEALING_EVENTS = 50;
+var PRUNE_PRIORITY = ["pending", "rejected", "accepted"];
+function pruneToLimit(events) {
+  if (events.length <= MAX_HEALING_EVENTS) return events;
+  const byPriority = [...events].sort((a, b) => {
+    const pa = PRUNE_PRIORITY.indexOf(a.status);
+    const pb = PRUNE_PRIORITY.indexOf(b.status);
+    if (pa !== pb) return pa - pb;
+    return a.timestamp < b.timestamp ? -1 : 1;
+  });
+  const excess = events.length - MAX_HEALING_EVENTS;
+  const toDelete = new Set(byPriority.slice(0, excess).map((e) => e.id));
+  logger7.info(
+    { excess, deleted: toDelete.size },
+    "Auto-pruning healing events to enforce cap"
+  );
+  return events.filter((e) => !toDelete.has(e.id));
+}
+async function appendPendingEvent(rootDir, event) {
+  const schema = HealingEventSchema.safeParse(event);
+  if (!schema.success) {
+    throw new ValidationError(
+      `Invalid healing event: ${schema.error.message}`,
+      "healingEvent",
+      "INVALID_HEALING_EVENT"
+    );
+  }
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  await import_fs_extra8.default.ensureDir(healingDir);
+  const existing = await readPendingEvents(rootDir);
+  existing.push(schema.data);
+  await atomicWriteJson(pendingFilePath(healingDir), pruneToLimit(existing));
+}
+async function acceptHealingEvent(rootDir, eventId) {
+  const pending = await readPendingEvents(rootDir);
+  const idx = pending.findIndex((e) => e.id === eventId);
+  if (idx === -1) {
+    throw new StorageError(
+      `Healing event "${eventId}" not found in pending list.`,
+      eventId,
+      "HEALING_EVENT_NOT_FOUND"
+    );
+  }
+  pending[idx] = {
+    ...pending[idx],
+    status: "accepted",
+    acceptedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  await atomicWriteJson(pendingFilePath(healingDir), pending);
+  logger7.info({ eventId }, "Healing event accepted");
+  return pending[idx];
+}
+async function rejectHealingEvent(rootDir, eventId) {
+  const pending = await readPendingEvents(rootDir);
+  const idx = pending.findIndex((e) => e.id === eventId);
+  if (idx === -1) {
+    throw new StorageError(
+      `Healing event "${eventId}" not found in pending list.`,
+      eventId,
+      "HEALING_EVENT_NOT_FOUND"
+    );
+  }
+  pending[idx] = {
+    ...pending[idx],
+    status: "rejected",
+    rejectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  await atomicWriteJson(pendingFilePath(healingDir), pending);
+  logger7.info({ eventId }, "Healing event rejected");
+  return pending[idx];
+}
+async function pruneResolvedEvents(rootDir, retentionDays = 30) {
+  const pending = await readPendingEvents(rootDir);
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
+  const before = pending.length;
+  const kept = pending.filter((e) => {
+    if (e.status === "pending") return true;
+    const resolvedAt = e.acceptedAt ?? e.rejectedAt;
+    if (!resolvedAt) return true;
+    return new Date(resolvedAt).getTime() > cutoff;
+  });
+  if (kept.length < before) {
+    const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+    await atomicWriteJson(pendingFilePath(healingDir), kept);
+  }
+  return before - kept.length;
+}
+async function getHealingStats(rootDir) {
+  const events = await readPendingEvents(rootDir);
+  const pending = events.filter((e) => e.status === "pending").length;
+  const accepted = events.filter((e) => e.status === "accepted").length;
+  const rejected = events.filter((e) => e.status === "rejected").length;
+  return { pending, accepted, rejected, total: events.length };
+}
+async function listHealingReportIds(rootDir) {
+  const healingDir = import_path7.default.join(rootDir, HEALING_DIR);
+  if (!await import_fs_extra8.default.pathExists(healingDir)) return [];
+  const entries = await import_fs_extra8.default.readdir(healingDir, { withFileTypes: true });
+  const ids = entries.filter((e) => e.isFile() && e.name.startsWith(REPORT_PREFIX) && e.name.endsWith(".json")).map((e) => e.name.slice(REPORT_PREFIX.length, -".json".length));
+  const withStats = await Promise.all(
+    ids.map(async (id) => {
+      const stat = await import_fs_extra8.default.stat(import_path7.default.join(healingDir, `${REPORT_PREFIX}${id}.json`));
+      return { id, mtime: stat.mtimeMs };
+    })
+  );
+  return withStats.sort((a, b) => b.mtime - a.mtime).map((x) => x.id);
+}
+
+// src/utils/hash.ts
+var import_crypto = require("crypto");
+function sha256(input) {
+  return (0, import_crypto.createHash)("sha256").update(input, "utf8").digest("hex");
+}
+function normalizeUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const normalizedPath = parsed.pathname.split("/").map((segment) => {
+      if (/^\d+$/.test(segment)) return "*";
+      if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(segment)) {
+        return "*";
+      }
+      if (/^[a-z0-9-]{8,}$/i.test(segment) && /-/.test(segment)) return "*";
+      return segment;
+    }).join("/");
+    return normalizedPath;
+  } catch {
+    return url;
+  }
+}
+function generateCacheKey(instruction, url) {
+  const normalizedInstruction = instruction.toLowerCase().replace(/\s+/g, " ").trim();
+  const urlPattern = normalizeUrl(url);
+  return sha256(`${normalizedInstruction}|${urlPattern}`).slice(0, 16);
+}
+
+// src/utils/env.ts
+var import_dotenv = require("dotenv");
+var import_zod6 = require("zod");
+(0, import_dotenv.config)();
+var AI_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "google",
+  "azure-openai",
+  "bedrock",
+  "deepseek",
+  "groq",
+  "together",
+  "qwen",
+  "perplexity",
+  "ollama",
+  "custom"
+];
+var BaseEnvSchema = import_zod6.z.object({
+  NODE_ENV: import_zod6.z.enum(["development", "production", "test"]).default("development"),
+  LOG_LEVEL: import_zod6.z.enum(["trace", "debug", "info", "warn", "error", "fatal"]).default("info"),
+  AI_PROVIDER: import_zod6.z.enum(AI_PROVIDERS),
+  AI_TIERED_ENABLED: import_zod6.z.string().transform((v) => v === "true").default("false"),
+  AI_TIERED_FAST_PROVIDER: import_zod6.z.enum(AI_PROVIDERS).optional(),
+  AI_TIERED_FAST_MODEL: import_zod6.z.string().optional(),
+  AI_TIMEOUT: import_zod6.z.coerce.number().int().positive().default(30),
+  AI_MAX_RETRIES: import_zod6.z.coerce.number().int().min(0).max(10).default(2)
+});
+var AnthropicEnvSchema = import_zod6.z.object({
+  ANTHROPIC_API_KEY: import_zod6.z.string().min(1),
+  ANTHROPIC_MODEL: import_zod6.z.string().default("claude-sonnet-4-20250514")
+});
+var OpenAIEnvSchema = import_zod6.z.object({
+  OPENAI_API_KEY: import_zod6.z.string().min(1),
+  OPENAI_MODEL: import_zod6.z.string().default("gpt-4o")
+});
+var GoogleEnvSchema = import_zod6.z.object({
+  GOOGLE_API_KEY: import_zod6.z.string().min(1),
+  GOOGLE_MODEL: import_zod6.z.string().default("gemini-2.5-pro")
+});
+var AzureOpenAIEnvSchema = import_zod6.z.object({
+  AZURE_OPENAI_API_KEY: import_zod6.z.string().min(1),
+  AZURE_OPENAI_ENDPOINT: import_zod6.z.string().url(),
+  AZURE_OPENAI_DEPLOYMENT: import_zod6.z.string().min(1),
+  AZURE_OPENAI_API_VERSION: import_zod6.z.string().default("2024-10-21")
+});
+var BedrockEnvSchema = import_zod6.z.object({
+  AWS_ACCESS_KEY_ID: import_zod6.z.string().min(1),
+  AWS_SECRET_ACCESS_KEY: import_zod6.z.string().min(1),
+  AWS_SESSION_TOKEN: import_zod6.z.string().optional(),
+  AWS_REGION: import_zod6.z.string().default("us-east-1"),
+  BEDROCK_MODEL: import_zod6.z.string().default("anthropic.claude-sonnet-4-20250514-v1:0")
+});
+var DeepSeekEnvSchema = import_zod6.z.object({
+  DEEPSEEK_API_KEY: import_zod6.z.string().min(1),
+  DEEPSEEK_MODEL: import_zod6.z.string().default("deepseek-chat")
+});
+var GroqEnvSchema = import_zod6.z.object({
+  GROQ_API_KEY: import_zod6.z.string().min(1),
+  GROQ_MODEL: import_zod6.z.string().default("llama-3.3-70b-versatile")
+});
+var TogetherEnvSchema = import_zod6.z.object({
+  TOGETHER_API_KEY: import_zod6.z.string().min(1),
+  TOGETHER_MODEL: import_zod6.z.string().default("meta-llama/Llama-3.3-70B-Instruct-Turbo")
+});
+var QwenEnvSchema = import_zod6.z.object({
+  QWEN_API_KEY: import_zod6.z.string().min(1),
+  QWEN_BASE_URL: import_zod6.z.string().url().default("https://dashscope-intl.aliyuncs.com/compatible-mode/v1"),
+  QWEN_MODEL: import_zod6.z.string().default("qwen-max")
+});
+var PerplexityEnvSchema = import_zod6.z.object({
+  PERPLEXITY_API_KEY: import_zod6.z.string().min(1),
+  PERPLEXITY_MODEL: import_zod6.z.string().default("sonar-pro")
+});
+var OllamaEnvSchema = import_zod6.z.object({
+  OLLAMA_BASE_URL: import_zod6.z.string().url().default("http://localhost:11434"),
+  OLLAMA_MODEL: import_zod6.z.string().default("llama3.3")
+});
+var CustomEnvSchema = import_zod6.z.object({
+  CUSTOM_API_KEY: import_zod6.z.string().min(1),
+  CUSTOM_BASE_URL: import_zod6.z.string().url(),
+  CUSTOM_MODEL: import_zod6.z.string().min(1)
+});
+var PROVIDER_SCHEMAS = {
+  anthropic: AnthropicEnvSchema,
+  openai: OpenAIEnvSchema,
+  google: GoogleEnvSchema,
+  "azure-openai": AzureOpenAIEnvSchema,
+  bedrock: BedrockEnvSchema,
+  deepseek: DeepSeekEnvSchema,
+  groq: GroqEnvSchema,
+  together: TogetherEnvSchema,
+  qwen: QwenEnvSchema,
+  perplexity: PerplexityEnvSchema,
+  ollama: OllamaEnvSchema,
+  custom: CustomEnvSchema
+};
+var _cachedEnv = null;
+function validateEnv() {
+  if (_cachedEnv !== null) return _cachedEnv;
+  const baseResult = BaseEnvSchema.safeParse(process.env);
+  if (!baseResult.success) {
+    const issues = baseResult.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigError(
+      `Missing or invalid environment variables:
+${issues}
+
+How to fix: Copy .env.example to .env and fill in your AI provider credentials.`,
+      "ENV_VALIDATION_FAILED"
+    );
+  }
+  const providerName = baseResult.data.AI_PROVIDER;
+  const providerSchema = PROVIDER_SCHEMAS[providerName];
+  const providerResult = providerSchema.safeParse(process.env);
+  if (!providerResult.success) {
+    const issues = providerResult.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new ConfigError(
+      `Provider "${providerName}" is missing required environment variables:
+${issues}
+
+How to fix: Check .env.example for the ${providerName} section and add the required keys to .env.`,
+      "PROVIDER_ENV_MISSING"
+    );
+  }
+  const merged = {
+    ...baseResult.data,
+    ...providerResult.data
+  };
+  _cachedEnv = merged;
+  return _cachedEnv;
+}
+function clearEnvCache() {
+  _cachedEnv = null;
+}
+function tryGetEnv() {
+  try {
+    return validateEnv();
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+function defineConfig(config) {
+  const merged = { ...DEFAULT_CONFIG, ...config };
+  const result = AutotestConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `  \u2022 ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid assuremind config:
+${issues}`);
+  }
+  return result.data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AssuremindError,
+  ConfigError,
+  ExecutionError,
+  HealingError,
+  ProviderError,
+  StorageError,
+  ValidationError,
+  acceptHealingEvent,
+  appendPendingEvent,
+  clearEnvCache,
+  configExists,
+  createCase,
+  createChildLogger,
+  createSuite,
+  defineConfig,
+  deleteCase,
+  deleteGlobalVariable,
+  deleteResult,
+  deleteSuite,
+  formatError,
+  generateCacheKey,
+  getCasePath,
+  getHealingStats,
+  isAssuremindError,
+  listCasePaths,
+  listCases,
+  listHealingReportIds,
+  listResultIds,
+  listResults,
+  listSuiteDirs,
+  listSuites,
+  listSuitesWithCounts,
+  listVariableFiles,
+  logger,
+  normalizeUrl,
+  pruneResolvedEvents,
+  readCase,
+  readConfig,
+  readEnvVariables,
+  readGlobalVariables,
+  readHealingReport,
+  readPendingEvents,
+  readResult,
+  readSuite,
+  readVariables,
+  redactSecrets,
+  rejectHealingEvent,
+  resolveVariables,
+  sanitizeGeneratedCode,
+  screenshotsDir,
+  setGlobalVariable,
+  sha256,
+  toSlug,
+  tracesDir,
+  tryGetEnv,
+  updateCase,
+  updateConfig,
+  updateSuite,
+  validateConfig,
+  validateEnv,
+  videosDir,
+  writeCase,
+  writeConfig,
+  writeHealingReport,
+  writeResult,
+  writeSuite,
+  writeVariables
+});
+//# sourceMappingURL=index.js.map