@testsmith/api-spector 0.3.1 → 0.3.3

package/out/main/index.js

@@ -22,11 +22,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 const electron = require("electron");
+const handle = require("./chunks/handle-C0IQL-Vl.js");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestCollection = require("./chunks/request-collection-d2vgYls1.js");
-const authBuilder = require("./chunks/auth-builder-CRQayp8x.js");
+const requestCollection = require("./chunks/request-collection-8TOVNXE0.js");
+const authBuilder = require("./chunks/auth-builder-CUs9yzOF.js");
+const ipcValidate = require("./chunks/ipc-validate-k6KI8adf.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
@@ -34,11 +36,10 @@ const JSZip = require("jszip");
 const mockServer = require("./chunks/mock-server-DSLR2ulH.js");
 const http = require("http");
 const WebSocket = require("ws");
-const soapHandler = require("./chunks/soap-handler-Cpj-JwyA.js");
+const soapHandler = require("./chunks/soap-handler-B9x_YCtj.js");
 const os = require("os");
 const crypto = require("crypto");
-const snapshots = require("./chunks/snapshots-CQliv7WB.js");
-const ipcValidate = require("./chunks/ipc-validate-CscN4HfG.js");
+const snapshots = require("./chunks/snapshots-UFd3XgSS.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-DFxJgn9c.js");
 require("vm");
@@ -211,7 +212,7 @@ function defaultWorkspaceName() {
   return "my-workspace.spector";
 }
 function registerFileHandlers(ipc) {
-  ipc.handle("file:openWorkspace", async () => {
+  handle.handleIpc(ipc, handle.IPC.file.openWorkspace, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Open Workspace",
       defaultPath: dialogStartDir(),
@@ -227,7 +228,7 @@ function registerFileHandlers(ipc) {
     const raw = await promises.readFile(wsPath, "utf8");
     return { workspace: JSON.parse(raw), workspacePath: wsPath };
   });
-  ipc.handle("file:newWorkspace", async () => {
+  handle.handleIpc(ipc, handle.IPC.file.newWorkspace, async () => {
     const startDir = dialogStartDir();
     const defaultPath = startDir ? path.join(startDir, defaultWorkspaceName()) : defaultWorkspaceName();
     const result = await electron.dialog.showSaveDialog({
@@ -254,34 +255,34 @@ function registerFileHandlers(ipc) {
     await saveLastWorkspacePath(result.filePath);
     return { workspace: ws, workspacePath: result.filePath };
   });
-  ipc.handle("file:saveWorkspace", async (_e, ws) => {
+  handle.handleIpc(ipc, handle.IPC.file.saveWorkspace, async (_e, ws) => {
     if (!workspaceFile) return;
     await atomicWrite(workspaceFile, JSON.stringify(ws, null, 2));
     if (workspaceDir) await ensureVscodeFileAssociation(workspaceDir);
   });
-  ipc.handle("file:loadCollection", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.file.loadCollection, async (_e, relPath) => {
     if (!workspaceDir) throw new Error("No workspace open");
     const raw = await promises.readFile(path.resolve(workspaceDir, relPath), "utf8");
     return JSON.parse(raw);
   });
-  ipc.handle("file:saveCollection", async (_e, relPath, col) => {
+  handle.handleIpc(ipc, handle.IPC.file.saveCollection, async (_e, relPath, col) => {
     if (!workspaceDir) throw new Error("No workspace open");
     const fullPath = path.resolve(workspaceDir, relPath);
     await promises.mkdir(path.dirname(fullPath), { recursive: true });
     await atomicWrite(fullPath, JSON.stringify(col, null, 2));
   });
-  ipc.handle("file:loadEnvironment", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.file.loadEnvironment, async (_e, relPath) => {
     if (!workspaceDir) throw new Error("No workspace open");
     const raw = await promises.readFile(path.resolve(workspaceDir, relPath), "utf8");
     return JSON.parse(raw);
   });
-  ipc.handle("file:saveEnvironment", async (_e, relPath, env) => {
+  handle.handleIpc(ipc, handle.IPC.file.saveEnvironment, async (_e, relPath, env) => {
     if (!workspaceDir) throw new Error("No workspace open");
     const fullPath = path.resolve(workspaceDir, relPath);
     await promises.mkdir(path.dirname(fullPath), { recursive: true });
     await atomicWrite(fullPath, JSON.stringify(env, null, 2));
   });
-  ipc.handle("file:deleteWorkspaceFile", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.file.deleteWorkspaceFile, async (_e, relPath) => {
     if (!workspaceDir) throw new Error("No workspace open");
     const fullPath = path.resolve(workspaceDir, relPath);
     if (!fullPath.startsWith(path.resolve(workspaceDir) + (process.platform === "win32" ? "\\" : "/"))) {
@@ -293,14 +294,14 @@ function registerFileHandlers(ipc) {
       if (err.code !== "ENOENT") throw err;
     }
   });
-  ipc.handle("dialog:pickDir", async () => {
+  handle.handleIpc(ipc, handle.IPC.dialog.pickDir, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Select Output Directory",
       properties: ["openDirectory", "createDirectory"]
     });
     return result.canceled ? null : result.filePaths[0];
   });
-  ipc.handle("results:save", async (_e, content, defaultName) => {
+  handle.handleIpc(ipc, handle.IPC.results.save, async (_e, content, defaultName) => {
     const ext = defaultName.endsWith(".xml") ? "xml" : defaultName.endsWith(".html") ? "html" : "json";
     const allFilters = [
       { name: "JSON", extensions: ["json"] },
@@ -316,19 +317,19 @@ function registerFileHandlers(ipc) {
     await promises.writeFile(result.filePath, content, "utf8");
     return true;
   });
-  ipc.handle("globals:get", () => requestCollection.getGlobals());
-  ipc.handle("globals:set", async (_e, patch) => {
+  handle.handleIpc(ipc, handle.IPC.globals.get, () => requestCollection.getGlobals());
+  handle.handleIpc(ipc, handle.IPC.globals.set, async (_e, patch) => {
     requestCollection.setGlobals(patch);
     await requestCollection.persistGlobals();
   });
-  ipc.handle("file:closeWorkspace", async () => {
+  handle.handleIpc(ipc, handle.IPC.file.closeWorkspace, async () => {
     workspaceDir = null;
     workspaceFile = null;
     await promises.writeFile(LAST_WS_FILE, JSON.stringify({ path: null }), "utf8").catch((err) => {
       console.warn("file-handler: could not clear last-workspace pointer", err);
     });
   });
-  ipc.handle("file:getLastWorkspace", async () => {
+  handle.handleIpc(ipc, handle.IPC.file.getLastWorkspace, async () => {
     const cwd = process.env.API_SPECTOR_LAUNCH_CWD;
     if (cwd) {
       const fromCwd = await tryOpenWorkspaceInDir(cwd);
@@ -372,6 +373,255 @@ async function tryOpenWorkspaceInDir(dir) {
 function getWorkspaceDir() {
   return workspaceDir;
 }
+function asObject(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function readStringField(obj, key) {
+  const value = obj?.[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function safeProxySummary(proxy) {
+  if (!proxy?.url?.trim()) return "off";
+  try {
+    const normalized = requestCollection.buildProxyUri({ url: proxy.url });
+    const parsed = new URL(normalized);
+    const host = parsed.port ? `${parsed.hostname}:${parsed.port}` : parsed.hostname;
+    const auth = proxy.auth ? "yes" : "no";
+    return `${parsed.protocol}//${host} auth=${auth}`;
+  } catch {
+    return `invalid input "${proxy.url}"`;
+  }
+}
+function safeTlsSummary(tls) {
+  if (!tls) return "off";
+  const parts = [];
+  if (tls.rejectUnauthorized !== void 0) parts.push(`rejectUnauthorized=${String(tls.rejectUnauthorized)}`);
+  if (tls.caCertPath) parts.push(`ca=${tls.caCertPath}`);
+  if (tls.clientCertPath) parts.push(`cert=${tls.clientCertPath}`);
+  if (tls.clientKeyPath) parts.push(`key=${tls.clientKeyPath}`);
+  return parts.length ? parts.join(", ") : "on";
+}
+function formatRequestError(err, context) {
+  const obj = asObject(err);
+  const message = err instanceof Error ? err.message : String(err);
+  const code = readStringField(obj, "code");
+  const stack = err instanceof Error ? err.stack : void 0;
+  const causeObj = obj ? asObject(obj["cause"]) : null;
+  const causeMessage = readStringField(causeObj, "message");
+  const causeCode = readStringField(causeObj, "code");
+  const lines = [
+    `[request:send] ${context.method} ${context.resolvedUrl}`,
+    `[request:send] requestId=${context.requestId}`,
+    `[request:send] proxy=${safeProxySummary(context.proxy)}`,
+    `[request:send] tls=${safeTlsSummary(context.tls)}`,
+    `[request:send] error=${message}${code ? ` (code=${code})` : ""}`
+  ];
+  if (causeMessage) {
+    lines.push(`[request:send] cause=${causeMessage}${causeCode ? ` (code=${causeCode})` : ""}`);
+  }
+  if (stack) {
+    const preview = stack.split("\n").slice(0, 6).join("\n");
+    lines.push("[request:send] stack:");
+    lines.push(preview);
+  }
+  return lines.join("\n");
+}
+function registerRequestHandler(ipc) {
+  handle.handleIpc(ipc, handle.IPC.request.send, async (_e, payload) => {
+    ipcValidate.validateSendRequestPayload(payload);
+    const {
+      request: req,
+      environment,
+      collectionVars,
+      globals: payloadGlobals,
+      proxy,
+      tls,
+      piiMaskPatterns = []
+    } = payload;
+    requestCollection.applyRequestDefaults(req);
+    const start = Date.now();
+    const liveGlobals = requestCollection.getGlobals();
+    const mergedGlobals = { ...payloadGlobals, ...liveGlobals };
+    const envVars = await authBuilder.buildEnvVars(environment);
+    let localVars = {};
+    const decryptionWarnings = [];
+    if (environment) {
+      const masterKeySet = Boolean(process.env["API_SPECTOR_MASTER_KEY"]);
+      for (const v of environment.variables) {
+        if (!v.enabled || !v.secret || !v.secretEncrypted) continue;
+        if (!masterKeySet) {
+          decryptionWarnings.push(`[warn] Secret "${v.key}" was not decrypted: API_SPECTOR_MASTER_KEY is not set. Use the master password modal or export the variable in your shell.`);
+        } else if (envVars[v.key] === void 0) {
+          decryptionWarnings.push(`[warn] Secret "${v.key}" could not be decrypted: wrong password or corrupted data.`);
+        }
+      }
+    }
+    const dynamicVars = await authBuilder.buildDynamicVars();
+    let vars = authBuilder.mergeVars(envVars, collectionVars, mergedGlobals, localVars, dynamicVars);
+    let preScriptMeta = { consoleOutput: [] };
+    let updatedCollectionVars = { ...collectionVars };
+    let updatedEnvVars = { ...envVars };
+    let updatedGlobals = { ...mergedGlobals };
+    if (req.preRequestScript?.trim()) {
+      const result = await requestCollection.runScript(authBuilder.interpolate(req.preRequestScript, vars), {
+        envVars: { ...envVars },
+        collectionVars: { ...collectionVars },
+        globals: { ...mergedGlobals },
+        localVars: {}
+      });
+      preScriptMeta = { error: result.error, consoleOutput: result.consoleOutput };
+      localVars = result.updatedLocalVars;
+      updatedEnvVars = result.updatedEnvVars;
+      updatedCollectionVars = result.updatedCollectionVars;
+      updatedGlobals = result.updatedGlobals;
+      requestCollection.patchGlobals(result.updatedGlobals);
+      await requestCollection.persistGlobals();
+      vars = authBuilder.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
+    }
+    let response;
+    let scriptResponse;
+    let sentRequest = { method: req.method, url: "", headers: {} };
+    const resolvedUrl = authBuilder.buildUrl(req.url, req.params, vars);
+    const secretValues = /* @__PURE__ */ new Set();
+    if (environment) {
+      for (const v of environment.variables) {
+        if (!v.enabled) continue;
+        if ((v.secret || v.envRef) && envVars[v.key]) {
+          secretValues.add(envVars[v.key]);
+        }
+      }
+    }
+    function redactSecrets(s) {
+      if (!secretValues.size) return s;
+      let result = s;
+      for (const secret of secretValues) {
+        if (secret) result = result.split(secret).join("[*****]");
+      }
+      return result;
+    }
+    function redactSentRequest(sr) {
+      const headers = {};
+      for (const [k, v] of Object.entries(sr.headers)) {
+        headers[k] = redactSecrets(v);
+      }
+      return {
+        method: sr.method,
+        url: redactSecrets(sr.url),
+        headers,
+        body: sr.body !== void 0 ? redactSecrets(sr.body) : void 0
+      };
+    }
+    try {
+      const dispatcher = await requestCollection.buildDispatcher(proxy, tls);
+      const exchange = await requestCollection.performHttpExchange({
+        req,
+        vars,
+        resolvedUrl,
+        dispatcher,
+        proxy,
+        tls,
+        onSent: (sent) => {
+          sentRequest = sent;
+        }
+      });
+      const maskedBody = requestCollection.maskPii(exchange.responseBody, piiMaskPatterns);
+      const maskedHeaders = requestCollection.maskHeaders(exchange.rawHeaders, piiMaskPatterns);
+      const bodySize = Buffer.byteLength(exchange.responseBody, "utf8");
+      response = {
+        status: exchange.status,
+        statusText: exchange.statusText,
+        headers: maskedHeaders,
+        body: maskedBody,
+        bodySize,
+        durationMs: exchange.durationMs
+      };
+      scriptResponse = {
+        status: exchange.status,
+        statusText: exchange.statusText,
+        headers: exchange.rawHeaders,
+        body: exchange.responseBody,
+        bodySize,
+        durationMs: exchange.durationMs
+      };
+    } catch (err) {
+      const diagnostic = formatRequestError(err, {
+        requestId: req.id,
+        method: req.method,
+        resolvedUrl,
+        proxy,
+        tls
+      });
+      console.error(diagnostic);
+      response = {
+        status: 0,
+        statusText: "Error",
+        headers: {},
+        body: "",
+        bodySize: 0,
+        durationMs: Date.now() - start,
+        error: diagnostic
+      };
+      scriptResponse = response;
+    }
+    const schemaTestResults = !response.error ? requestCollection.buildSchemaTestResults(req.schema, scriptResponse.body) : [];
+    let postTestResults = [];
+    let postConsole = [];
+    let postError;
+    if (req.postRequestScript?.trim() && !response.error) {
+      const result = await requestCollection.runScript(authBuilder.interpolate(req.postRequestScript, vars), {
+        envVars: { ...updatedEnvVars },
+        collectionVars: { ...updatedCollectionVars },
+        globals: { ...updatedGlobals },
+        localVars: { ...localVars },
+        // Pass the *unmasked* response so the script can extract real values
+        // (tokens, ids, …). The displayed `response` keeps the redacted copy.
+        response: scriptResponse
+      });
+      postTestResults = result.testResults;
+      postConsole = result.consoleOutput;
+      postError = result.error;
+      updatedEnvVars = result.updatedEnvVars;
+      updatedCollectionVars = result.updatedCollectionVars;
+      updatedGlobals = result.updatedGlobals;
+      localVars = result.updatedLocalVars;
+      requestCollection.patchGlobals(result.updatedGlobals);
+      await requestCollection.persistGlobals();
+    }
+    const combinedTestResults = [...schemaTestResults, ...postTestResults];
+    if (!response.error && response.status >= 400 && combinedTestResults.length === 0) {
+      combinedTestResults.push({
+        name: `HTTP status ${response.status} ${response.statusText}`.trim(),
+        passed: false,
+        error: `Request returned ${response.status} — no assertion was defined to verify the status code.`
+      });
+    }
+    const scriptResult = {
+      testResults: combinedTestResults,
+      consoleOutput: [...decryptionWarnings, ...preScriptMeta.consoleOutput, ...postConsole],
+      updatedEnvVars,
+      updatedCollectionVars,
+      updatedGlobals,
+      updatedLocalVars: localVars,
+      resolvedUrl,
+      preScriptError: preScriptMeta.error,
+      postScriptError: postError
+    };
+    return { response, scriptResult, sentRequest: redactSentRequest(sentRequest) };
+  });
+  handle.handleIpc(ipc, handle.IPC.script.runHook, async (_e, payload) => {
+    const { script, envVars, collectionVars, globals } = payload;
+    const result = await requestCollection.runScript(script, { envVars, collectionVars, globals, localVars: {} });
+    requestCollection.patchGlobals(result.updatedGlobals);
+    await requestCollection.persistGlobals();
+    return {
+      updatedEnvVars: result.updatedEnvVars,
+      updatedCollectionVars: result.updatedCollectionVars,
+      updatedGlobals: result.updatedGlobals,
+      consoleOutput: result.consoleOutput,
+      error: result.error
+    };
+  });
+}
 const POSTMAN_RULES = [
   // Variables — environment
   [/\bpm\.environment\.get\(/g, "sp.environment.get("],
@@ -1125,8 +1375,160 @@ async function importBruno(filePath) {
     requests
   };
 }
+const METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+const HTTP_TO_SPECTOR = {
+  $guid: "$uuid",
+  $randomInt: "$randomInt",
+  $timestamp: "$timestamp",
+  $datetime: "$isoTimestamp",
+  $localDatetime: "$isoTimestamp"
+};
+const SPECTOR_TO_HTTP = {
+  $uuid: "$guid",
+  $randomInt: "$randomInt",
+  $timestamp: "$timestamp",
+  $isoTimestamp: "$datetime iso8601"
+};
+function mapDynamicVars(s) {
+  return s.replace(/\{\{\s*(\$[A-Za-z]+)[^}]*\}\}/g, (_m, name) => `{{${HTTP_TO_SPECTOR[name] ?? name}}}`);
+}
+function contentTypeOf(headers) {
+  return headers.find((h) => h.key.toLowerCase() === "content-type")?.value.toLowerCase() ?? "";
+}
+function toRequestBody(bodyText, headers) {
+  if (!bodyText.trim()) return { mode: "none" };
+  const ct = contentTypeOf(headers);
+  if (ct.includes("json") || !ct && /^\s*[[{]/.test(bodyText)) {
+    return { mode: "json", json: bodyText };
+  }
+  if (ct.includes("graphql")) {
+    return { mode: "graphql", graphql: { query: bodyText, variables: "{}" } };
+  }
+  if (ct.includes("x-www-form-urlencoded")) {
+    const form = bodyText.split("&").filter(Boolean).map((pair) => {
+      const [k, v = ""] = pair.split("=");
+      return { key: decodeURIComponent(k.trim()), value: decodeURIComponent(v.trim()), enabled: true };
+    });
+    return { mode: "form", form };
+  }
+  return { mode: "raw", raw: bodyText, rawContentType: ct || "text/plain" };
+}
+function extractAuth(headers) {
+  const authHeader = headers.find((h) => h.key.toLowerCase() === "authorization");
+  if (authHeader) {
+    const bearer = /^Bearer\s+(.+)$/i.exec(authHeader.value.trim());
+    if (bearer) {
+      return {
+        headers: headers.filter((h) => h !== authHeader),
+        auth: { type: "bearer", token: bearer[1].trim() }
+      };
+    }
+  }
+  return { headers, auth: { type: "none" } };
+}
+function stripScriptBlocks(bodyLines2) {
+  const joined = bodyLines2.join("\n");
+  return joined.replace(/[<>]\s*\{%[\s\S]*?%\}/g, "").replace(/^\s*>\s+\S.*$/gm, "").replace(/^\s*<\s+\S.*$/gm, "").trim();
+}
+function splitBlocks(text) {
+  const blocks = [];
+  let current = null;
+  for (const raw of text.split(/\r?\n/)) {
+    const sep = /^###\s*(.*)$/.exec(raw);
+    if (sep) {
+      current = { label: sep[1].trim() || void 0, lines: [] };
+      blocks.push(current);
+    } else if (current) {
+      current.lines.push(raw);
+    } else {
+      current = { lines: [raw] };
+      blocks.push(current);
+    }
+  }
+  return blocks;
+}
+function parseBlock(block) {
+  const { lines } = block;
+  let name = block.label;
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const t = lines[i].trim();
+    if (!t) continue;
+    const named = /^(?:#|\/\/)\s*@name\s*=?\s*(.+)$/.exec(t);
+    if (named) {
+      name = named[1].trim();
+      continue;
+    }
+    if (t.startsWith("#") || t.startsWith("//")) continue;
+    if (/^@[A-Za-z0-9_]+\s*=/.test(t)) continue;
+    break;
+  }
+  if (i >= lines.length) return null;
+  const requestLine = lines[i++].trim();
+  const rm = new RegExp(`^(?:(${METHODS.join("|")})\\s+)?(\\S.*?)(?:\\s+HTTP/[\\d.]+)?$`, "i").exec(requestLine);
+  if (!rm) return null;
+  const method = (rm[1] ?? "GET").toUpperCase();
+  let url = rm[2].trim();
+  const rawHeaders = [];
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i++;
+      break;
+    }
+    if (/^\s*[?&]/.test(line)) {
+      url += line.trim();
+      continue;
+    }
+    const h = /^([^:\s][^:]*):\s*(.*)$/.exec(line);
+    if (h) rawHeaders.push({ key: h[1].trim(), value: mapDynamicVars(h[2].trim()), enabled: true });
+  }
+  const bodyText = mapDynamicVars(stripScriptBlocks(lines.slice(i)));
+  const { headers, auth } = extractAuth(rawHeaders);
+  const body = toRequestBody(bodyText, headers);
+  return {
+    id: uuid.v4(),
+    name: name ?? `${method} ${url}`,
+    method,
+    url: mapDynamicVars(url),
+    headers,
+    params: [],
+    auth,
+    body,
+    meta: { tags: ["http-file"] }
+  };
+}
+function parseHttpFile(text, name) {
+  const collectionVariables = {};
+  for (const line of text.split(/\r?\n/)) {
+    const m = /^@([A-Za-z0-9_]+)\s*=\s*(.*)$/.exec(line);
+    if (m) collectionVariables[m[1]] = mapDynamicVars(m[2].trim());
+  }
+  const rootFolder = { id: uuid.v4(), name: "root", description: "", folders: [], requestIds: [] };
+  const requests = {};
+  for (const block of splitBlocks(text)) {
+    const req = parseBlock(block);
+    if (!req) continue;
+    requests[req.id] = req;
+    rootFolder.requestIds.push(req.id);
+  }
+  return {
+    version: "1.0",
+    id: uuid.v4(),
+    name,
+    description: "",
+    rootFolder,
+    requests,
+    ...Object.keys(collectionVariables).length ? { collectionVariables } : {}
+  };
+}
+async function importHttpFile(filePath) {
+  const raw = await promises.readFile(filePath, "utf8");
+  const name = path.basename(filePath).replace(/\.(http|rest)$/i, "") || "Imported HTTP";
+  return parseHttpFile(raw, name);
+}
 function registerImportHandlers(ipc) {
-  ipc.handle("import:postman", async () => {
+  handle.handleIpc(ipc, handle.IPC.import.postman, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Import Postman Collection",
       filters: [{ name: "JSON", extensions: ["json"] }],
@@ -1135,7 +1537,7 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importPostman(result.filePaths[0]);
   });
-  ipc.handle("import:openapi", async () => {
+  handle.handleIpc(ipc, handle.IPC.import.openapi, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Import OpenAPI Definition",
       filters: [{ name: "OpenAPI", extensions: ["json", "yaml", "yml"] }],
@@ -1144,10 +1546,10 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importOpenApi(result.filePaths[0]);
   });
-  ipc.handle("import:openapi-url", async (_event, url) => {
+  handle.handleIpc(ipc, handle.IPC.import.openapiUrl, async (_event, url) => {
     return importOpenApiFromUrl(url);
   });
-  ipc.handle("import:insomnia", async () => {
+  handle.handleIpc(ipc, handle.IPC.import.insomnia, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Import Insomnia Collection",
       filters: [{ name: "JSON", extensions: ["json"] }],
@@ -1156,7 +1558,7 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importInsomnia(result.filePaths[0]);
   });
-  ipc.handle("import:bruno", async () => {
+  handle.handleIpc(ipc, handle.IPC.import.bruno, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Import Bruno Collection",
       filters: [{ name: "Bruno Collection", extensions: ["json"] }],
@@ -1165,7 +1567,16 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importBruno(result.filePaths[0]);
   });
-  ipc.handle("import:openapi-schemas", async () => {
+  handle.handleIpc(ipc, handle.IPC.import.http, async () => {
+    const result = await electron.dialog.showOpenDialog({
+      title: "Import .http / .rest file",
+      filters: [{ name: "HTTP file", extensions: ["http", "rest"] }],
+      properties: ["openFile"]
+    });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return importHttpFile(result.filePaths[0]);
+  });
+  handle.handleIpc(ipc, handle.IPC.import.openapiSchemas, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Load OpenAPI spec for schema sync",
       filters: [{ name: "OpenAPI", extensions: ["json", "yaml", "yml"] }],
@@ -1174,7 +1585,7 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return extractSchemasFromFile(result.filePaths[0]);
   });
-  ipc.handle("import:openapi-schemas-url", async (_event, url) => {
+  handle.handleIpc(ipc, handle.IPC.import.openapiSchemasUrl, async (_event, url) => {
     return extractSchemasFromUrl(url);
   });
 }
@@ -1232,6 +1643,97 @@ function parsePostScript(script) {
 function accessorToJsonPath(accessor) {
   return accessor.replace(/^json\.?/, "").replace(/\["([^"]+)"\]/g, "['$1']");
 }
+function slug(name) {
+  return name.replace(/\W+/g, "-").toLowerCase().replace(/^-|-$/g, "");
+}
+function toEnvVar(key) {
+  return key.replace(/\W+/g, "_").toUpperCase();
+}
+function interpolateEnvVars(value, sharedVars = /* @__PURE__ */ new Set()) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const envKey = toEnvVar(key.trim());
+    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
+  });
+}
+function renderJsValue(value, indent, sharedVars = /* @__PURE__ */ new Set()) {
+  const next = indent + "  ";
+  if (value === null) return "null";
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    if (value.includes("{{")) {
+      return "`" + interpolateEnvVars(value, sharedVars) + "`";
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    if (!value.length) return "[]";
+    return `[
+${value.map((v) => next + renderJsValue(v, next, sharedVars)).join(",\n")},
+${indent}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (!entries.length) return "{}";
+    return `{
+${entries.map(([k, v]) => `${next}${k}: ${renderJsValue(v, next, sharedVars)}`).join(",\n")},
+${indent}}`;
+  }
+  return JSON.stringify(value);
+}
+function buildNameMap$1(folder, requests) {
+  const map = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const id of folder.requestIds) {
+    const req = requests[id];
+    if (!req) continue;
+    const base = req.name;
+    let name = base;
+    if (used.has(name)) {
+      let i = 2;
+      while (used.has(`${base} ${i}`)) i++;
+      name = `${base} ${i}`;
+    }
+    used.add(name);
+    map.set(id, name);
+  }
+  return map;
+}
+function javaClass(name) {
+  return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function resolveEffectiveAuth(req, inherited) {
+  return req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+}
+function mergeHeaders(req, inherited) {
+  return [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+}
+function hasBody(req) {
+  return req.body.mode !== "none" && !["get", "head"].includes(req.method.toLowerCase());
+}
+function getEnvBaseUrl(environment, fallback) {
+  return environment?.variables.find(
+    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
+  )?.value ?? fallback;
+}
+function renderTree(paths) {
+  const root = {};
+  for (const p of [...paths].sort()) {
+    let cur = root;
+    for (const part of p.split("/")) {
+      cur = cur[part] ??= {};
+    }
+  }
+  function render(node, prefix = "") {
+    const entries = Object.entries(node);
+    return entries.flatMap(([name, children], i) => {
+      const last = i === entries.length - 1;
+      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
+      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
+      return lines;
+    });
+  }
+  return [".", ...render(root)].join("\n");
+}
 function safeName(name) {
   return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
@@ -1247,7 +1749,7 @@ function interpolate(value, vars) {
     return v?.secret ? envVar(key.trim()) : robotVar(key.trim());
   });
 }
-function buildNameMap$2(root, requests) {
+function buildNameMap(root, requests) {
   const map = /* @__PURE__ */ new Map();
   const used = /* @__PURE__ */ new Set();
   function visit(folder) {
@@ -1317,8 +1819,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
       lines.push(kwName);
       lines.push(`    [Documentation]    Hook: ${req.hookType} — ${req.name}`);
       const { body } = req;
-      const hasBody = body.mode !== "none" && !["GET", "HEAD"].includes(req.method);
-      if (hasBody && body.mode === "json" && body.json) {
+      if (hasBody(req) && body.mode === "json" && body.json) {
         const bodyPairs = jsonToRfDictPairs(body.json, varMap);
         if (bodyPairs !== null) {
           lines.push(`    VAR    &{body}    ${bodyPairs}`);
@@ -1327,7 +1828,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
         }
       }
       const callArgs = [];
-      if (hasBody && body.mode === "json") callArgs.push("json=${body}");
+      if (hasBody(req) && body.mode === "json") callArgs.push("json=${body}");
       lines.push(`    \${response}=    ${method}    ${url}`);
       if (callArgs.length) lines.push(`    ...    ${callArgs.join("    ")}`);
       const parsed = parsePostScript(req.postRequestScript);
@@ -1353,8 +1854,8 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
       lines.push(kwName);
       lines.push(`    [Documentation]    ${req.description || req.name}`);
       const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-      const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-      const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+      const effectiveAuth = resolveEffectiveAuth(req, inherited);
+      const allHeaders = mergeHeaders(req, inherited);
       const headerPairs = [];
       if (effectiveAuth.type === "bearer") {
         const token = effectiveAuth.token ?? "";
@@ -1392,8 +1893,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
         lines.push(`    VAR    &{params}    ${pairs}`);
       }
       const { body } = req;
-      const hasBody = body.mode !== "none" && !["GET", "HEAD"].includes(req.method);
-      if (hasBody && body.mode === "json" && body.json) {
+      if (hasBody(req) && body.mode === "json" && body.json) {
         const bodyPairs = jsonToRfDictPairs(body.json, varMap);
         if (bodyPairs !== null) {
           lines.push(`    VAR    &{body}    ${bodyPairs}`);
@@ -1405,7 +1905,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
       const callArgs = [];
       if (headerPairs.length) callArgs.push("headers=${headers}");
       if (enabledParams.length) callArgs.push("params=${params}");
-      if (hasBody && body.mode === "json") callArgs.push("json=${body}");
+      if (hasBody(req) && body.mode === "json") callArgs.push("json=${body}");
       lines.push(`    \${response}=    ${method}    ${url}`);
       if (callArgs.length) {
         lines.push(`    ...    ${callArgs.join("    ")}`);
@@ -1494,27 +1994,8 @@ function buildTestSuite(collection, environment, nameMap) {
   processFolder(collection.rootFolder);
   return lines.join("\n");
 }
-function renderTree$6(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$6(collectionName, filePaths) {
-  const tree = renderTree$6(filePaths);
+  const tree = renderTree(filePaths);
   return `# ${collectionName} — API Tests (Robot Framework)
 
 ## Project structure
@@ -1543,7 +2024,7 @@ function generateRobotFramework(collection, environment) {
   const varMap = new Map(
     (environment?.variables ?? []).map((v) => [v.key, v])
   );
-  const nameMap = buildNameMap$2(collection.rootFolder, collection.requests);
+  const nameMap = buildNameMap(collection.rootFolder, collection.requests);
   const slug2 = collection.name.replace(/\W+/g, "_").toLowerCase();
   const hookExtractedVars = /* @__PURE__ */ new Set();
   const contentFiles = [
@@ -1558,65 +2039,8 @@ function generateRobotFramework(collection, environment) {
     ...contentFiles
   ];
 }
-function slug$3(name) {
-  return name.replace(/\W+/g, "-").toLowerCase().replace(/^-|-$/g, "");
-}
-function toEnvVar$3(key) {
-  return key.replace(/\W+/g, "_").toUpperCase();
-}
-function interpolatePath$1(value, sharedVars = /* @__PURE__ */ new Set()) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
-    const envKey = toEnvVar$3(key.trim());
-    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
-  });
-}
-function buildNameMap$1(folder, requests) {
-  const map = /* @__PURE__ */ new Map();
-  const used = /* @__PURE__ */ new Set();
-  for (const id of folder.requestIds) {
-    const req = requests[id];
-    if (!req) continue;
-    const base = req.name;
-    let name = base;
-    if (used.has(name)) {
-      let i = 2;
-      while (used.has(`${base} ${i}`)) i++;
-      name = `${base} ${i}`;
-    }
-    used.add(name);
-    map.set(id, name);
-  }
-  return map;
-}
-function renderJsValue$1(value, indent, sharedVars = /* @__PURE__ */ new Set()) {
-  const next = indent + "  ";
-  if (value === null) return "null";
-  if (typeof value === "boolean" || typeof value === "number") return String(value);
-  if (typeof value === "string") {
-    if (value.includes("{{")) {
-      return "`" + interpolatePath$1(value, sharedVars) + "`";
-    }
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    if (!value.length) return "[]";
-    return `[
-${value.map((v) => next + renderJsValue$1(v, next, sharedVars)).join(",\n")},
-${indent}]`;
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value);
-    if (!entries.length) return "{}";
-    return `{
-${entries.map(([k, v]) => `${next}${k}: ${renderJsValue$1(v, next, sharedVars)}`).join(",\n")},
-${indent}}`;
-  }
-  return JSON.stringify(value);
-}
 function buildPlaywrightConfig$1(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:3000";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:3000");
   return `import { defineConfig } from '@playwright/test'
 import * as dotenv from 'dotenv'
 
@@ -1636,19 +2060,19 @@ export default defineConfig({
 function buildHookLines$1(req, sharedVars) {
   const method = req.method.toLowerCase();
   const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-  const pathExpr = path2.includes("{{") ? "`" + interpolatePath$1(path2) + "`" : `'${path2}'`;
+  const pathExpr = path2.includes("{{") ? "`" + interpolateEnvVars(path2) + "`" : `'${path2}'`;
   const headerEntries = [];
   if (req.auth.type === "bearer") {
     const token = req.auth.token ?? "";
     if (token.includes("{{")) {
-      headerEntries.push(`Authorization: \`Bearer ${interpolatePath$1(token)}\``);
+      headerEntries.push(`Authorization: \`Bearer ${interpolateEnvVars(token)}\``);
     } else {
       const ref = req.auth.tokenSecretRef ?? "API_TOKEN";
-      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\``);
     }
   }
   for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
-    headerEntries.push(`'${h.key}': \`${interpolatePath$1(h.value)}\``);
+    headerEntries.push(`'${h.key}': \`${interpolateEnvVars(h.value)}\``);
   }
   const optionParts = [];
   if (headerEntries.length) {
@@ -1656,7 +2080,7 @@ function buildHookLines$1(req, sharedVars) {
   }
   if (req.body.mode === "json" && req.body.json && !["get", "head"].includes(method)) {
     try {
-      optionParts.push(`data: ${renderJsValue$1(JSON.parse(req.body.json), "        ")}`);
+      optionParts.push(`data: ${renderJsValue(JSON.parse(req.body.json), "        ")}`);
     } catch {
     }
   }
@@ -1670,7 +2094,7 @@ function buildHookLines$1(req, sharedVars) {
     for (const e of parsed.extractions) {
       const jsonPath = e.accessor.replace(/^json\.?/, "");
       const expr = jsonPath ? `hookJson.${jsonPath}` : "hookJson";
-      const varName = toEnvVar$3(e.varName);
+      const varName = toEnvVar(e.varName);
       sharedVars.add(varName);
       lines.push(`    ${varName} = String(${expr});`);
     }
@@ -1728,32 +2152,32 @@ ${lines.join("\n")}
     const testName = nameMap.get(reqId) ?? req.name;
     const method = req.method.toLowerCase();
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-    const pathExpr = path2.includes("{{") ? "`" + interpolatePath$1(path2, sharedVars) + "`" : `'${path2}'`;
+    const pathExpr = path2.includes("{{") ? "`" + interpolateEnvVars(path2, sharedVars) + "`" : `'${path2}'`;
     const optionParts = [];
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const headerEntries = [];
     if (effectiveAuth.type === "bearer") {
       const token = effectiveAuth.token ?? "";
       if (token.includes("{{")) {
-        headerEntries.push(`Authorization: \`Bearer ${interpolatePath$1(token, sharedVars)}\``);
+        headerEntries.push(`Authorization: \`Bearer ${interpolateEnvVars(token, sharedVars)}\``);
       } else {
         const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
-        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\``);
       }
     } else if (effectiveAuth.type === "apikey" && effectiveAuth.apiKeyIn === "header") {
       const val = effectiveAuth.apiKeyValue ?? "";
       const name = effectiveAuth.apiKeyName ?? "X-API-Key";
       if (val.includes("{{")) {
-        headerEntries.push(`'${name}': \`${interpolatePath$1(val, sharedVars)}\``);
+        headerEntries.push(`'${name}': \`${interpolateEnvVars(val, sharedVars)}\``);
       } else {
         const ref = effectiveAuth.apiKeySecretRef ?? "API_KEY";
-        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar(ref)} ?? ''}\``);
       }
     }
     for (const h of allHeaders) {
-      headerEntries.push(`'${h.key}': \`${interpolatePath$1(h.value, sharedVars)}\``);
+      headerEntries.push(`'${h.key}': \`${interpolateEnvVars(h.value, sharedVars)}\``);
     }
     if (headerEntries.length) {
       optionParts.push(`      headers: {
@@ -1763,17 +2187,16 @@ ${lines.join("\n")}
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     if (enabledParams.length) {
       const pairs = enabledParams.map(
-        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolatePath$1(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
+        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolateEnvVars(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
       ).join(", ");
       optionParts.push(`      params: { ${pairs} }`);
     }
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
-    if (hasBody && req.body.mode === "json" && req.body.json) {
+    if (hasBody(req) && req.body.mode === "json" && req.body.json) {
       try {
-        const rendered = renderJsValue$1(JSON.parse(req.body.json), "      ", sharedVars);
+        const rendered = renderJsValue(JSON.parse(req.body.json), "      ", sharedVars);
         optionParts.push(`      data: ${rendered}`);
       } catch {
-        optionParts.push(`      data: \`${interpolatePath$1(req.body.json, sharedVars)}\``);
+        optionParts.push(`      data: \`${interpolateEnvVars(req.body.json, sharedVars)}\``);
       }
     }
     const optionsStr = optionParts.length ? `, {
@@ -1828,7 +2251,7 @@ ${optionParts.join(",\n")},
       const path22 = e.accessor.replace(/^json\.?/, "");
       const expr = path22 ? `json.${path22}` : "json";
       lines.push(`    // Extract: ${e.varName} = ${expr}`);
-      lines.push(`    process.env.${toEnvVar$3(e.varName)} = String(${expr});`);
+      lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  });`);
     tests.push(lines.join("\n"));
@@ -1859,27 +2282,8 @@ function buildPackageJson$3(collectionName) {
     }
   }, null, 2) + "\n";
 }
-function renderTree$5(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$5(collectionName, filePaths) {
-  const tree = renderTree$5([...filePaths, ".env.local"]);
+  const tree = renderTree([...filePaths, ".env.local"]);
   return `# ${collectionName} — API Tests (Playwright TypeScript)
 
 ## Project structure
@@ -1900,83 +2304,26 @@ npm test
 `;
 }
 function generatePlaywright(collection, environment) {
-  const files = [];
-  function processFolder(folder, name) {
-    if (folder.requestIds.length > 0) {
-      const nameMap = buildNameMap$1(folder, collection.requests);
-      files.push({ path: `tests/${slug$3(name)}.spec.ts`, content: buildSpec$1(name, folder, collection, nameMap) });
-    }
-    for (const sub of folder.folders) processFolder(sub, sub.name);
-  }
-  if (collection.rootFolder.requestIds.length > 0) processFolder(collection.rootFolder, collection.name);
-  for (const sub of collection.rootFolder.folders) processFolder(sub, sub.name);
-  const scaffoldPaths = ["package.json", "playwright.config.ts", ...files.map((f) => f.path)];
-  files.unshift(
-    { path: "package.json", content: buildPackageJson$3(collection.name) },
-    { path: "playwright.config.ts", content: buildPlaywrightConfig$1(environment) },
-    { path: "README.md", content: buildReadme$5(collection.name, scaffoldPaths) }
-  );
-  return files;
-}
-function slug$2(name) {
-  return name.replace(/\W+/g, "-").toLowerCase().replace(/^-|-$/g, "");
-}
-function toEnvVar$2(key) {
-  return key.replace(/\W+/g, "_").toUpperCase();
-}
-function interpolatePath(value, sharedVars = /* @__PURE__ */ new Set()) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
-    const envKey = toEnvVar$2(key.trim());
-    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
-  });
-}
-function buildNameMap(folder, requests) {
-  const map = /* @__PURE__ */ new Map();
-  const used = /* @__PURE__ */ new Set();
-  for (const id of folder.requestIds) {
-    const req = requests[id];
-    if (!req) continue;
-    const base = req.name;
-    let name = base;
-    if (used.has(name)) {
-      let i = 2;
-      while (used.has(`${base} ${i}`)) i++;
-      name = `${base} ${i}`;
-    }
-    used.add(name);
-    map.set(id, name);
-  }
-  return map;
-}
-function renderJsValue(value, indent, sharedVars = /* @__PURE__ */ new Set()) {
-  const next = indent + "  ";
-  if (value === null) return "null";
-  if (typeof value === "boolean" || typeof value === "number") return String(value);
-  if (typeof value === "string") {
-    if (value.includes("{{")) {
-      return "`" + interpolatePath(value, sharedVars) + "`";
+  const files = [];
+  function processFolder(folder, name) {
+    if (folder.requestIds.length > 0) {
+      const nameMap = buildNameMap$1(folder, collection.requests);
+      files.push({ path: `tests/${slug(name)}.spec.ts`, content: buildSpec$1(name, folder, collection, nameMap) });
     }
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    if (!value.length) return "[]";
-    return `[
-${value.map((v) => next + renderJsValue(v, next, sharedVars)).join(",\n")},
-${indent}]`;
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value);
-    if (!entries.length) return "{}";
-    return `{
-${entries.map(([k, v]) => `${next}${k}: ${renderJsValue(v, next, sharedVars)}`).join(",\n")},
-${indent}}`;
+    for (const sub of folder.folders) processFolder(sub, sub.name);
   }
-  return JSON.stringify(value);
+  if (collection.rootFolder.requestIds.length > 0) processFolder(collection.rootFolder, collection.name);
+  for (const sub of collection.rootFolder.folders) processFolder(sub, sub.name);
+  const scaffoldPaths = ["package.json", "playwright.config.ts", ...files.map((f) => f.path)];
+  files.unshift(
+    { path: "package.json", content: buildPackageJson$3(collection.name) },
+    { path: "playwright.config.ts", content: buildPlaywrightConfig$1(environment) },
+    { path: "README.md", content: buildReadme$5(collection.name, scaffoldPaths) }
+  );
+  return files;
 }
 function buildPlaywrightConfig(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:3000";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:3000");
   return `// @ts-check
 const { defineConfig } = require('@playwright/test');
 require('dotenv').config({ path: '.env.local' });
@@ -1995,19 +2342,19 @@ module.exports = defineConfig({
 function buildHookLines(req, sharedVars) {
   const method = req.method.toLowerCase();
   const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-  const pathExpr = path2.includes("{{") ? "`" + interpolatePath(path2) + "`" : `'${path2}'`;
+  const pathExpr = path2.includes("{{") ? "`" + interpolateEnvVars(path2) + "`" : `'${path2}'`;
   const headerEntries = [];
   if (req.auth.type === "bearer") {
     const token = req.auth.token ?? "";
     if (token.includes("{{")) {
-      headerEntries.push(`Authorization: \`Bearer ${interpolatePath(token)}\``);
+      headerEntries.push(`Authorization: \`Bearer ${interpolateEnvVars(token)}\``);
     } else {
       const ref = req.auth.tokenSecretRef ?? "API_TOKEN";
-      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\``);
     }
   }
   for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
-    headerEntries.push(`'${h.key}': \`${interpolatePath(h.value)}\``);
+    headerEntries.push(`'${h.key}': \`${interpolateEnvVars(h.value)}\``);
   }
   const optParts = [];
   if (headerEntries.length) optParts.push(`headers: { ${headerEntries.join(", ")} }`);
@@ -2026,7 +2373,7 @@ function buildHookLines(req, sharedVars) {
     for (const e of parsed.extractions) {
       const jp = e.accessor.replace(/^json\.?/, "");
       const expr = jp ? `hookJson.${jp}` : "hookJson";
-      const varName = toEnvVar$2(e.varName);
+      const varName = toEnvVar(e.varName);
       sharedVars.add(varName);
       lines.push(`    ${varName} = String(${expr});`);
     }
@@ -2082,32 +2429,32 @@ ${lines.join("\n")}
     const testName = nameMap.get(reqId) ?? req.name;
     const method = req.method.toLowerCase();
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-    const pathExpr = path2.includes("{{") ? "`" + interpolatePath(path2, sharedVars) + "`" : `'${path2}'`;
+    const pathExpr = path2.includes("{{") ? "`" + interpolateEnvVars(path2, sharedVars) + "`" : `'${path2}'`;
     const optionParts = [];
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const headerEntries = [];
     if (effectiveAuth.type === "bearer") {
       const token = effectiveAuth.token ?? "";
       if (token.includes("{{")) {
-        headerEntries.push(`Authorization: \`Bearer ${interpolatePath(token, sharedVars)}\``);
+        headerEntries.push(`Authorization: \`Bearer ${interpolateEnvVars(token, sharedVars)}\``);
       } else {
         const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
-        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\``);
       }
     } else if (effectiveAuth.type === "apikey" && effectiveAuth.apiKeyIn === "header") {
       const val = effectiveAuth.apiKeyValue ?? "";
       const name = effectiveAuth.apiKeyName ?? "X-API-Key";
       if (val.includes("{{")) {
-        headerEntries.push(`'${name}': \`${interpolatePath(val, sharedVars)}\``);
+        headerEntries.push(`'${name}': \`${interpolateEnvVars(val, sharedVars)}\``);
       } else {
         const ref = effectiveAuth.apiKeySecretRef ?? "API_KEY";
-        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar(ref)} ?? ''}\``);
       }
     }
     for (const h of allHeaders) {
-      headerEntries.push(`'${h.key}': \`${interpolatePath(h.value, sharedVars)}\``);
+      headerEntries.push(`'${h.key}': \`${interpolateEnvVars(h.value, sharedVars)}\``);
     }
     if (headerEntries.length) {
       optionParts.push(`      headers: {
@@ -2117,17 +2464,16 @@ ${lines.join("\n")}
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     if (enabledParams.length) {
       const pairs = enabledParams.map(
-        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolatePath(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
+        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolateEnvVars(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
       ).join(", ");
       optionParts.push(`      params: { ${pairs} }`);
     }
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
-    if (hasBody && req.body.mode === "json" && req.body.json) {
+    if (hasBody(req) && req.body.mode === "json" && req.body.json) {
       try {
         const rendered = renderJsValue(JSON.parse(req.body.json), "      ", sharedVars);
         optionParts.push(`      data: ${rendered}`);
       } catch {
-        optionParts.push(`      data: \`${interpolatePath(req.body.json, sharedVars)}\``);
+        optionParts.push(`      data: \`${interpolateEnvVars(req.body.json, sharedVars)}\``);
       }
     }
     const optionsStr = optionParts.length ? `, {
@@ -2173,7 +2519,7 @@ ${optionParts.join(",\n")},
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
       const expr = path22 ? `json.${path22}` : "json";
-      lines.push(`    process.env.${toEnvVar$2(e.varName)} = String(${expr});`);
+      lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  });`);
     tests.push(lines.join("\n"));
@@ -2203,27 +2549,8 @@ function buildPackageJson$2(collectionName) {
     }
   }, null, 2) + "\n";
 }
-function renderTree$4(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$4(collectionName, filePaths) {
-  const tree = renderTree$4([...filePaths, ".env.local"]);
+  const tree = renderTree([...filePaths, ".env.local"]);
   return `# ${collectionName} — API Tests (Playwright JavaScript)
 
 ## Project structure
@@ -2247,8 +2574,8 @@ function generatePlaywrightJs(collection, environment) {
   const files = [];
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
-      const nameMap = buildNameMap(folder, collection.requests);
-      files.push({ path: `tests/${slug$2(name)}.spec.js`, content: buildSpec(name, folder, collection, nameMap) });
+      const nameMap = buildNameMap$1(folder, collection.requests);
+      files.push({ path: `tests/${slug(name)}.spec.js`, content: buildSpec(name, folder, collection, nameMap) });
     }
     for (const sub of folder.folders) processFolder(sub, sub.name);
   }
@@ -2262,18 +2589,6 @@ function generatePlaywrightJs(collection, environment) {
   );
   return files;
 }
-function slug$1(name) {
-  return name.replace(/\W+/g, "-").toLowerCase().replace(/^-|-$/g, "");
-}
-function toEnvVar$1(key) {
-  return key.replace(/\W+/g, "_").toUpperCase();
-}
-function interpolateValue$1(value, sharedVars = /* @__PURE__ */ new Set()) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
-    const envKey = toEnvVar$1(key.trim());
-    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
-  });
-}
 function buildJestConfig$1() {
   return `import type { Config } from 'jest'
 
@@ -2288,11 +2603,9 @@ export default config
 `;
 }
 function buildClient$1(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:3000";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:3000");
   const secretVars = environment?.variables.filter((v) => v.secret && v.secretRef) ?? [];
-  const envComments = secretVars.map((v) => `# ${toEnvVar$1(v.key)}=<from keychain>`).join("\n");
+  const envComments = secretVars.map((v) => `# ${toEnvVar(v.key)}=<from keychain>`).join("\n");
   return `import supertest from 'supertest'
 import * as dotenv from 'dotenv'
 
@@ -2337,7 +2650,7 @@ function buildTestFile$1(folderName, folder, collection) {
       for (const e of parsed.extractions) {
         const jp = e.accessor.replace(/^json\.?/, "");
         const expr = jp ? `hookRes.body.${jp}` : "hookRes.body";
-        const varName = toEnvVar$1(e.varName);
+        const varName = toEnvVar(e.varName);
         sharedVars.add(varName);
         lines.push(`    ${varName} = String(${expr});`);
       }
@@ -2368,12 +2681,11 @@ ${lines.join("\n")}
     const req = requests[reqId];
     if (!req || req.disabled || req.hookType) continue;
     const method = req.method.toLowerCase();
-    const path2 = interpolateValue$1(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
+    const path2 = interpolateEnvVars(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`  it('${nameMap.get(reqId)}', async () => {`);
     lines.push(`    const res = await api`);
@@ -2381,29 +2693,29 @@ ${lines.join("\n")}
     if (effectiveAuth.type === "bearer") {
       const token = effectiveAuth.token ?? "";
       if (token.includes("{{")) {
-        lines.push(`      .set('Authorization', \`Bearer ${interpolateValue$1(token, sharedVars)}\`)`);
+        lines.push(`      .set('Authorization', \`Bearer ${interpolateEnvVars(token, sharedVars)}\`)`);
       } else {
         const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
-        lines.push(`      .set('Authorization', \`Bearer \${process.env.${toEnvVar$1(ref)} ?? ''}\`)`);
+        lines.push(`      .set('Authorization', \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\`)`);
       }
     }
     for (const h of allHeaders) {
-      lines.push(`      .set('${h.key}', \`${interpolateValue$1(h.value, sharedVars)}\`)`);
+      lines.push(`      .set('${h.key}', \`${interpolateEnvVars(h.value, sharedVars)}\`)`);
     }
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue$1(p.value, sharedVars)}\``).join(", ");
+      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateEnvVars(p.value, sharedVars)}\``).join(", ");
       lines.push(`      .query({ ${pairs} })`);
     }
-    if (hasBody) {
+    if (hasBody(req)) {
       if (req.body.mode === "json") {
         const jsonBody = req.body.json ?? "{}";
         if (jsonBody.includes("{{")) {
-          lines.push(`      .send(JSON.parse(\`${interpolateValue$1(jsonBody, sharedVars)}\`))`);
+          lines.push(`      .send(JSON.parse(\`${interpolateEnvVars(jsonBody, sharedVars)}\`))`);
         } else {
           lines.push(`      .send(${jsonBody})`);
         }
       } else if (req.body.mode === "form" && req.body.form) {
-        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue$1(p.value, sharedVars)}\``).join(", ");
+        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateEnvVars(p.value, sharedVars)}\``).join(", ");
         lines.push(`      .type('form')`);
         lines.push(`      .send({ ${pairs} })`);
       }
@@ -2442,7 +2754,7 @@ ${lines.join("\n")}
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
       const expr = path22 ? `res.body.${path22}` : "res.body";
-      lines.push(`    process.env.${toEnvVar$1(e.varName)} = String(${expr});`);
+      lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  })`);
     tests.push(lines.join("\n"));
@@ -2486,27 +2798,8 @@ function buildTsConfig() {
     exclude: ["node_modules", "dist"]
   }, null, 2) + "\n";
 }
-function renderTree$3(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$3(collectionName, filePaths) {
-  const tree = renderTree$3([...filePaths, ".env.local"]);
+  const tree = renderTree([...filePaths, ".env.local"]);
   return `# ${collectionName} — API Tests (Supertest + Jest TypeScript)
 
 ## Project structure
@@ -2533,7 +2826,7 @@ function generateSupertestTs(collection, environment) {
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
       files.push({
-        path: `tests/${slug$1(name)}.test.ts`,
+        path: `tests/${slug(name)}.test.ts`,
         content: buildTestFile$1(name, folder, collection)
       });
     }
@@ -2555,18 +2848,6 @@ function generateSupertestTs(collection, environment) {
   );
   return files;
 }
-function slug(name) {
-  return name.replace(/\W+/g, "-").toLowerCase().replace(/^-|-$/g, "");
-}
-function toEnvVar(key) {
-  return key.replace(/\W+/g, "_").toUpperCase();
-}
-function interpolateValue(value, sharedVars = /* @__PURE__ */ new Set()) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
-    const envKey = toEnvVar(key.trim());
-    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
-  });
-}
 function buildJestConfig() {
   return `/** @type {import('jest').Config} */
 module.exports = {
@@ -2577,9 +2858,7 @@ module.exports = {
 `;
 }
 function buildClient(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:3000";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:3000");
   const secretVars = environment?.variables.filter((v) => v.secret && v.secretRef) ?? [];
   const envComments = secretVars.map((v) => `# ${toEnvVar(v.key)}=<from keychain>`).join("\n");
   return `const supertest = require('supertest');
@@ -2655,12 +2934,11 @@ ${lines.join("\n")}
     const req = requests[reqId];
     if (!req || req.disabled || req.hookType) continue;
     const method = req.method.toLowerCase();
-    const path2 = interpolateValue(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
+    const path2 = interpolateEnvVars(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`  it('${nameMap.get(reqId)}', async () => {`);
     lines.push(`    const res = await api`);
@@ -2668,29 +2946,29 @@ ${lines.join("\n")}
     if (effectiveAuth.type === "bearer") {
       const token = effectiveAuth.token ?? "";
       if (token.includes("{{")) {
-        lines.push(`      .set('Authorization', \`Bearer ${interpolateValue(token, sharedVars)}\`)`);
+        lines.push(`      .set('Authorization', \`Bearer ${interpolateEnvVars(token, sharedVars)}\`)`);
       } else {
         const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
         lines.push(`      .set('Authorization', \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\`)`);
       }
     }
     for (const h of allHeaders) {
-      lines.push(`      .set('${h.key}', \`${interpolateValue(h.value, sharedVars)}\`)`);
+      lines.push(`      .set('${h.key}', \`${interpolateEnvVars(h.value, sharedVars)}\`)`);
     }
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue(p.value, sharedVars)}\``).join(", ");
+      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateEnvVars(p.value, sharedVars)}\``).join(", ");
       lines.push(`      .query({ ${pairs} })`);
     }
-    if (hasBody) {
+    if (hasBody(req)) {
       if (req.body.mode === "json") {
         const jsonBody = req.body.json ?? "{}";
         if (jsonBody.includes("{{")) {
-          lines.push(`      .send(JSON.parse(\`${interpolateValue(jsonBody, sharedVars)}\`))`);
+          lines.push(`      .send(JSON.parse(\`${interpolateEnvVars(jsonBody, sharedVars)}\`))`);
         } else {
           lines.push(`      .send(${jsonBody})`);
         }
       } else if (req.body.mode === "form" && req.body.form) {
-        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue(p.value, sharedVars)}\``).join(", ");
+        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateEnvVars(p.value, sharedVars)}\``).join(", ");
         lines.push(`      .type('form')`);
         lines.push(`      .send({ ${pairs} })`);
       }
@@ -2755,27 +3033,8 @@ function buildPackageJson(collectionName) {
     }
   }, null, 2) + "\n";
 }
-function renderTree$2(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$2(collectionName, filePaths) {
-  const tree = renderTree$2([...filePaths, ".env.local"]);
+  const tree = renderTree([...filePaths, ".env.local"]);
   return `# ${collectionName} — API Tests (Supertest + Jest JavaScript)
 
 ## Project structure
@@ -2823,9 +3082,6 @@ function generateSupertestJs(collection, environment) {
   );
   return files;
 }
-function javaClass$1(name) {
-  return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
-}
 function javaMethod(name) {
   const parts = name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean);
   return parts[0].toLowerCase() + parts.slice(1).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
@@ -2842,12 +3098,9 @@ function javaTypeFor(expected) {
       return "Object.class";
   }
 }
-function toEnvConst(key) {
-  return key.replace(/\W+/g, "_").toUpperCase();
-}
 function interpolateJava(value, sharedVars = /* @__PURE__ */ new Set()) {
   return '"' + value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
-    const envKey = toEnvConst(key.trim());
+    const envKey = toEnvVar(key.trim());
     if (sharedVars.has(envKey)) {
       return `" + ${envKey} + "`;
     }
@@ -2922,12 +3175,10 @@ function buildPom$1(collectionName) {
 `;
 }
 function buildBaseTest(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:8080";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:8080");
   const secretVars = environment?.variables.filter((v) => v.secret && v.secretRef) ?? [];
   const secretComments = secretVars.map(
-    (v) => `     * - ${toEnvConst(v.key)}=<value from keychain>`
+    (v) => `     * - ${toEnvVar(v.key)}=<value from keychain>`
   ).join("\n");
   return `package com.example.api;
 
@@ -2966,7 +3217,7 @@ public class BaseTest {
 }
 function buildTestClass(folderName, folder, collection) {
   const requests = collection.requests;
-  const className = javaClass$1(folderName) + "Test";
+  const className = javaClass(folderName) + "Test";
   const methods = [];
   const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
   const beforeAllH = hooks.beforeAll;
@@ -2986,7 +3237,7 @@ function buildTestClass(folderName, folder, collection) {
       lines.push(`            .when().${method}("${path2}");`);
       for (const e of parsed.extractions) {
         const jp = accessorToJsonPath(e.accessor);
-        const varName = toEnvConst(e.varName);
+        const varName = toEnvVar(e.varName);
         sharedVars.add(varName);
         lines.push(`        ${varName} = hookResponse.jsonPath().getString("${jp}");`);
       }
@@ -3032,10 +3283,9 @@ ${lines.join("\n")}
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
     const javaPath = interpolateJava(path2, sharedVars);
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`    @Test`);
     lines.push(`    public void ${methodName}() {`);
@@ -3045,14 +3295,14 @@ ${lines.join("\n")}
       const token = effectiveAuth.token ?? "";
       if (token.includes("{{")) {
         const varRef = token.match(/\{\{([^}]+)\}\}/)?.[1]?.trim();
-        const envKey = varRef ? toEnvConst(varRef) : "";
+        const envKey = varRef ? toEnvVar(varRef) : "";
         if (envKey && sharedVars.has(envKey)) {
           lines.push(`            .header("Authorization", "Bearer " + ${envKey})`);
         } else {
           lines.push(`            .header("Authorization", "Bearer " + ${interpolateJava(token, sharedVars)})`);
         }
       } else {
-        lines.push(`            .header("Authorization", "Bearer " + System.getenv("${toEnvConst(effectiveAuth.tokenSecretRef ?? "API_TOKEN")}"))`);
+        lines.push(`            .header("Authorization", "Bearer " + System.getenv("${toEnvVar(effectiveAuth.tokenSecretRef ?? "API_TOKEN")}"))`);
       }
     }
     for (const h of allHeaders) {
@@ -3061,7 +3311,7 @@ ${lines.join("\n")}
     for (const p of enabledParams) {
       lines.push(`            .queryParam("${p.key}", ${interpolateJava(p.value, sharedVars)})`);
     }
-    if (hasBody) {
+    if (hasBody(req)) {
       if (req.body.mode === "json" && req.body.json) {
         const escaped = req.body.json.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
         lines.push(`            .body(${interpolateJava(escaped, sharedVars)})`);
@@ -3122,27 +3372,8 @@ ${methods.join("\n\n")}
 }
 `;
 }
-function renderTree$1(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme$1(collectionName, filePaths) {
-  const tree = renderTree$1(filePaths);
+  const tree = renderTree(filePaths);
   return `# ${collectionName} — API Tests (REST Assured + JUnit 5)
 
 ## Project structure
@@ -3171,7 +3402,7 @@ function generateRestAssured(collection, environment) {
   ];
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
-      const className = javaClass$1(name) + "Test";
+      const className = javaClass(name) + "Test";
       files.push({
         path: `src/test/java/com/example/api/${className}.java`,
         content: buildTestClass(name, folder, collection)
@@ -3190,9 +3421,6 @@ function generateRestAssured(collection, environment) {
   files.unshift({ path: "README.md", content: buildReadme$1(collection.name, files.map((f) => f.path)) });
   return files;
 }
-function javaClass(name) {
-  return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
-}
 function jsVar(name) {
   const parts = name.replace(/[^a-zA-Z0-9]+/g, " ").split(/\s+/).filter(Boolean).map((p) => p.toLowerCase());
   if (parts.length === 0) return "_";
@@ -3290,9 +3518,7 @@ function buildPom(collectionName) {
 `;
 }
 function buildKarateConfig(environment) {
-  const baseUrl = environment?.variables.find(
-    (v) => ["base_url", "baseurl", "base-url"].includes(v.key.toLowerCase()) && !v.secret
-  )?.value ?? "http://localhost:8080";
+  const baseUrl = getEnvBaseUrl(environment, "http://localhost:8080");
   const lines = [];
   lines.push(`function fn() {`);
   lines.push(`  var env = karate.env || 'dev';`);
@@ -3364,7 +3590,7 @@ function buildBackground(folderId, collection) {
     for (const x of (h.headers ?? []).filter((x2) => x2.enabled && x2.key)) {
       lines.push(`  * header ${x.key} = ${interpolateKarate(x.value)}`);
     }
-    if (h.body.mode !== "none" && !["get", "head"].includes(method)) {
+    if (hasBody(h)) {
       for (const block of bodySteps(h.body, has)) {
         lines.push(`  * ${block[0]}`);
         for (let i = 1; i < block.length; i++) lines.push(block[i]);
@@ -3453,11 +3679,10 @@ function buildFeature(folderName, folder, collection) {
     }
     usedTags.add(tag);
     const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
-    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
-    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
+    const effectiveAuth = resolveEffectiveAuth(req, inherited);
+    const allHeaders = mergeHeaders(req, inherited);
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     const method = req.method.toLowerCase();
-    const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`@${tag}`);
     lines.push(`Scenario: ${req.name}`);
@@ -3487,7 +3712,7 @@ function buildFeature(folderName, folder, collection) {
     for (const p of enabledParams) {
       setup.push([`param ${p.key} = ${interpolateKarate(p.value)}`]);
     }
-    if (hasBody) {
+    if (hasBody(req)) {
       const declared = new Set(allHeaders.map((h) => h.key.toLowerCase()));
       const has = (n) => declared.has(n.toLowerCase());
       for (const block of bodySteps(req.body, has)) setup.push(block);
@@ -3547,25 +3772,6 @@ ${bgBlock}
 ${scenarios.join("\n\n")}
 `;
 }
-function renderTree(paths) {
-  const root = {};
-  for (const p of [...paths].sort()) {
-    let cur = root;
-    for (const part of p.split("/")) {
-      cur = cur[part] ??= {};
-    }
-  }
-  function render(node, prefix = "") {
-    const entries = Object.entries(node);
-    return entries.flatMap(([name, children], i) => {
-      const last = i === entries.length - 1;
-      const lines = [`${prefix}${last ? "└── " : "├── "}${name}`];
-      if (Object.keys(children).length) lines.push(...render(children, prefix + (last ? "    " : "│   ")));
-      return lines;
-    });
-  }
-  return [".", ...render(root)].join("\n");
-}
 function buildReadme(collectionName, filePaths) {
   const tree = renderTree(filePaths);
   return `# ${collectionName} — API Tests (Karate + JUnit 5)
@@ -3626,8 +3832,106 @@ function generateKarate(collection, environment) {
   files.unshift({ path: "README.md", content: buildReadme(collection.name, files.map((f) => f.path)) });
   return files;
 }
+function mapOut(s) {
+  return s.replace(/\{\{\s*(\$[A-Za-z]+)\s*\}\}/g, (_m, name) => `{{${SPECTOR_TO_HTTP[name] ?? name}}}`);
+}
+function orderedRequests(collection) {
+  const out = [];
+  const walk = (folder) => {
+    for (const id of folder.requestIds) {
+      const req = collection.requests[id];
+      if (req) out.push(req);
+    }
+    for (const sub of folder.folders) walk(sub);
+  };
+  walk(collection.rootFolder);
+  return out;
+}
+function authToHeader(auth) {
+  switch (auth.type) {
+    case "bearer":
+      return auth.token ? { key: "Authorization", value: `Bearer ${auth.token}`, enabled: true } : null;
+    case "basic": {
+      const user = auth.username ?? "";
+      const pass = auth.password ?? "";
+      const templated = /\{\{/.test(user) || /\{\{/.test(pass);
+      const value = templated ? `Basic {{base64(${user}:${pass})}}` : `Basic ${Buffer.from(`${user}:${pass}`).toString("base64")}`;
+      return { key: "Authorization", value, enabled: true };
+    }
+    case "apikey":
+      if (auth.apiKeyIn === "query") return null;
+      return auth.apiKeyName ? { key: auth.apiKeyName, value: auth.apiKeyValue ?? "", enabled: true } : null;
+    default:
+      return null;
+  }
+}
+function buildUrl(req) {
+  const query = (req.params ?? []).filter((p) => p.enabled && p.key && p.paramType !== "path");
+  if (req.auth.type === "apikey" && req.auth.apiKeyIn === "query" && req.auth.apiKeyName) {
+    query.push({ key: req.auth.apiKeyName, value: req.auth.apiKeyValue ?? "", enabled: true });
+  }
+  if (!query.length) return req.url;
+  const qs = query.map((p) => `${p.key}=${p.value}`).join("&");
+  return req.url + (req.url.includes("?") ? "&" : "?") + qs;
+}
+function bodyLines(req) {
+  const b = req.body;
+  switch (b.mode) {
+    case "json":
+      return { contentType: "application/json", text: b.json ?? "" };
+    case "graphql":
+      return { contentType: "application/json", text: b.graphql?.query ?? "" };
+    case "soap":
+      return { contentType: "text/xml", text: b.soap?.envelope ?? "" };
+    case "raw":
+      return { contentType: b.rawContentType, text: b.raw ?? "" };
+    case "form":
+      return {
+        contentType: "application/x-www-form-urlencoded",
+        text: (b.form ?? []).filter((f) => f.enabled && f.key).map((f) => `${encodeURIComponent(f.key)}=${encodeURIComponent(f.value)}`).join("&")
+      };
+    default:
+      return {};
+  }
+}
+function generateHttpFile(collection, environment) {
+  const lines = [];
+  const vars = {};
+  for (const v of environment?.variables ?? []) {
+    if (v.enabled && !v.secret) vars[v.key] = v.value;
+  }
+  Object.assign(vars, collection.collectionVariables ?? {});
+  const varKeys = Object.keys(vars);
+  if (varKeys.length) {
+    for (const k of varKeys) lines.push(`@${k} = ${mapOut(vars[k])}`);
+    lines.push("");
+  }
+  orderedRequests(collection).forEach((req, idx) => {
+    if (idx > 0) lines.push("");
+    lines.push(`### ${req.name}`);
+    if (req.description?.trim()) {
+      for (const l of req.description.trim().split(/\r?\n/)) lines.push(`# ${l}`);
+    }
+    lines.push(`${req.method} ${mapOut(buildUrl(req))}`);
+    const headers = [...(req.headers ?? []).filter((h) => h.enabled && h.key)];
+    const authHeader = authToHeader(req.auth);
+    if (authHeader) headers.unshift(authHeader);
+    const body = bodyLines(req);
+    const hasCT = headers.some((h) => h.key.toLowerCase() === "content-type");
+    if (body.text && body.contentType && !hasCT) {
+      headers.push({ key: "Content-Type", value: body.contentType, enabled: true });
+    }
+    for (const h of headers) lines.push(`${h.key}: ${mapOut(h.value)}`);
+    if (body.text) {
+      lines.push("");
+      lines.push(mapOut(body.text));
+    }
+  });
+  const slug2 = collection.name.replace(/\W+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "collection";
+  return [{ path: `${slug2}.http`, content: lines.join("\n") + "\n" }];
+}
 function registerGenerateHandlers(ipc) {
-  ipc.handle("generate:code", (_e, opts) => {
+  handle.handleIpc(ipc, handle.IPC.generate.code, (_e, opts) => {
     const { collection, environment, target } = opts;
     switch (target) {
       case "robot_framework":
@@ -3644,18 +3948,20 @@ function registerGenerateHandlers(ipc) {
         return generateRestAssured(collection, environment);
       case "karate":
         return generateKarate(collection, environment);
+      case "http_file":
+        return generateHttpFile(collection, environment);
       default:
         throw new Error(`Unknown target: ${target}`);
     }
   });
-  ipc.handle("generate:save", async (_e, files, outputDir) => {
+  handle.handleIpc(ipc, handle.IPC.generate.save, async (_e, files, outputDir) => {
     for (const file of files) {
       const fullPath = path.join(outputDir, file.path);
       await promises.mkdir(path.dirname(fullPath), { recursive: true });
       await promises.writeFile(fullPath, file.content, "utf8");
     }
   });
-  ipc.handle("generate:saveZip", async (_e, files, collectionName, target) => {
+  handle.handleIpc(ipc, handle.IPC.generate.saveZip, async (_e, files, collectionName, target) => {
     const colSlug = collectionName.replace(/\W+/g, "-").toLowerCase();
     const targetSlug = target.replace(/_/g, "-");
     const defaultName = `${colSlug}-${targetSlug}.zip`;
@@ -3672,294 +3978,23 @@ function registerGenerateHandlers(ipc) {
     return true;
   });
 }
-async function buildDispatcher(proxy, tls) {
-  const connectOpts = {};
-  let hasTls = false;
-  if (tls) {
-    hasTls = true;
-    if (tls.rejectUnauthorized !== void 0) connectOpts["rejectUnauthorized"] = tls.rejectUnauthorized;
-    if (tls.caCertPath) {
-      try {
-        connectOpts["ca"] = await promises.readFile(tls.caCertPath);
-      } catch {
-      }
-    }
-    if (tls.clientCertPath) {
-      try {
-        connectOpts["cert"] = await promises.readFile(tls.clientCertPath);
-      } catch {
-      }
-    }
-    if (tls.clientKeyPath) {
-      try {
-        connectOpts["key"] = await promises.readFile(tls.clientKeyPath);
-      } catch {
-      }
-    }
-  }
-  if (proxy?.url) {
-    return new undici.ProxyAgent({
-      uri: proxyUri,
-      requestTls: proxyConnect,
-      proxyTls: proxyConnect
-    });
-  }
-  if (hasTls) return new undici.Agent({ connect: connectOpts });
-  return void 0;
-}
-async function executeOne(req, collectionVars, envVars, globals, localVars, dispatcher, piiMaskPatterns, proxy, tls) {
-  if (!req.headers) req.headers = [];
-  if (!req.params) req.params = [];
-  if (!req.body) req.body = { mode: "none" };
-  if (!req.auth) req.auth = { type: "none" };
-  const base = {
-    requestId: req.id,
-    name: req.name,
-    method: req.method,
-    resolvedUrl: "",
-    status: "running"
-  };
-  const dynamicVars = await authBuilder.buildDynamicVars();
-  let vars = authBuilder.mergeVars(envVars, collectionVars, globals, localVars, dynamicVars);
-  let updatedEnvVars = { ...envVars };
-  let updatedCollectionVars = { ...collectionVars };
-  let updatedGlobals = { ...globals };
-  let preScriptError;
-  if (req.preRequestScript?.trim()) {
-    const r = await requestCollection.runScript(authBuilder.interpolate(req.preRequestScript, vars), {
-      envVars: { ...envVars },
-      collectionVars: { ...collectionVars },
-      globals: { ...globals },
-      localVars: {},
-      piiMaskPatterns
-    });
-    preScriptError = r.error;
-    localVars = r.updatedLocalVars;
-    updatedEnvVars = r.updatedEnvVars;
-    updatedCollectionVars = r.updatedCollectionVars;
-    updatedGlobals = r.updatedGlobals;
-    requestCollection.patchGlobals(r.updatedGlobals);
-    await requestCollection.persistGlobals();
-    vars = authBuilder.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
-  }
-  const resolvedUrl = authBuilder.buildUrl(req.url, req.params, vars);
-  base.resolvedUrl = resolvedUrl;
-  const start = Date.now();
-  try {
-    if (req.auth.type === "oauth2") {
-      const now = Date.now();
-      const tokenMissing = !req.auth.oauth2CachedToken;
-      const tokenExpired = req.auth.oauth2TokenExpiry ? req.auth.oauth2TokenExpiry <= now + 5e3 : true;
-      if (tokenMissing || tokenExpired) {
-        const result = await authBuilder.fetchOAuth2Token(req.auth, vars);
-        req.auth.oauth2CachedToken = result.accessToken;
-        req.auth.oauth2TokenExpiry = result.expiresAt;
-      }
-    }
-    const authHeaders = await authBuilder.buildAuthHeaders(req.auth, vars);
-    const headers = new undici.Headers();
-    for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(authBuilder.interpolate(h.key, vars), authBuilder.interpolate(h.value, vars));
-    }
-    for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
-    let body;
-    if (req.body.mode === "json" && req.body.json) {
-      body = authBuilder.interpolate(req.body.json, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
-    } else if (req.body.mode === "raw" && req.body.raw) {
-      body = authBuilder.interpolate(req.body.raw, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", req.body.rawContentType ?? "text/plain");
-    } else if (req.body.mode === "graphql" && req.body.graphql) {
-      const gql = req.body.graphql;
-      const gqlBody = { query: authBuilder.interpolate(gql.query, vars) };
-      const rawVars = gql.variables?.trim();
-      if (rawVars) {
-        try {
-          gqlBody.variables = JSON.parse(authBuilder.interpolate(rawVars, vars));
-        } catch {
-        }
-      }
-      if (gql.operationName?.trim()) gqlBody.operationName = gql.operationName.trim();
-      body = JSON.stringify(gqlBody);
-      if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
-    } else if (req.body.mode === "soap" && req.body.soap) {
-      body = authBuilder.interpolate(req.body.soap.envelope, vars);
-      if (!headers.has("content-type")) headers.set("Content-Type", "text/xml; charset=utf-8");
-      if (req.body.soap.soapAction && !headers.has("soapaction")) {
-        headers.set("SOAPAction", req.body.soap.soapAction);
-      }
-    }
-    const methodHasBody = !["GET", "HEAD"].includes(req.method);
-    const doFetch = (h) => undici.fetch(resolvedUrl, {
-      method: req.method,
-      headers: h,
-      body: methodHasBody ? body : void 0,
-      dispatcher
-    });
-    let fetchResp;
-    if (req.auth.type === "ntlm") {
-      const capturedHeaders = {};
-      headers.forEach((v, k) => {
-        capturedHeaders[k] = v;
-      });
-      fetchResp = await authBuilder.performNtlmRequest({
-        url: resolvedUrl,
-        method: req.method,
-        auth: req.auth,
-        vars,
-        baseHeaders: capturedHeaders,
-        body: methodHasBody ? body : void 0,
-        tls,
-        proxy
-      });
-    } else if (req.auth.type === "digest") {
-      const probeFetch = (url, init) => undici.fetch(url, {
-        ...init,
-        dispatcher
-      });
-      const digestHeader = await authBuilder.performDigestAuth(resolvedUrl, req.method, req.auth, vars, probeFetch);
-      if (digestHeader) headers.set("Authorization", digestHeader);
-      fetchResp = await doFetch(headers);
-    } else {
-      fetchResp = await doFetch(headers);
-    }
-    const responseBody = await fetchResp.text();
-    const durationMs = Date.now() - start;
-    const rawRespHeaders = {};
-    fetchResp.headers.forEach((v, k) => {
-      rawRespHeaders[k] = v;
-    });
-    const maskedBody = requestCollection.maskPii(responseBody, piiMaskPatterns);
-    const maskedHeaders = requestCollection.maskHeaders(rawRespHeaders, piiMaskPatterns);
-    const scriptResponse = {
-      status: fetchResp.status,
-      statusText: fetchResp.statusText,
-      headers: rawRespHeaders,
-      body: responseBody,
-      bodySize: Buffer.byteLength(responseBody, "utf8"),
-      durationMs
-    };
-    const schemaTestResults = requestCollection.buildSchemaTestResults(req.schema, responseBody);
-    const protocolFaultTests = requestCollection.buildProtocolFaultTests(req.body.mode, responseBody);
-    let testResults = [...schemaTestResults, ...protocolFaultTests];
-    let consoleOutput = [];
-    let postScriptError;
-    if (req.postRequestScript?.trim()) {
-      const r = await requestCollection.runScript(authBuilder.interpolate(req.postRequestScript, vars), {
-        envVars: updatedEnvVars,
-        collectionVars: updatedCollectionVars,
-        globals: updatedGlobals,
-        localVars,
-        response: scriptResponse,
-        piiMaskPatterns
-      });
-      testResults = [...schemaTestResults, ...protocolFaultTests, ...r.testResults];
-      consoleOutput = r.consoleOutput;
-      postScriptError = r.error;
-      updatedEnvVars = r.updatedEnvVars;
-      updatedCollectionVars = r.updatedCollectionVars;
-      updatedGlobals = r.updatedGlobals;
-      localVars = r.updatedLocalVars;
-      requestCollection.patchGlobals(r.updatedGlobals);
-      await requestCollection.persistGlobals();
-    }
-    const allPassed = testResults.every((t) => t.passed);
-    const httpFailed = fetchResp.status >= 400;
-    const hasTests = testResults.length > 0;
-    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "passed";
-    if (httpFailed && testResults.length === 0) {
-      testResults = [
-        ...testResults,
-        {
-          name: `HTTP status ${fetchResp.status} ${fetchResp.statusText}`.trim(),
-          passed: false,
-          error: `Request returned ${fetchResp.status} — no assertion was defined to verify the status code.`
-        }
-      ];
-    }
-    const sentHeaders = {};
-    headers.forEach((v, k) => {
-      sentHeaders[k] = v;
-    });
-    return {
-      result: {
-        ...base,
-        status,
-        httpStatus: fetchResp.status,
-        durationMs,
-        testResults,
-        consoleOutput,
-        preScriptError,
-        postScriptError,
-        sentRequest: { headers: sentHeaders, body: body ?? void 0 },
-        receivedResponse: {
-          status: fetchResp.status,
-          statusText: fetchResp.statusText,
-          headers: maskedHeaders,
-          body: maskedBody
-        }
-      },
-      updatedEnvVars,
-      updatedCollectionVars,
-      updatedGlobals,
-      updatedLocalVars: localVars
-    };
-  } catch (err) {
-    return {
-      result: {
-        ...base,
-        status: "error",
-        durationMs: Date.now() - start,
-        error: err instanceof Error ? err.cause instanceof Error ? `${err.message}: ${err.cause.message}` : err.message : String(err),
-        preScriptError
-      },
-      updatedEnvVars,
-      updatedCollectionVars,
-      updatedGlobals,
-      updatedLocalVars: localVars
-    };
-  }
-}
 const sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function registerRunnerHandler(ipc) {
-  ipc.handle("runner:start", async (event, payload) => {
+  handle.handleIpc(ipc, handle.IPC.runner.start, async (event, payload) => {
     const { items, environment, globals: payloadGlobals, proxy, tls, piiMaskPatterns = [], requestDelay = 0 } = payload;
     const envVars = await authBuilder.buildEnvVars(environment);
     const liveGlobals = requestCollection.getGlobals();
     const globals = { ...payloadGlobals, ...liveGlobals };
-    const dispatcher = await buildDispatcher(proxy, tls);
+    const dispatcher = await requestCollection.buildDispatcher(proxy, tls);
     const summary = { total: items.length, passed: 0, failed: 0, errors: 0, skipped: 0, durationMs: 0 };
     const totalStart = Date.now();
     let runEnvVars = { ...envVars };
     let runCollectionVars = {};
     let runGlobals = { ...globals };
     let runLocalVars = {};
-    const failedScopes = /* @__PURE__ */ new Set();
-    const skipRequests = /* @__PURE__ */ new Set();
+    const skipTracker = new requestCollection.HookSkipTracker();
     for (const item of items) {
-      const { isHook, hookType, scopeId, scopeAncestors, mainRequestId } = item;
-      let skipReason;
-      if (isHook) {
-        if (hookType === "beforeAll") {
-          if ((scopeAncestors ?? []).some((id) => failedScopes.has(id))) {
-            skipReason = "Skipped — outer scope hook failed";
-          }
-        } else if (hookType === "before") {
-          const allScopes = [...scopeAncestors ?? [], scopeId].filter(Boolean);
-          if (allScopes.some((id) => failedScopes.has(id))) {
-            skipReason = "Skipped — scope hook failed";
-          } else if (mainRequestId && skipRequests.has(mainRequestId)) {
-            skipReason = "Skipped — before hook failed";
-          }
-        }
-      } else {
-        const allScopes = [...item.scopeAncestors ?? [], item.scopeId].filter(Boolean);
-        if (allScopes.some((id) => failedScopes.has(id))) {
-          skipReason = "Skipped — beforeAll hook failed";
-        } else if (skipRequests.has(item.request.id)) {
-          skipReason = "Skipped — before hook failed";
-        }
-      }
+      const skipReason = skipTracker.shouldSkip(item);
       if (skipReason) {
         const skipped = {
           requestId: item.request.id,
@@ -3975,7 +4010,7 @@ function registerRunnerHandler(ipc) {
           iterationLabel: item.iterationLabel
         };
         summary.failed++;
-        event.sender.send("runner:progress", skipped);
+        event.sender.send(handle.IPC.runner.progress, skipped);
         continue;
       }
       const runningUpdate = {
@@ -3986,35 +4021,28 @@ function registerRunnerHandler(ipc) {
         scopeId: item.scopeId,
         scopePath: item.scopePath
       };
-      event.sender.send("runner:progress", { requestId: item.request.id, ...runningUpdate });
-      const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await executeOne(
-        item.request,
-        { ...item.collectionVars, ...runCollectionVars },
-        runEnvVars,
-        runGlobals,
-        { ...runLocalVars, ...item.dataRow ?? {} },
+      event.sender.send(handle.IPC.runner.progress, { requestId: item.request.id, ...runningUpdate });
+      const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await requestCollection.executeRunnerRequest({
+        req: item.request,
+        collectionVars: { ...item.collectionVars, ...runCollectionVars },
+        envVars: runEnvVars,
+        globals: runGlobals,
+        localVars: { ...runLocalVars, ...item.dataRow ?? {} },
         dispatcher,
         piiMaskPatterns,
         proxy,
         tls
-      );
+      });
       runEnvVars = updatedEnvVars;
       runCollectionVars = updatedCollectionVars;
       runGlobals = updatedGlobals;
       runLocalVars = updatedLocalVars;
-      const hookFailed = result.status === "failed" || result.status === "error";
-      if (isHook && hookFailed) {
-        if (hookType === "beforeAll" && scopeId) {
-          failedScopes.add(scopeId);
-        } else if (hookType === "before" && mainRequestId) {
-          skipRequests.add(mainRequestId);
-        }
-      }
+      skipTracker.recordResult(item, result.status);
       if (result.status === "passed") summary.passed++;
       else if (result.status === "failed") summary.failed++;
       else if (result.status === "skipped") summary.skipped++;
       else summary.errors++;
-      event.sender.send("runner:progress", {
+      event.sender.send(handle.IPC.runner.progress, {
         ...result,
         iterationLabel: item.iterationLabel,
         isHook: item.isHook,
@@ -4031,26 +4059,26 @@ function registerRunnerHandler(ipc) {
   });
 }
 function registerMockHandlers(ipc) {
-  ipc.handle("mock:start", async (e, server) => {
-    mockServer.setHitCallback((hit) => e.sender.send("mock:hit", hit));
+  handle.handleIpc(ipc, handle.IPC.mock.start, async (e, server) => {
+    mockServer.setHitCallback((hit) => e.sender.send(handle.IPC.mock.hit, hit));
     await mockServer.startMock(server);
   });
-  ipc.handle("mock:stop", async (_e, id) => {
+  handle.handleIpc(ipc, handle.IPC.mock.stop, async (_e, id) => {
     await mockServer.stopMock(id);
   });
-  ipc.handle("mock:isRunning", (_e, id) => mockServer.isRunning(id));
-  ipc.handle("mock:updateRoutes", (_e, id, routes) => {
+  handle.handleIpc(ipc, handle.IPC.mock.isRunning, (_e, id) => mockServer.isRunning(id));
+  handle.handleIpc(ipc, handle.IPC.mock.updateRoutes, (_e, id, routes) => {
     mockServer.updateMockRoutes(id, routes);
   });
-  ipc.handle("mock:runningIds", () => mockServer.getRunningIds());
-  ipc.handle("file:saveMock", async (_e, relPath, server) => {
+  handle.handleIpc(ipc, handle.IPC.mock.runningIds, () => mockServer.getRunningIds());
+  handle.handleIpc(ipc, handle.IPC.file.saveMock, async (_e, relPath, server) => {
     const wsDir = getWorkspaceDir();
     if (!wsDir) throw new Error("No workspace open");
     const fullPath = path.join(wsDir, relPath);
     await promises.mkdir(path.dirname(fullPath), { recursive: true });
     await promises.writeFile(fullPath, JSON.stringify(server, null, 2), "utf8");
   });
-  ipc.handle("file:loadMock", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.file.loadMock, async (_e, relPath) => {
     const wsDir = getWorkspaceDir();
     if (!wsDir) throw new Error("No workspace open");
     const raw = await promises.readFile(path.join(wsDir, relPath), "utf8");
@@ -4058,7 +4086,7 @@ function registerMockHandlers(ipc) {
   });
 }
 function registerOAuth2Handlers(ipc) {
-  ipc.handle("oauth2:startFlow", async (_e, auth, vars) => {
+  handle.handleIpc(ipc, handle.IPC.oauth2.startFlow, async (_e, auth, vars) => {
     const port = auth.oauth2RedirectPort ?? 9876;
     const redirectUri = `http://localhost:${port}/callback`;
     const authUrl = authBuilder.interpolate(auth.oauth2AuthUrl ?? "", vars);
@@ -4142,7 +4170,7 @@ function registerOAuth2Handlers(ipc) {
       refreshToken: json["refresh_token"] ? String(json["refresh_token"]) : void 0
     };
   });
-  ipc.handle("oauth2:refreshToken", async (_e, auth, vars, refreshToken) => {
+  handle.handleIpc(ipc, handle.IPC.oauth2.refreshToken, async (_e, auth, vars, refreshToken) => {
     const tokenUrl = authBuilder.interpolate(auth.oauth2TokenUrl ?? "", vars);
     const clientId = authBuilder.interpolate(auth.oauth2ClientId ?? "", vars);
     let clientSecret = auth.oauth2ClientSecret ?? "";
@@ -4188,17 +4216,17 @@ function closeAllWsConnections() {
   connections.clear();
 }
 function registerWsHandlers(ipc) {
-  ipc.handle("ws:connect", async (event, requestId, url, headers) => {
+  handle.handleIpc(ipc, handle.IPC.ws.connect, async (event, requestId, url, headers) => {
     const existing = connections.get(requestId);
     if (existing) {
       existing.close();
       connections.delete(requestId);
     }
-    event.sender.send("ws:status", { requestId, status: "connecting" });
+    event.sender.send(handle.IPC.ws.status, { requestId, status: "connecting" });
     const ws = new WebSocket(url, { headers });
     connections.set(requestId, ws);
     ws.on("open", () => {
-      event.sender.send("ws:status", { requestId, status: "connected" });
+      event.sender.send(handle.IPC.ws.status, { requestId, status: "connected" });
     });
     ws.on("message", (data) => {
       const message = {
@@ -4207,25 +4235,25 @@ function registerWsHandlers(ipc) {
         data: data.toString(),
         timestamp: Date.now()
       };
-      event.sender.send("ws:message", { requestId, message });
+      event.sender.send(handle.IPC.ws.message, { requestId, message });
     });
     ws.on("error", (err) => {
-      event.sender.send("ws:status", { requestId, status: "error", error: err.message });
+      event.sender.send(handle.IPC.ws.status, { requestId, status: "error", error: err.message });
       connections.delete(requestId);
     });
     ws.on("close", () => {
-      event.sender.send("ws:status", { requestId, status: "disconnected" });
+      event.sender.send(handle.IPC.ws.status, { requestId, status: "disconnected" });
       connections.delete(requestId);
     });
   });
-  ipc.handle("ws:send", async (_event, requestId, data) => {
+  handle.handleIpc(ipc, handle.IPC.ws.send, async (_event, requestId, data) => {
     const ws = connections.get(requestId);
     if (!ws || ws.readyState !== WebSocket.OPEN) {
       throw new Error("WebSocket is not connected");
     }
     ws.send(data);
   });
-  ipc.handle("ws:disconnect", async (_event, requestId) => {
+  handle.handleIpc(ipc, handle.IPC.ws.disconnect, async (_event, requestId) => {
     const ws = connections.get(requestId);
     if (ws) {
       ws.close();
@@ -4516,7 +4544,7 @@ ${body}
 </html>`;
 }
 function registerDocsHandlers(ipc) {
-  ipc.handle("docs:generate", async (_event, payload) => {
+  handle.handleIpc(ipc, handle.IPC.docs.generate, async (_event, payload) => {
     if (payload.format === "html") {
       return generateHtml(payload);
     }
@@ -4564,9 +4592,9 @@ async function resolveSnapshotSpec(relPath) {
   return { specPath: tmp };
 }
 function registerContractHandlers(ipc) {
-  ipc.handle("contract:run", async (_e, payload) => {
+  handle.handleIpc(ipc, handle.IPC.contract.run, async (_e, payload) => {
     ipcValidate.validateContractRunPayload(payload);
-    const { mode, requests, envVars, collectionVars = {}, requestBaseUrl } = payload;
+    const { mode, requests, envVars, collectionVars = {}, requestBaseUrl, providerBaseUrl, stateHandlerUrl } = payload;
     let { specUrl, specPath } = payload;
     if (payload.specSnapshotRelPath) {
       const resolved = await resolveSnapshotSpec(payload.specSnapshotRelPath);
@@ -4578,15 +4606,27 @@ function registerContractHandlers(ipc) {
         return snapshots.runConsumerContracts(requests, envVars, collectionVars);
       case "provider":
         return snapshots.runProviderVerification(requests, envVars, specUrl, specPath, requestBaseUrl);
+      case "provider-live":
+        return snapshots.runLiveProviderVerification(requests, envVars, collectionVars, providerBaseUrl, stateHandlerUrl);
       case "bidirectional":
         return snapshots.runBidirectional(requests, envVars, collectionVars, specUrl, specPath, requestBaseUrl);
     }
   });
-  ipc.handle("contract:inferSchema", (_e, jsonBody) => {
+  handle.handleIpc(ipc, handle.IPC.contract.inferSchema, (_e, jsonBody) => {
     const schema = inferSchemaFromJson(jsonBody);
     return schema ? JSON.stringify(schema, null, 2) : null;
   });
-  ipc.handle("contract:captureSnapshot", async (_e, opts) => {
+  handle.handleIpc(ipc, handle.IPC.contract.exportReportHtml, async (_e, report, meta = {}) => {
+    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      title: "Save contract report",
+      defaultPath: `contract-report-${report.mode}.html`,
+      filters: [{ name: "HTML", extensions: ["html"] }]
+    });
+    if (canceled || !filePath) return false;
+    await promises.writeFile(filePath, snapshots.reportToHtml(report, { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...meta }), "utf8");
+    return true;
+  });
+  handle.handleIpc(ipc, handle.IPC.contract.captureSnapshot, async (_e, opts) => {
     const dir = getWorkspaceDir();
     if (!dir) throw new Error("No workspace open — cannot capture snapshot.");
     const snapshot = await snapshots.captureSnapshot(dir, opts);
@@ -4594,17 +4634,17 @@ function registerContractHandlers(ipc) {
     if (!relPath) throw new Error("Snapshot created but relPath was not attached.");
     return { relPath, snapshot };
   });
-  ipc.handle("contract:listSnapshots", async (_e, registered = []) => {
+  handle.handleIpc(ipc, handle.IPC.contract.listSnapshots, async (_e, registered = []) => {
     const dir = getWorkspaceDir();
     if (!dir) return [];
     return snapshots.listSnapshots(dir, registered);
   });
-  ipc.handle("contract:loadSnapshot", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.contract.loadSnapshot, async (_e, relPath) => {
     const dir = getWorkspaceDir();
     if (!dir) throw new Error("No workspace open.");
     return snapshots.loadSnapshot(dir, relPath);
   });
-  ipc.handle("contract:deleteSnapshot", async (_e, relPath) => {
+  handle.handleIpc(ipc, handle.IPC.contract.deleteSnapshot, async (_e, relPath) => {
     const dir = getWorkspaceDir();
     if (!dir) return;
     await snapshots.deleteSnapshot(dir, relPath);
@@ -4616,7 +4656,7 @@ function git() {
   return simpleGit.simpleGit(dir);
 }
 function registerGitHandlers(ipc) {
-  ipc.handle("git:isRepo", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.isRepo, async () => {
     const dir = getWorkspaceDir();
     if (!dir) return false;
     try {
@@ -4626,12 +4666,12 @@ function registerGitHandlers(ipc) {
       return false;
     }
   });
-  ipc.handle("git:init", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.init, async () => {
     await git().init();
     const dir = getWorkspaceDir();
     if (dir) await ensureGitignore(dir);
   });
-  ipc.handle("git:status", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.status, async () => {
     const result = await git().status();
     return {
       staged: result.staged.map((f) => ({ path: f, status: resolveStatus(result, f, true) })),
@@ -4644,40 +4684,40 @@ function registerGitHandlers(ipc) {
       remote: result.tracking ?? null
     };
   });
-  ipc.handle("git:resolveOurs", async (_e, filePath) => {
+  handle.handleIpc(ipc, handle.IPC.git.resolveOurs, async (_e, filePath) => {
     const g = git();
     await g.checkout(["--ours", "--", filePath]);
     await g.add([filePath]);
   });
-  ipc.handle("git:resolveTheirs", async (_e, filePath) => {
+  handle.handleIpc(ipc, handle.IPC.git.resolveTheirs, async (_e, filePath) => {
     const g = git();
     await g.checkout(["--theirs", "--", filePath]);
     await g.add([filePath]);
   });
-  ipc.handle("git:markResolved", async (_e, filePath) => {
+  handle.handleIpc(ipc, handle.IPC.git.markResolved, async (_e, filePath) => {
     await git().add([filePath]);
   });
-  ipc.handle("git:diff", async (_e, filePath) => {
+  handle.handleIpc(ipc, handle.IPC.git.diff, async (_e, filePath) => {
     if (filePath) return git().diff(["--", filePath]);
     return git().diff();
   });
-  ipc.handle("git:diffStaged", async (_e, filePath) => {
+  handle.handleIpc(ipc, handle.IPC.git.diffStaged, async (_e, filePath) => {
     if (filePath) return git().diff(["--cached", "--", filePath]);
     return git().diff(["--cached"]);
   });
-  ipc.handle("git:stage", async (_e, paths) => {
+  handle.handleIpc(ipc, handle.IPC.git.stage, async (_e, paths) => {
     await git().add(paths);
   });
-  ipc.handle("git:unstage", async (_e, paths) => {
+  handle.handleIpc(ipc, handle.IPC.git.unstage, async (_e, paths) => {
     await git().reset(["HEAD", "--", ...paths]);
   });
-  ipc.handle("git:stageAll", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.stageAll, async () => {
     await git().add(["."]);
   });
-  ipc.handle("git:commit", async (_e, message) => {
+  handle.handleIpc(ipc, handle.IPC.git.commit, async (_e, message) => {
     await git().commit(message);
   });
-  ipc.handle("git:log", async (_e, limit = 50) => {
+  handle.handleIpc(ipc, handle.IPC.git.log, async (_e, limit = 50) => {
     const result = await git().log({ maxCount: limit });
     return result.all.map((c) => ({
       hash: c.hash,
@@ -4688,7 +4728,7 @@ function registerGitHandlers(ipc) {
       date: c.date
     }));
   });
-  ipc.handle("git:branches", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.branches, async () => {
     const raw = await git().raw([
       "for-each-ref",
       "--format=%(refname:short)|%(HEAD)|%(upstream:short)|%(upstream:track)",
@@ -4720,7 +4760,7 @@ function registerGitHandlers(ipc) {
     }
     return branches;
   });
-  ipc.handle("git:checkout", async (_e, branch, create) => {
+  handle.handleIpc(ipc, handle.IPC.git.checkout, async (_e, branch, create) => {
     if (create) {
       await git().checkoutLocalBranch(branch);
       return;
@@ -4739,13 +4779,13 @@ function registerGitHandlers(ipc) {
     }
     await git().checkout(branch);
   });
-  ipc.handle("git:deleteBranch", async (_e, name, force = false) => {
+  handle.handleIpc(ipc, handle.IPC.git.deleteBranch, async (_e, name, force = false) => {
     await git().deleteLocalBranch(name, force);
   });
-  ipc.handle("git:pull", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.pull, async () => {
     await git().pull();
   });
-  ipc.handle("git:push", async (_e, setUpstream) => {
+  handle.handleIpc(ipc, handle.IPC.git.push, async (_e, setUpstream) => {
     if (setUpstream) {
       const status = await git().status();
       await git().push(["--set-upstream", "origin", status.current ?? "main"]);
@@ -4753,20 +4793,20 @@ function registerGitHandlers(ipc) {
       await git().push();
     }
   });
-  ipc.handle("git:remotes", async () => {
+  handle.handleIpc(ipc, handle.IPC.git.remotes, async () => {
     const result = await git().getRemotes(true);
     return result.map((r) => ({ name: r.name, url: r.refs.fetch || r.refs.push || "" }));
   });
-  ipc.handle("git:addRemote", async (_e, name, url) => {
+  handle.handleIpc(ipc, handle.IPC.git.addRemote, async (_e, name, url) => {
     await git().addRemote(name, url);
   });
-  ipc.handle("git:setRemoteUrl", async (_e, name, url) => {
+  handle.handleIpc(ipc, handle.IPC.git.setRemoteUrl, async (_e, name, url) => {
     await git().remote(["set-url", name, url]);
   });
-  ipc.handle("git:removeRemote", async (_e, name) => {
+  handle.handleIpc(ipc, handle.IPC.git.removeRemote, async (_e, name) => {
     await git().removeRemote(name);
   });
-  ipc.handle("git:writeCiFile", async (_e, relPath, content) => {
+  handle.handleIpc(ipc, handle.IPC.git.writeCiFile, async (_e, relPath, content) => {
     const wsDir = getWorkspaceDir();
     if (!wsDir) throw new Error("No workspace open");
     const fullPath = path.join(wsDir, relPath);
@@ -4785,20 +4825,20 @@ function resolveStatus(result, filePath, staged) {
   return "modified";
 }
 function registerRecordHandlers(ipc, getWebContents) {
-  ipc.handle("record:start", async (_e, config) => {
+  handle.handleIpc(ipc, handle.IPC.record.start, async (_e, config) => {
     await recorder.startRecorder(config);
     recorder.setRecorderHitCallback((entry) => {
-      getWebContents()?.send("record:hit", entry);
+      getWebContents()?.send(handle.IPC.record.hit, entry);
     });
   });
-  ipc.handle("record:stop", async () => {
+  handle.handleIpc(ipc, handle.IPC.record.stop, async () => {
     const session = recorder.stopRecorder();
     recorder.setRecorderHitCallback(null);
     return session;
   });
-  ipc.handle("record:isRunning", () => recorder.isRecorderRunning());
-  ipc.handle("record:entries", () => recorder.getRecorderEntries());
-  ipc.handle("record:toMock", (_e, entries, upstream, name, port) => {
+  handle.handleIpc(ipc, handle.IPC.record.isRunning, () => recorder.isRecorderRunning());
+  handle.handleIpc(ipc, handle.IPC.record.entries, () => recorder.getRecorderEntries());
+  handle.handleIpc(ipc, handle.IPC.record.toMock, (_e, entries, upstream, name, port) => {
     return recorder.entriesToMockServer(entries, upstream, name, port);
   });
 }
@@ -4892,7 +4932,7 @@ electron.app.whenReady().then(async () => {
   if (process.platform !== "darwin") electron.Menu.setApplicationMenu(null);
   await authBuilder.initSecretStore(electron.app.getPath("userData"));
   registerFileHandlers(electron.ipcMain);
-  requestCollection.registerRequestHandler(electron.ipcMain);
+  registerRequestHandler(electron.ipcMain);
   authBuilder.registerSecretHandlers(electron.ipcMain);
   registerImportHandlers(electron.ipcMain);
   registerGenerateHandlers(electron.ipcMain);
@@ -4905,7 +4945,7 @@ electron.app.whenReady().then(async () => {
   registerContractHandlers(electron.ipcMain);
   registerGitHandlers(electron.ipcMain);
   registerRecordHandlers(electron.ipcMain, () => electron.BrowserWindow.getAllWindows()[0]?.webContents ?? null);
-  electron.ipcMain.handle("shell:openExternal", (_e, url) => electron.shell.openExternal(url));
+  handle.handleIpc(electron.ipcMain, handle.IPC.shell.openExternal, (_e, url) => electron.shell.openExternal(url));
   createWindow();
   electron.app.on("activate", () => {
     if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();