apitestcenter 0.9.0 → 0.10.0

package/dist/cli.mjs

@@ -231,15 +231,15 @@ function normalizeView(raw) {
   const v = raw;
   if (typeof v.id !== "string" || !v.id || typeof v.name !== "string") return null;
   const scope = v.scope === "compare" ? "compare" : "run";
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const widgets = [];
   for (const item of Array.isArray(v.widgets) ? v.widgets : []) {
     const w = item;
     const def = METRICS[w.metric];
     if (!def || scope === "compare" && !def.compare) continue;
     let id = typeof w.id === "string" && w.id ? w.id : `${def.id}-${widgets.length}`;
-    while (seen.has(id)) id = `${id}-x`;
-    seen.add(id);
+    while (seen2.has(id)) id = `${id}-x`;
+    seen2.add(id);
     const kind = def.kinds.includes(w.kind) ? w.kind : def.kinds[0];
     const width = clamp(w.w ?? def.size.w, def.min.w, GRID_COLUMNS);
     widgets.push({
@@ -781,12 +781,12 @@ function variablesOf(env) {
 }
 function normalizeEnvironments(raw) {
   if (!Array.isArray(raw)) return [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const out = [];
   for (const item of raw) {
     const e = item;
-    if (typeof e?.id !== "string" || !e.id || seen.has(e.id)) continue;
-    seen.add(e.id);
+    if (typeof e?.id !== "string" || !e.id || seen2.has(e.id)) continue;
+    seen2.add(e.id);
     const keys = /* @__PURE__ */ new Set();
     const variables = [];
     for (const v of Array.isArray(e.variables) ? e.variables : []) {
@@ -12334,14 +12334,14 @@ function initializeContext(params) {
 function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
-  if (seen) {
-    seen.count++;
+  const seen2 = ctx.seen.get(schema);
+  if (seen2) {
+    seen2.count++;
     const isCycle = _params.schemaPath.includes(schema);
     if (isCycle) {
-      seen.cycle = _params.path;
+      seen2.cycle = _params.path;
     }
-    return seen.schema;
+    return seen2.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
   ctx.seen.set(schema, result);
@@ -12424,12 +12424,12 @@ function extractDefs(ctx, schema) {
     if (entry[1].schema.$ref) {
       return;
     }
-    const seen = entry[1];
+    const seen2 = entry[1];
     const { ref, defId } = makeURI(entry);
-    seen.def = { ...seen.schema };
+    seen2.def = { ...seen2.schema };
     if (defId)
-      seen.defId = defId;
-    const schema2 = seen.schema;
+      seen2.defId = defId;
+    const schema2 = seen2.schema;
     for (const key in schema2) {
       delete schema2[key];
     }
@@ -12437,16 +12437,16 @@ function extractDefs(ctx, schema) {
   };
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
-      const seen = entry[1];
-      if (seen.cycle) {
-        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+      const seen2 = entry[1];
+      if (seen2.cycle) {
+        throw new Error(`Cycle detected: #/${seen2.cycle?.join("/")}/<root>
 
 Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
       }
     }
   }
   for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
+    const seen2 = entry[1];
     if (schema === entry[0]) {
       extractToDef(entry);
       continue;
@@ -12463,11 +12463,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       extractToDef(entry);
       continue;
     }
-    if (seen.cycle) {
+    if (seen2.cycle) {
       extractToDef(entry);
       continue;
     }
-    if (seen.count > 1) {
+    if (seen2.count > 1) {
       if (ctx.reused === "ref") {
         extractToDef(entry);
         continue;
@@ -12480,13 +12480,13 @@ function finalize(ctx, schema) {
   if (!root2)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = (zodSchema) => {
-    const seen = ctx.seen.get(zodSchema);
-    if (seen.ref === null)
+    const seen2 = ctx.seen.get(zodSchema);
+    if (seen2.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
+    const schema2 = seen2.def ?? seen2.schema;
     const _cached = { ...schema2 };
-    const ref = seen.ref;
-    seen.ref = null;
+    const ref = seen2.ref;
+    seen2.ref = null;
     if (ref) {
       flattenRef(ref);
       const refSeen = ctx.seen.get(ref);
@@ -12538,7 +12538,7 @@ function finalize(ctx, schema) {
     ctx.override({
       zodSchema,
       jsonSchema: schema2,
-      path: seen.path ?? []
+      path: seen2.path ?? []
     });
   };
   for (const entry of [...ctx.seen.entries()].reverse()) {
@@ -12566,11 +12566,11 @@ function finalize(ctx, schema) {
     delete result.id;
   const defs = ctx.external?.defs ?? {};
   for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
-    if (seen.def && seen.defId) {
-      if (seen.def.id === seen.defId)
-        delete seen.def.id;
-      defs[seen.defId] = seen.def;
+    const seen2 = entry[1];
+    if (seen2.def && seen2.defId) {
+      if (seen2.def.id === seen2.defId)
+        delete seen2.def.id;
+      defs[seen2.defId] = seen2.def;
     }
   }
   if (ctx.external) {
@@ -13106,9 +13106,9 @@ var init_json_schema_processors = __esm({
     nullableProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       const inner = process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
+      const seen2 = ctx.seen.get(schema);
       if (ctx.target === "openapi-3.0") {
-        seen.ref = def.innerType;
+        seen2.ref = def.innerType;
         json2.nullable = true;
       } else {
         json2.anyOf = [inner, { type: "null" }];
@@ -13117,29 +13117,29 @@ var init_json_schema_processors = __esm({
     nonoptionalProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
     };
     defaultProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
       json2.default = JSON.parse(JSON.stringify(def.defaultValue));
     };
     prefaultProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
       if (ctx.io === "input")
         json2._prefault = JSON.parse(JSON.stringify(def.defaultValue));
     };
     catchProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
       let catchValue;
       try {
         catchValue = def.catchValue(void 0);
@@ -13153,33 +13153,33 @@ var init_json_schema_processors = __esm({
       const inIsTransform = def.in._zod.traits.has("$ZodTransform");
       const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
       process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = innerType;
     };
     readonlyProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
       json2.readOnly = true;
     };
     promiseProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
     };
     optionalProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
       process2(def.innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = def.innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = def.innerType;
     };
     lazyProcessor = (schema, ctx, _json, params) => {
       const innerType = schema._zod.innerType;
       process2(innerType, ctx, params);
-      const seen = ctx.seen.get(schema);
-      seen.ref = innerType;
+      const seen2 = ctx.seen.get(schema);
+      seen2.ref = innerType;
     };
     allProcessors = {
       string: stringProcessor,
@@ -16068,13 +16068,41 @@ function checkLabel(check2) {
     case "status":
       return `status is ${check2.expect.replace(/\s+/g, "")}`;
     case "body":
+      if (check2.op === "is_json") return "body is JSON";
+      if (check2.op === "matches") return `body matches /${clip(check2.value)}/`;
       return `body ${check2.op === "contains" ? "contains" : "does not contain"} "${clip(check2.value)}"`;
-    case "json":
-      return check2.op === "exists" || check2.op === "not_exists" ? `${jsonPathLabel(check2.path)} ${check2.op === "exists" ? "exists" : "does not exist"}` : `${jsonPathLabel(check2.path)} ${check2.op === "equals" ? "=" : check2.op === "not_equals" ? "\u2260" : "contains"} "${clip(check2.value)}"`;
+    case "json": {
+      const path = jsonPathLabel(check2.path);
+      switch (check2.op) {
+        case "exists":
+          return `${path} exists`;
+        case "not_exists":
+          return `${path} does not exist`;
+        case "greater":
+          return `${path} > ${clip(check2.value)}`;
+        case "less":
+          return `${path} < ${clip(check2.value)}`;
+        case "matches":
+          return `${path} matches /${clip(check2.value)}/`;
+        case "type":
+          return `${path} is ${/^[aeiou]/.test(check2.value) ? "an" : "a"} ${check2.value || "?"}`;
+        case "length":
+          return `length of ${path} ${lengthRule(check2.value).label}`;
+        default:
+          return `${path} ${check2.op === "equals" ? "=" : check2.op === "not_equals" ? "\u2260" : "contains"} "${clip(check2.value)}"`;
+      }
+    }
     case "header":
-      return check2.op === "exists" ? `header ${check2.name} exists` : `header ${check2.name} ${check2.op === "equals" ? "=" : "contains"} "${clip(check2.value)}"`;
+      if (check2.op === "exists") return `header ${check2.name} exists`;
+      if (check2.op === "not_exists") return `header ${check2.name} does not exist`;
+      if (check2.op === "matches") return `header ${check2.name} matches /${clip(check2.value)}/`;
+      return `header ${check2.name} ${check2.op === "equals" ? "=" : "contains"} "${clip(check2.value)}"`;
     case "time":
       return `responds within ${check2.maxMs} ms`;
+    case "schema": {
+      const title = schemaTitle(check2.schema);
+      return title ? `body matches schema "${clip(title)}"` : "body matches the JSON schema";
+    }
   }
 }
 function clip(text) {
@@ -16082,26 +16110,86 @@ function clip(text) {
 }
 function jsonPathLabel(path) {
   const trimmed = path.trim().replace(/^\$\.?/, "");
-  return `$.${trimmed}`;
+  return trimmed ? `$.${trimmed}` : "$";
+}
+function schemaTitle(schema) {
+  try {
+    const parsed = JSON.parse(schema);
+    return typeof parsed?.title === "string" && parsed.title.trim() ? parsed.title.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function lengthRule(value) {
+  const m = /^\s*(>=|<=|!=|>|<|=)?\s*(\d+)\s*$/.exec(value);
+  if (!m) return { label: `is ${value.trim() || "?"}` };
+  const op = m[1] ?? "=";
+  return { label: `${op === "=" ? "=" : op === "!=" ? "\u2260" : op === ">=" ? "\u2265" : op === "<=" ? "\u2264" : op} ${m[2]}` };
 }
 function checksNeedBody(checks) {
-  return checks.some((c) => c.type === "body" || c.type === "json");
+  return checks.some((c) => c.type === "body" || c.type === "json" || c.type === "schema");
 }
 function evaluator() {
   compiled ??= new Function(`${CHECK_EVALUATOR_JS}
-return __atcCheck;`)();
+return { check: __atcCheck, schemaError: __atcSchemaError, jsonGet: __atcJsonGet };`)();
   return compiled;
 }
+function explain(check2, res) {
+  if (check2.type === "status") return `got ${res.status}`;
+  if (check2.type === "time") return `took ${Math.round(res.durationMs)} ms`;
+  if (check2.type === "header") {
+    const h = res.headers[check2.name.toLowerCase()];
+    return h === void 0 ? "no such header" : `is "${clip(h)}"`;
+  }
+  if (res.body === null) return "no body";
+  if (check2.type === "body") return check2.op === "is_json" ? "not valid JSON" : void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(res.body);
+  } catch {
+    return "the body is not JSON";
+  }
+  if (check2.type === "schema") {
+    let schema;
+    try {
+      schema = JSON.parse(check2.schema);
+    } catch {
+      return "the schema is not valid JSON";
+    }
+    return evaluator().schemaError(schema, parsed, "", schema, 0) ?? void 0;
+  }
+  if (check2.type === "json") {
+    const got = evaluator().jsonGet(parsed, check2.path);
+    if (!got.found) return check2.op === "not_exists" ? void 0 : "not found";
+    const v = got.value;
+    if (check2.op === "type") return `is ${v === null ? "null" : Array.isArray(v) ? "an array" : typeof v === "object" ? "an object" : `a ${typeof v}`}`;
+    if (check2.op === "length") {
+      const n = typeof v === "string" || Array.isArray(v) ? v.length : v && typeof v === "object" ? Object.keys(v).length : void 0;
+      return n === void 0 ? "has no length" : `length is ${n}`;
+    }
+    if (check2.op === "not_exists") return "it exists";
+    const text = typeof v === "string" ? v : JSON.stringify(v);
+    return `is ${clip(text ?? "")}`;
+  }
+  return void 0;
+}
 function evaluateChecks(checks, res) {
-  const run2 = evaluator();
+  const run2 = evaluator().check;
   return checks.map((check2) => {
     let ok = false;
     try {
-      ok = Boolean(run2(check2, res));
+      ok = Boolean(run2({ ...check2 }, res));
     } catch {
       ok = false;
     }
-    return { name: checkLabel(check2), ok };
+    if (ok) return { name: checkLabel(check2), ok };
+    let detail;
+    try {
+      detail = explain(check2, res);
+    } catch {
+      detail = void 0;
+    }
+    return detail ? { name: checkLabel(check2), ok, detail } : { name: checkLabel(check2), ok };
   });
 }
 var responseCheckSchema, CHECK_EVALUATOR_JS, compiled;
@@ -16111,20 +16199,28 @@ var init_checks3 = __esm({
     init_zod();
     responseCheckSchema = external_exports.discriminatedUnion("type", [
       external_exports.object({ type: external_exports.literal("status"), expect: external_exports.string().min(1).max(100) }).strict(),
-      external_exports.object({ type: external_exports.literal("body"), op: external_exports.enum(["contains", "not_contains"]), value: external_exports.string().min(1).max(2e3) }).strict(),
+      external_exports.object({
+        type: external_exports.literal("body"),
+        op: external_exports.enum(["contains", "not_contains", "matches", "is_json"]),
+        // Not used by is_json.
+        value: external_exports.string().max(2e3).default("")
+      }).strict(),
       external_exports.object({
         type: external_exports.literal("json"),
         path: external_exports.string().min(1).max(300),
-        op: external_exports.enum(["exists", "not_exists", "equals", "not_equals", "contains"]),
+        op: external_exports.enum(["exists", "not_exists", "equals", "not_equals", "contains", "greater", "less", "matches", "type", "length"]),
         value: external_exports.string().max(2e3).default("")
       }).strict(),
       external_exports.object({
         type: external_exports.literal("header"),
         name: external_exports.string().min(1).max(200),
-        op: external_exports.enum(["exists", "equals", "contains"]),
+        op: external_exports.enum(["exists", "not_exists", "equals", "contains", "matches"]),
         value: external_exports.string().max(2e3).default("")
       }).strict(),
-      external_exports.object({ type: external_exports.literal("time"), maxMs: external_exports.number().positive().max(6e5) }).strict()
+      external_exports.object({ type: external_exports.literal("time"), maxMs: external_exports.number().positive().max(6e5) }).strict(),
+      // A JSON Schema (draft 7 subset) the whole body must match.
+      // Kept while still empty (being written); only a JSON object is sent.
+      external_exports.object({ type: external_exports.literal("schema"), schema: external_exports.string().max(2e5) }).strict()
     ]);
     CHECK_EVALUATOR_JS = String.raw`
 function __atcStatusOk(expect, status) {
@@ -16159,28 +16255,167 @@ function __atcAsText(value) {
   if (value === undefined) return "";
   return JSON.stringify(value);
 }
+function __atcTypeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function __atcIsType(value, type) {
+  if (type === "integer") return typeof value === "number" && isFinite(value) && Math.floor(value) === value;
+  if (type === "number") return typeof value === "number" && isFinite(value);
+  return __atcTypeOf(value) === type;
+}
+function __atcMatches(pattern, text) {
+  try { return new RegExp(pattern).test(text); } catch (e) { return false; }
+}
+function __atcLengthOk(rule, n) {
+  var m = String(rule).match(/^\s*(>=|<=|!=|>|<|=)?\s*(\d+)\s*$/);
+  if (!m) return false;
+  var want = Number(m[2]);
+  var op = m[1] || "=";
+  if (op === ">") return n > want;
+  if (op === "<") return n < want;
+  if (op === ">=") return n >= want;
+  if (op === "<=") return n <= want;
+  if (op === "!=") return n !== want;
+  return n === want;
+}
+function __atcPathText(path) { return path === "" ? "$" : "$" + path; }
+// JSON Schema, the parts APIs use: type (and nullable), enum, const, properties, required,
+// additionalProperties, items, min/max (Length, Items, imum), pattern, allOf/anyOf/oneOf,
+// local $ref. Returns the first problem as "$.items[0].id should be number", or null.
+function __atcSchemaError(schema, value, path, root, depth) {
+  if (schema === true || schema === undefined || schema === null) return null;
+  if (schema === false) return __atcPathText(path) + " should not be there";
+  if (depth > 60) return null;
+  if (typeof schema.$ref === "string") {
+    var ref = schema.$ref.replace(/^#\/?/, "").split("/");
+    var target = root;
+    for (var r = 0; r < ref.length && target; r++) if (ref[r]) target = target[ref[r].replace(/~1/g, "/").replace(/~0/g, "~")];
+    return target ? __atcSchemaError(target, value, path, root, depth + 1) : null;
+  }
+  var where = __atcPathText(path);
+  if (schema.type !== undefined) {
+    var types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (schema.nullable === true) types = types.concat(["null"]);
+    var okType = false;
+    for (var t = 0; t < types.length; t++) if (__atcIsType(value, types[t])) okType = true;
+    if (!okType) return where + " should be " + types.join(" or ") + " (it is " + __atcTypeOf(value) + ")";
+  }
+  if (schema.enum && Array.isArray(schema.enum)) {
+    var inEnum = false;
+    for (var e = 0; e < schema.enum.length; e++) if (JSON.stringify(schema.enum[e]) === JSON.stringify(value)) inEnum = true;
+    if (!inEnum) return where + " should be one of " + JSON.stringify(schema.enum);
+  }
+  if (schema.const !== undefined && JSON.stringify(schema.const) !== JSON.stringify(value)) return where + " should be " + JSON.stringify(schema.const);
+  if (typeof value === "string") {
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) return where + " should be at least " + schema.minLength + " characters";
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return where + " should be at most " + schema.maxLength + " characters";
+    if (typeof schema.pattern === "string" && !__atcMatches(schema.pattern, value)) return where + " should match /" + schema.pattern + "/";
+  }
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) return where + " should be at least " + schema.minimum;
+    if (typeof schema.maximum === "number" && value > schema.maximum) return where + " should be at most " + schema.maximum;
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) return where + " should be more than " + schema.exclusiveMinimum;
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) return where + " should be less than " + schema.exclusiveMaximum;
+  }
+  if (Array.isArray(value)) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) return where + " should have at least " + schema.minItems + " items";
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return where + " should have at most " + schema.maxItems + " items";
+    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+      for (var i = 0; i < value.length; i++) {
+        var itemErr = __atcSchemaError(schema.items, value[i], path + "[" + i + "]", root, depth + 1);
+        if (itemErr) return itemErr;
+      }
+    }
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    var req = Array.isArray(schema.required) ? schema.required : [];
+    for (var q = 0; q < req.length; q++) if (!Object.prototype.hasOwnProperty.call(value, req[q])) return where + " should have " + req[q];
+    var props = schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+    for (var key in value) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      var sub = path + (/^[A-Za-z_$][\w$]*$/.test(key) ? "." + key : "[" + JSON.stringify(key) + "]");
+      if (Object.prototype.hasOwnProperty.call(props, key)) {
+        var propErr = __atcSchemaError(props[key], value[key], sub, root, depth + 1);
+        if (propErr) return propErr;
+      } else if (schema.additionalProperties === false) {
+        return __atcPathText(sub) + " is not expected";
+      } else if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+        var addErr = __atcSchemaError(schema.additionalProperties, value[key], sub, root, depth + 1);
+        if (addErr) return addErr;
+      }
+    }
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (var a = 0; a < schema.allOf.length; a++) {
+      var allErr = __atcSchemaError(schema.allOf[a], value, path, root, depth + 1);
+      if (allErr) return allErr;
+    }
+  }
+  var some = schema.anyOf || schema.oneOf;
+  if (Array.isArray(some) && some.length) {
+    var first = null;
+    var matched = 0;
+    for (var s = 0; s < some.length; s++) {
+      var someErr = __atcSchemaError(some[s], value, path, root, depth + 1);
+      if (!someErr) matched++;
+      else if (!first) first = someErr;
+    }
+    if (!matched) return first;
+    if (schema.oneOf && matched > 1) return where + " matches more than one of oneOf";
+  }
+  return null;
+}
+function __atcParsedSchema(check) {
+  if (check.__parsed === undefined) {
+    try { check.__parsed = JSON.parse(check.schema); } catch (e) { check.__parsed = null; }
+  }
+  return check.__parsed;
+}
 function __atcCheck(check, res) {
   if (check.type === "status") return __atcStatusOk(check.expect, res.status);
   if (check.type === "time") return res.durationMs <= check.maxMs;
   if (check.type === "header") {
     var h = res.headers[String(check.name).toLowerCase()];
     if (check.op === "exists") return h !== undefined;
+    if (check.op === "not_exists") return h === undefined;
     if (h === undefined) return false;
+    if (check.op === "matches") return __atcMatches(check.value, h);
     return check.op === "equals" ? h === check.value : h.indexOf(check.value) >= 0;
   }
   if (res.body === null || res.body === undefined) return false;
   if (check.type === "body") {
+    if (check.op === "is_json") { try { JSON.parse(res.body); return true; } catch (e) { return false; } }
+    if (check.op === "matches") return __atcMatches(check.value, res.body);
     var has = res.body.indexOf(check.value) >= 0;
     return check.op === "contains" ? has : !has;
   }
+  var parsed;
+  try { parsed = JSON.parse(res.body); } catch (e) { return false; }
+  if (check.type === "schema") {
+    var schema = __atcParsedSchema(check);
+    return schema !== null && __atcSchemaError(schema, parsed, "", schema, 0) === null;
+  }
   if (check.type === "json") {
-    var parsed;
-    try { parsed = JSON.parse(res.body); } catch (e) { return false; }
     var got = __atcJsonGet(parsed, check.path);
     if (check.op === "exists") return got.found;
     if (check.op === "not_exists") return !got.found;
     if (!got.found) return check.op === "not_equals";
+    if (check.op === "type") return __atcIsType(got.value, String(check.value).trim().toLowerCase());
+    if (check.op === "length") {
+      var v = got.value;
+      var n = typeof v === "string" || Array.isArray(v) ? v.length : v !== null && typeof v === "object" ? Object.keys(v).length : -1;
+      return n >= 0 && __atcLengthOk(check.value, n);
+    }
+    if (check.op === "greater" || check.op === "less") {
+      var num = Number(got.value);
+      var lim = Number(check.value);
+      if (got.value === null || got.value === "" || typeof got.value === "boolean" || !isFinite(num) || String(check.value).trim() === "" || !isFinite(lim)) return false;
+      return check.op === "greater" ? num > lim : num < lim;
+    }
     var text = __atcAsText(got.value);
+    if (check.op === "matches") return __atcMatches(check.value, text);
     if (check.op === "equals") return text === check.value;
     if (check.op === "not_equals") return text !== check.value;
     return text.indexOf(check.value) >= 0;
@@ -16604,31 +16839,32 @@ var init_definition = __esm({
 });
 
 // ../shared/src/chain.ts
-function fillText(text, vars, mode = "raw") {
+function fillText(text, vars, mode = "raw", builtins = true) {
   fillFn ??= new Function(`${FILL_JS}
 return __atcFill;`)();
-  return fillFn(text, vars, mode);
+  return fillFn(text, vars, mode, builtins);
 }
-function fillDeep(value, vars) {
-  if (typeof value === "string") return fillText(value, vars, "raw");
-  if (Array.isArray(value)) return value.map((v) => fillDeep(v, vars));
+function fillDeep(value, vars, builtins) {
+  if (typeof value === "string") return fillText(value, vars, "raw", builtins);
+  if (Array.isArray(value)) return value.map((v) => fillDeep(v, vars, builtins));
   if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, fillDeep(v, vars)]));
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, fillDeep(v, vars, builtins)]));
   }
   return value;
 }
-function fillLab(lab, vars) {
-  if (!Object.keys(vars).length) return lab;
-  const raw = (s) => fillText(s, vars, "raw");
+function fillLab(lab, vars, { builtins = true } = {}) {
+  if (!Object.keys(vars).length && !builtins) return lab;
+  const raw = (s) => fillText(s, vars, "raw", builtins);
+  const deep = (v) => fillDeep(v, vars, builtins);
   const { request: request3, auth } = lab;
   const body = request3.body;
-  const filledBody = body.mode === "json" ? { ...body, json: fillDeep(body.json, vars) } : body.mode === "text" ? { ...body, text: raw(body.text) } : body.mode === "form" ? { ...body, fields: body.fields.map((f) => ({ key: raw(f.key), value: raw(f.value) })) } : body.mode === "raw" ? { ...body, raw: raw(body.raw) } : body;
+  const filledBody = body.mode === "json" ? { ...body, json: deep(body.json) } : body.mode === "text" ? { ...body, text: raw(body.text) } : body.mode === "form" ? { ...body, fields: body.fields.map((f) => ({ key: raw(f.key), value: raw(f.value) })) } : body.mode === "raw" ? { ...body, raw: raw(body.raw) } : body;
   const filledAuth = auth.mode === "bearer" ? { ...auth, token: raw(auth.token) } : auth.mode === "basic" ? { ...auth, username: raw(auth.username), password: raw(auth.password) } : auth.mode === "api_key" ? { ...auth, name: raw(auth.name), value: raw(auth.value) } : auth;
   return {
     ...lab,
     request: {
       ...request3,
-      url: fillText(request3.url, vars, "url"),
+      url: fillText(request3.url, vars, "url", builtins),
       query: request3.query.map((q) => ({ key: raw(q.key), value: raw(q.value) })),
       headers: request3.headers.map((h) => ({ key: h.key, value: raw(h.value) })),
       body: filledBody
@@ -16680,12 +16916,58 @@ var init_chain = __esm({
     init_checks3();
     init_definition();
     FILL_JS = String.raw`
-function __atcFill(text, vars, mode) {
+var __ATC_FIRST = ["Alex", "Maria", "Sam", "Priya", "Omar", "Lena", "Kofi", "Yuki", "Diego", "Emma", "Noah", "Aisha", "Ivan", "Sofia", "Liam", "Mei"];
+var __ATC_LAST = ["Smith", "Garcia", "Kim", "Patel", "Muller", "Silva", "Nguyen", "Okafor", "Rossi", "Cohen", "Tanaka", "Novak", "Brown", "Khan", "Lopez", "Berg"];
+function __atcRand(n) { return Math.floor(Math.random() * n); }
+function __atcRandText(len, chars) {
+  var out = "";
+  for (var i = 0; i < len; i++) out += chars.charAt(__atcRand(chars.length));
+  return out;
+}
+function __atcBuiltin(name, arg) {
+  var args = arg === undefined || String(arg).trim() === "" ? [] : String(arg).split(",");
+  for (var i = 0; i < args.length; i++) args[i] = Number(String(args[i]).trim());
+  switch (name.slice(1).toLowerCase()) {
+    case "uuid": case "guid": case "randomuuid":
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) { var r = __atcRand(16); return (c === "x" ? r : (r & 3) | 8).toString(16); });
+    case "timestamp": return String(Math.floor(Date.now() / 1000));
+    case "timestampms": return String(Date.now());
+    case "isotimestamp": return new Date().toISOString();
+    case "isodate": return new Date().toISOString().slice(0, 10);
+    case "randomint": {
+      var lo = args.length > 1 ? args[0] : 0;
+      var hi = args.length > 1 ? args[1] : args.length ? args[0] : 1000;
+      if (!isFinite(lo) || !isFinite(hi)) return undefined;
+      var min = Math.ceil(Math.min(lo, hi)), max = Math.floor(Math.max(lo, hi));
+      return String(min + __atcRand(max - min + 1));
+    }
+    case "randomstring": {
+      var len = args.length && isFinite(args[0]) ? Math.max(1, Math.min(1000, Math.floor(args[0]))) : 8;
+      return __atcRandText(len, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
+    }
+    case "randomemail": return "user." + __atcRandText(8, "abcdefghijklmnopqrstuvwxyz0123456789") + "@example.com";
+    case "randomfirstname": return __ATC_FIRST[__atcRand(__ATC_FIRST.length)];
+    case "randomlastname": return __ATC_LAST[__atcRand(__ATC_LAST.length)];
+    case "randomfullname": return __ATC_FIRST[__atcRand(__ATC_FIRST.length)] + " " + __ATC_LAST[__atcRand(__ATC_LAST.length)];
+    case "randomboolean": return Math.random() < 0.5 ? "true" : "false";
+  }
+  return undefined;
+}
+function __atcFill(text, vars, mode, builtins) {
   if (typeof text !== "string") return text;
-  return text.replace(/\{\{\s*([A-Za-z_][\w.-]*)\s*\}\}|%7B%7B([A-Za-z_][\w.-]*)%7D%7D/gi, function (whole, a, b) {
+  return text.replace(/\{\{\s*(\$?[A-Za-z_][\w.-]*)(?:\(([^(){}]*)\))?\s*\}\}|%7B%7B(\$?[A-Za-z_][\w.-]*)(?:\(([^(){}]*)\))?%7D%7D/gi, function (whole, a, aArg, b, bArg) {
     var name = a || b;
-    if (!Object.prototype.hasOwnProperty.call(vars, name)) return whole;
-    var v = String(vars[name]);
+    var arg = a ? aArg : bArg;
+    var v;
+    if (name.charAt(0) === "$") {
+      if (builtins === false) return whole;
+      if (b && arg !== undefined) { try { arg = decodeURIComponent(arg); } catch (e) {} }
+      v = __atcBuiltin(name, arg);
+      if (v === undefined) return whole;
+    } else {
+      if (arg !== undefined || !Object.prototype.hasOwnProperty.call(vars, name)) return whole;
+      v = String(vars[name]);
+    }
     if (mode === "url") return encodeURIComponent(v);
     if (mode === "json") return JSON.stringify(v).slice(1, -1);
     return v;
@@ -16697,6 +16979,32 @@ function __atcFill(text, vars, mode) {
   }
 });
 
+// ../shared/src/codegen.ts
+function parseSetCookie(header) {
+  const [pair, ...attrs] = header.split(";");
+  const eq = pair?.indexOf("=") ?? -1;
+  if (!pair || eq <= 0) return null;
+  const cookie = { name: pair.slice(0, eq).trim(), value: pair.slice(eq + 1).trim(), httpOnly: false, secure: false };
+  for (const attr of attrs) {
+    const i = attr.indexOf("=");
+    const key = (i < 0 ? attr : attr.slice(0, i)).trim().toLowerCase();
+    const value = i < 0 ? "" : attr.slice(i + 1).trim();
+    if (key === "domain") cookie.domain = value;
+    else if (key === "path") cookie.path = value;
+    else if (key === "expires") cookie.expires = value;
+    else if (key === "max-age" && /^-?\d+$/.test(value)) cookie.maxAge = Number(value);
+    else if (key === "httponly") cookie.httpOnly = true;
+    else if (key === "secure") cookie.secure = true;
+    else if (key === "samesite") cookie.sameSite = value;
+  }
+  return cookie;
+}
+var init_codegen = __esm({
+  "../shared/src/codegen.ts"() {
+    "use strict";
+  }
+});
+
 // ../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS({
   "../../node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/dist/nodes/identity.js"(exports) {
@@ -24120,7 +24428,9 @@ function defaultRequestDraft() {
     maxRedirects: 5,
     connectionReuse: true,
     useCookies: true,
-    tlsSkip: false,
+    // On for new requests, so test servers with their own certificates just work. Saved requests
+    // keep what they have; one saved without the setting checks certificates (as before).
+    tlsSkip: true,
     checks: [],
     before: null,
     testData: null,
@@ -24307,6 +24617,8 @@ function requestParts(draft) {
     } catch (err) {
       const bare = draftRuntimeNames(draft).find((n) => new RegExp(`(^|[^"])\\{\\{\\s*${n.replace(/[.-]/g, "\\$&")}\\s*\\}\\}(?!")`).test(draft.bodyText));
       if (bare) throw new Error(`Put quotes around {{${bare}}} in the JSON body \u2014 values from test data and run-first steps are filled in as text`);
+      const builtin = /(^|[^"])\{\{\s*(\$[A-Za-z]+)/.exec(draft.bodyText)?.[2];
+      if (builtin) throw new Error(`Put quotes around {{${builtin}}} in the JSON body \u2014 built-in values are filled in as text`);
       throw new Error(`Body is not valid JSON: ${err instanceof Error ? err.message : "parse error"}`);
     }
   } else if (hasBody(draft.method) && draft.bodyMode === "graphql") {
@@ -24348,12 +24660,21 @@ function requestParts(draft) {
     }
   };
 }
+function isJsonObject(text) {
+  try {
+    const v = JSON.parse(text);
+    return Boolean(v) && typeof v === "object" && !Array.isArray(v);
+  } catch {
+    return false;
+  }
+}
 function usableChecks(checks) {
   return checks.filter((c) => {
     if (c.type === "status") return c.expect.trim().length > 0;
-    if (c.type === "body") return c.value.length > 0;
+    if (c.type === "body") return c.op === "is_json" || c.value.length > 0;
     if (c.type === "json") return c.path.trim().length > 0;
     if (c.type === "header") return c.name.trim().length > 0;
+    if (c.type === "schema") return isJsonObject(c.schema);
     return c.maxMs > 0;
   });
 }
@@ -24630,10 +24951,10 @@ function sustainedFrom(buckets) {
 function percentileFromHist(hist, p) {
   const total = hist.reduce((a, n) => a + n, 0);
   if (!total) return null;
-  let seen = 0;
+  let seen2 = 0;
   for (let i = 0; i < hist.length; i++) {
-    seen += hist[i];
-    if (seen / total >= p) {
+    seen2 += hist[i];
+    if (seen2 / total >= p) {
       const edge = LATENCY_BIN_EDGES_MS[i];
       return Number.isFinite(edge) ? edge : LATENCY_BIN_EDGES_MS[LATENCY_BIN_EDGES_MS.length - 2];
     }
@@ -25163,7 +25484,7 @@ function stepOutcome(r) {
     if (!failed.length) return { state: "passed" };
     return {
       state: "failed",
-      message: `${failed.length} of ${r.checks.length} check${r.checks.length === 1 ? "" : "s"} failed: ${failed.map((c) => c.name).join("; ")}`
+      message: `${failed.length} of ${r.checks.length} check${r.checks.length === 1 ? "" : "s"} failed: ${failed.map((c) => c.detail ? `${c.name} (${c.detail})` : c.name).join("; ")}`
     };
   }
   if (r.status >= 200 && r.status < 400) return { state: "passed" };
@@ -25186,16 +25507,16 @@ function suitePassed(run2) {
 }
 function orderSuite(items, plan) {
   const byId = new Map(items.map((i) => [i.id, i]));
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   const out = [];
   for (const id of plan?.order ?? []) {
     const item = byId.get(id);
-    if (item && !seen.has(id)) {
+    if (item && !seen2.has(id)) {
       out.push(item);
-      seen.add(id);
+      seen2.add(id);
     }
   }
-  for (const item of items) if (!seen.has(item.id)) out.push(item);
+  for (const item of items) if (!seen2.has(item.id)) out.push(item);
   const skip = new Set(plan?.skip ?? []);
   return out.map((item) => ({ item, skipped: skip.has(item.id) }));
 }
@@ -26660,6 +26981,7 @@ var init_src = __esm({
     init_dashboard();
     init_workspace();
     init_chain();
+    init_codegen();
     init_import();
     init_email_report();
     init_junit();
@@ -26772,7 +27094,7 @@ token, password, or key.
       async scan() {
         await this.ensure();
         let changed = false;
-        const seen = /* @__PURE__ */ new Set();
+        const seen2 = /* @__PURE__ */ new Set();
         for (const folder of ["runs", "compares"]) {
           let names = [];
           try {
@@ -26782,7 +27104,7 @@ token, password, or key.
           }
           for (const name of names) {
             const key = `${folder}/${name}`;
-            seen.add(key);
+            seen2.add(key);
             let info;
             try {
               info = await stat(join(this.folder(folder), name));
@@ -26796,7 +27118,7 @@ token, password, or key.
           }
         }
         for (const key of [...this.entries.keys()]) {
-          if (!seen.has(key)) {
+          if (!seen2.has(key)) {
             this.entries.delete(key);
             changed = true;
           }
@@ -27183,6 +27505,11 @@ function generateK6Script(run2, extra2 = {}) {
     ATC_NAME: run2.name,
     ATC_CHECKS: JSON.stringify(run2.request.checks.map((check2) => ({ label: checkLabel(check2), check: check2 })))
   };
+  if (run2.request.checks.some((c) => c.type === "schema")) {
+    files["checks.json"] = env.ATC_CHECKS;
+    env.ATC_CHECKS = "";
+    env.ATC_CHECKS_FILE = "1";
+  }
   if (extra2.tlsAuth?.length) env.ATC_TLS_AUTH = JSON.stringify(extra2.tlsAuth);
   if (extra2.jwt) {
     const { tokens, ...rest } = extra2.jwt;
@@ -27213,15 +27540,14 @@ function generateK6Script(run2, extra2 = {}) {
     env.ATC_AUTH_USER = run2.auth.mode === "ntlm" && run2.auth.domain ? `${run2.auth.domain}\\${run2.auth.username}` : run2.auth.username;
     env.ATC_AUTH_PASS = run2.auth.password;
   }
+  const bodyMode = run2.request.body.mode;
+  env.ATC_BODY_FILL = bodyMode === "json" ? "json" : bodyMode === "form" ? "url" : "raw";
   if (data) {
     files["data.json"] = JSON.stringify(data.rows);
     env.ATC_DATA_COLUMNS = JSON.stringify(data.columns);
     env.ATC_DATA_ORDER = data.order;
-    const mode = run2.request.body.mode;
-    env.ATC_BODY_FILL = mode === "json" ? "json" : mode === "form" ? "url" : "raw";
   }
   const dataBlock = data ? `
-${FILL_JS}
 const ROWS = new SharedArray("rows", function () { return JSON.parse(open("./data.json")); });
 const COLUMNS = JSON.parse(__ENV.ATC_DATA_COLUMNS);
 function __atcRow() {
@@ -27245,12 +27571,12 @@ import { SharedArray } from "k6/data";
 export const options = Object.assign(${optionsBlock(run2)}, __ENV.ATC_TLS_AUTH ? { tlsAuth: JSON.parse(__ENV.ATC_TLS_AUTH) } : {});
 
 ${CHECK_EVALUATOR_JS}
-${dataBlock}${run2.auth.mode === "aws_sigv4" ? `
+${FILL_JS}${dataBlock}${run2.auth.mode === "aws_sigv4" ? `
 const AWS = JSON.parse(__ENV.ATC_AWS);
 ${SIGV4_JS}` : ""}${run2.auth.mode === "oauth1" ? `
 const OAUTH1 = JSON.parse(__ENV.ATC_OAUTH1);
 ${OAUTH1_JS}` : ""}
-const CHECKS = JSON.parse(__ENV.ATC_CHECKS || "[]");
+const CHECKS = __ENV.ATC_CHECKS_FILE ? JSON.parse(open("./checks.json")) : JSON.parse(__ENV.ATC_CHECKS || "[]");
 // JWT: tokens signed by the app for the whole run; each is used for its stretch of time.
 const JWT = __ENV.ATC_JWT ? JSON.parse(__ENV.ATC_JWT) : null;
 const JWTS = JWT ? JSON.parse(open("./jwt.json")) : [];
@@ -27278,7 +27604,9 @@ function __atcFreshToken() {
 }
 
 export default function () {
-  ${data ? 'const vars = __atcRow();\n  const f = function (text, mode) { return __atcFill(text, vars, mode || "raw"); };' : "const f = function (text) { return text; };"}
+  // Test-data values, and built-in values ({{$uuid}}, \u2026) made anew for every request.
+  const vars = ${data ? "__atcRow()" : "{}"};
+  const f = function (text, mode) { return __atcFill(text, vars, mode || "raw"); };
   const headers = JSON.parse(__ENV.ATC_HEADERS || "{}");
   for (const key in headers) headers[key] = f(headers[key]);
   if (__ENV.ATC_COOKIE) headers.Cookie = __ENV.ATC_COOKIE;
@@ -45374,13 +45702,13 @@ function toPem(m) {
 }
 async function k6TlsAuth(urls) {
   const out = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seen2 = /* @__PURE__ */ new Set();
   for (const target of urls) {
     const m = await certificateFor(target);
     if (!m) continue;
     const domain2 = new URL(target).hostname;
-    if (seen.has(domain2)) continue;
-    seen.add(domain2);
+    if (seen2.has(domain2)) continue;
+    seen2.add(domain2);
     const pem = toPem(m);
     out.push({ domains: [domain2], cert: pem.cert, key: pem.key, ...pem.password ? { password: pem.password } : {} });
   }
@@ -45485,7 +45813,7 @@ function defaultPath(url2) {
   if (!p.startsWith("/") || p.lastIndexOf("/") === 0) return "/";
   return p.slice(0, p.lastIndexOf("/"));
 }
-function parseSetCookie(header, url2, now = Date.now()) {
+function parseSetCookie2(header, url2, now = Date.now()) {
   const [pair, ...attrs] = header.split(";");
   const eq = pair.indexOf("=");
   if (eq <= 0) return null;
@@ -45536,7 +45864,7 @@ async function storeCookies(target, setCookie) {
   const now = Date.now();
   let next = [...await load()];
   for (const header of Array.isArray(setCookie) ? setCookie : [setCookie]) {
-    const c = parseSetCookie(header, url2, now);
+    const c = parseSetCookie2(header, url2, now);
     if (!c) continue;
     next = next.filter((o) => !(o.name === c.name && o.domain === c.domain && o.path === c.path));
     if (c.expires === null || c.expires > now) next.push(c);
@@ -69245,7 +69573,7 @@ var require_parse = __commonJS({
     var { maxNameValuePairSize, maxAttributeValueSize } = require_constants4();
     var { isCTLExcludingHtab } = require_util5();
     var assert2 = __require("node:assert");
-    function parseSetCookie2(header) {
+    function parseSetCookie3(header) {
       if (isCTLExcludingHtab(header)) {
         return null;
       }
@@ -69369,7 +69697,7 @@ var require_parse = __commonJS({
       return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList);
     }
     module.exports = {
-      parseSetCookie: parseSetCookie2,
+      parseSetCookie: parseSetCookie3,
       parseUnparsedAttributes
     };
   }
@@ -69379,7 +69707,7 @@ var require_parse = __commonJS({
 var require_cookies = __commonJS({
   "../../node_modules/.pnpm/undici@8.10.0/node_modules/undici/lib/web/cookies/index.js"(exports, module) {
     "use strict";
-    var { parseSetCookie: parseSetCookie2 } = require_parse();
+    var { parseSetCookie: parseSetCookie3 } = require_parse();
     var { stringify } = require_util5();
     var { webidl } = require_webidl();
     var { Headers } = require_headers();
@@ -69418,11 +69746,11 @@ var require_cookies = __commonJS({
       if (!cookies) {
         return [];
       }
-      return cookies.map((pair) => parseSetCookie2(pair));
+      return cookies.map((pair) => parseSetCookie3(pair));
     }
     function parseCookie(cookie) {
       cookie = webidl.converters.DOMString(cookie);
-      return parseSetCookie2(cookie);
+      return parseSetCookie3(cookie);
     }
     function setCookie(headers, cookie) {
       webidl.argumentLengthCheck(arguments, 2, "setCookie");
@@ -73150,7 +73478,7 @@ function parseLab(input) {
   return labRequestSchema.parse(input);
 }
 async function runSetupStep(setup) {
-  const sent = await sendOnce(setup);
+  const sent = await sendOnce(fillLab(setup, {}));
   const vars = {};
   const values = [];
   let problem = sent.result.error ? `could not reach it: ${sent.result.error}` : void 0;
@@ -73219,6 +73547,12 @@ function takeValues(rules, sent) {
   });
 }
 async function sendOnce(lab) {
+  const out = await sendOnceAuthed(lab);
+  const note = AUTH_NOTES[lab.auth.mode];
+  if (note && out.result.sent) out.result.sent.authNote = note;
+  return out;
+}
+async function sendOnceAuthed(lab) {
   if (lab.auth.mode === "digest" || lab.auth.mode === "ntlm") return sendChallenged(lab, lab.auth);
   if (lab.auth.mode === "jwt") {
     const { mode: _mode, ...config3 } = lab.auth;
@@ -73296,6 +73630,7 @@ async function sendRaw(lab, extra2 = {}) {
     headers[pair.key] = pair.value;
   }
   const secretNames = applyAuth(headers, url2, lab.auth);
+  const secretQuery = lab.auth.mode === "api_key" && lab.auth.in === "query" ? [lab.auth.name] : [];
   if (extra2.authorization) {
     headers.authorization = extra2.authorization;
     secretNames.push("authorization");
@@ -73312,7 +73647,10 @@ async function sendRaw(lab, extra2 = {}) {
     if (signed.authorization) {
       headers.authorization = signed.authorization;
       secretNames.push("authorization");
-    } else target = new URL(signed.url);
+    } else {
+      target = new URL(signed.url);
+      secretQuery.push("oauth_signature", "oauth_token");
+    }
   }
   if (lab.auth.mode === "aws_sigv4") {
     const { mode: _mode, ...creds } = lab.auth;
@@ -73326,6 +73664,8 @@ async function sendRaw(lab, extra2 = {}) {
   const agent = extra2.dispatcher ?? new import_undici2.Agent({ connect: await tlsConnect(url2, options.tlsSkipVerify) });
   const dispatcher = extra2.dispatcher ?? (useJar ? agent : agent.compose(import_undici2.interceptors.redirect({ maxRedirections: options.maxRedirects })));
   const started = performance.now();
+  let sent;
+  const cookies = [];
   try {
     let current = target;
     let method = lab.request.method;
@@ -73337,9 +73677,16 @@ async function sendRaw(lab, extra2 = {}) {
         const jar2 = await cookieHeader(current);
         if (jar2) sendHeaders.cookie = jar2;
       }
+      if (!sent) sent = describeSent(method, current, sendHeaders, body, [...secretNames, ...ALWAYS_SECRET], secretQuery, options.tlsSkipVerify);
+      else (sent.redirects ??= []).push(`${method} ${current.toString()}`);
       response = await (0, import_undici2.request)(current, { method, headers: sendHeaders, body, headersTimeout: timeout, bodyTimeout: timeout, dispatcher });
+      const setCookie = response.headers["set-cookie"];
+      for (const line of typeof setCookie === "string" ? [setCookie] : setCookie ?? []) {
+        const parsed = parseSetCookie(line);
+        if (parsed) cookies.push(parsed);
+      }
       if (!useJar) break;
-      await storeCookies(current, response.headers["set-cookie"]);
+      await storeCookies(current, setCookie);
       const location = response.headers.location;
       if (![301, 302, 303, 307, 308].includes(response.statusCode) || typeof location !== "string" || hops >= options.maxRedirects) break;
       await response.body.dump();
@@ -73354,8 +73701,11 @@ async function sendRaw(lab, extra2 = {}) {
       }
       current = next;
     }
-    const raw = await response.body.text();
+    const bytes2 = Buffer.from(await response.body.arrayBuffer());
+    const raw = bytes2.toString("utf8");
     const durationMs = Math.round((performance.now() - started) * 10) / 10;
+    const responseType = String(response.headers["content-type"] ?? "").toLowerCase();
+    const bodyBase64 = /^image\/(png|jpe?g|gif|webp|bmp|svg\+xml|x-icon|vnd\.microsoft\.icon|avif)/.test(responseType) && bytes2.length <= IMAGE_LIMIT ? bytes2.toString("base64") : void 0;
     const truncated = raw.length > BODY_LIMIT;
     const headerBag = {};
     for (const [key, value] of Object.entries(response.headers)) {
@@ -73376,7 +73726,10 @@ async function sendRaw(lab, extra2 = {}) {
         truncated,
         durationMs,
         url: url2.toString(),
-        checks
+        checks,
+        sent,
+        ...cookies.length ? { cookies } : {},
+        ...bodyBase64 ? { bodyBase64 } : {}
       }
     };
   } catch (err) {
@@ -73393,14 +73746,29 @@ async function sendRaw(lab, extra2 = {}) {
         truncated: false,
         durationMs,
         url: url2.toString(),
-        error: err instanceof Error ? err.message : String(err)
+        error: err instanceof Error ? err.message : String(err),
+        sent
       }
     };
   } finally {
     if (!extra2.dispatcher) await dispatcher.close();
   }
 }
-var import_undici2, BODY_LIMIT;
+function describeSent(method, url2, headers, body, secretHeaders, secretQuery, insecure) {
+  const list = [["host", url2.host], ...Object.entries(headers)];
+  if (body !== void 0) list.push(["content-length", String(Buffer.byteLength(body))]);
+  return {
+    method,
+    url: url2.toString(),
+    headers: list,
+    ...body !== void 0 ? { body: body.length > BODY_LIMIT ? body.slice(0, BODY_LIMIT) : body, bodyTruncated: body.length > BODY_LIMIT || void 0 } : {},
+    secretHeaders: [...new Set(secretHeaders.map((h) => h.toLowerCase()))],
+    secretQuery,
+    // Only https has a certificate to skip.
+    insecure: insecure && url2.protocol === "https:" || void 0
+  };
+}
+var import_undici2, BODY_LIMIT, IMAGE_LIMIT, ALWAYS_SECRET, AUTH_NOTES;
 var init_probe = __esm({
   "../../apps/engine/src/probe.ts"() {
     "use strict";
@@ -73414,6 +73782,16 @@ var init_probe = __esm({
     init_cookies();
     init_oauth();
     BODY_LIMIT = 64 * 1024;
+    IMAGE_LIMIT = 5 * 1024 * 1024;
+    ALWAYS_SECRET = ["authorization", "proxy-authorization", "cookie", "x-api-key", "api-key", "x-amz-security-token"];
+    AUTH_NOTES = {
+      oauth2: "OAuth 2.0 \u2014 the app got the token and sent it as a Bearer token",
+      oauth1: "OAuth 1.0 \u2014 signed for this one request (nonce and timestamp)",
+      aws_sigv4: "AWS Signature \u2014 signed for this one request",
+      jwt: "JWT \u2014 signed by the app for this request",
+      digest: "Digest \u2014 answers the server's 401 challenge; this is the second request",
+      ntlm: "NTLM \u2014 signs in over one connection; this is the last of three requests"
+    };
   }
 });
 
@@ -73454,10 +73832,10 @@ var init_latency_histogram = __esm({
       percentile(p) {
         if (this.count === 0) return 0;
         const rank = Math.ceil(p / 100 * this.count);
-        let seen = 0;
+        let seen2 = 0;
         for (const bin of [...this.bins.keys()].sort((a, b) => a - b)) {
-          seen += this.bins.get(bin);
-          if (seen >= rank) {
+          seen2 += this.bins.get(bin);
+          if (seen2 >= rank) {
             const mid = FLOOR_MS * Math.exp((bin + 0.5) * GROWTH);
             return Math.min(this.max, Math.max(this.min, mid));
           }
@@ -73968,7 +74346,7 @@ async function startRun(lab, repoRoot2) {
       err.statusCode = 422;
       throw err;
     }
-    filled = fillLab(lab, step.vars);
+    filled = fillLab(lab, step.vars, { builtins: false });
   }
   const id = crypto.randomUUID();
   const dir2 = await mkdtemp(join5(tmpdir2(), "atc-run-"));
@@ -74318,7 +74696,7 @@ function explainMissing(message, index, savers, steps) {
   });
   return hints.length ? hints.join("; ") : message;
 }
-async function runStep(step, workspace, vars, envName, setups, explain = (m) => m) {
+async function runStep(step, workspace, vars, envName, setups, explain2 = (m) => m) {
   const saved = await workspace.getRequest(step.id);
   if (!saved) throw new StepProblem("This request is no longer saved");
   if (saved.secretsMissing?.length) {
@@ -74328,7 +74706,7 @@ async function runStep(step, workspace, vars, envName, setups, explain = (m) =>
   try {
     draft = await resolveSaved(workspace, saved, vars, envName);
   } catch (err) {
-    throw new StepProblem(explain(err instanceof Error ? err.message.replace(/ — pick one next to the URL$/, " \u2014 pick an environment for this run") : String(err)));
+    throw new StepProblem(explain2(err instanceof Error ? err.message.replace(/ — pick one next to the URL$/, " \u2014 pick an environment for this run") : String(err)));
   }
   const payload = buildPayload(draft, toLoadConfig(DEFAULT_LOAD), saved.name);
   let runtime = {};
@@ -74354,23 +74732,23 @@ async function runStep(step, workspace, vars, envName, setups, explain = (m) =>
     runtime = done.vars;
   }
   if (payload.data) runtime = { ...runtime, ...firstRowVars(payload.data) };
-  const probe = await runProbe({ ...fillLab({ request: payload.request, auth: payload.auth, options: payload.options }, runtime), save: payload.save });
-  const outcome = stepOutcome(probe);
+  const probe2 = await runProbe({ ...fillLab({ request: payload.request, auth: payload.auth, options: payload.options }, runtime), save: payload.save });
+  const outcome = stepOutcome(probe2);
   step.state = outcome.state;
   step.message = outcome.message;
-  if (probe.saved?.length) {
-    step.saved = probe.saved.map((v) => ({ name: v.name, found: v.found, preview: v.preview }));
-    for (const v of probe.saved) if (v.found && v.value !== void 0) vars[v.name] = v.value;
-    const missing = probe.saved.filter((v) => !v.found);
+  if (probe2.saved?.length) {
+    step.saved = probe2.saved.map((v) => ({ name: v.name, found: v.found, preview: v.preview }));
+    for (const v of probe2.saved) if (v.found && v.value !== void 0) vars[v.name] = v.value;
+    const missing = probe2.saved.filter((v) => !v.found);
     if (missing.length && step.state === "passed") {
       step.state = "failed";
       step.message = missing.map((v) => `{{${v.name}}} was not found in the answer (looked for ${v.from})`).join("; ");
     }
   }
-  step.status = probe.status || void 0;
-  step.durationMs = probe.durationMs;
-  step.checks = probe.checks;
-  if (outcome.state !== "passed" && probe.body) step.bodyPreview = probe.body.slice(0, BODY_PREVIEW_CHARS);
+  step.status = probe2.status || void 0;
+  step.durationMs = probe2.durationMs;
+  step.checks = probe2.checks;
+  if (outcome.state !== "passed" && probe2.body) step.bodyPreview = probe2.body.slice(0, BODY_PREVIEW_CHARS);
 }
 function registerSuiteRoutes(api, workspace, plans, builtins) {
   api.get("/suites/plan", async (request3) => {
@@ -81457,32 +81835,32 @@ var require_err_helpers = __commonJS({
         return isErrorLike(cause) ? cause : void 0;
       }
     };
-    var _stackWithCauses = (err, seen) => {
+    var _stackWithCauses = (err, seen2) => {
       if (!isErrorLike(err)) return "";
       const stack = err.stack || "";
-      if (seen.has(err)) {
+      if (seen2.has(err)) {
         return stack + "\ncauses have become circular...";
       }
       const cause = getErrorCause(err);
       if (cause) {
-        seen.add(err);
-        return stack + "\ncaused by: " + _stackWithCauses(cause, seen);
+        seen2.add(err);
+        return stack + "\ncaused by: " + _stackWithCauses(cause, seen2);
       } else {
         return stack;
       }
     };
     var stackWithCauses = (err) => _stackWithCauses(err, /* @__PURE__ */ new Set());
-    var _messageWithCauses = (err, seen, skip) => {
+    var _messageWithCauses = (err, seen2, skip) => {
       if (!isErrorLike(err)) return "";
       const message = skip ? "" : err.message || "";
-      if (seen.has(err)) {
+      if (seen2.has(err)) {
         return message + ": ...";
       }
       const cause = getErrorCause(err);
       if (cause) {
-        seen.add(err);
+        seen2.add(err);
         const skipIfVErrorStyleCause = typeof err.cause === "function";
-        return message + (skipIfVErrorStyleCause ? "" : ": ") + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
+        return message + (skipIfVErrorStyleCause ? "" : ": ") + _messageWithCauses(cause, seen2, skipIfVErrorStyleCause);
       } else {
         return message;
       }
@@ -81501,7 +81879,7 @@ var require_err_helpers = __commonJS({
 var require_err_proto = __commonJS({
   "../../node_modules/.pnpm/pino-std-serializers@7.1.0/node_modules/pino-std-serializers/lib/err-proto.js"(exports, module) {
     "use strict";
-    var seen = /* @__PURE__ */ Symbol("circular-ref-tag");
+    var seen2 = /* @__PURE__ */ Symbol("circular-ref-tag");
     var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-err-ref");
     var pinoErrProto = Object.create({}, {
       type: {
@@ -81541,7 +81919,7 @@ var require_err_proto = __commonJS({
     module.exports = {
       pinoErrProto,
       pinoErrorSymbols: {
-        seen,
+        seen: seen2,
         rawSymbol
       }
     };
@@ -81555,13 +81933,13 @@ var require_err = __commonJS({
     module.exports = errSerializer;
     var { messageWithCauses, stackWithCauses, isErrorLike } = require_err_helpers();
     var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
-    var { seen } = pinoErrorSymbols;
+    var { seen: seen2 } = pinoErrorSymbols;
     var { toString } = Object.prototype;
     function errSerializer(err) {
       if (!isErrorLike(err)) {
         return err;
       }
-      err[seen] = void 0;
+      err[seen2] = void 0;
       const _err = Object.create(pinoErrProto);
       _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
       _err.message = messageWithCauses(err);
@@ -81573,7 +81951,7 @@ var require_err = __commonJS({
         if (_err[key] === void 0) {
           const val = err[key];
           if (isErrorLike(val)) {
-            if (key !== "cause" && !Object.prototype.hasOwnProperty.call(val, seen)) {
+            if (key !== "cause" && !Object.prototype.hasOwnProperty.call(val, seen2)) {
               _err[key] = errSerializer(val);
             }
           } else {
@@ -81581,7 +81959,7 @@ var require_err = __commonJS({
           }
         }
       }
-      delete err[seen];
+      delete err[seen2];
       _err.raw = err;
       return _err;
     }
@@ -81595,13 +81973,13 @@ var require_err_with_cause = __commonJS({
     module.exports = errWithCauseSerializer;
     var { isErrorLike } = require_err_helpers();
     var { pinoErrProto, pinoErrorSymbols } = require_err_proto();
-    var { seen } = pinoErrorSymbols;
+    var { seen: seen2 } = pinoErrorSymbols;
     var { toString } = Object.prototype;
     function errWithCauseSerializer(err) {
       if (!isErrorLike(err)) {
         return err;
       }
-      err[seen] = void 0;
+      err[seen2] = void 0;
       const _err = Object.create(pinoErrProto);
       _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name;
       _err.message = err.message;
@@ -81609,14 +81987,14 @@ var require_err_with_cause = __commonJS({
       if (Array.isArray(err.errors)) {
         _err.aggregateErrors = err.errors.map((err2) => errWithCauseSerializer(err2));
       }
-      if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
+      if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen2)) {
         _err.cause = errWithCauseSerializer(err.cause);
       }
       for (const key in err) {
         if (_err[key] === void 0) {
           const val = err[key];
           if (isErrorLike(val)) {
-            if (!Object.prototype.hasOwnProperty.call(val, seen)) {
+            if (!Object.prototype.hasOwnProperty.call(val, seen2)) {
               _err[key] = errWithCauseSerializer(val);
             }
           } else {
@@ -81624,7 +82002,7 @@ var require_err_with_cause = __commonJS({
           }
         }
       }
-      delete err[seen];
+      delete err[seen2];
       _err.raw = err;
       return _err;
     }
@@ -108779,7 +109157,7 @@ var require_dist5 = __commonJS({
     exports.stringifyCookie = stringifyCookie;
     exports.stringifySetCookie = stringifySetCookie;
     exports.serialize = stringifySetCookie;
-    exports.parseSetCookie = parseSetCookie2;
+    exports.parseSetCookie = parseSetCookie3;
     exports.stringifySetCookie = stringifySetCookie;
     exports.serialize = stringifySetCookie;
     var cookieNameRegExp = /^[\u0021-\u003A\u003C\u003E-\u007E]+$/;
@@ -108916,7 +109294,7 @@ var require_dist5 = __commonJS({
       }
       return str2;
     }
-    function parseSetCookie2(str2, options) {
+    function parseSetCookie3(str2, options) {
       const dec = options?.decode || decode4;
       const len = str2.length;
       const endIdx = endIndex(str2, 0, len);
@@ -112029,7 +112407,7 @@ import http from "node:http";
 import https from "node:https";
 function run(cmd, args) {
   return new Promise((resolve5) => {
-    execFile2(cmd, args, { timeout: 4e3, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => resolve5(err && !stdout ? "" : String(stdout)));
+    execFile2(cmd, args, { timeout: 2e4, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => resolve5(err && !stdout ? "" : String(stdout)));
   });
 }
 function local(address) {
@@ -112098,11 +112476,10 @@ function parseSs(text) {
 async function listPorts() {
   if (process.platform === "win32") {
     const tasks = run("tasklist", ["/FO", "CSV", "/NH"]);
-    const [v4, v6] = await Promise.all([run("netstat", ["-ano", "-p", "TCP"]), run("netstat", ["-ano", "-p", "TCPv6"])]);
-    const found2 = parseNetstat(v4);
-    for (const [port2, l] of parseNetstat(v6)) if (!found2.has(port2)) found2.set(port2, l);
+    const found2 = parseNetstat(await run("netstat", ["-ano"]));
     const named = tasks.then((text) => {
       const names = parseTasklist(text);
+      if (!names.size) return;
       for (const l of found2.values()) {
         const t = names.get(l.pid);
         l.name = t?.name;
@@ -112126,20 +112503,34 @@ function ask(scheme, host2, port2, verify, timeoutMs) {
         resolve5("yes");
       }
     );
-    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("timeout", () => {
+      resolve5("slow");
+      req.destroy(new Error("timeout"));
+    });
     req.on("error", (err) => resolve5(scheme === "https" && verify && /CERT|SELF_SIGNED|UNABLE_TO|SIGNATURE|HOSTNAME|ALTNAME/i.test(err.code ?? err.message) ? "cert" : "no"));
     req.end();
   });
 }
 async function identify(l, timeoutMs) {
+  const before = seen.get(l.port);
+  const server = await probe(l, timeoutMs);
+  if (server && server !== "slow") {
+    seen.set(l.port, { pid: l.pid, server });
+    return server;
+  }
+  if (server === "slow" && before && before.pid === l.pid) return before.server;
+  seen.delete(l.port);
+  return null;
+}
+async function probe(l, timeoutMs) {
   const host2 = l.ipv4 ? "127.0.0.1" : "::1";
   const [plain, tls] = await Promise.all([ask("http", host2, l.port, true, timeoutMs), ask("https", host2, l.port, true, timeoutMs)]);
   if (plain === "yes") return { port: l.port, scheme: "http", name: l.name };
   if (tls === "yes") return { port: l.port, scheme: "https", name: l.name };
   if (tls === "cert" && await ask("https", host2, l.port, false, timeoutMs) === "yes") return { port: l.port, scheme: "https", name: l.name, selfSigned: true };
-  return null;
+  return plain === "slow" || tls === "slow" ? "slow" : null;
 }
-async function findLocalServers(skip = [], timeoutMs = 600) {
+async function findLocalServers(skip = [], timeoutMs = 1500) {
   const { ports, named } = await listPorts();
   const [answers] = await Promise.all([
     Promise.all(ports.filter((l) => !skip.includes(l.port) && !NOT_HTTP.has(l.port)).map(async (l) => ({ l, server: await identify(l, timeoutMs) }))),
@@ -112147,12 +112538,13 @@ async function findLocalServers(skip = [], timeoutMs = 600) {
   ]);
   return answers.filter(({ l, server }) => server && !l.service && !SYSTEM.has((l.name ?? "").toLowerCase())).map(({ l, server }) => ({ ...server, name: l.name })).sort((a, b) => a.port - b.port);
 }
-var SYSTEM, NOT_HTTP;
+var SYSTEM, NOT_HTTP, seen;
 var init_local_servers = __esm({
   "../../apps/engine/src/local-servers.ts"() {
     "use strict";
     SYSTEM = /* @__PURE__ */ new Set(["system", "svchost", "lsass", "wininit", "services", "spoolsv", "launchd", "systemd", "systemd-resolved", "cupsd", "sshd", "rpcbind"]);
     NOT_HTTP = /* @__PURE__ */ new Set([22, 25, 53, 135, 139, 445, 1433, 1521, 3306, 3389, 5432, 5672, 6379, 9042, 11211, 27017]);
+    seen = /* @__PURE__ */ new Map();
   }
 });
 
@@ -112255,9 +112647,11 @@ async function routes(api) {
     }
     const key = skip.join(",");
     if (!localCache || localCache.key !== key || Date.now() - localCache.at > 2e3) {
-      localCache = { at: Date.now(), key, servers: await findLocalServers(skip) };
+      const entry = { at: Number.POSITIVE_INFINITY, key, servers: findLocalServers(skip) };
+      void entry.servers.finally(() => entry.at = Date.now());
+      localCache = entry;
     }
-    return { servers: localCache.servers };
+    return { servers: await localCache.servers };
   });
   registerSuiteRoutes(api, workspace, suitePlans, (port2) => ({ practiceApi: `http://127.0.0.1:${port2}${api.prefix}/demo-api` }));
   onRunFinished(async (report, error51) => {
@@ -112448,7 +112842,7 @@ init_cookies();
 init_workspace_store();
 var repoRoot = resolve4(dirname3(fileURLToPath2(import.meta.url)), "../../..");
 var EXIT = { passed: 0, failed: 1, error: 2 };
-var VERSION = "0.9.0";
+var VERSION = "0.10.0";
 var HELP = `APITestCenter CLI ${VERSION} \u2014 https://apitestcenter.com/docs/cli-and-ci.html
 
 Usage (apitestcenter, or the short name atc once installed)
@@ -112675,10 +113069,10 @@ Environments (${index.environments.length})`);
   }
   if (payload.data) log(`data   ${payload.data.fileName} \xB7 ${payload.data.rows.length} rows \xB7 ${payload.data.order}`);
   if (!values["no-check"]) {
-    const probe = await runProbe({ request: payload.request, auth: payload.auth, options: payload.options, setup: payload.setup, data: payload.data });
-    const failedChecks = probe.checks?.filter((c) => !c.ok) ?? [];
-    log(`check  ${probe.status || "ERR"} in ${probe.durationMs} ms${probe.checks ? ` \xB7 checks ${probe.checks.length - failedChecks.length}/${probe.checks.length}` : ""}`);
-    if (!probe.ok || probe.status < 200 || probe.status >= 300) fail(`check request returned ${probe.status || probe.error}; load did not start (use --no-check to force)`);
+    const probe2 = await runProbe({ request: payload.request, auth: payload.auth, options: payload.options, setup: payload.setup, data: payload.data });
+    const failedChecks = probe2.checks?.filter((c) => !c.ok) ?? [];
+    log(`check  ${probe2.status || "ERR"} in ${probe2.durationMs} ms${probe2.checks ? ` \xB7 checks ${probe2.checks.length - failedChecks.length}/${probe2.checks.length}` : ""}`);
+    if (!probe2.ok || probe2.status < 200 || probe2.status >= 300) fail(`check request returned ${probe2.status || probe2.error}; load did not start (use --no-check to force)`);
   }
   const history2 = values.save ? new HistoryStore(dataDir) : null;
   if (history2) onRunFinished(async (report2, error51) => void await history2.saveRun(report2, { source: "run", error: error51 }));