@testsmith/api-spector 0.7.7 → 0.7.9

package/out/main/chunks/perf-run-Co_5unBR.js

@@ -0,0 +1,578 @@
+"use strict";
+const requestExec = require("./request-exec-CgyqbNWk.js");
+const grpc = require("@grpc/grpc-js");
+const protoLoader = require("@grpc/proto-loader");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const flowEngine = require("./flow-engine-BxwjEy37.js");
+const requestCollection = require("./request-collection-gkOYlWml.js");
+function _interopNamespaceDefault(e) {
+  const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n2, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n2.default = e;
+  return Object.freeze(n2);
+}
+const grpc__namespace = /* @__PURE__ */ _interopNamespaceDefault(grpc);
+const protoLoader__namespace = /* @__PURE__ */ _interopNamespaceDefault(protoLoader);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const os__namespace = /* @__PURE__ */ _interopNamespaceDefault(os);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const n = (v, min, max, dflt) => {
+  const x = Math.floor(Number(v));
+  if (!Number.isFinite(x)) return dflt;
+  return Math.max(min, Math.min(max, x));
+};
+function deriveLoad(plan) {
+  let executor = "vus";
+  let stages = [];
+  let maxVus = 0;
+  if (plan.pattern === "basic") {
+    const b = plan.basic;
+    const vus = n(b.vus, 1, 5e3, 10);
+    if (n(b.rampUpSec, 0, 36e3, 0) > 0) stages.push({ durationSec: n(b.rampUpSec, 0, 36e3, 0), target: vus, ramp: true });
+    stages.push({ durationSec: n(b.durationSec, 1, 36e3, 30), target: vus, ramp: false });
+    if (n(b.rampDownSec, 0, 36e3, 0) > 0) stages.push({ durationSec: n(b.rampDownSec, 0, 36e3, 0), target: 0, ramp: true });
+  } else if (plan.pattern === "stepping") {
+    const s = plan.stepping;
+    const start = n(s.startUsers, 1, 5e3, 5);
+    const step = n(s.stepUsers, 1, 5e3, 5);
+    const max = n(s.maxUsers, start, 5e3, 50);
+    const stepDur = n(s.stepDurationSec, 1, 36e3, 60);
+    const rampStep = n(s.rampStepSec, 0, 36e3, 0);
+    for (let level = start; ; level = Math.min(max, level + step)) {
+      if (rampStep > 0) stages.push({ durationSec: rampStep, target: level, ramp: true });
+      stages.push({ durationSec: stepDur, target: level, ramp: false });
+      if (level >= max) break;
+    }
+    const hold = n(s.holdFinalSec, 0, 36e3, 0);
+    if (hold > 0) stages.push({ durationSec: hold, target: max, ramp: false });
+  } else if (plan.pattern === "arrivals") {
+    executor = "arrival";
+    const a = plan.arrivals;
+    stages.push({ durationSec: n(a.durationSec, 1, 36e3, 60), target: n(a.rate, 1, 1e5, 50), ramp: false });
+    maxVus = n(a.maxVus, 1, 2e4, 200);
+  } else {
+    stages = (plan.custom.stages ?? []).map((st) => ({
+      durationSec: n(st.durationSec, 1, 36e3, 30),
+      target: n(st.target, 0, 2e4, 10),
+      ramp: Boolean(st.ramp)
+    }));
+    if (stages.length === 0) stages.push({ durationSec: 30, target: 10, ramp: false });
+  }
+  const totalSec = stages.reduce((sum, st) => sum + st.durationSec, 0);
+  return { executor, stages, maxVus, totalSec };
+}
+function targetAt(load, tSec) {
+  let start = 0;
+  let prevTarget = 0;
+  for (const st of load.stages) {
+    const end = start + st.durationSec;
+    if (tSec < end || st === load.stages[load.stages.length - 1]) {
+      if (st.ramp && st.durationSec > 0) {
+        const frac = Math.max(0, Math.min(1, (tSec - start) / st.durationSec));
+        return prevTarget + (st.target - prevTarget) * frac;
+      }
+      return st.target;
+    }
+    start = end;
+    prevTarget = st.target;
+  }
+  return 0;
+}
+function thresholdActual(result, metric) {
+  switch (metric) {
+    case "iteration_p95":
+      return result.iterationLatency.p95;
+    case "iteration_p99":
+      return result.iterationLatency.p99;
+    case "req_p95":
+      return result.requestLatency.p95;
+    case "error_rate":
+      return result.iterations > 0 ? result.iterationsFailed / result.iterations * 100 : 0;
+    case "throughput":
+      return result.iterationsPerSec;
+    default:
+      return 0;
+  }
+}
+function compare(actual, op, value) {
+  switch (op) {
+    case "lt":
+      return actual < value;
+    case "lte":
+      return actual <= value;
+    case "gt":
+      return actual > value;
+    case "gte":
+      return actual >= value;
+    default:
+      return false;
+  }
+}
+function evaluateThresholds(result, thresholds) {
+  return (thresholds ?? []).map((th) => {
+    const actual = thresholdActual(result, th.metric);
+    return { ...th, actual, passed: compare(actual, th.op, th.value) };
+  });
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
+  return sorted[idx];
+}
+function latency(values) {
+  const s = [...values].sort((a, b) => a - b);
+  return {
+    min: s[0] ?? 0,
+    max: s[s.length - 1] ?? 0,
+    mean: s.length ? s.reduce((a, b) => a + b, 0) / s.length : 0,
+    p50: percentile(s, 50),
+    p90: percentile(s, 90),
+    p95: percentile(s, 95),
+    p99: percentile(s, 99)
+  };
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+let active = null;
+function stopPerfRun() {
+  active?.stop();
+}
+async function runPerfTest(schedule, iterate, onProgress, progressMs = 500) {
+  const totalMs = Math.max(100, schedule.totalSec * 1e3);
+  const maxVus = Math.max(1, schedule.maxVus || 1e5);
+  const iterLat = [];
+  const reqLat = [];
+  const statusCounts = {};
+  const errors = {};
+  const stepOrder = [];
+  const stepMap = /* @__PURE__ */ new Map();
+  const buckets = /* @__PURE__ */ new Map();
+  let iterations = 0;
+  let iterationsFailed = 0;
+  let bytes = 0;
+  let activeVus = 0;
+  let peakVus = 0;
+  let dropped = 0;
+  let stopped = false;
+  const start = Date.now();
+  active = { stop: () => {
+    stopped = true;
+  } };
+  const record = (s) => {
+    iterations += 1;
+    if (!s.ok) iterationsFailed += 1;
+    iterLat.push(s.durationMs);
+    const sec = Math.floor((Date.now() - start) / 1e3);
+    let b = buckets.get(sec);
+    if (!b) {
+      b = { count: 0, lat: [] };
+      buckets.set(sec, b);
+    }
+    b.count += 1;
+    b.lat.push(s.durationMs);
+    for (const step of s.steps) {
+      let e = stepMap.get(step.name);
+      if (!e) {
+        e = { count: 0, failed: 0, lat: [], status: {} };
+        stepMap.set(step.name, e);
+        stepOrder.push(step.name);
+      }
+      e.count += 1;
+      if (!step.ok) e.failed += 1;
+      e.lat.push(step.ms);
+      reqLat.push(step.ms);
+      bytes += step.bytes;
+      const key = step.statusLabel ?? (step.status > 0 ? String(step.status) : "error");
+      e.status[key] = (e.status[key] ?? 0) + 1;
+      statusCounts[key] = (statusCounts[key] ?? 0) + 1;
+      if (step.error) errors[step.error] = (errors[step.error] ?? 0) + 1;
+    }
+  };
+  const runOne = async () => {
+    activeVus += 1;
+    if (activeVus > peakVus) peakVus = activeVus;
+    const t0 = Date.now();
+    let controller;
+    let to;
+    if (schedule.timeoutMs) {
+      controller = new AbortController();
+      to = setTimeout(() => controller.abort(), schedule.timeoutMs);
+    }
+    try {
+      record(await iterate(controller?.signal));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      record({ ok: false, durationMs: Date.now() - t0, steps: [{ name: "(iteration)", ok: false, status: 0, ms: Date.now() - t0, bytes: 0, error: msg || "Iteration failed" }] });
+    } finally {
+      if (to) clearTimeout(to);
+      activeVus -= 1;
+    }
+  };
+  const emit = () => {
+    if (!onProgress) return;
+    const elapsedMs = Date.now() - start;
+    onProgress({
+      running: true,
+      elapsedMs,
+      iterations,
+      iterationsFailed,
+      activeVus,
+      targetNow: targetAt(schedule, elapsedMs / 1e3),
+      iterationsPerSec: elapsedMs > 0 ? iterations / elapsedMs * 1e3 : 0,
+      p95: percentile([...iterLat].sort((a, b) => a - b), 95)
+    });
+  };
+  const progressTimer = setInterval(emit, progressMs);
+  if (schedule.executor === "vus") {
+    const workers = [];
+    let retire = 0;
+    let settled = 0;
+    const thinkMin = Math.max(0, schedule.thinkMinMs ?? 0);
+    const thinkMax = Math.max(thinkMin, schedule.thinkMaxMs ?? 0);
+    const worker = async () => {
+      while (!stopped && Date.now() - start < totalMs) {
+        if (retire > 0) {
+          retire -= 1;
+          break;
+        }
+        await runOne();
+        if (thinkMax > 0 && !stopped) await sleep(thinkMin + Math.random() * (thinkMax - thinkMin));
+      }
+    };
+    const reconcile = () => {
+      if (stopped) return;
+      const desired = Math.max(0, Math.round(targetAt(schedule, (Date.now() - start) / 1e3)));
+      const effective = workers.length - settled - retire;
+      if (effective < desired) {
+        for (let i = 0; i < desired - effective; i++) workers.push(worker().then(() => {
+          settled += 1;
+        }));
+      } else if (effective > desired) {
+        retire += effective - desired;
+      }
+    };
+    const tick = setInterval(reconcile, 200);
+    reconcile();
+    while (!stopped && Date.now() - start < totalMs) await sleep(100);
+    clearInterval(tick);
+    stopped = true;
+    await Promise.allSettled(workers);
+  } else {
+    let acc = 0;
+    let last = Date.now();
+    const inflight = [];
+    while (!stopped && Date.now() - start < totalMs) {
+      const now = Date.now();
+      const dt = (now - last) / 1e3;
+      last = now;
+      acc += targetAt(schedule, (now - start) / 1e3) * dt;
+      while (acc >= 1) {
+        acc -= 1;
+        if (activeVus >= maxVus) {
+          dropped += 1;
+          continue;
+        }
+        inflight.push(runOne());
+      }
+      await sleep(50);
+    }
+    stopped = true;
+    await Promise.allSettled(inflight);
+  }
+  clearInterval(progressTimer);
+  active = null;
+  const durationMs = Date.now() - start;
+  const steps = stepOrder.map((name) => {
+    const e = stepMap.get(name);
+    return { name, count: e.count, failed: e.failed, latency: latency(e.lat), statusCounts: e.status };
+  });
+  const totalRequests = reqLat.length;
+  const series = [...buckets.entries()].sort((a, b) => a[0] - b[0]).map(([second, b]) => ({ second, rps: b.count, p95: percentile([...b.lat].sort((x, y) => x - y), 95) }));
+  return {
+    mode: schedule.mode,
+    pattern: schedule.pattern,
+    executor: schedule.executor,
+    iterations,
+    iterationsFailed,
+    durationMs,
+    iterationsPerSec: durationMs > 0 ? iterations / durationMs * 1e3 : 0,
+    requestsPerSec: durationMs > 0 ? totalRequests / durationMs * 1e3 : 0,
+    iterationLatency: latency(iterLat),
+    requestLatency: latency(reqLat),
+    bytes,
+    bytesPerSec: durationMs > 0 ? bytes / durationMs * 1e3 : 0,
+    statusCounts,
+    errors,
+    steps,
+    series,
+    peakVus,
+    droppedArrivals: dropped,
+    stopped,
+    thresholds: [],
+    passed: true
+  };
+}
+const LOADER_OPTS = { keepCase: true, longs: String, enums: String, defaults: true, oneofs: true };
+function resolveProtoFile(src) {
+  const importPaths = (src.importPaths ?? []).filter(Boolean);
+  if (src.protoPath) return { file: src.protoPath, includeDirs: [path__namespace.dirname(src.protoPath), ...importPaths] };
+  if (src.protoSource?.trim()) {
+    const dir = fs__namespace.mkdtempSync(path__namespace.join(os__namespace.tmpdir(), "apispector-proto-"));
+    const file = path__namespace.join(dir, "main.proto");
+    fs__namespace.writeFileSync(file, src.protoSource, "utf8");
+    return { file, includeDirs: [dir, ...importPaths] };
+  }
+  throw new Error("No proto source: paste a .proto or provide a file path.");
+}
+function resolveService(grpcObj, serviceName) {
+  let node = grpcObj;
+  for (const part of serviceName.split(".")) {
+    node = node?.[part];
+    if (!node) throw new Error(`Service "${serviceName}" not found in the proto.`);
+  }
+  if (typeof node !== "function") throw new Error(`"${serviceName}" is not a service.`);
+  return node;
+}
+function normalizeTarget(url) {
+  return url.replace(/^[a-z0-9+.-]+:\/\//i, "").replace(/\/+$/, "");
+}
+function statusName(code) {
+  return Object.keys(grpc__namespace.status).find((k) => grpc__namespace.status[k] === code) ?? String(code);
+}
+function createGrpcInvoker(cfg) {
+  const { file, includeDirs } = resolveProtoFile(cfg);
+  const pkgDef = protoLoader__namespace.loadSync(file, { ...LOADER_OPTS, includeDirs });
+  const grpcObj = grpc__namespace.loadPackageDefinition(pkgDef);
+  const ServiceCtor = resolveService(grpcObj, cfg.serviceName);
+  const serviceDef = ServiceCtor.service;
+  const methodKey = Object.keys(serviceDef).find((k) => k === cfg.methodName) ?? Object.keys(serviceDef).find((k) => k.toLowerCase() === cfg.methodName.toLowerCase());
+  if (!methodKey) throw new Error(`Method "${cfg.methodName}" not found on ${cfg.serviceName}.`);
+  const def = serviceDef[methodKey];
+  if (def.requestStream || def.responseStream) throw new Error("Only unary gRPC methods can be load tested.");
+  const request = cfg.message?.trim() ? JSON.parse(cfg.message) : {};
+  const creds = cfg.plaintext ? grpc__namespace.credentials.createInsecure() : grpc__namespace.credentials.createSsl();
+  const client = new ServiceCtor(normalizeTarget(cfg.target), creds);
+  const metadata = new grpc__namespace.Metadata();
+  for (const [k, v] of Object.entries(cfg.metadata ?? {})) metadata.set(k, v);
+  const method = client[methodKey].bind(client);
+  return {
+    invoke() {
+      return new Promise((resolve) => {
+        try {
+          method(request, metadata, (err, response) => {
+            if (err) resolve({ ok: false, code: err.code ?? grpc__namespace.status.UNKNOWN, codeName: statusName(err.code ?? grpc__namespace.status.UNKNOWN), bytes: 0, error: err.details || err.message });
+            else resolve({ ok: true, code: grpc__namespace.status.OK, codeName: "OK", bytes: Buffer.byteLength(JSON.stringify(response ?? {}), "utf8") });
+          });
+        } catch (e) {
+          resolve({ ok: false, code: grpc__namespace.status.UNKNOWN, codeName: "UNKNOWN", bytes: 0, error: e instanceof Error ? e.message : String(e) });
+        }
+      });
+    },
+    close() {
+      try {
+        client.close();
+      } catch {
+      }
+    }
+  };
+}
+async function buildFlowDeps(payload) {
+  const envVars = payload.resolvedEnvVars ?? await requestExec.buildEnvVars(payload.environment ?? null);
+  const globals = { ...payload.globals, ...requestExec.getGlobals() };
+  const dispatcher = await requestExec.buildDispatcher(payload.proxy, payload.tls);
+  const flow = flowEngine.normalizeFlow(payload.flow);
+  const flows = (payload.flows ?? []).map(flowEngine.normalizeFlow);
+  const colById = new Map((payload.collections ?? []).map((c) => [c.id, c]));
+  const deps = {
+    runRequest: async (ref, input) => {
+      const col = colById.get(ref.collectionId);
+      const original = col?.requests[ref.requestId];
+      if (!col || !original) return null;
+      const req = JSON.parse(JSON.stringify(original));
+      const inherited = requestCollection.resolveInheritedAuthAndHeaders(original.id, col);
+      if (!requestCollection.authIsConfigured(req.auth) && inherited.auth && inherited.auth.type !== "none") req.auth = inherited.auth;
+      const inheritedHeaders = inherited.headers.filter((h) => h.enabled && h.key);
+      if (inheritedHeaders.length) req.headers = [...inheritedHeaders, ...req.headers ?? []];
+      const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await requestExec.executeRunnerRequest({
+        req,
+        collectionVars: { ...col.collectionVariables ?? {}, ...input.collectionVars },
+        envVars: input.envVars,
+        globals: input.globals,
+        localVars: input.localVars,
+        dispatcher,
+        piiMaskPatterns: [],
+        proxy: payload.proxy,
+        tls: payload.tls
+      });
+      const rr = result.receivedResponse;
+      const response = rr ? { status: rr.status, statusText: rr.statusText, headers: rr.headers, body: rr.body, bodySize: rr.body?.length ?? 0, durationMs: result.durationMs ?? 0 } : null;
+      return {
+        envVars: updatedEnvVars,
+        collectionVars: updatedCollectionVars,
+        globals: updatedGlobals,
+        localVars: updatedLocalVars,
+        response,
+        status: result.status,
+        httpStatus: result.httpStatus,
+        durationMs: result.durationMs,
+        error: result.error,
+        testResults: result.testResults,
+        name: result.name,
+        method: result.method,
+        resolvedUrl: result.resolvedUrl
+      };
+    },
+    runScript: async (code, input) => {
+      const out = await requestExec.runScript(code, { envVars: input.envVars, collectionVars: input.collectionVars, globals: input.globals, localVars: input.localVars, response: input.response ?? void 0, piiMaskPatterns: [], data: input.data });
+      return { envVars: out.updatedEnvVars, collectionVars: out.updatedCollectionVars, globals: out.updatedGlobals, localVars: out.updatedLocalVars, testResults: out.testResults, consoleOutput: out.consoleOutput, error: out.error };
+    },
+    evalExpression: async (code, input) => {
+      const out = await requestExec.evaluateExpression(code, { envVars: input.envVars, collectionVars: input.collectionVars, globals: input.globals, localVars: input.localVars, response: input.response ?? void 0, piiMaskPatterns: [], data: input.data });
+      return { envVars: out.updatedEnvVars, collectionVars: out.updatedCollectionVars, globals: out.updatedGlobals, localVars: out.updatedLocalVars, value: out.value, consoleOutput: out.consoleOutput, error: out.error };
+    },
+    resolveFlow: (flowId) => flows.find((f) => f.id === flowId) ?? null,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
+  };
+  return { deps, flow, envVars, globals };
+}
+async function runPerfPlan(payload, onProgress) {
+  const plan = payload.plan;
+  const load = deriveLoad(plan);
+  const schedule = {
+    ...load,
+    mode: plan.target.kind,
+    pattern: plan.pattern,
+    timeoutMs: plan.timeoutSec > 0 ? plan.timeoutSec * 1e3 : void 0,
+    thinkMinMs: Math.max(0, plan.thinkTime?.minSec ?? 0) * 1e3,
+    thinkMaxMs: Math.max(0, plan.thinkTime?.maxSec ?? 0) * 1e3
+  };
+  let iterate;
+  let grpcInvoker;
+  if (plan.target.kind === "request") {
+    if (!payload.request) throw new Error("No request selected for this plan");
+    const req = payload.request;
+    requestExec.applyRequestDefaults(req);
+    const dynamicVars = await requestExec.buildDynamicVars();
+    const vars = requestExec.mergeVars(payload.vars ?? {}, {}, {}, {}, dynamicVars, {});
+    if (req.protocol === "grpc") {
+      const g = req.body?.grpc;
+      if (!g || !g.serviceName || !g.methodName) throw new Error("This gRPC request has no service/method configured");
+      const ip = (s) => requestExec.interpolate(s ?? "", vars);
+      const metadata = {};
+      for (const m of g.metadata ?? []) if (m.enabled !== false && m.key) metadata[ip(m.key)] = ip(m.value);
+      grpcInvoker = createGrpcInvoker({
+        target: ip(req.url),
+        protoSource: g.protoSource,
+        protoPath: g.protoPath,
+        importPaths: g.importPaths,
+        serviceName: g.serviceName,
+        methodName: g.methodName,
+        message: ip(g.message ?? "{}"),
+        metadata,
+        plaintext: g.plaintext
+      });
+      const label = `${g.serviceName}/${g.methodName}`;
+      iterate = async () => {
+        const t0 = Date.now();
+        const r = await grpcInvoker.invoke();
+        const ms = Date.now() - t0;
+        return { ok: r.ok, durationMs: ms, steps: [{ name: label, ok: r.ok, status: r.code, statusLabel: r.codeName, ms, bytes: r.bytes, error: r.error }] };
+      };
+    } else {
+      const resolvedUrl = requestExec.buildUrl(req.url, req.params, vars);
+      const dispatcher = await requestExec.buildDispatcher(payload.proxy, payload.tls);
+      iterate = async (signal) => {
+        const t0 = Date.now();
+        try {
+          const ex = await requestExec.performHttpExchange({ req, vars, resolvedUrl, dispatcher, proxy: payload.proxy, tls: payload.tls, signal });
+          return { ok: ex.status < 400, durationMs: ex.durationMs, steps: [{ name: req.name || "request", ok: ex.status < 400, status: ex.status, ms: ex.durationMs, bytes: Buffer.byteLength(ex.responseBody ?? "", "utf8") }] };
+        } catch (e) {
+          const msg = e instanceof Error ? e.name === "AbortError" ? "Timeout" : e.message : String(e);
+          return { ok: false, durationMs: Date.now() - t0, steps: [{ name: req.name || "request", ok: false, status: 0, ms: Date.now() - t0, bytes: 0, error: msg || "Request failed" }] };
+        }
+      };
+    }
+  } else if (plan.target.kind === "sequence") {
+    if (!payload.collection) throw new Error("No collection selected for this plan");
+    const collection = payload.collection;
+    const envVars = payload.resolvedEnvVars ?? await requestExec.buildEnvVars(payload.environment ?? null);
+    const globals = { ...payload.globals, ...requestExec.getGlobals() };
+    const dispatcher = await requestExec.buildDispatcher(payload.proxy, payload.tls);
+    const items = requestCollection.buildRunPlan(collection, plan.target.folderId ?? null, []);
+    if (items.length === 0) throw new Error("This collection or folder has no requests to run");
+    iterate = async () => {
+      let env = { ...envVars };
+      let col = { ...collection.collectionVariables ?? {} };
+      let glob = { ...globals };
+      let loc = {};
+      const steps = [];
+      const t0 = Date.now();
+      for (const item of items) {
+        const original = item.request;
+        const req = JSON.parse(JSON.stringify(original));
+        const inherited = requestCollection.resolveInheritedAuthAndHeaders(original.id, collection);
+        if (!requestCollection.authIsConfigured(req.auth) && inherited.auth && inherited.auth.type !== "none") req.auth = inherited.auth;
+        const inheritedHeaders = inherited.headers.filter((h) => h.enabled && h.key);
+        if (inheritedHeaders.length) req.headers = [...inheritedHeaders, ...req.headers ?? []];
+        const out = await requestExec.executeRunnerRequest({
+          req,
+          collectionVars: col,
+          envVars: env,
+          globals: glob,
+          localVars: { ...loc, ...item.dataRow ?? {} },
+          folderVars: item.folderVars,
+          dispatcher,
+          piiMaskPatterns: [],
+          proxy: payload.proxy,
+          tls: payload.tls
+        });
+        env = out.updatedEnvVars;
+        col = out.updatedCollectionVars;
+        glob = out.updatedGlobals;
+        loc = out.updatedLocalVars;
+        const ok2 = out.result.status === "passed" || out.result.status === "skipped";
+        if (!item.isHook) steps.push({ name: original.name, ok: ok2, status: out.result.httpStatus ?? 0, ms: out.result.durationMs ?? 0, bytes: out.result.receivedResponse?.body?.length ?? 0, error: ok2 ? void 0 : out.result.error });
+      }
+      const ok = steps.every((s) => s.ok);
+      return { ok, durationMs: Date.now() - t0, steps: steps.length ? steps : [{ name: "(sequence)", ok, status: 0, ms: Date.now() - t0, bytes: 0 }] };
+    };
+  } else {
+    if (!payload.flow) throw new Error("No flow selected for this plan");
+    const { deps, flow, envVars, globals } = await buildFlowDeps(payload);
+    iterate = async () => {
+      const summary = await flowEngine.runFlow(flow, deps, { envVars, globals });
+      const steps = summary.blocks.filter((b) => b.type === "request").map((b) => ({
+        name: b.label || b.resolvedUrl || b.blockId,
+        ok: b.status === "passed" || b.status === "done",
+        status: b.httpStatus ?? 0,
+        ms: b.durationMs ?? 0,
+        bytes: b.http?.bodySize ?? 0,
+        error: b.status === "error" || b.status === "failed" ? b.error || "Step failed" : void 0
+      }));
+      const ok = summary.failed === 0 && summary.errors === 0;
+      return { ok, durationMs: summary.durationMs, steps: steps.length ? steps : [{ name: "(flow)", ok, status: 0, ms: summary.durationMs, bytes: 0, error: ok ? void 0 : "Flow failed" }] };
+    };
+  }
+  let res;
+  try {
+    res = await runPerfTest(schedule, iterate, onProgress);
+  } finally {
+    grpcInvoker?.close();
+  }
+  const thresholds = evaluateThresholds(res, plan.thresholds ?? []);
+  return { ...res, thresholds, passed: thresholds.length ? thresholds.every((t) => t.passed) : true };
+}
+exports.deriveLoad = deriveLoad;
+exports.runPerfPlan = runPerfPlan;
+exports.stopPerfRun = stopPerfRun;