@testsmith/api-spector 0.7.7 → 0.7.8

package/out/main/index.js

@@ -22,29 +22,33 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 const electron = require("electron");
-const handle = require("./chunks/handle-Bz0C56Eq.js");
+const handle = require("./chunks/handle-Crv1i9hb.js");
 const path = require("node:path");
 const fs = require("node:fs");
 const promises = require("node:fs/promises");
 const crypto = require("node:crypto");
 const JSZip = require("jszip");
 const dataFiles = require("./chunks/data-files-BYqhsoPe.js");
-const requestExec = require("./chunks/request-exec-B-F0K-pN.js");
+const requestExec = require("./chunks/request-exec-Cv2jkrO1.js");
 const ipcValidate = require("./chunks/ipc-validate-sqUFqRmE.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
-const requestCollection = require("./chunks/request-collection-KGPuvN7o.js");
-const flowEngine = require("./chunks/flow-engine-BVzjz4lJ.js");
+const requestCollection = require("./chunks/request-collection-gkOYlWml.js");
+const runConcurrent = require("./chunks/run-concurrent-468tH0AX.js");
+const flowEngine = require("./chunks/flow-engine-BxwjEy37.js");
 const mockServer = require("./chunks/mock-server-C4kTFkod.js");
 const http = require("node:http");
 const WebSocket = require("ws");
+const socket_ioClient = require("socket.io-client");
+const mqtt = require("mqtt");
+const perfReport = require("./chunks/perf-report-ChaO3K0w.js");
 const os = require("node:os");
 const grpc = require("@grpc/grpc-js");
 const protoLoader = require("@grpc/proto-loader");
-const soapHandler = require("./chunks/soap-handler-DqIPcIQL.js");
+const soapHandler = require("./chunks/soap-handler-Brr7BPWO.js");
 const escape = require("./chunks/escape-DDVAlOvZ.js");
-const brokerClient = require("./chunks/broker-client-Df4PpJqB.js");
+const brokerClient = require("./chunks/broker-client-BYpWeOWT.js");
 const simpleGit = require("simple-git");
 const recorder = require("./chunks/recorder-BkO8G_mB.js");
 const electronUpdater = require("electron-updater");
@@ -1257,11 +1261,11 @@ function parseFolder(item, requests, collectionAuth) {
     folders: [],
     requestIds: []
   };
-  for (const child of item.item ?? []) {
-    if (Array.isArray(child.item)) {
-      folder.folders.push(parseFolder(child, requests, collectionAuth));
+  for (const child2 of item.item ?? []) {
+    if (Array.isArray(child2.item)) {
+      folder.folders.push(parseFolder(child2, requests, collectionAuth));
     } else {
-      const req = parseRequest(child, collectionAuth);
+      const req = parseRequest(child2, collectionAuth);
       requests[req.id] = req;
       folder.requestIds.push(req.id);
     }
@@ -1415,12 +1419,29 @@ function buildResponseSchema(operation, spec) {
   }
   return void 0;
 }
-function buildBody(operation, spec) {
-  const content = resolve(spec, operation.requestBody?.content ?? {});
-  if ("application/json" in content) {
-    const schema = resolve(spec, content["application/json"].schema ?? {});
-    const example = schemaToExample(schema);
-    return { mode: "json", json: JSON.stringify(example, null, 2) };
+function buildBody(rawOperation, params, spec) {
+  const requestBody = resolve(spec, rawOperation?.requestBody ?? {}, /* @__PURE__ */ new Set());
+  const content = requestBody?.content ?? {};
+  const jsonKey = Object.keys(content).find((k) => k.includes("json"));
+  if (jsonKey) {
+    return { mode: "json", json: JSON.stringify(schemaToExample(content[jsonKey].schema ?? {}), null, 2) };
+  }
+  const bodyParam = params.find((p) => p?.in === "body");
+  if (bodyParam) {
+    const schema = resolve(spec, bodyParam.schema ?? {}, /* @__PURE__ */ new Set());
+    return { mode: "json", json: JSON.stringify(schemaToExample(schema), null, 2) };
+  }
+  const formParams = params.filter((p) => p?.in === "formData");
+  if (formParams.length) {
+    return {
+      mode: "form",
+      form: formParams.map((p) => ({
+        key: String(p.name ?? ""),
+        value: String(schemaToExample(p.schema ?? p) ?? ""),
+        enabled: p.required ?? false,
+        description: p.description ?? ""
+      }))
+    };
   }
   return { mode: "none" };
 }
@@ -1463,17 +1484,28 @@ function buildExamples(operation, spec, baseParams, baseHeaders, baseBody) {
   }
   return examples.length ? examples : void 0;
 }
+function enumChoices(schema) {
+  if (!schema || !Array.isArray(schema.enum) || !schema.enum.length) return void 0;
+  return schema.enum.filter((v) => v !== null && v !== void 0).map((v) => String(v));
+}
 function buildParams(operation) {
-  return (operation.parameters ?? []).filter((p) => p.in === "query").map((p) => ({
-    key: p.name,
-    value: String(schemaToExample(p.schema ?? {}) ?? ""),
-    enabled: p.required ?? false,
-    description: p.description ?? ""
-  }));
+  return (operation.parameters ?? []).filter((p) => p.in === "query").map((p) => {
+    const schema = p.schema ?? p;
+    const choices = enumChoices(schema);
+    return {
+      key: p.name,
+      // When the schema is an enum, default to its first value so the dropdown
+      // starts on a valid choice; otherwise use the usual example.
+      value: choices ? choices[0] : String(schemaToExample(schema) ?? ""),
+      enabled: p.required ?? false,
+      description: p.description ?? "",
+      ...choices ? { enum: choices } : {}
+    };
+  });
 }
 function buildPathParamRows(operation) {
   return (operation.parameters ?? []).filter((p) => p.in === "path" && p.name).map((p) => {
-    const schema = p.schema ?? {};
+    const schema = p.schema ?? p;
     let value;
     if (p.example !== void 0) value = p.example;
     else if (schema.example !== void 0) value = schema.example;
@@ -1492,12 +1524,14 @@ function buildPathParamRows(operation) {
           value = "";
       }
     }
+    const choices = enumChoices(schema);
     return {
       key: String(p.name),
       value: value === null || value === void 0 ? "" : String(value),
       enabled: true,
       description: p.description ?? "",
-      paramType: "path"
+      paramType: "path",
+      ...choices ? { enum: choices } : {}
     };
   });
 }
@@ -1534,10 +1568,17 @@ function buildAuth(security, securitySchemes) {
   return { type: "none" };
 }
 const HTTP_METHODS$1 = ["get", "post", "put", "patch", "delete", "head", "options", "query"];
+function resolveBaseUrl(spec) {
+  if (Array.isArray(spec.servers) && spec.servers[0]?.url) return String(spec.servers[0].url).replace(/\/$/, "");
+  if (spec.host) {
+    const scheme = Array.isArray(spec.schemes) && spec.schemes[0] || "https";
+    return `${scheme}://${spec.host}${spec.basePath ?? ""}`.replace(/\/$/, "");
+  }
+  return "";
+}
 function buildCollection(spec) {
   const info = spec.info ?? {};
-  const servers = spec.servers ?? [{}];
-  const baseUrl = servers[0]?.url ?? "";
+  const baseUrl = resolveBaseUrl(spec);
   const securitySchemes = resolve(spec, spec.components?.securitySchemes ?? {});
   const globalSecurity = spec.security ?? [];
   const requests = {};
@@ -1548,23 +1589,23 @@ function buildCollection(spec) {
   }
   for (const [pathStr, pathItem] of Object.entries(spec.paths ?? {})) {
     const resolved = resolve(spec, pathItem);
-    const pathLevelParams = resolved.parameters ?? [];
     for (const method of HTTP_METHODS$1) {
       const operation = resolved[method];
       if (!operation) continue;
       const tags = operation.tags?.length ? operation.tags : ["default"];
       const tag = tags[0];
-      const allParams = [...pathLevelParams, ...operation.parameters ?? []];
+      const rawOperation = pathItem[method] ?? {};
+      const rawParams = [...pathItem.parameters ?? [], ...rawOperation.parameters ?? []];
+      const allParams = rawParams.map((p) => resolve(spec, p, /* @__PURE__ */ new Set()));
       const opWithParams = { ...operation, parameters: allParams };
       const security = operation.security ?? globalSecurity;
       const params = [
         ...buildPathParamRows(opWithParams),
         ...buildParams(opWithParams)
       ];
-      const rawOperation = pathItem[method];
       const responseSchema = buildResponseSchema(rawOperation, spec);
       const headers = buildHeaders(opWithParams);
-      const body = buildBody(opWithParams, spec);
+      const body = buildBody(rawOperation, allParams, spec);
       const examples = buildExamples(opWithParams, spec, params, headers, body);
       const req = {
         id: uuid.v4(),
@@ -1576,7 +1617,7 @@ function buildCollection(spec) {
         auth: buildAuth(security, securitySchemes),
         body,
         description: operation.description || operation.summary || "",
-        meta: { tags },
+        meta: { tags, ...operation.operationId ? { operationId: String(operation.operationId) } : {} },
         ...responseSchema ? { schema: responseSchema } : {},
         ...examples ? { examples } : {}
       };
@@ -2054,6 +2095,421 @@ async function importHttpFile(filePath) {
   const name = path.basename(filePath).replace(/\.(http|rest)$/i, "") || "Imported HTTP";
   return parseHttpFile(raw, name);
 }
+const STATIC_EXT = /\.(?:js|mjs|cjs|css|png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|otf|eot|map|mp4|webm|mp3|wav)(?:\?|#|$)/i;
+const SKIP_HEADER = /* @__PURE__ */ new Set(["host", "connection", "content-length", "accept-encoding", "cookie"]);
+function isApiLike(entry) {
+  const rt = (entry._resourceType ?? "").toLowerCase();
+  if (rt) return rt === "xhr" || rt === "fetch";
+  const url = entry.request?.url ?? "";
+  if (STATIC_EXT.test(url)) return false;
+  const ct = (entry.response?.content?.mimeType ?? "").toLowerCase();
+  if (ct.startsWith("image/") || ct.startsWith("font/") || ct.startsWith("audio/") || ct.startsWith("video/")) return false;
+  if (ct.includes("css") || ct.includes("javascript")) return false;
+  return true;
+}
+function bodyFrom(postData) {
+  if (!postData) return { mode: "none" };
+  const mime = (postData.mimeType ?? "").toLowerCase();
+  if (postData.params && postData.params.length && mime.includes("x-www-form-urlencoded")) {
+    return { mode: "form", form: postData.params.map((p) => ({ key: p.name, value: p.value ?? "", enabled: true })) };
+  }
+  const text = postData.text ?? "";
+  if (!text.trim()) return { mode: "none" };
+  if (mime.includes("json")) return { mode: "json", json: text };
+  return { mode: "raw", raw: text, rawContentType: postData.mimeType || "text/plain" };
+}
+function requestName(method, url) {
+  try {
+    const u = new URL(url);
+    const path2 = u.pathname.replace(/\/+$/, "") || "/";
+    return `${method} ${path2}`;
+  } catch {
+    return `${method} ${url}`;
+  }
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "other";
+  }
+}
+function harToCollection(data, name) {
+  const entries = data.log?.entries;
+  if (!Array.isArray(entries)) throw new Error("Not a HAR file (no log.entries array found).");
+  const requests = {};
+  const byHost = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const r = entry.request;
+    if (!r?.url || !r.method || !isApiLike(entry)) continue;
+    const body = bodyFrom(r.postData);
+    const bodyText = body.mode === "json" ? body.json ?? "" : body.mode === "raw" ? body.raw ?? "" : "";
+    const dedupeKey = `${r.method} ${r.url} ${bodyText}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    const headers = (r.headers ?? []).filter((h) => h.name && !h.name.startsWith(":") && !SKIP_HEADER.has(h.name.toLowerCase())).map((h) => ({ key: h.name, value: h.value ?? "", enabled: true }));
+    const req = {
+      id: uuid.v4(),
+      name: requestName(r.method, r.url),
+      method: r.method,
+      url: r.url,
+      headers,
+      params: [],
+      auth: { type: "none" },
+      body
+    };
+    requests[req.id] = req;
+    const host = hostOf(r.url);
+    const list = byHost.get(host) ?? [];
+    list.push(req.id);
+    byHost.set(host, list);
+  }
+  const folders = [...byHost.entries()].map(([host, requestIds]) => ({
+    id: uuid.v4(),
+    name: host,
+    description: "",
+    folders: [],
+    requestIds
+  }));
+  return {
+    version: "1.0",
+    id: uuid.v4(),
+    name: name || "Imported HAR",
+    description: "",
+    // Single host collapses to a flat list; multiple hosts group into folders.
+    rootFolder: folders.length === 1 ? { id: uuid.v4(), name: "root", description: "", folders: [], requestIds: folders[0].requestIds } : { id: uuid.v4(), name: "root", description: "", folders, requestIds: [] },
+    requests
+  };
+}
+async function importHar(filePath) {
+  const raw = await promises.readFile(filePath, "utf8");
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    throw new Error("Not valid JSON — pick a .har file exported from your browser or proxy.");
+  }
+  return harToCollection(data, path.basename(filePath).replace(/\.har$/i, ""));
+}
+function jsonPointerToAccessor(pointer) {
+  const parts = pointer.split("/").filter((p) => p !== "");
+  let out = "";
+  for (const raw of parts) {
+    const part = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (/^\d+$/.test(part)) out += `[${part}]`;
+    else if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part)) out += `.${part}`;
+    else out += `[${JSON.stringify(part)}]`;
+  }
+  return out;
+}
+function translateRuntimeExpr(expr, warn) {
+  const e = expr.trim();
+  if (e === "$statusCode") return "sp.response.code";
+  if (e === "$response.body") return "sp.response.json()";
+  let m = /^\$response\.body#(\/.*)$/.exec(e);
+  if (m) return `sp.response.json()${jsonPointerToAccessor(m[1])}`;
+  m = /^\$response\.header[s]?\.(.+)$/.exec(e);
+  if (m) return `sp.response.headers.get(${JSON.stringify(m[1])})`;
+  m = /^\$inputs\.(.+)$/.exec(e);
+  if (m) return `sp.variables.get(${JSON.stringify(m[1])})`;
+  m = /^\$(?:steps|workflows)\.[^.]+\.outputs\.(.+)$/.exec(e);
+  if (m) return `sp.variables.get(${JSON.stringify(m[1])})`;
+  m = /^\$outputs\.(.+)$/.exec(e);
+  if (m) return `sp.variables.get(${JSON.stringify(m[1])})`;
+  warn?.(`Could not translate runtime expression: ${e}`);
+  return `/* TODO: ${e} */ undefined`;
+}
+function translateTemplateValue(value, warn) {
+  if (typeof value !== "string") return value == null ? "" : JSON.stringify(value);
+  if (/^\$[A-Za-z]/.test(value)) {
+    const m = /^\$(?:inputs|outputs)\.(.+)$/.exec(value) ?? /^\$(?:steps|workflows)\.[^.]+\.outputs\.(.+)$/.exec(value);
+    if (m) return `{{${m[1]}}}`;
+    warn?.(`Parameter value uses an expression that needs a variable: ${value}`);
+    return value;
+  }
+  return value.replace(/\{\$([^}]+)\}/g, (_full, inner) => {
+    const ref = `$${inner}`;
+    const m = /^\$(?:inputs|outputs)\.(.+)$/.exec(ref) ?? /^\$(?:steps|workflows)\.[^.]+\.outputs\.(.+)$/.exec(ref);
+    if (m) return `{{${m[1]}}}`;
+    warn?.(`Embedded expression left as-is: {$${inner}}`);
+    return `{$${inner}}`;
+  });
+}
+function translateCondition(cond, warn) {
+  const translated = cond.replace(/\$[A-Za-z][\w.#/~[\]]*/g, (tok) => `(${translateRuntimeExpr(tok, warn)})`);
+  return translated.replace(/([^=!<>])={2}([^=])/g, "$1===$2").replace(/!={1}([^=])/g, "!==$1");
+}
+function buildValidateScript(criteria, warn) {
+  const lines = [];
+  criteria.forEach((c, i) => {
+    const name = `criterion ${i + 1}`;
+    const type = c.type?.type ?? c.type;
+    if (type === "regex") {
+      const ctx = c.context ? translateRuntimeExpr(c.context, warn) : "sp.response.text()";
+      lines.push(`sp.test(${JSON.stringify(name)}, () => { sp.expect(String(${ctx})).to.match(${toRegexLiteral(c.condition)}); });`);
+    } else if (type === "jsonpath") {
+      const ctx = c.context ? translateRuntimeExpr(c.context, warn) : "sp.response.json()";
+      lines.push(`sp.test(${JSON.stringify(name)}, () => { sp.expect(sp.jsonPath(${ctx}, ${JSON.stringify(c.condition)}).length).to.be.above(0); });`);
+    } else if (type === "xpath") {
+      warn?.(`xpath successCriteria left as a TODO: ${c.condition}`);
+      lines.push(`sp.test(${JSON.stringify(name)}, () => { /* TODO xpath: ${c.condition} */ });`);
+    } else {
+      lines.push(`sp.test(${JSON.stringify(name)}, () => { sp.expect(Boolean(${translateCondition(String(c.condition), warn)})).to.equal(true); });`);
+    }
+  });
+  return lines.join("\n");
+}
+function toRegexLiteral(pattern) {
+  return `/${String(pattern).replace(/\//g, "\\/")}/`;
+}
+function buildOutputsScript(outputs, warn) {
+  return Object.entries(outputs).map(([name, expr]) => `sp.variables.set(${JSON.stringify(name)}, ${typeof expr === "string" && expr.startsWith("$") ? translateRuntimeExpr(expr, warn) : JSON.stringify(expr)});`).join("\n");
+}
+function resolveStepOperation(step, ctx) {
+  const candidates = [];
+  const add = (v) => {
+    if (typeof v !== "string" || !v) return;
+    candidates.push(v);
+    const tail = v.split(/[./#]/).filter(Boolean).pop();
+    if (tail && tail !== v) candidates.push(tail);
+  };
+  add(step?.operationId);
+  add(step?.operationPath);
+  add(step?.operationRef);
+  for (const key of candidates) {
+    const id = ctx.opToRequest.get(key);
+    if (id) return id;
+  }
+  return void 0;
+}
+function cloneRequestForStep(baseId, step, ctx) {
+  const base = ctx.requests[baseId];
+  const clone = structuredClone(base);
+  clone.id = uuid.v4();
+  clone.name = step.stepId ? String(step.stepId) : clone.name;
+  const warn = (m) => ctx.warnings.push(m);
+  for (const p of step.parameters ?? []) {
+    if (!p || !p.name) continue;
+    const value = translateTemplateValue(p.value, warn);
+    const where = p.in ?? "query";
+    if (where === "header") {
+      const h = clone.headers.find((x) => x.key.toLowerCase() === String(p.name).toLowerCase());
+      if (h) h.value = value;
+      else clone.headers.push({ key: String(p.name), value, enabled: true });
+    } else if (where === "path") {
+      const pp = clone.params.find((x) => x.key === p.name && x.paramType === "path");
+      if (pp) pp.value = value;
+      else clone.params.push({ key: String(p.name), value, enabled: true, paramType: "path" });
+    } else {
+      const qp = clone.params.find((x) => x.key === p.name && x.paramType !== "path");
+      if (qp) qp.value = value;
+      else clone.params.push({ key: String(p.name), value, enabled: true, paramType: "query" });
+    }
+  }
+  if (step.requestBody && step.requestBody.payload !== void 0) {
+    const payload = step.requestBody.payload;
+    const text = translateTemplateValue(
+      typeof payload === "string" ? payload : JSON.stringify(payload, null, 2),
+      warn
+    );
+    clone.body = { ...clone.body, mode: "json", json: text };
+  }
+  ctx.requests[clone.id] = clone;
+  return clone.id;
+}
+function buildWorkflowFlow(workflow, ctx) {
+  const nodes = [];
+  const edges = [];
+  const warn = (m) => ctx.warnings.push(m);
+  const node = (type, config, col, row, label) => {
+    const b = { id: uuid.v4(), type, position: { x: 120 + col * 240, y: 80 + row * 120 }, config, label };
+    nodes.push(b);
+    return b;
+  };
+  const link = (source, target, sourcePort) => {
+    edges.push({ id: uuid.v4(), source, target, sourcePort });
+  };
+  const inputProps = workflow.inputs?.properties ?? {};
+  const inputs = Object.entries(inputProps).map(([key, schema]) => ({
+    key,
+    value: schema?.default !== void 0 ? String(schema.default) : ""
+  }));
+  const start = node("start", { inputs }, 0, 0, workflow.workflowId);
+  const end = node("end", {}, (workflow.steps?.length ?? 0) + 1, 0);
+  const stepFirstBlock = /* @__PURE__ */ new Map();
+  const stepExit = [];
+  (workflow.steps ?? []).forEach((step, i) => {
+    const col = i + 1;
+    let requestId;
+    const baseId = resolveStepOperation(step, ctx);
+    if (baseId) {
+      requestId = cloneRequestForStep(baseId, step, ctx);
+    } else {
+      const ref = step.operationId ?? step.operationPath ?? step.operationRef ?? step.workflowId ?? "(unknown)";
+      warn(`Step "${step.stepId}" references ${ref}, which was not found among the imported operations. Check that the OpenAPI spec defines that operationId.`);
+    }
+    const reqBlock = node("request", requestId ? { ref: { collectionId: ctx.collectionId, requestId } } : {}, col, 0, step.stepId);
+    stepFirstBlock.set(String(step.stepId), reqBlock.id);
+    let exitId = reqBlock.id;
+    let exitPort = "success";
+    if (Array.isArray(step.successCriteria) && step.successCriteria.length) {
+      const v = node("validate", { script: buildValidateScript(step.successCriteria, warn) }, col, 1, `${step.stepId} checks`);
+      link(exitId, v.id, exitPort);
+      exitId = v.id;
+      exitPort = "pass";
+    }
+    if (step.outputs && Object.keys(step.outputs).length) {
+      const ev = node("evaluate", { script: buildOutputsScript(step.outputs, warn) }, col, 2, `${step.stepId} outputs`);
+      link(exitId, ev.id, exitPort);
+      exitId = ev.id;
+      exitPort = "out";
+    }
+    stepExit.push({ stepId: String(step.stepId), blockId: exitId, requestId: reqBlock.id });
+    const onFailure = step.onFailure ?? [];
+    const failGoto = onFailure.find((a) => a.type === "goto" && a.stepId);
+    if (failGoto) {
+      step.__failGoto = failGoto.stepId;
+    } else {
+      link(reqBlock.id, end.id, "fail");
+    }
+  });
+  const steps = workflow.steps ?? [];
+  steps.forEach((step, i) => {
+    const exit = stepExit[i];
+    if (!exit) return;
+    const exitPort = exit.blockId === exit.requestId ? "success" : nodes.find((n) => n.id === exit.blockId)?.type === "validate" ? "pass" : "out";
+    const onSuccess = step.onSuccess ?? [];
+    const sucEnd = onSuccess.find((a) => a.type === "end");
+    const sucGoto = onSuccess.find((a) => a.type === "goto" && a.stepId);
+    if (sucEnd) {
+      link(exit.blockId, end.id, exitPort);
+    } else if (sucGoto && stepFirstBlock.has(String(sucGoto.stepId))) {
+      link(exit.blockId, stepFirstBlock.get(String(sucGoto.stepId)), exitPort);
+    } else if (i + 1 < steps.length && stepExit[i + 1]) {
+      link(exit.blockId, stepFirstBlock.get(String(steps[i + 1].stepId)), exitPort);
+    } else {
+      link(exit.blockId, end.id, exitPort);
+    }
+    if (step.__failGoto && stepFirstBlock.has(String(step.__failGoto))) {
+      link(exit.requestId, stepFirstBlock.get(String(step.__failGoto)), "fail");
+    }
+  });
+  const firstStepId = steps[0]?.stepId;
+  link(start.id, firstStepId ? stepFirstBlock.get(String(firstStepId)) : end.id);
+  return {
+    version: "1.0",
+    id: uuid.v4(),
+    name: String(workflow.workflowId ?? workflow.summary ?? "Imported workflow"),
+    description: workflow.summary ?? workflow.description ?? "",
+    nodes,
+    edges
+  };
+}
+async function importSource(source, baseDir, sourcePaths, allowSingleFallback) {
+  const url = typeof source?.url === "string" ? source.url : "";
+  if (/^https?:\/\//i.test(url)) {
+    try {
+      return await importOpenApiFromUrl(url);
+    } catch {
+    }
+  } else if (url) {
+    try {
+      return await importOpenApi(path.resolve(baseDir, url));
+    } catch {
+    }
+  }
+  if (url) {
+    const base = url.split(/[\\/]/).pop();
+    const match = sourcePaths.find((p) => path.basename(p) === base);
+    if (match) {
+      try {
+        return await importOpenApi(match);
+      } catch {
+      }
+    }
+  }
+  if (allowSingleFallback && sourcePaths.length === 1) {
+    try {
+      return await importOpenApi(sourcePaths[0]);
+    } catch {
+    }
+  }
+  return null;
+}
+function mergeSourceIntoCollection(col, source, folderName, opMap) {
+  for (const [id, req] of Object.entries(source.requests)) {
+    col.requests[id] = req;
+    const opId = req.meta?.operationId;
+    if (opId) {
+      opMap.set(opId, id);
+      opMap.set(`${folderName}.${opId}`, id);
+    }
+  }
+  col.rootFolder.folders.push({
+    id: uuid.v4(),
+    name: folderName,
+    description: source.description ?? "",
+    folders: source.rootFolder.folders,
+    requestIds: source.rootFolder.requestIds
+  });
+}
+async function importArazzoDoc(doc, baseDir, sourcePaths = []) {
+  const warnings = [];
+  const title = doc?.info?.title ?? "Arazzo import";
+  const collection = {
+    version: "1.0",
+    id: uuid.v4(),
+    name: String(title),
+    description: doc?.info?.summary ?? doc?.info?.description ?? "",
+    rootFolder: { id: uuid.v4(), name: "root", description: "", folders: [], requestIds: [] },
+    requests: {}
+  };
+  const opToRequest = /* @__PURE__ */ new Map();
+  const sources = Array.isArray(doc?.sourceDescriptions) ? doc.sourceDescriptions : [];
+  const singleSource = sources.length === 1;
+  for (const source of sources) {
+    const imported = await importSource(source, baseDir, sourcePaths, singleSource);
+    if (!imported) {
+      warnings.push(`Could not load the OpenAPI spec for source "${source?.name ?? source?.url ?? "(unnamed)"}". Import the Arazzo file together with its OpenAPI spec file(s), or make the sourceDescription url reachable.`);
+      continue;
+    }
+    mergeSourceIntoCollection(collection, imported, String(source?.name ?? "source"), opToRequest);
+  }
+  const ctx = { collectionId: collection.id, opToRequest, requests: collection.requests, warnings };
+  const workflows = Array.isArray(doc?.workflows) ? doc.workflows : [];
+  const flows = workflows.map((wf) => buildWorkflowFlow(wf, ctx));
+  if (flows.length === 0) warnings.push("The Arazzo document defined no workflows.");
+  return { collection, flows, warnings };
+}
+async function loadDoc(filePath) {
+  const raw = await promises.readFile(filePath, "utf8");
+  return filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? jsYaml.load(raw) : JSON.parse(raw);
+}
+function looksLikeArazzo(doc) {
+  return Boolean(doc && (doc.arazzo || Array.isArray(doc.workflows)));
+}
+async function importArazzo(filePath, sourcePaths = []) {
+  const doc = await loadDoc(filePath);
+  return importArazzoDoc(doc, path.dirname(filePath), sourcePaths);
+}
+async function importArazzoFiles(paths) {
+  let arazzoPath;
+  const sourcePaths = [];
+  for (const p of paths) {
+    let doc;
+    try {
+      doc = await loadDoc(p);
+    } catch {
+      sourcePaths.push(p);
+      continue;
+    }
+    if (!arazzoPath && looksLikeArazzo(doc)) arazzoPath = p;
+    else sourcePaths.push(p);
+  }
+  if (!arazzoPath) throw new Error('No Arazzo workflow document was found among the selected files (expected an "arazzo" field or "workflows").');
+  return importArazzo(arazzoPath, sourcePaths);
+}
 function registerImportHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.import.postman, async () => {
     const result = await electron.dialog.showOpenDialog({
@@ -2112,6 +2568,24 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importHttpFile(result.filePaths[0]);
   });
+  handle.handleIpc(ipc, handle.IPC.import.har, async () => {
+    const result = await electron.dialog.showOpenDialog({
+      title: "Import HTTP Archive (.har)",
+      filters: [{ name: "HTTP Archive", extensions: ["har", "json"] }],
+      properties: ["openFile"]
+    });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return importHar(result.filePaths[0]);
+  });
+  handle.handleIpc(ipc, handle.IPC.import.arazzo, async () => {
+    const result = await electron.dialog.showOpenDialog({
+      title: "Import Arazzo workflow — select the .arazzo file and its OpenAPI spec file(s)",
+      filters: [{ name: "Arazzo + OpenAPI", extensions: ["arazzo", "yaml", "yml", "json"] }],
+      properties: ["openFile", "multiSelections"]
+    });
+    if (result.canceled || result.filePaths.length === 0) return null;
+    return importArazzoFiles(result.filePaths);
+  });
   handle.handleIpc(ipc, handle.IPC.import.spector, async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Import API Spector Collection",
@@ -2189,6 +2663,11 @@ function parsePostScript(script) {
   if (statusMatch) {
     assertions.push({ name: `status is ${statusMatch[1]}`, accessor: "", kind: "status", expected: statusMatch[1] });
   }
+  const jsonPathLocals = /* @__PURE__ */ new Map();
+  const localRegex = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*sp\.jsonPath\(\s*[^,]+,\s*(['"])((?:(?!\2).|\\.)*)\2\s*\)\s*;?/g;
+  while (match = localRegex.exec(script)) {
+    jsonPathLocals.set(match[1], match[3]);
+  }
   const extractRegex = /sp\.(variables|environment|globals)\.set\(\s*"([^"]+)"\s*,\s*(.+)\s*\)\s*;/g;
   while (match = extractRegex.exec(script)) {
     const target = match[1];
@@ -2196,9 +2675,42 @@ function parsePostScript(script) {
     let accessor = match[3].trim();
     const stringWrap = /^String\((.+)\)$/.exec(accessor);
     if (stringWrap) accessor = stringWrap[1];
-    extractions.push({ varName, accessor, target });
+    const jsonPath = parseJsonPathAccessor(accessor, jsonPathLocals);
+    if (jsonPath) {
+      extractions.push({ varName, accessor: "", target, jsonPath });
+    } else {
+      extractions.push({ varName, accessor, target });
+    }
   }
-  return { assertions, extractions };
+  return {
+    assertions: assertions.filter((a) => a.kind === "status" || isSimpleAccessor(a.accessor)),
+    extractions: extractions.filter((e) => e.jsonPath || isSimpleAccessor(e.accessor))
+  };
+}
+function parseJsonPathAccessor(accessor, locals) {
+  let core = accessor.trim();
+  let fallback = null;
+  const fbMatch = /\?\?\s*(.+)$/.exec(core);
+  if (fbMatch) {
+    fallback = fbMatch[1].trim().replace(/^(['"])(.*)\1$/, "$2");
+    core = core.slice(0, fbMatch.index).trim();
+  }
+  let index = null;
+  const idxMatch = /\[(\d+)\]$/.exec(core);
+  if (idxMatch) {
+    index = Number.parseInt(idxMatch[1], 10);
+    core = core.slice(0, idxMatch.index).trim();
+  }
+  const inline = /^sp\.jsonPath\(\s*[^,]+,\s*(['"])((?:(?!\1).|\\.)*)\1\s*\)$/.exec(core);
+  if (inline) return { query: inline[2], index, fallback };
+  if (locals.has(core)) return { query: locals.get(core), index, fallback };
+  return null;
+}
+function isSimpleAccessor(accessor) {
+  if (!accessor) return false;
+  if (/\?\?|\|\||&&|=>|[`]|\bfunction\b/.test(accessor)) return false;
+  const withoutBracketKeys = accessor.replaceAll(/\[(['"]).*?\1\]/g, "");
+  return !/\s/.test(withoutBracketKeys);
 }
 function accessorToJsonPath(accessor) {
   return accessor.replace(/^json\.?/, "").replaceAll(/\["([^"]+)"\]/g, "['$1']");
@@ -2301,6 +2813,29 @@ function restAssuredCall(method, pathArg) {
   return verbs.includes(method) ? `.${method}(${pathArg})` : `.request("${method.toUpperCase()}", ${pathArg})`;
 }
 const ROBOT_REQUESTS_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+function jsJsonPathExpr(q, jsonVar) {
+  const base = `JSONPath({ path: ${JSON.stringify(q.query)}, json: ${jsonVar} })`;
+  const picked = q.index !== null ? `${base}[${q.index}]` : base;
+  if (q.fallback !== null) return `(${picked} ?? ${JSON.stringify(q.fallback)})`;
+  return picked;
+}
+function karateJsonPathExpr(q) {
+  const base = `karate.jsonPath(response, '${q.query.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}')`;
+  const picked = q.index !== null ? `${base}[${q.index}]` : base;
+  if (q.fallback !== null) return `(${picked} || '${q.fallback.replaceAll("'", "\\'")}')`;
+  return picked;
+}
+function collectionUsesJsonPath(collection) {
+  return Object.values(collection.requests).some(
+    (req) => parsePostScript(req.postRequestScript).extractions.some((e) => e.jsonPath)
+  );
+}
+function folderUsesJsonPath(folder, collection) {
+  return folder.requestIds.some((id) => {
+    const req = collection.requests[id];
+    return !!req && parsePostScript(req.postRequestScript).extractions.some((e) => e.jsonPath);
+  });
+}
 function safeName(name) {
   return name.replaceAll(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
@@ -2354,6 +2889,33 @@ function buildVariablesFile(environment) {
   }
   return lines.join("\n") + "\n";
 }
+function compactJsonBody(json) {
+  try {
+    return JSON.stringify(JSON.parse(json));
+  } catch {
+    return json.replace(/\s*\r?\n\s*/g, " ").trim();
+  }
+}
+function isNestedPath(jp) {
+  return /[.[]/.test(jp);
+}
+function pyIndex(jp) {
+  return jp.replaceAll(/\.([A-Za-z_$][\w$]*)/g, "['$1']").replace(/^([A-Za-z_$][\w$]*)/, "['$1']");
+}
+function jsonPathPlaceholder(name, query) {
+  return [
+    `    # JSONPath not auto-translated to Robot: ${query}`,
+    `    # Set \${${name}} manually, or use a JSONPath library and adapt the query to jsonpath-ng syntax.`,
+    `    VAR    \${${name}}    \${EMPTY}`,
+    `    Set Suite Variable    \${${name}}`
+  ];
+}
+function readJsonValue(name, jp) {
+  if (isNestedPath(jp)) {
+    return [`    \${${name}}=    Evaluate    str($response.json()${pyIndex(jp)})`];
+  }
+  return [`    \${${name}}=    Get From Dictionary    \${response.json()}    ${jp}`];
+}
 function jsonToRfDictPairs(json, vars) {
   try {
     const parsed = JSON.parse(json);
@@ -2393,7 +2955,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
         if (bodyPairs !== null) {
           lines.push(`    VAR    &{body}    ${bodyPairs}`);
         } else {
-          lines.push(`    VAR    \${body}    ${interpolate(body.json, varMap)}`);
+          lines.push(`    VAR    \${body}    ${interpolate(compactJsonBody(body.json), varMap)}`);
         }
       }
       const callArgs = [];
@@ -2402,10 +2964,13 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
       if (callArgs.length) lines.push(`    ...    ${callArgs.join("    ")}`);
       const parsed = parsePostScript(req.postRequestScript);
       for (const e of parsed.extractions) {
-        const jp = accessorToJsonPath(e.accessor);
         const rfVar = e.varName.replaceAll(/\W+/g, "_").toUpperCase();
         hookExtractedVars.add(rfVar);
-        lines.push(`    \${${rfVar}}=    Evaluate    str($response.json().get('${jp}', ''))`, `    Set Suite Variable    \${${rfVar}}`);
+        if (e.jsonPath) {
+          lines.push(...jsonPathPlaceholder(rfVar, e.jsonPath.query));
+        } else {
+          lines.push(...readJsonValue(rfVar, accessorToJsonPath(e.accessor)), `    Set Suite Variable    \${${rfVar}}`);
+        }
       }
       lines.push(`    RETURN    \${response}`, "");
     }
@@ -2468,7 +3033,7 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
         if (bodyPairs !== null) {
           lines.push(`    VAR    &{body}    ${bodyPairs}`);
         } else {
-          lines.push(`    VAR    \${body}    ${interpolate(body.json, varMap)}`);
+          lines.push(`    VAR    \${body}    ${interpolate(compactJsonBody(body.json), varMap)}`);
         }
       }
       const method = req.method.charAt(0) + req.method.slice(1).toLowerCase();
@@ -2490,6 +3055,9 @@ function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
 function buildTestSuite(collection, environment, nameMap) {
   const colName = safeName(collection.name);
   const envName = environment?.name ?? "default";
+  const varMap = new Map(
+    (environment?.variables ?? []).map((v) => [v.key, v])
+  );
   const beforeAllHooks = [];
   const afterAllHooks = [];
   function collectAll(folder) {
@@ -2528,17 +3096,21 @@ function buildTestSuite(collection, environment, nameMap) {
               lines.push(`    Status Should Be    ${a.expected ?? 200}    \${response}`);
               break;
             case "equals": {
-              const expected = a.expected?.replaceAll(/^"|"$/g, "") ?? "";
-              lines.push(`    \${value}=    Get From Dictionary    \${response.json()}    ${jp}`, `    Should Be Equal As Strings    \${value}    ${expected}`);
+              const expected = interpolate(a.expected?.replaceAll(/^"|"$/g, "") ?? "", varMap);
+              lines.push(...readJsonValue("value", jp), `    Should Be Equal As Strings    \${value}    ${expected}`);
               break;
             }
             case "contains": {
-              const expected = a.expected?.replaceAll(/^"|"$/g, "") ?? "";
-              lines.push(`    \${value}=    Get From Dictionary    \${response.json()}    ${jp}`, `    Should Contain    \${value}    ${expected}`);
+              const expected = interpolate(a.expected?.replaceAll(/^"|"$/g, "") ?? "", varMap);
+              lines.push(...readJsonValue("value", jp), `    Should Contain    \${value}    ${expected}`);
               break;
             }
             case "exists":
-              lines.push(`    Dictionary Should Contain Key    \${response.json()}    ${jp}`);
+              if (isNestedPath(jp)) {
+                lines.push(`    \${value}=    Evaluate    $response.json()${pyIndex(jp)}`, `    Should Not Be Equal    \${value}    \${None}`);
+              } else {
+                lines.push(`    Dictionary Should Contain Key    \${response.json()}    ${jp}`);
+              }
               break;
             default:
               lines.push(`    Status Should Be    200    \${response}`);
@@ -2548,8 +3120,11 @@ function buildTestSuite(collection, environment, nameMap) {
         lines.push(`    Status Should Be    200    \${response}`);
       }
       for (const e of parsed.extractions) {
-        const jp = accessorToJsonPath(e.accessor);
-        lines.push(`    \${${e.varName}}=    Get From Dictionary    \${response.json()}    ${jp}`, `    Set Suite Variable    \${${e.varName}}`);
+        if (e.jsonPath) {
+          lines.push(...jsonPathPlaceholder(e.varName, e.jsonPath.query));
+        } else {
+          lines.push(...readJsonValue(e.varName, accessorToJsonPath(e.accessor)), `    Set Suite Variable    \${${e.varName}}`);
+        }
       }
       lines.push("");
     }
@@ -2658,8 +3233,7 @@ function buildHookLines$1(req, sharedVars) {
   if (parsed.extractions.length > 0) {
     lines.push(`    const hookResponse = await ${hookCall};`, `    const hookJson = await hookResponse.json();`);
     for (const e of parsed.extractions) {
-      const jsonPath = e.accessor.replace(/^json\.?/, "");
-      const expr = jsonPath ? `hookJson.${jsonPath}` : "hookJson";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "hookJson") : e.accessor.replace(/^json\.?/, "") ? `hookJson.${e.accessor.replace(/^json\.?/, "")}` : "hookJson";
       const varName = toEnvVar(e.varName);
       sharedVars.add(varName);
       lines.push(`    ${varName} = String(${expr});`);
@@ -2817,14 +3391,15 @@ ${optionParts.join(",\n")},
     }
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
-      const expr = path22 ? `json.${path22}` : "json";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "json") : path22 ? `json.${path22}` : "json";
       lines.push(`    // Extract: ${e.varName} = ${expr}`, `    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  });`);
     tests.push(lines.join("\n"));
   }
+  const jsonPathImport = folderUsesJsonPath(folder, collection) ? "import { JSONPath } from 'jsonpath-plus'\n" : "";
   return `import { test, expect } from '@playwright/test'
-
+${jsonPathImport}
 test.describe('${folderName}', () => {
 
 ${tests.join("\n\n")}
@@ -2832,7 +3407,7 @@ ${tests.join("\n\n")}
 })
 `;
 }
-function buildPackageJson$3(collectionName) {
+function buildPackageJson$3(collectionName, usesJsonPath) {
   const name = collectionName.replaceAll(/\W+/g, "-").toLowerCase();
   return JSON.stringify({
     name: `${name}-api-tests`,
@@ -2845,6 +3420,7 @@ function buildPackageJson$3(collectionName) {
     devDependencies: {
       "@playwright/test": "^1.44.0",
       dotenv: "^16.4.0",
+      ...usesJsonPath ? { "jsonpath-plus": "^10.4.0" } : {},
       typescript: "^5.4.0"
     }
   }, null, 2) + "\n";
@@ -2879,11 +3455,10 @@ function generatePlaywright(collection, environment) {
     }
     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);
+  processFolder(collection.rootFolder, collection.name);
   const scaffoldPaths = ["package.json", "playwright.config.ts", ...files.map((f) => f.path)];
   files.unshift(
-    { path: "package.json", content: buildPackageJson$3(collection.name) },
+    { path: "package.json", content: buildPackageJson$3(collection.name, collectionUsesJsonPath(collection)) },
     { path: "playwright.config.ts", content: buildPlaywrightConfig$1(environment) },
     { path: "README.md", content: buildReadme$5(collection.name, scaffoldPaths) }
   );
@@ -2941,7 +3516,7 @@ function buildHookLines(req, sharedVars) {
     lines.push(`    const hookResponse = await ${hookCall};`, `    const hookJson = await hookResponse.json();`);
     for (const e of parsed.extractions) {
       const jp = e.accessor.replace(/^json\.?/, "");
-      const expr = jp ? `hookJson.${jp}` : "hookJson";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "hookJson") : jp ? `hookJson.${jp}` : "hookJson";
       const varName = toEnvVar(e.varName);
       sharedVars.add(varName);
       lines.push(`    ${varName} = String(${expr});`);
@@ -3090,14 +3665,15 @@ ${optionParts.join(",\n")},
     }
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
-      const expr = path22 ? `json.${path22}` : "json";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "json") : path22 ? `json.${path22}` : "json";
       lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  });`);
     tests.push(lines.join("\n"));
   }
+  const jsonPathImport = folderUsesJsonPath(folder, collection) ? "const { JSONPath } = require('jsonpath-plus');\n" : "";
   return `const { test, expect } = require('@playwright/test');
-
+${jsonPathImport}
 test.describe('${folderName}', () => {
 
 ${tests.join("\n\n")}
@@ -3105,7 +3681,7 @@ ${tests.join("\n\n")}
 });
 `;
 }
-function buildPackageJson$2(collectionName) {
+function buildPackageJson$2(collectionName, usesJsonPath) {
   const name = collectionName.replaceAll(/\W+/g, "-").toLowerCase();
   return JSON.stringify({
     name: `${name}-api-tests`,
@@ -3117,7 +3693,8 @@ function buildPackageJson$2(collectionName) {
     },
     devDependencies: {
       "@playwright/test": "^1.44.0",
-      dotenv: "^16.4.0"
+      dotenv: "^16.4.0",
+      ...usesJsonPath ? { "jsonpath-plus": "^10.4.0" } : {}
     }
   }, null, 2) + "\n";
 }
@@ -3151,11 +3728,10 @@ function generatePlaywrightJs(collection, environment) {
     }
     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);
+  processFolder(collection.rootFolder, collection.name);
   const scaffoldPaths = ["package.json", "playwright.config.js", ...files.map((f) => f.path)];
   files.unshift(
-    { path: "package.json", content: buildPackageJson$2(collection.name) },
+    { path: "package.json", content: buildPackageJson$2(collection.name, collectionUsesJsonPath(collection)) },
     { path: "playwright.config.js", content: buildPlaywrightConfig(environment) },
     { path: "README.md", content: buildReadme$4(collection.name, scaffoldPaths) }
   );
@@ -3225,7 +3801,7 @@ function buildTestFile$1(folderName, folder, collection) {
       lines.push(`    const hookRes = await api.${method}('${path2}');`);
       for (const e of parsed.extractions) {
         const jp = e.accessor.replace(/^json\.?/, "");
-        const expr = jp ? `hookRes.body.${jp}` : "hookRes.body";
+        const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "hookRes.body") : jp ? `hookRes.body.${jp}` : "hookRes.body";
         const varName = toEnvVar(e.varName);
         sharedVars.add(varName);
         lines.push(`    ${varName} = String(${expr});`);
@@ -3331,20 +3907,21 @@ ${lines.join("\n")}
     }
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
-      const expr = path22 ? `res.body.${path22}` : "res.body";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "res.body") : path22 ? `res.body.${path22}` : "res.body";
       lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  })`);
     tests.push(lines.join("\n"));
   }
+  const jsonPathImport = folderUsesJsonPath(folder, collection) ? "import { JSONPath } from 'jsonpath-plus'\n" : "";
   return `import { api } from '../helpers/api-client'
-
+${jsonPathImport}
 describe('${folderName}', () => {
 ${tests.join("\n\n")}
 })
 `;
 }
-function buildPackageJson$1(collectionName) {
+function buildPackageJson$1(collectionName, usesJsonPath) {
   const name = collectionName.replaceAll(/\W+/g, "-").toLowerCase();
   return JSON.stringify({
     name: `${name}-api-tests`,
@@ -3356,6 +3933,7 @@ function buildPackageJson$1(collectionName) {
       "@types/supertest": "^6.0.0",
       dotenv: "^16.4.0",
       jest: "^29.7.0",
+      ...usesJsonPath ? { "jsonpath-plus": "^10.4.0" } : {},
       supertest: "^7.0.0",
       "ts-jest": "^29.1.0",
       "ts-node": "^10.9.2",
@@ -3412,15 +3990,10 @@ function generateSupertestTs(collection, environment) {
       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);
-  }
+  processFolder(collection.rootFolder, collection.name);
   const scaffoldPaths = ["package.json", "tsconfig.json", ...files.map((f) => f.path)];
   files.unshift(
-    { path: "package.json", content: buildPackageJson$1(collection.name) },
+    { path: "package.json", content: buildPackageJson$1(collection.name, collectionUsesJsonPath(collection)) },
     { path: "tsconfig.json", content: buildTsConfig() },
     { path: "README.md", content: buildReadme$3(collection.name, scaffoldPaths) }
   );
@@ -3484,7 +4057,7 @@ function buildTestFile(folderName, folder, collection) {
       lines.push(`    const hookRes = await api.${method}('${path2}');`);
       for (const e of parsed.extractions) {
         const jp = e.accessor.replace(/^json\.?/, "");
-        const expr = jp ? `hookRes.body.${jp}` : "hookRes.body";
+        const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "hookRes.body") : jp ? `hookRes.body.${jp}` : "hookRes.body";
         const varName = toEnvVar(e.varName);
         sharedVars.add(varName);
         lines.push(`    ${varName} = String(${expr});`);
@@ -3590,20 +4163,21 @@ ${lines.join("\n")}
     }
     for (const e of parsed.extractions) {
       const path22 = e.accessor.replace(/^json\.?/, "");
-      const expr = path22 ? `res.body.${path22}` : "res.body";
+      const expr = e.jsonPath ? jsJsonPathExpr(e.jsonPath, "res.body") : path22 ? `res.body.${path22}` : "res.body";
       lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
     }
     lines.push(`  })`);
     tests.push(lines.join("\n"));
   }
+  const jsonPathImport = folderUsesJsonPath(folder, collection) ? "const { JSONPath } = require('jsonpath-plus');\n" : "";
   return `const { api } = require('../helpers/api-client');
-
+${jsonPathImport}
 describe('${folderName}', () => {
 ${tests.join("\n\n")}
 })
 `;
 }
-function buildPackageJson(collectionName) {
+function buildPackageJson(collectionName, usesJsonPath) {
   const name = collectionName.replaceAll(/\W+/g, "-").toLowerCase();
   return JSON.stringify({
     name: `${name}-api-tests`,
@@ -3613,6 +4187,7 @@ function buildPackageJson(collectionName) {
     devDependencies: {
       dotenv: "^16.4.0",
       jest: "^29.7.0",
+      ...usesJsonPath ? { "jsonpath-plus": "^10.4.0" } : {},
       supertest: "^7.0.0"
     }
   }, null, 2) + "\n";
@@ -3653,19 +4228,22 @@ function generateSupertestJs(collection, environment) {
       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);
-  }
+  processFolder(collection.rootFolder, collection.name);
   const scaffoldPaths = ["package.json", ...files.map((f) => f.path)];
   files.unshift(
-    { path: "package.json", content: buildPackageJson(collection.name) },
+    { path: "package.json", content: buildPackageJson(collection.name, collectionUsesJsonPath(collection)) },
     { path: "README.md", content: buildReadme$2(collection.name, scaffoldPaths) }
   );
   return files;
 }
+function javaStr(s) {
+  return s.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+function restAssuredJsonPath(q) {
+  const index = q.index ?? -1;
+  const fallback = q.fallback ?? "";
+  return `jsonPath(hookResponse.asString(), "${javaStr(q.query)}", ${index}, "${javaStr(fallback)}")`;
+}
 function javaMethod(name) {
   const parts = name.replaceAll(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean);
   return parts[0].toLowerCase() + parts.slice(1).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
@@ -3691,8 +4269,17 @@ function interpolateJava(value, sharedVars = /* @__PURE__ */ new Set()) {
     return `" + System.getenv("${envKey}") + "`;
   }) + '"';
 }
-function buildPom$1(collectionName) {
+function buildPom$1(collectionName, usesJsonPath) {
   const artifact = collectionName.replaceAll(/\W+/g, "-").toLowerCase();
+  const jsonPathDep = usesJsonPath ? `
+    <!-- Jayway JSONPath (for sp.jsonPath extractions) -->
+    <dependency>
+      <groupId>com.jayway.jsonpath</groupId>
+      <artifactId>json-path</artifactId>
+      <version>2.9.0</version>
+      <scope>test</scope>
+    </dependency>
+` : "";
   return `<?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
@@ -3744,7 +4331,7 @@ function buildPom$1(collectionName) {
       <version>2.2</version>
       <scope>test</scope>
     </dependency>
-  </dependencies>
+${jsonPathDep}  </dependencies>
 
   <build>
     <plugins>
@@ -3758,12 +4345,29 @@ function buildPom$1(collectionName) {
 </project>
 `;
 }
-function buildBaseTest(environment) {
+function buildBaseTest(environment, usesJsonPath) {
   const baseUrl = getEnvBaseUrl(environment, "http://localhost:8080");
   const secretVars = environment?.variables.filter((v) => v.secret && v.secretRef) ?? [];
   const secretComments = secretVars.map(
     (v) => `     * - ${toEnvVar(v.key)}=<value from keychain>`
   ).join("\n");
+  const jsonPathHelper = usesJsonPath ? `
+    private static final com.jayway.jsonpath.Configuration JSONPATH_CFG =
+        com.jayway.jsonpath.Configuration.defaultConfiguration()
+            .addOptions(com.jayway.jsonpath.Option.SUPPRESS_EXCEPTIONS);
+
+    /** Resolve a JSONPath query; pick element \`index\` (or -1 for the whole result); fall back when absent. */
+    protected static String jsonPath(String body, String query, int index, String fallback) {
+        Object value = com.jayway.jsonpath.JsonPath.using(JSONPATH_CFG).parse(body).read(query);
+        Object out = value;
+        if (index >= 0) {
+            out = (value instanceof java.util.List && index < ((java.util.List<?>) value).size())
+                ? ((java.util.List<?>) value).get(index)
+                : null;
+        }
+        return out == null ? fallback : String.valueOf(out);
+    }
+` : "";
   return `package com.example.api;
 
 import io.restassured.RestAssured;
@@ -3781,7 +4385,7 @@ ${secretComments ? secretComments + "\n" : ""} * - BASE_URL (optional, default:
 public class BaseTest {
 
     protected static RequestSpecification requestSpec;
-
+${jsonPathHelper}
     @BeforeAll
     static void setupRestAssured() {
         String baseUrl = System.getenv("BASE_URL") != null
@@ -3820,10 +4424,13 @@ function buildTestClass(folderName, folder, collection) {
       }
       lines.push(`            .when()${restAssuredCall(method, `"${path2}"`)};`);
       for (const e of parsed.extractions) {
-        const jp = accessorToJsonPath(e.accessor);
         const varName = toEnvVar(e.varName);
         sharedVars.add(varName);
-        lines.push(`        ${varName} = hookResponse.jsonPath().getString("${jp}");`);
+        if (e.jsonPath) {
+          lines.push(`        ${varName} = ${restAssuredJsonPath(e.jsonPath)};`);
+        } else {
+          lines.push(`        ${varName} = hookResponse.jsonPath().getString("${accessorToJsonPath(e.accessor)}");`);
+        }
       }
     } else {
       lines.push(`        given().spec(requestSpec).when()${restAssuredCall(method, `"${path2}"`)};`);
@@ -3971,9 +4578,10 @@ BASE_URL=https://api.example.com mvn test
 `;
 }
 function generateRestAssured(collection, environment) {
+  const usesJsonPath = collectionUsesJsonPath(collection);
   const files = [
-    { path: "pom.xml", content: buildPom$1(collection.name) },
-    { path: "src/test/java/com/example/api/BaseTest.java", content: buildBaseTest(environment) }
+    { path: "pom.xml", content: buildPom$1(collection.name, usesJsonPath) },
+    { path: "src/test/java/com/example/api/BaseTest.java", content: buildBaseTest(environment, usesJsonPath) }
   ];
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
@@ -3987,12 +4595,7 @@ function generateRestAssured(collection, environment) {
       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);
-  }
+  processFolder(collection.rootFolder, collection.name);
   files.unshift({ path: "README.md", content: buildReadme$1(collection.name, files.map((f) => f.path)) });
   return files;
 }
@@ -4159,7 +4762,7 @@ function buildBackground(folderId, collection) {
     const parsed = parsePostScript(h.postRequestScript);
     for (const e of parsed.extractions) {
       const jp = accessorToJsonPath(e.accessor).replace(/^json\.?/, "");
-      const expr = jp ? `response.${jp}` : "response";
+      const expr = e.jsonPath ? karateJsonPathExpr(e.jsonPath) : jp ? `response.${jp}` : "response";
       const name = configKey(e.varName);
       defined.add(name);
       lines.push(`  * def ${name} = ${expr}`);
@@ -4383,10 +4986,7 @@ function generateKarate(collection, environment) {
     }
     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);
+  processFolder(collection.rootFolder, collection.name);
   files.unshift({ path: "README.md", content: buildReadme(collection.name, files.map((f) => f.path)) });
   return files;
 }
@@ -4649,6 +5249,7 @@ const sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function registerRunnerHandler(ipc) {
   handle.handleIpc(ipc, handle.IPC.runner.start, async (event, payload) => {
     const { items, environment, globals: payloadGlobals, proxy, tls, piiMaskPatterns = [], requestDelay = 0 } = payload;
+    const concurrency = Math.max(1, Math.min(20, Math.floor(payload.concurrency ?? 1)));
     const envVars = await requestExec.buildEnvVars(environment);
     const liveGlobals = requestExec.getGlobals();
     const globals = { ...payloadGlobals, ...liveGlobals };
@@ -4659,72 +5260,111 @@ function registerRunnerHandler(ipc) {
     let runCollectionVars = {};
     let runGlobals = { ...globals };
     let runLocalVars = {};
+    const runFolderVars = {};
     const skipTracker = new requestExec.HookSkipTracker();
-    for (const item of items) {
-      const skipReason = skipTracker.shouldSkip(item);
-      if (skipReason) {
-        const skipped = {
-          requestId: item.request.id,
-          name: item.request.name,
-          method: item.request.method,
-          resolvedUrl: item.request.url,
-          status: "failed",
-          error: skipReason,
-          isHook: item.isHook,
-          hookType: item.hookType,
-          scopeId: item.scopeId,
-          collection: item.collection,
-          scopePath: item.scopePath,
-          iterationLabel: item.iterationLabel
-        };
-        summary.failed++;
-        event.sender.send(handle.IPC.runner.progress, skipped);
-        continue;
-      }
-      const runningUpdate = {
-        status: "running",
-        iterationLabel: item.iterationLabel,
-        isHook: item.isHook,
-        hookType: item.hookType,
-        scopeId: item.scopeId,
-        collection: item.collection,
-        scopePath: item.scopePath
-      };
-      event.sender.send(handle.IPC.runner.progress, { requestId: item.request.id, ...runningUpdate });
-      const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await requestExec.executeRunnerRequest({
-        req: item.request,
-        collectionVars: { ...item.collectionVars, ...runCollectionVars },
-        envVars: runEnvVars,
-        globals: runGlobals,
-        localVars: { ...runLocalVars, ...item.dataRow },
-        dispatcher,
-        piiMaskPatterns,
-        proxy,
-        tls,
-        expectStatus: item.expectStatus,
-        owaspTag: item.owaspTag
-      });
-      runEnvVars = updatedEnvVars;
-      runCollectionVars = updatedCollectionVars;
-      runGlobals = updatedGlobals;
-      runLocalVars = updatedLocalVars;
-      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++;
+    const meta = (item, index) => ({
+      index,
+      iterationLabel: item.iterationLabel,
+      isHook: item.isHook,
+      hookType: item.hookType,
+      scopeId: item.scopeId,
+      collection: item.collection,
+      scopePath: item.scopePath
+    });
+    const emitRunning = (item, index) => event.sender.send(handle.IPC.runner.progress, { requestId: item.request.id, status: "running", ...meta(item, index) });
+    const emitResult = (item, index, result) => event.sender.send(handle.IPC.runner.progress, { ...result, ...meta(item, index) });
+    const tally = (status) => {
+      if (status === "passed") summary.passed++;
+      else if (status === "failed") summary.failed++;
+      else if (status === "skipped") summary.skipped++;
       else summary.errors++;
-      event.sender.send(handle.IPC.runner.progress, {
-        ...result,
-        iterationLabel: item.iterationLabel,
-        isHook: item.isHook,
-        hookType: item.hookType,
-        scopeId: item.scopeId,
-        collection: item.collection,
-        scopePath: item.scopePath
-      });
-      if (requestDelay > 0 && item !== items[items.length - 1]) {
-        await sleep(requestDelay);
+    };
+    const skippedResult = (item, reason) => ({
+      requestId: item.request.id,
+      name: item.request.name,
+      method: item.request.method,
+      resolvedUrl: item.request.url,
+      status: "failed",
+      error: reason,
+      isHook: item.isHook,
+      hookType: item.hookType,
+      scopeId: item.scopeId,
+      collection: item.collection,
+      scopePath: item.scopePath,
+      iterationLabel: item.iterationLabel
+    });
+    const execItem = (item) => requestExec.executeRunnerRequest({
+      req: item.request,
+      collectionVars: { ...item.collectionVars, ...runCollectionVars },
+      envVars: runEnvVars,
+      globals: runGlobals,
+      localVars: { ...runLocalVars, ...item.dataRow },
+      folderVars: { ...item.folderVars ?? {}, ...item.folderId ? runFolderVars[item.folderId] ?? {} : {} },
+      dispatcher,
+      piiMaskPatterns,
+      proxy,
+      tls,
+      expectStatus: item.expectStatus,
+      owaspTag: item.owaspTag
+    });
+    const applyUpdates = (item, out, mode) => {
+      if (mode === "replace") {
+        runEnvVars = out.updatedEnvVars;
+        runCollectionVars = out.updatedCollectionVars;
+        runGlobals = out.updatedGlobals;
+        runLocalVars = out.updatedLocalVars;
+      } else {
+        runEnvVars = { ...runEnvVars, ...out.updatedEnvVars };
+        runCollectionVars = { ...runCollectionVars, ...out.updatedCollectionVars };
+        runGlobals = { ...runGlobals, ...out.updatedGlobals };
+        runLocalVars = { ...runLocalVars, ...out.updatedLocalVars };
+      }
+      if (item.folderId) {
+        runFolderVars[item.folderId] = { ...runFolderVars[item.folderId] ?? {}, ...out.updatedFolderVars };
       }
+    };
+    if (concurrency <= 1) {
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const skipReason = skipTracker.shouldSkip(item);
+        if (skipReason) {
+          const skipped = skippedResult(item, skipReason);
+          tally(skipped.status);
+          emitResult(item, i, skipped);
+          continue;
+        }
+        emitRunning(item, i);
+        const out = await execItem(item);
+        applyUpdates(item, out, "replace");
+        skipTracker.recordResult(item, out.result.status);
+        tally(out.result.status);
+        emitResult(item, i, out.result);
+        if (requestDelay > 0 && i < items.length - 1) await sleep(requestDelay);
+      }
+    } else {
+      const runItem = async (item, index) => {
+        const skipReason = skipTracker.shouldSkip(item);
+        if (skipReason) {
+          const sk = skippedResult(item, skipReason);
+          tally(sk.status);
+          emitResult(item, index, sk);
+          return;
+        }
+        emitRunning(item, index);
+        try {
+          const out = await execItem(item);
+          applyUpdates(item, out, "merge");
+          skipTracker.recordResult(item, out.result.status);
+          tally(out.result.status);
+          emitResult(item, index, out.result);
+        } catch (err) {
+          const r = { ...skippedResult(item, err instanceof Error ? err.message : String(err)), status: "error" };
+          skipTracker.recordResult(item, "error");
+          tally("error");
+          emitResult(item, index, r);
+        }
+      };
+      await runConcurrent.runPlanConcurrent(concurrency, items, (it) => Boolean(it.isHook), runItem);
     }
     summary.durationMs = Date.now() - totalStart;
     return summary;
@@ -5069,30 +5709,42 @@ function registerVaultHandlers(ipc) {
     };
   });
 }
-const connections = /* @__PURE__ */ new Map();
+const connections$3 = /* @__PURE__ */ new Map();
 function closeAllWsConnections() {
-  for (const [, ws] of connections) {
+  for (const [, ws] of connections$3) {
     try {
       ws.close();
     } catch {
     }
   }
-  connections.clear();
+  connections$3.clear();
 }
 function registerWsHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.ws.connect, async (event, requestId, url, headers) => {
-    const existing = connections.get(requestId);
+    const existing = connections$3.get(requestId);
     if (existing) {
       existing.close();
-      connections.delete(requestId);
+      connections$3.delete(requestId);
     }
-    event.sender.send(handle.IPC.ws.status, { requestId, status: "connecting" });
+    const alive = () => !event.sender.isDestroyed();
+    const status = (s, error) => {
+      if (alive()) event.sender.send(handle.IPC.ws.status, { requestId, status: s, error });
+    };
+    status("connecting");
     const ws = new WebSocket(url, { headers });
-    connections.set(requestId, ws);
+    connections$3.set(requestId, ws);
+    event.sender.once("destroyed", () => {
+      try {
+        ws.close();
+      } catch {
+      }
+      connections$3.delete(requestId);
+    });
     ws.on("open", () => {
-      event.sender.send(handle.IPC.ws.status, { requestId, status: "connected" });
+      status("connected");
     });
     ws.on("message", (data) => {
+      if (!alive()) return;
       const message = {
         id: uuid.v4(),
         direction: "received",
@@ -5102,27 +5754,526 @@ function registerWsHandlers(ipc) {
       event.sender.send(handle.IPC.ws.message, { requestId, message });
     });
     ws.on("error", (err) => {
-      event.sender.send(handle.IPC.ws.status, { requestId, status: "error", error: err.message });
-      connections.delete(requestId);
+      status("error", err.message);
+      connections$3.delete(requestId);
     });
     ws.on("close", () => {
-      event.sender.send(handle.IPC.ws.status, { requestId, status: "disconnected" });
-      connections.delete(requestId);
+      status("disconnected");
+      connections$3.delete(requestId);
     });
   });
   handle.handleIpc(ipc, handle.IPC.ws.send, async (_event, requestId, data) => {
-    const ws = connections.get(requestId);
+    const ws = connections$3.get(requestId);
     if (ws?.readyState !== WebSocket.OPEN) {
       throw new Error("WebSocket is not connected");
     }
     ws.send(data);
   });
+  handle.handleIpc(ipc, handle.IPC.ws.test, async (_event, cfg) => {
+    const t0 = Date.now();
+    const res = await requestExec.runWsTest(cfg);
+    console.log(`[ws:test] url=${cfg.url} collectMs=${cfg.collectMs} ran=${Date.now() - t0}ms messages=${res.messages.length}${res.error ? ` error=${res.error}` : ""}`);
+    return res;
+  });
   handle.handleIpc(ipc, handle.IPC.ws.disconnect, async (_event, requestId) => {
-    const ws = connections.get(requestId);
+    const ws = connections$3.get(requestId);
     if (ws) {
       ws.close();
+      connections$3.delete(requestId);
+    }
+  });
+}
+const connections$2 = /* @__PURE__ */ new Map();
+function closeAllSocketIoConnections() {
+  for (const [, socket] of connections$2) {
+    try {
+      socket.disconnect();
+    } catch {
+    }
+  }
+  connections$2.clear();
+}
+function targetUrl(url, namespace) {
+  const ns = (namespace ?? "").trim();
+  if (!ns || ns === "/") return url;
+  return url.replace(/\/+$/, "") + (ns.startsWith("/") ? ns : `/${ns}`);
+}
+function jsonText(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function registerSocketIoHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.socketio.connect, async (event, requestId, opts) => {
+    const existing = connections$2.get(requestId);
+    if (existing) {
+      existing.disconnect();
+      connections$2.delete(requestId);
+    }
+    const alive = () => !event.sender.isDestroyed();
+    const send = (message) => {
+      if (alive()) event.sender.send(handle.IPC.socketio.message, { requestId, message });
+    };
+    const status = (s, error) => {
+      if (alive()) event.sender.send(handle.IPC.socketio.status, { requestId, status: s, error });
+    };
+    const note = (ev, text) => send({ id: uuid.v4(), direction: "received", kind: "system", event: ev, data: text, timestamp: Date.now() });
+    let auth;
+    if (opts.auth && opts.auth.trim()) {
+      try {
+        const parsed = JSON.parse(opts.auth);
+        auth = parsed && typeof parsed === "object" ? parsed : void 0;
+      } catch {
+        status("error", "Auth is not valid JSON");
+        return;
+      }
+    }
+    status("connecting");
+    let socket;
+    try {
+      socket = socket_ioClient.io(targetUrl(opts.url, opts.namespace), {
+        path: opts.path?.trim() || "/socket.io",
+        transports: ["websocket", "polling"],
+        extraHeaders: opts.headers,
+        auth,
+        forceNew: true,
+        reconnection: true
+      });
+    } catch (err) {
+      status("error", err instanceof Error ? err.message : String(err));
+      return;
+    }
+    connections$2.set(requestId, socket);
+    event.sender.once("destroyed", () => {
+      try {
+        socket.disconnect();
+      } catch {
+      }
+      connections$2.delete(requestId);
+    });
+    socket.on("connect", () => {
+      status("connected");
+      note("connect", `Connected (id ${socket.id})`);
+    });
+    socket.on("disconnect", (reason) => {
+      status("disconnected");
+      note("disconnect", `Disconnected: ${reason}`);
+    });
+    socket.on("connect_error", (err) => {
+      status("error", err.message);
+    });
+    socket.onAny((eventName, ...args) => {
+      send({ id: uuid.v4(), direction: "received", kind: "event", event: eventName, data: jsonText(args), timestamp: Date.now() });
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.socketio.emit, async (event, requestId, opts) => {
+    const socket = connections$2.get(requestId);
+    if (!socket || !socket.connected) {
+      throw new Error("Socket.IO is not connected");
+    }
+    let args = [];
+    if (opts.args && opts.args.trim()) {
+      let parsed;
+      try {
+        parsed = JSON.parse(opts.args);
+      } catch {
+        throw new Error("Emit arguments are not valid JSON");
+      }
+      args = Array.isArray(parsed) ? parsed : [parsed];
+    }
+    if (opts.withAck) {
+      const send = (message) => {
+        if (!event.sender.isDestroyed()) event.sender.send(handle.IPC.socketio.message, { requestId, message });
+      };
+      socket.timeout(opts.ackTimeoutMs ?? 5e3).emit(opts.event, ...args, (err, ...response) => {
+        send(err ? { id: uuid.v4(), direction: "received", kind: "system", event: opts.event, data: `No acknowledgement: ${err.message}`, timestamp: Date.now() } : { id: uuid.v4(), direction: "received", kind: "ack", event: opts.event, data: jsonText(response), timestamp: Date.now() });
+      });
+    } else {
+      socket.emit(opts.event, ...args);
+    }
+  });
+  handle.handleIpc(ipc, handle.IPC.socketio.test, async (_event, cfg) => {
+    const t0 = Date.now();
+    const res = await requestExec.runSocketIoTest(cfg);
+    console.log(`[socketio:test] url=${cfg.url} collectMs=${cfg.collectMs} ran=${Date.now() - t0}ms messages=${res.messages.length}${res.error ? ` error=${res.error}` : ""}`);
+    return res;
+  });
+  handle.handleIpc(ipc, handle.IPC.socketio.disconnect, async (_event, requestId) => {
+    const socket = connections$2.get(requestId);
+    if (socket) {
+      socket.disconnect();
+      connections$2.delete(requestId);
+    }
+  });
+}
+let jqPromise = null;
+function getJq() {
+  if (!jqPromise) {
+    jqPromise = (async () => {
+      const mod = require("jq-web");
+      return mod && typeof mod.json === "function" ? mod : await mod;
+    })();
+  }
+  return jqPromise;
+}
+function registerJqHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.jq.filter, async (_event, jsonText2, filter) => {
+    const expr = (filter ?? "").trim();
+    if (!expr) return jsonText2;
+    let data;
+    try {
+      data = JSON.parse(jsonText2);
+    } catch {
+      throw new Error("The response body is not valid JSON, so it cannot be filtered with jq.");
+    }
+    const jq = await getJq();
+    let result;
+    try {
+      result = jq.json(data, expr);
+    } catch (e) {
+      throw new Error(e instanceof Error ? e.message.trim() : String(e));
+    }
+    return JSON.stringify(result, null, 2);
+  });
+}
+const SUB_ID = "1";
+const connections$1 = /* @__PURE__ */ new Map();
+function closeAllGraphqlWsConnections() {
+  for (const [, ws] of connections$1) {
+    try {
+      ws.close();
+    } catch {
+    }
+  }
+  connections$1.clear();
+}
+function parseJsonObject(text, label) {
+  if (!text || !text.trim()) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error(`${label} is not valid JSON`);
+  }
+  return parsed && typeof parsed === "object" ? parsed : void 0;
+}
+function registerGraphqlWsHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.graphqlws.subscribe, async (event, requestId, opts) => {
+    const existing = connections$1.get(requestId);
+    if (existing) {
+      existing.close();
+      connections$1.delete(requestId);
+    }
+    const alive = () => !event.sender.isDestroyed();
+    const send = (message) => {
+      if (alive()) event.sender.send(handle.IPC.graphqlws.message, { requestId, message });
+    };
+    const status = (s, error) => {
+      if (alive()) event.sender.send(handle.IPC.graphqlws.status, { requestId, status: s, error });
+    };
+    const note = (text) => send({ id: uuid.v4(), kind: "system", data: text, timestamp: Date.now() });
+    let variables;
+    let connectionParams;
+    try {
+      variables = parseJsonObject(opts.variables, "Variables");
+      connectionParams = parseJsonObject(opts.connectionParams, "Connection params");
+    } catch (e) {
+      status("error", e instanceof Error ? e.message : String(e));
+      return;
+    }
+    status("connecting");
+    let ws;
+    try {
+      ws = new WebSocket(opts.url, "graphql-transport-ws", { headers: opts.headers });
+    } catch (e) {
+      status("error", e instanceof Error ? e.message : String(e));
+      return;
+    }
+    connections$1.set(requestId, ws);
+    event.sender.once("destroyed", () => {
+      try {
+        ws.close();
+      } catch {
+      }
+      connections$1.delete(requestId);
+    });
+    ws.on("open", () => {
+      ws.send(JSON.stringify({ type: "connection_init", payload: connectionParams }));
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      switch (msg.type) {
+        case "connection_ack":
+          status("connected");
+          note("Connected; subscription started");
+          ws.send(JSON.stringify({ id: SUB_ID, type: "subscribe", payload: { query: opts.query, variables, operationName: opts.operationName } }));
+          break;
+        case "next":
+          send({ id: uuid.v4(), kind: "next", data: JSON.stringify(msg.payload), timestamp: Date.now() });
+          break;
+        case "error":
+          send({ id: uuid.v4(), kind: "error", data: JSON.stringify(msg.payload), timestamp: Date.now() });
+          break;
+        case "complete":
+          send({ id: uuid.v4(), kind: "complete", data: "Subscription complete", timestamp: Date.now() });
+          ws.close();
+          break;
+        case "ping":
+          ws.send(JSON.stringify({ type: "pong" }));
+          break;
+        default:
+          break;
+      }
+    });
+    ws.on("error", (err) => {
+      status("error", err.message);
+      connections$1.delete(requestId);
+    });
+    ws.on("close", () => {
+      status("disconnected");
+      connections$1.delete(requestId);
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.graphqlws.test, async (_event, cfg) => {
+    const t0 = Date.now();
+    const res = await requestExec.runGraphqlWsTest(cfg);
+    console.log(`[graphqlws:test] url=${cfg.url} collectMs=${cfg.collectMs} ran=${Date.now() - t0}ms messages=${res.messages.length}${res.error ? ` error=${res.error}` : ""}`);
+    return res;
+  });
+  handle.handleIpc(ipc, handle.IPC.graphqlws.stop, async (_event, requestId) => {
+    const ws = connections$1.get(requestId);
+    if (!ws) return;
+    try {
+      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ id: SUB_ID, type: "complete" }));
+    } catch {
+    }
+    ws.close();
+    connections$1.delete(requestId);
+  });
+}
+const connections = /* @__PURE__ */ new Map();
+function closeAllMqttConnections() {
+  for (const [, client] of connections) {
+    try {
+      client.end(true);
+    } catch {
+    }
+  }
+  connections.clear();
+}
+function normalizeQos(q) {
+  return q === 1 || q === 2 ? q : 0;
+}
+function registerMqttHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.mqtt.connect, async (event, requestId, opts) => {
+    const existing = connections.get(requestId);
+    if (existing) {
+      try {
+        existing.end(true);
+      } catch {
+      }
       connections.delete(requestId);
     }
+    const alive = () => !event.sender.isDestroyed();
+    const send = (message) => {
+      if (alive()) event.sender.send(handle.IPC.mqtt.message, { requestId, message });
+    };
+    const status = (s, error) => {
+      if (alive()) event.sender.send(handle.IPC.mqtt.status, { requestId, status: s, error });
+    };
+    const note = (topic, text) => send({ id: uuid.v4(), direction: "received", kind: "system", topic, data: text, timestamp: Date.now() });
+    const url = (opts.url ?? "").trim();
+    if (!url) {
+      status("error", "No broker URL");
+      return;
+    }
+    status("connecting");
+    let client;
+    try {
+      client = mqtt.connect(url, {
+        clientId: opts.clientId?.trim() || `api-spector-${Math.random().toString(16).slice(2, 10)}`,
+        username: opts.username?.trim() || void 0,
+        password: opts.password ? opts.password : void 0,
+        clean: opts.cleanSession !== false,
+        // Recover from a transient drop on its own and re-apply subscriptions,
+        // so a brief hiccup doesn't force the user to reconnect by hand.
+        reconnectPeriod: 2e3,
+        resubscribe: true,
+        connectTimeout: 3e4
+      });
+    } catch (err) {
+      status("error", err instanceof Error ? err.message : String(err));
+      return;
+    }
+    connections.set(requestId, client);
+    event.sender.once("destroyed", () => {
+      try {
+        client.end(true);
+      } catch {
+      }
+      connections.delete(requestId);
+    });
+    client.on("connect", () => {
+      status("connected");
+      note("", `Connected to ${url}`);
+      const topic = opts.subscribeTopic?.trim();
+      if (topic) {
+        client.subscribe(topic, { qos: normalizeQos(opts.qos) }, (err) => {
+          note(topic, err ? `Subscribe failed: ${err.message}` : `Subscribed to ${topic}`);
+        });
+      }
+    });
+    client.on("message", (topic, payload, packet) => {
+      send({
+        id: uuid.v4(),
+        direction: "received",
+        kind: "message",
+        topic,
+        data: payload.toString("utf8"),
+        qos: normalizeQos(packet?.qos),
+        retain: Boolean(packet?.retain),
+        timestamp: Date.now()
+      });
+    });
+    client.on("error", (err) => {
+      note("", `Error: ${err.message}`);
+    });
+    client.on("reconnect", () => {
+      status("connecting");
+    });
+    client.on("offline", () => {
+      status("connecting");
+      note("", "Connection lost, reconnecting…");
+    });
+    client.on("close", () => {
+      if (connections.get(requestId) === client) status("connecting");
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.mqtt.publish, async (_event, requestId, opts) => {
+    const client = connections.get(requestId);
+    if (!client || !client.connected) throw new Error("MQTT is not connected");
+    const topic = (opts.topic ?? "").trim();
+    if (!topic) throw new Error("Publish topic is required");
+    await new Promise((resolve2, reject) => {
+      client.publish(topic, opts.payload ?? "", { qos: normalizeQos(opts.qos), retain: Boolean(opts.retain) }, (err) => {
+        if (err) reject(err);
+        else resolve2();
+      });
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.mqtt.subscribe, async (event, requestId, opts) => {
+    const client = connections.get(requestId);
+    if (!client || !client.connected) throw new Error("MQTT is not connected");
+    const topic = (opts.topic ?? "").trim();
+    if (!topic) throw new Error("Subscribe topic is required");
+    const send = (message) => {
+      if (!event.sender.isDestroyed()) event.sender.send(handle.IPC.mqtt.message, { requestId, message });
+    };
+    await new Promise((resolve2, reject) => {
+      client.subscribe(topic, { qos: normalizeQos(opts.qos) }, (err) => {
+        send({ id: uuid.v4(), direction: "received", kind: "system", topic, data: err ? `Subscribe failed: ${err.message}` : `Subscribed to ${topic}`, timestamp: Date.now() });
+        if (err) reject(err);
+        else resolve2();
+      });
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.mqtt.unsubscribe, async (event, requestId, opts) => {
+    const client = connections.get(requestId);
+    if (!client || !client.connected) return;
+    const topic = (opts.topic ?? "").trim();
+    if (!topic) return;
+    const send = (message) => {
+      if (!event.sender.isDestroyed()) event.sender.send(handle.IPC.mqtt.message, { requestId, message });
+    };
+    client.unsubscribe(topic, () => {
+      send({ id: uuid.v4(), direction: "received", kind: "system", topic, data: `Unsubscribed from ${topic}`, timestamp: Date.now() });
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.mqtt.test, async (_event, cfg) => {
+    const t0 = Date.now();
+    const res = await requestExec.runMqttTest(cfg);
+    console.log(`[mqtt:test] url=${cfg.url} sub=${cfg.subscribeTopic ?? "(none)"} clientId=${res.clientId} collectMs=${cfg.collectMs} ran=${Date.now() - t0}ms messages=${res.messages.length}${res.error ? ` error=${res.error}` : ""}`);
+    return res;
+  });
+  handle.handleIpc(ipc, handle.IPC.mqtt.disconnect, async (event, requestId) => {
+    const client = connections.get(requestId);
+    if (client) {
+      connections.delete(requestId);
+      try {
+        client.end(true);
+      } catch {
+      }
+    }
+    if (!event.sender.isDestroyed()) event.sender.send(handle.IPC.mqtt.status, { requestId, status: "disconnected" });
+  });
+}
+let child = null;
+function runInWorker(payload, onProgress) {
+  return new Promise((resolve2, reject) => {
+    const proc = electron.utilityProcess.fork(path.join(__dirname, "perf-worker.js"));
+    child = proc;
+    let settled = false;
+    const done = () => {
+      settled = true;
+      if (child === proc) child = null;
+      try {
+        proc.kill();
+      } catch {
+      }
+    };
+    proc.on("message", (msg) => {
+      if (msg.type === "progress") {
+        onProgress(msg.p);
+        return;
+      }
+      if (msg.type === "result") {
+        done();
+        resolve2(msg.result);
+        return;
+      }
+      if (msg.type === "error") {
+        done();
+        reject(new Error(msg.message || "Load test failed"));
+        return;
+      }
+    });
+    proc.on("exit", () => {
+      if (!settled) {
+        if (child === proc) child = null;
+        reject(new Error("Load test worker exited unexpectedly"));
+      }
+    });
+    proc.postMessage({ type: "run", payload });
+  });
+}
+function registerPerfHandlers(ipc) {
+  handle.handleIpc(ipc, handle.IPC.perf.run, async (event, payload) => {
+    if ((payload.plan.target.kind === "sequence" || payload.plan.target.kind === "flow") && !payload.resolvedEnvVars) {
+      payload.resolvedEnvVars = await requestExec.buildEnvVars(payload.environment ?? null);
+    }
+    return runInWorker(payload, (p) => {
+      if (!event.sender.isDestroyed()) event.sender.send(handle.IPC.perf.progress, p);
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.perf.stop, async () => {
+    child?.postMessage({ type: "stop" });
+  });
+  handle.handleIpc(ipc, handle.IPC.perf.exportHtml, async (_e, result, meta = {}) => {
+    const { canceled, filePath } = await electron.dialog.showSaveDialog({
+      title: "Save performance report",
+      defaultPath: `perf-report-${(meta.planName ?? "run").replace(/[^a-z0-9]+/gi, "-").toLowerCase()}.html`,
+      filters: [{ name: "HTML", extensions: ["html"] }]
+    });
+    if (canceled || !filePath) return false;
+    await promises.writeFile(filePath, perfReport.perfReportToHtml(result, { generatedAt: (/* @__PURE__ */ new Date()).toISOString(), ...meta }), "utf8");
+    return true;
   });
 }
 const calls = /* @__PURE__ */ new Map();
@@ -6142,7 +7293,7 @@ function isNewer(a, b) {
   return a2 > b2;
 }
 async function checkForUpdate() {
-  const current = "0.7.7";
+  const current = "0.7.8";
   try {
     const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(4e3) });
     if (!res.ok) return null;
@@ -6360,6 +7511,11 @@ electron.app.whenReady().then(async () => {
   registerOAuth2Handlers(electron.ipcMain);
   registerVaultHandlers(electron.ipcMain);
   registerWsHandlers(electron.ipcMain);
+  registerSocketIoHandlers(electron.ipcMain);
+  registerJqHandlers(electron.ipcMain);
+  registerGraphqlWsHandlers(electron.ipcMain);
+  registerMqttHandlers(electron.ipcMain);
+  registerPerfHandlers(electron.ipcMain);
   registerGrpcHandlers(electron.ipcMain);
   soapHandler.registerSoapHandlers(electron.ipcMain);
   registerDocsHandlers(electron.ipcMain);
@@ -6387,6 +7543,9 @@ electron.app.on("window-all-closed", () => {
 });
 electron.app.on("before-quit", async () => {
   closeAllWsConnections();
+  closeAllSocketIoConnections();
+  closeAllGraphqlWsConnections();
+  closeAllMqttConnections();
   closeAllGrpcConnections();
   await mockServer.stopAll();
 });