assuremind 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1525 @@
+// src/types/config.ts
+import { z } from "zod";
+var ScreenshotModeSchema = z.enum(["off", "on", "only-on-failure"]);
+var VideoModeSchema = z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
+var TraceModeSchema = z.enum(["off", "on", "on-first-retry", "retain-on-failure"]);
+var BrowserNameSchema = z.enum(["chromium", "firefox", "webkit"]);
+var PageLoadStrategySchema = z.enum(["commit", "domcontentloaded", "load", "networkidle"]);
+var EnvironmentSchema = z.enum(["dev", "stage", "test", "prod"]);
+var EnvironmentUrlsSchema = z.object({
+  dev: z.string().url().or(z.literal("")).default(""),
+  stage: z.string().url().or(z.literal("")).default(""),
+  test: z.string().url().or(z.literal("")).default(""),
+  prod: z.string().url().or(z.literal("")).default("")
+});
+var HealingConfigSchema = z.object({
+  enabled: z.boolean(),
+  maxLevel: z.number().int().min(1).max(6),
+  dailyBudget: z.number().positive(),
+  autoPR: z.boolean()
+});
+var ReportingConfigSchema = z.object({
+  allure: z.boolean(),
+  html: z.boolean(),
+  json: z.boolean()
+});
+var ViewportSchema = z.object({
+  width: z.number().int().positive(),
+  height: z.number().int().positive()
+});
+var EnvironmentProfileSchema = z.object({
+  name: z.string().min(1),
+  environment: EnvironmentSchema,
+  baseUrl: z.string().url(),
+  browsers: z.array(BrowserNameSchema).min(1),
+  headless: z.boolean().optional()
+});
+var AutotestConfigSchema = z.object({
+  baseUrl: z.string().url(),
+  environment: EnvironmentSchema.default("stage"),
+  environmentUrls: EnvironmentUrlsSchema.default({
+    dev: "",
+    stage: "",
+    test: "",
+    prod: ""
+  }),
+  browsers: z.array(BrowserNameSchema).min(1),
+  headless: z.boolean(),
+  viewport: ViewportSchema.default({ width: 1280, height: 720 }),
+  timeout: z.number().int().positive(),
+  retries: z.number().int().min(0),
+  parallel: z.number().int().positive(),
+  pageLoad: PageLoadStrategySchema.default("domcontentloaded"),
+  screenshot: ScreenshotModeSchema,
+  video: VideoModeSchema,
+  trace: TraceModeSchema,
+  healing: HealingConfigSchema,
+  reporting: ReportingConfigSchema,
+  studioPort: z.number().int().min(1024).max(65535),
+  profiles: z.array(EnvironmentProfileSchema).default([]),
+  activeProfile: z.string().optional(),
+  /** Playwright device descriptor name for emulation (e.g. 'iPhone 15 Pro'). */
+  device: 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
+import path2 from "path";
+import fs3 from "fs-extra";
+import { v4 as uuidv4 } from "uuid";
+
+// src/types/suite.ts
+import { z as z2 } from "zod";
+var TestStepSchema = z2.object({
+  id: z2.string().min(1),
+  order: z2.number().int().positive(),
+  instruction: z2.string().min(1),
+  generatedCode: z2.string(),
+  strategy: z2.enum(["template", "cache", "batch", "fast", "primary"]),
+  stepType: z2.enum(["ui", "api", "mock"]).default("ui"),
+  lastHealed: z2.string().nullable(),
+  timeout: z2.number().int().positive().optional(),
+  retries: z2.number().int().min(0).optional(),
+  mockUrl: z2.string().optional(),
+  mockResponse: z2.string().optional(),
+  mockStatus: z2.number().int().optional(),
+  runAudit: z2.boolean().optional()
+  // Mark this step as a Lighthouse audit checkpoint
+});
+var DataSourceSchema = z2.object({
+  type: z2.enum(["inline", "json-file", "csv-file"]),
+  path: z2.string().optional(),
+  data: z2.array(z2.record(z2.string())).optional()
+}).optional();
+var CaseHookStepSchema = z2.object({
+  id: z2.string(),
+  instruction: z2.string(),
+  generatedCode: z2.string().default(""),
+  order: z2.number().int().default(0)
+});
+var CaseHooksSchema = z2.object({
+  before: z2.array(CaseHookStepSchema).default([]),
+  after: z2.array(CaseHookStepSchema).default([])
+}).default({ before: [], after: [] });
+var TestCaseSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string(),
+  tags: z2.array(z2.string()),
+  priority: z2.enum(["critical", "high", "medium", "low"]),
+  timeout: z2.number().int().positive().optional(),
+  dataSource: DataSourceSchema,
+  steps: z2.array(TestStepSchema),
+  caseHooks: CaseHooksSchema,
+  lighthouseCategories: z2.array(z2.enum(["performance", "accessibility", "seo"])).default(["performance", "accessibility", "seo"]),
+  createdAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime()
+});
+var TestSuiteSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  description: z2.string(),
+  tags: z2.array(z2.string()),
+  type: z2.enum(["ui", "api", "audit", "performance"]).default("ui"),
+  timeout: z2.number().int().positive().optional(),
+  createdAt: z2.string().datetime(),
+  updatedAt: z2.string().datetime()
+});
+var HookTypeEnum = z2.enum(["before_all", "before_each", "after_each", "after_all"]);
+var SuiteHooksSchema = z2.object({
+  before_all: z2.array(TestStepSchema).default([]),
+  before_each: z2.array(TestStepSchema).default([]),
+  after_each: z2.array(TestStepSchema).default([]),
+  after_all: z2.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
+import pino from "pino";
+import fs from "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 = pino(
+  {
+    level: process.env["LOG_LEVEL"] ?? "info",
+    base: { name: "assuremind" }
+  },
+  transport ? pino.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
+import path from "path";
+import fs2 from "fs-extra";
+async function atomicWriteJson(filePath, data) {
+  const dir = path.dirname(filePath);
+  await fs2.ensureDir(dir);
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    await fs2.writeJson(tmpPath, data, { spaces: 2 });
+    await fs2.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs2.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 fs2.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 = path.dirname(filePath);
+  await fs2.ensureDir(dir);
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  try {
+    await fs2.writeFile(tmpPath, content, "utf8");
+    await fs2.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs2.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 = path2.join(suiteDir, SUITE_FILE);
+  if (!await fs3.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 = path2.basename(path2.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 fs3.ensureDir(suiteDir);
+  const filePath = path2.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: uuidv4(),
+    createdAt: now,
+    updatedAt: now
+  };
+  const targetDir = path2.join(testsDir, suiteType);
+  const suiteDir = path2.join(targetDir, toSlug(newSuite.name));
+  if (await fs3.pathExists(path2.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 fs3.pathExists(suiteDir)) {
+    throw new StorageError(
+      `Suite directory not found at "${suiteDir}".`,
+      suiteDir,
+      "SUITE_NOT_FOUND"
+    );
+  }
+  await fs3.remove(suiteDir);
+  logger2.info({ path: suiteDir }, "Suite deleted");
+}
+async function listSuiteDirs(testsDir) {
+  const suiteDirs = [];
+  const searchDirs = [
+    path2.join(testsDir, "ui"),
+    path2.join(testsDir, "api"),
+    path2.join(testsDir, "audit"),
+    path2.join(testsDir, "performance"),
+    // legacy: keep scanning for backward compat
+    testsDir
+    // legacy: suites at root level
+  ];
+  for (const baseDir of searchDirs) {
+    if (!await fs3.pathExists(baseDir)) continue;
+    const entries = await fs3.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 = path2.join(baseDir, entry.name, SUITE_FILE);
+      if (await fs3.pathExists(suiteFile)) {
+        suiteDirs.push(path2.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 fs3.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
+import path3 from "path";
+import fs4 from "fs-extra";
+import { v4 as uuidv42 } from "uuid";
+var logger3 = createChildLogger("case-store");
+var CASE_EXTENSION = ".test.json";
+async function readCase(casePath) {
+  if (!await fs4.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: uuidv42(),
+    createdAt: now,
+    updatedAt: now
+  };
+  const casePath = path3.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 fs4.pathExists(casePath)) {
+    throw new StorageError(
+      `Test case file not found at "${casePath}".`,
+      casePath,
+      "CASE_NOT_FOUND"
+    );
+  }
+  await fs4.remove(casePath);
+  logger3.info({ path: casePath }, "Test case deleted");
+}
+async function listCasePaths(suiteDir) {
+  if (!await fs4.pathExists(suiteDir)) return [];
+  const entries = await fs4.readdir(suiteDir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(CASE_EXTENSION)).map((e) => path3.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 path3.join(suiteDir, `${toSlug(caseName)}${CASE_EXTENSION}`);
+}
+
+// src/storage/variable-store.ts
+import path4 from "path";
+import fs5 from "fs-extra";
+
+// src/types/variable.ts
+import { z as z3 } from "zod";
+var SecretVariableSchema = z3.object({
+  value: z3.string(),
+  secret: z3.literal(true)
+});
+var VariableValueSchema = z3.union([z3.string(), SecretVariableSchema]);
+var VariableStoreSchema = z3.record(z3.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 fs5.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 = path4.join(rootDir, VARIABLES_DIR, GLOBAL_FILE);
+  return readVariables(filePath);
+}
+async function readEnvVariables(rootDir, env) {
+  const filePath = path4.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 = path4.join(rootDir, VARIABLES_DIR, GLOBAL_FILE);
+  await fs5.ensureDir(path4.dirname(filePath));
+  const existing = await readVariables(filePath);
+  existing[key] = value;
+  await writeVariables(filePath, existing);
+}
+async function deleteGlobalVariable(rootDir, key) {
+  const filePath = path4.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 = path4.join(rootDir, VARIABLES_DIR);
+  if (!await fs5.pathExists(dir)) return [];
+  const entries = await fs5.readdir(dir, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".json")).map((e) => path4.join(dir, e.name));
+}
+
+// src/storage/config-store.ts
+import path5 from "path";
+import fs6 from "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 = path5.join(rootDir, CONFIG_JSON);
+  if (!await fs6.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 = path5.join(rootDir, CONFIG_JSON);
+  await atomicWriteJson(jsonPath, result.data);
+  const tsPath = path5.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 = path5.join(rootDir, CONFIG_JSON);
+  const tsPath = path5.join(rootDir, CONFIG_TS);
+  return await fs6.pathExists(jsonPath) || await fs6.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
+import path6 from "path";
+import fs7 from "fs-extra";
+
+// src/types/run.ts
+import { z as z4 } from "zod";
+var RunStatusSchema = z4.enum(["pending", "running", "passed", "failed", "skipped"]);
+var ApiRequestSchema = z4.object({
+  method: z4.string(),
+  url: z4.string(),
+  headers: z4.record(z4.string()).optional(),
+  body: z4.string().optional()
+}).optional();
+var ApiResponseSchema = z4.object({
+  status: z4.number(),
+  statusText: z4.string(),
+  headers: z4.record(z4.string()).optional(),
+  body: z4.string().optional(),
+  duration: z4.number()
+}).optional();
+var optionalNum = z4.number().nullish().transform((v) => v ?? void 0);
+var AuditItemSchema = z4.object({
+  id: z4.string(),
+  title: z4.string(),
+  passed: z4.boolean(),
+  // true  = score === 1
+  partial: z4.boolean().optional(),
+  // true  = 0 < score < 1 (needs work)
+  na: z4.boolean().optional()
+  // true  = score === null (not applicable)
+});
+var PageLoadMetricSchema = z4.object({
+  url: z4.string(),
+  stepIndex: z4.number().int(),
+  stepInstruction: z4.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: z4.array(AuditItemSchema).optional(),
+  seoAudits: z4.array(AuditItemSchema).optional(),
+  lighthouseError: z4.string().optional()
+});
+var StepResultSchema = z4.object({
+  stepId: z4.string(),
+  instruction: z4.string(),
+  status: RunStatusSchema,
+  code: z4.string(),
+  error: z4.string().optional(),
+  duration: z4.number(),
+  screenshotPath: z4.string().optional(),
+  healed: z4.boolean().optional(),
+  healedCode: z4.string().optional(),
+  stepType: z4.enum(["ui", "api", "mock"]).optional(),
+  apiRequest: ApiRequestSchema,
+  apiResponse: ApiResponseSchema,
+  navigatedToUrl: z4.string().optional(),
+  auditUrl: z4.string().optional()
+  // URL captured when step has runAudit=true (may not have navigated)
+});
+var TestCaseResultSchema = z4.object({
+  caseId: z4.string(),
+  caseName: z4.string(),
+  status: RunStatusSchema,
+  steps: z4.array(StepResultSchema),
+  duration: z4.number(),
+  browser: z4.string(),
+  /** Playwright device descriptor used for this case (undefined = no emulation). */
+  device: z4.string().optional(),
+  startedAt: z4.string().datetime(),
+  finishedAt: z4.string().datetime(),
+  videoPath: z4.string().optional(),
+  tracePath: z4.string().optional(),
+  dataRowIndex: z4.number().int().optional(),
+  dataRow: z4.record(z4.string()).optional(),
+  pageLoads: z4.array(PageLoadMetricSchema).default([])
+});
+var SuiteResultSchema = z4.object({
+  suiteId: z4.string(),
+  suiteName: z4.string(),
+  suiteType: z4.enum(["ui", "api", "audit", "performance"]).optional(),
+  status: RunStatusSchema,
+  cases: z4.array(TestCaseResultSchema),
+  duration: z4.number(),
+  browser: z4.string(),
+  startedAt: z4.string().datetime(),
+  finishedAt: z4.string().datetime()
+});
+var RunResultSchema = z4.object({
+  runId: z4.string(),
+  status: RunStatusSchema,
+  environment: z4.string().optional(),
+  suites: z4.array(SuiteResultSchema),
+  duration: z4.number(),
+  startedAt: z4.string().datetime(),
+  finishedAt: z4.string().datetime(),
+  totalTests: z4.number().int(),
+  passed: z4.number().int(),
+  failed: z4.number().int(),
+  skipped: z4.number().int(),
+  logFilePath: z4.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 path6.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(path6.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(path6.join(rootDir, RESULTS_DIR), runId);
+  if (!await fs7.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 = path6.join(rootDir, RESULTS_DIR, RUNS_DIR);
+  if (!await fs7.pathExists(runsDir)) return [];
+  const entries = await fs7.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 fs7.stat(path6.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(path6.join(rootDir, RESULTS_DIR), runId);
+  if (!await fs7.pathExists(filePath)) {
+    throw new StorageError(
+      `Run result not found for runId "${runId}".`,
+      filePath,
+      "RESULT_NOT_FOUND"
+    );
+  }
+  await fs7.remove(filePath);
+  logger6.info({ runId }, "Run result deleted");
+}
+function screenshotsDir(rootDir) {
+  return path6.join(rootDir, RESULTS_DIR, "screenshots");
+}
+function videosDir(rootDir) {
+  return path6.join(rootDir, RESULTS_DIR, "videos");
+}
+function tracesDir(rootDir) {
+  return path6.join(rootDir, RESULTS_DIR, "traces");
+}
+
+// src/storage/healing-store.ts
+import path7 from "path";
+import fs8 from "fs-extra";
+
+// src/types/healing.ts
+import { z as z5 } from "zod";
+var HealingStatusSchema = z5.enum(["pending", "accepted", "rejected"]);
+var HealingStrategySchema = z5.enum([
+  "retry",
+  "regenerate",
+  "multi-selector",
+  "visual",
+  "decompose",
+  "manual"
+]);
+var HealingEventSchema = z5.object({
+  id: z5.string(),
+  runId: z5.string(),
+  suiteId: z5.string(),
+  caseId: z5.string(),
+  stepId: z5.string(),
+  stepInstruction: z5.string(),
+  failedCode: z5.string(),
+  healedCode: z5.string(),
+  error: z5.string(),
+  strategy: HealingStrategySchema,
+  level: z5.number().int().min(1).max(6),
+  status: HealingStatusSchema,
+  pageUrl: z5.string(),
+  timestamp: z5.string().datetime(),
+  acceptedAt: z5.string().datetime().optional(),
+  rejectedAt: z5.string().datetime().optional()
+});
+var HealingReportSchema = z5.object({
+  runId: z5.string(),
+  generatedAt: z5.string().datetime(),
+  totalHeals: z5.number().int(),
+  accepted: z5.number().int(),
+  rejected: z5.number().int(),
+  pending: z5.number().int(),
+  events: z5.array(HealingEventSchema)
+});
+
+// src/storage/healing-store.ts
+var logger7 = createChildLogger("healing-store");
+var HEALING_DIR = path7.join("results", "healing");
+var PENDING_FILE = "pending.json";
+var REPORT_PREFIX = "healing-report-";
+function reportFilePath(healingDir, runId) {
+  return path7.join(healingDir, `${REPORT_PREFIX}${runId}.json`);
+}
+function pendingFilePath(healingDir) {
+  return path7.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 = path7.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 = path7.join(rootDir, HEALING_DIR);
+  const filePath = reportFilePath(healingDir, runId);
+  if (!await fs8.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 = path7.join(rootDir, HEALING_DIR);
+  const filePath = pendingFilePath(healingDir);
+  if (!await fs8.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 = path7.join(rootDir, HEALING_DIR);
+  await fs8.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 = path7.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 = path7.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 = path7.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 = path7.join(rootDir, HEALING_DIR);
+  if (!await fs8.pathExists(healingDir)) return [];
+  const entries = await fs8.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 fs8.stat(path7.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
+import { createHash } from "crypto";
+function sha256(input) {
+  return 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
+import { config as loadDotenv } from "dotenv";
+import { z as z6 } from "zod";
+loadDotenv();
+var AI_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "google",
+  "azure-openai",
+  "bedrock",
+  "deepseek",
+  "groq",
+  "together",
+  "qwen",
+  "perplexity",
+  "ollama",
+  "custom"
+];
+var BaseEnvSchema = z6.object({
+  NODE_ENV: z6.enum(["development", "production", "test"]).default("development"),
+  LOG_LEVEL: z6.enum(["trace", "debug", "info", "warn", "error", "fatal"]).default("info"),
+  AI_PROVIDER: z6.enum(AI_PROVIDERS),
+  AI_TIERED_ENABLED: z6.string().transform((v) => v === "true").default("false"),
+  AI_TIERED_FAST_PROVIDER: z6.enum(AI_PROVIDERS).optional(),
+  AI_TIERED_FAST_MODEL: z6.string().optional(),
+  AI_TIMEOUT: z6.coerce.number().int().positive().default(30),
+  AI_MAX_RETRIES: z6.coerce.number().int().min(0).max(10).default(2)
+});
+var AnthropicEnvSchema = z6.object({
+  ANTHROPIC_API_KEY: z6.string().min(1),
+  ANTHROPIC_MODEL: z6.string().default("claude-sonnet-4-20250514")
+});
+var OpenAIEnvSchema = z6.object({
+  OPENAI_API_KEY: z6.string().min(1),
+  OPENAI_MODEL: z6.string().default("gpt-4o")
+});
+var GoogleEnvSchema = z6.object({
+  GOOGLE_API_KEY: z6.string().min(1),
+  GOOGLE_MODEL: z6.string().default("gemini-2.5-pro")
+});
+var AzureOpenAIEnvSchema = z6.object({
+  AZURE_OPENAI_API_KEY: z6.string().min(1),
+  AZURE_OPENAI_ENDPOINT: z6.string().url(),
+  AZURE_OPENAI_DEPLOYMENT: z6.string().min(1),
+  AZURE_OPENAI_API_VERSION: z6.string().default("2024-10-21")
+});
+var BedrockEnvSchema = z6.object({
+  AWS_ACCESS_KEY_ID: z6.string().min(1),
+  AWS_SECRET_ACCESS_KEY: z6.string().min(1),
+  AWS_SESSION_TOKEN: z6.string().optional(),
+  AWS_REGION: z6.string().default("us-east-1"),
+  BEDROCK_MODEL: z6.string().default("anthropic.claude-sonnet-4-20250514-v1:0")
+});
+var DeepSeekEnvSchema = z6.object({
+  DEEPSEEK_API_KEY: z6.string().min(1),
+  DEEPSEEK_MODEL: z6.string().default("deepseek-chat")
+});
+var GroqEnvSchema = z6.object({
+  GROQ_API_KEY: z6.string().min(1),
+  GROQ_MODEL: z6.string().default("llama-3.3-70b-versatile")
+});
+var TogetherEnvSchema = z6.object({
+  TOGETHER_API_KEY: z6.string().min(1),
+  TOGETHER_MODEL: z6.string().default("meta-llama/Llama-3.3-70B-Instruct-Turbo")
+});
+var QwenEnvSchema = z6.object({
+  QWEN_API_KEY: z6.string().min(1),
+  QWEN_BASE_URL: z6.string().url().default("https://dashscope-intl.aliyuncs.com/compatible-mode/v1"),
+  QWEN_MODEL: z6.string().default("qwen-max")
+});
+var PerplexityEnvSchema = z6.object({
+  PERPLEXITY_API_KEY: z6.string().min(1),
+  PERPLEXITY_MODEL: z6.string().default("sonar-pro")
+});
+var OllamaEnvSchema = z6.object({
+  OLLAMA_BASE_URL: z6.string().url().default("http://localhost:11434"),
+  OLLAMA_MODEL: z6.string().default("llama3.3")
+});
+var CustomEnvSchema = z6.object({
+  CUSTOM_API_KEY: z6.string().min(1),
+  CUSTOM_BASE_URL: z6.string().url(),
+  CUSTOM_MODEL: z6.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;
+}
+export {
+  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.mjs.map