mmt-testlight 1.43.0-pre → 1.43.1-pre

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-globalThis.__MMT_CLI_VERSION__ = "1.43.0-pre";
+globalThis.__MMT_CLI_VERSION__ = "1.43.1-pre";
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -121,33 +121,63 @@ var init_mmtFileType = __esm({
 var CommonData_exports = {};
 __export(CommonData_exports, {
   FORMAT_VALUES: () => FORMAT_VALUES,
+  REQUEST_FORMAT_VALUES: () => REQUEST_FORMAT_VALUES,
+  RESPONSE_FORMAT_VALUES: () => RESPONSE_FORMAT_VALUES,
   formatDuration: () => formatDuration,
   jsonTypes: () => jsonTypes,
   normalizeFormat: () => normalizeFormat,
   packFormatSpec: () => packFormatSpec,
   requestFormat: () => requestFormat,
   responseFormat: () => responseFormat,
+  toResponseFormat: () => toResponseFormat,
   typeOptions: () => MMT_FILE_TYPE_OPTIONS
 });
+function toResponseFormat(format) {
+  return format === "none" ? "auto" : format;
+}
 function isFormatValue(value) {
   return typeof value === "string" && FORMAT_VALUES.includes(value);
 }
+function isRequestFormatValue(value) {
+  return typeof value === "string" && (value === "auto" || FORMAT_VALUES.includes(value));
+}
+function isResponseFormatValue(value) {
+  return typeof value === "string" && RESPONSE_FORMAT_VALUES.includes(value);
+}
+function coerceResponseFormat(rawResponse, request2) {
+  if (rawResponse === void 0 || rawResponse === null || rawResponse === "none") {
+    return "auto";
+  }
+  if (isResponseFormatValue(rawResponse)) {
+    return rawResponse;
+  }
+  if (request2 !== "none" && request2 !== "auto" && isResponseFormatValue(request2)) {
+    return request2;
+  }
+  return "auto";
+}
 function normalizeFormat(format) {
   if (format == null) {
-    return { request: "json", response: "json" };
+    return { request: "auto", response: "auto" };
   }
   if (typeof format === "string") {
+    if (format === "auto") {
+      return { request: "auto", response: "auto" };
+    }
+    if (format === "none") {
+      return { request: "none", response: "auto" };
+    }
     const value = isFormatValue(format) ? format : "json";
-    return { request: value, response: value };
+    return { request: value, response: "auto" };
   }
   if (typeof format === "object" && !Array.isArray(format)) {
     const rawRequest = format.request;
     const rawResponse = format.response ?? format.respond;
-    const request2 = isFormatValue(rawRequest) ? rawRequest : isFormatValue(rawResponse) ? rawResponse : "json";
-    const response = isFormatValue(rawResponse) ? rawResponse : request2;
+    const request2 = isRequestFormatValue(rawRequest) ? rawRequest : isFormatValue(rawResponse) ? rawResponse : "auto";
+    const response = coerceResponseFormat(rawResponse, request2);
     return { request: request2, response };
   }
-  return { request: "json", response: "json" };
+  return { request: "auto", response: "auto" };
 }
 function requestFormat(format) {
   return normalizeFormat(format).request;
@@ -160,6 +190,18 @@ function packFormatSpec(format) {
     return void 0;
   }
   const { request: request2, response } = normalizeFormat(format);
+  if (request2 === "none" && response === "auto") {
+    return "none";
+  }
+  if (response === "auto" && request2 !== "auto") {
+    return request2;
+  }
+  if (request2 === "auto" && response === "auto") {
+    return "auto";
+  }
+  if (request2 === "auto" || response === "auto") {
+    return { request: request2, response };
+  }
   if (request2 === response) {
     return request2;
   }
@@ -191,12 +233,24 @@ function formatDuration(ms) {
   const h = Math.round(ms % 864e5 / 36e5);
   return h > 0 ? `${d}d ${h}h` : `${d}d`;
 }
-var FORMAT_VALUES, jsonTypes;
+var FORMAT_VALUES, REQUEST_FORMAT_VALUES, RESPONSE_BODY_FORMATS, RESPONSE_FORMAT_VALUES, jsonTypes;
 var init_CommonData = __esm({
   "../core/src/CommonData.ts"() {
     "use strict";
     init_mmtFileType();
-    FORMAT_VALUES = ["json", "xml", "xmle", "text", "urlencoded", "binary", "multipart"];
+    FORMAT_VALUES = ["none", "json", "xml", "xmle", "text", "html", "urlencoded", "binary", "multipart"];
+    REQUEST_FORMAT_VALUES = [...FORMAT_VALUES, "auto"];
+    RESPONSE_BODY_FORMATS = [
+      "json",
+      "xml",
+      "xmle",
+      "text",
+      "html",
+      "urlencoded",
+      "binary",
+      "multipart"
+    ];
+    RESPONSE_FORMAT_VALUES = [...RESPONSE_BODY_FORMATS, "auto"];
     jsonTypes = [
       "object",
       "object[]",
@@ -649,6 +703,7 @@ var init_TestData = __esm({
 var apiMethod_exports = {};
 __export(apiMethod_exports, {
   hasApiRequestBody: () => hasApiRequestBody,
+  httpMethodAllowsRequestBody: () => httpMethodAllowsRequestBody,
   resolveApiHttpMethod: () => resolveApiHttpMethod
 });
 function hasApiRequestBody(body) {
@@ -666,6 +721,10 @@ function hasApiRequestBody(body) {
   }
   return true;
 }
+function httpMethodAllowsRequestBody(method) {
+  const trimmed = typeof method === "string" ? method.trim().toLowerCase() : "";
+  return trimmed !== "get";
+}
 function resolveApiHttpMethod(method, body) {
   const trimmed = typeof method === "string" ? method.trim().toLowerCase() : "";
   if (trimmed) {
@@ -679,6 +738,181 @@ var init_apiMethod = __esm({
   }
 });
 
+// ../core/src/binaryBody.ts
+function bytesToBase64(bytes) {
+  let output = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    const triplet = a << 16 | b << 8 | c;
+    output += BASE64_CHARS[triplet >> 18 & 63];
+    output += BASE64_CHARS[triplet >> 12 & 63];
+    output += i + 1 < bytes.length ? BASE64_CHARS[triplet >> 6 & 63] : "=";
+    output += i + 2 < bytes.length ? BASE64_CHARS[triplet & 63] : "=";
+  }
+  return output;
+}
+function toByteArray(data) {
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  return new Uint8Array(0);
+}
+function primaryContentType(contentType) {
+  return (contentType || "").split(";")[0].trim().toLowerCase();
+}
+function isBinaryContentType(contentType) {
+  const ct = primaryContentType(contentType);
+  if (!ct) {
+    return false;
+  }
+  if (ct.startsWith("image/")) {
+    return true;
+  }
+  if (ct === "application/octet-stream") {
+    return true;
+  }
+  if (ct === "application/pdf") {
+    return true;
+  }
+  return false;
+}
+function sniffImageMime(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) {
+    return "image/gif";
+  }
+  if (bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) {
+    return "image/webp";
+  }
+  const sample = bytes.subarray(0, Math.min(bytes.length, 256));
+  let text = "";
+  try {
+    text = new TextDecoder().decode(sample).trimStart();
+  } catch {
+    return void 0;
+  }
+  if (text.startsWith("<svg") || text.startsWith("<?xml") && text.includes("<svg")) {
+    return "image/svg+xml";
+  }
+  return void 0;
+}
+function resolveBinaryPreviewMime(contentType, bytes) {
+  const ct = primaryContentType(contentType);
+  if (ct.startsWith("image/")) {
+    return ct;
+  }
+  return sniffImageMime(bytes);
+}
+function encodeBinaryBody(bytes, contentType) {
+  const previewMime = resolveBinaryPreviewMime(contentType, bytes);
+  return {
+    __mmtBinary: true,
+    base64: bytesToBase64(bytes),
+    byteLength: bytes.length,
+    contentType: primaryContentType(contentType) || void 0,
+    previewMime
+  };
+}
+function normalizeHttpResponseBody(data, headers) {
+  const bytes = toByteArray(data);
+  const contentType = headerContentType(headers);
+  if (isBinaryContentType(contentType)) {
+    return encodeBinaryBody(bytes, contentType);
+  }
+  return new TextDecoder("utf-8").decode(bytes);
+}
+function headerContentType(headers) {
+  if (!headers) {
+    return "";
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "content-type") {
+      return value == null ? "" : String(value);
+    }
+  }
+  return "";
+}
+var BASE64_CHARS;
+var init_binaryBody = __esm({
+  "../core/src/binaryBody.ts"() {
+    "use strict";
+    BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  }
+});
+
+// ../core/src/formatResolve.ts
+function headerContentType2(headers) {
+  if (!headers) {
+    return "";
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === "content-type") {
+      return value == null ? "" : String(value);
+    }
+  }
+  return "";
+}
+function formatFromContentType(contentType) {
+  const ct = (contentType || "").toLowerCase();
+  if (!ct) {
+    return void 0;
+  }
+  if (ct.includes("json")) {
+    return "json";
+  }
+  if (ct.includes("html")) {
+    return "html";
+  }
+  if (ct.includes("xml")) {
+    return "xml";
+  }
+  if (ct.includes("urlencoded") || ct.includes("x-www-form-urlencoded")) {
+    return "urlencoded";
+  }
+  if (ct.includes("multipart")) {
+    return "multipart";
+  }
+  if (ct.startsWith("image/")) {
+    return "binary";
+  }
+  if (ct.includes("octet-stream")) {
+    return "binary";
+  }
+  if (ct.includes("text/plain")) {
+    return "text";
+  }
+  return void 0;
+}
+function resolveRequestFormat(declared, headers, method) {
+  if (declared !== "auto") {
+    return declared;
+  }
+  if (method !== void 0 && !httpMethodAllowsRequestBody(method)) {
+    return "none";
+  }
+  return formatFromContentType(headerContentType2(headers)) ?? "json";
+}
+var init_formatResolve = __esm({
+  "../core/src/formatResolve.ts"() {
+    "use strict";
+    init_apiMethod();
+    init_binaryBody();
+  }
+});
+
 // ../core/src/RandomResources.ts
 var COLOR_PALETTE, FIRST_NAMES, LAST_NAMES, CITY_LIST, COUNTRY_LIST, EMAIL_DOMAINS, WEEKDAYS, MONTHS;
 var init_RandomResources = __esm({
@@ -3650,12 +3884,27 @@ function generateBoundary() {
   }
   return `mmt${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
 }
+function coerceMultipartPartsInput(body) {
+  if (typeof body !== "string") {
+    return body;
+  }
+  const trimmed = body.trim();
+  if (!trimmed.startsWith("[")) {
+    return body;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return body;
+  }
+}
 function normalizeMultipartParts(body) {
-  if (!Array.isArray(body)) {
+  const input = coerceMultipartPartsInput(body);
+  if (!Array.isArray(input)) {
     throw new Error("Invalid multipart body: expected an array of parts");
   }
   const parts = [];
-  for (const raw of body) {
+  for (const raw of input) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
       throw new Error("Invalid multipart body: each part must be an object");
     }
@@ -4841,6 +5090,117 @@ var init_JSerHelper = __esm({
   }
 });
 
+// ../core/src/htmlFormat.ts
+function formatHtmlLenient(html) {
+  const normalized = normalizeNewlines(html);
+  const lines = [];
+  let indent = 0;
+  let i = 0;
+  const pushLine = (text, level = indent) => {
+    const trimmed = text.trim();
+    if (trimmed) {
+      lines.push(`${"  ".repeat(level)}${trimmed}`);
+    }
+  };
+  while (i < normalized.length) {
+    if (normalized.slice(i, i + 4) === "<!--") {
+      const commentEnd = normalized.indexOf("-->", i + 4);
+      if (commentEnd === -1) {
+        pushLine(normalized.slice(i));
+        break;
+      }
+      pushLine(normalized.slice(i, commentEnd + 3));
+      i = commentEnd + 3;
+      continue;
+    }
+    if (normalized[i] !== "<") {
+      const next = normalized.indexOf("<", i);
+      const text = normalized.slice(i, next === -1 ? void 0 : next);
+      pushLine(text);
+      i = next === -1 ? normalized.length : next;
+      continue;
+    }
+    const tagEnd = normalized.indexOf(">", i);
+    if (tagEnd === -1) {
+      pushLine(normalized.slice(i));
+      break;
+    }
+    const tag = normalized.slice(i, tagEnd + 1);
+    const tagName = tag.match(/^<\/?([a-zA-Z0-9-]+)/)?.[1]?.toLowerCase();
+    const isClosing = tag.startsWith("</");
+    const isSelfClosing = /\/>\s*$/.test(tag);
+    const isSpecial = tag.startsWith("<!") || tag.startsWith("<?");
+    if (!isClosing && tagName && HTML_RAW_TEXT_ELEMENTS.has(tagName)) {
+      const closeTag = `</${tagName}>`;
+      const closeIdx = normalized.toLowerCase().indexOf(closeTag, tagEnd + 1);
+      pushLine(tag);
+      if (closeIdx !== -1) {
+        pushLine(normalized.slice(tagEnd + 1, closeIdx), indent + 1);
+        pushLine(closeTag);
+        i = closeIdx + closeTag.length;
+        continue;
+      }
+    }
+    if (isClosing && tagName) {
+      indent = Math.max(0, indent - 1);
+      pushLine(tag);
+      i = tagEnd + 1;
+      continue;
+    }
+    pushLine(tag);
+    if (!isSelfClosing && !isSpecial && tagName && !HTML_VOID_ELEMENTS.has(tagName)) {
+      indent++;
+    }
+    i = tagEnd + 1;
+  }
+  return lines.join("\n");
+}
+function formatHtmlStrict(html) {
+  const normalized = normalizeNewlines(html);
+  const xmlObj = (0, import_xml_js.xml2js)(normalized, { compact: true });
+  return (0, import_xml_js.js2xml)(xmlObj, {
+    compact: true,
+    spaces: 2,
+    fullTagEmptyElement: true
+  });
+}
+function formatHtmlBody(html) {
+  try {
+    return formatHtmlStrict(html);
+  } catch {
+    try {
+      return formatHtmlLenient(html);
+    } catch {
+      return html;
+    }
+  }
+}
+var import_xml_js, HTML_VOID_ELEMENTS, HTML_RAW_TEXT_ELEMENTS;
+var init_htmlFormat = __esm({
+  "../core/src/htmlFormat.ts"() {
+    "use strict";
+    import_xml_js = require("xml-js");
+    init_textLines();
+    HTML_VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    HTML_RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+  }
+});
+
 // ../core/src/expectOperatorYaml.ts
 function quoteExpectOperators(yaml4) {
   const eol = detectNewline(yaml4);
@@ -5233,6 +5593,57 @@ var init_yamlAstMerge = __esm({
   }
 });
 
+// ../core/src/yamlBlockSteps.ts
+function pairKey2(pair) {
+  if ((0, import_yaml2.isScalar)(pair.key)) {
+    return String(pair.key.value);
+  }
+  return void 0;
+}
+function normalizeStepSequence(seq) {
+  seq.flow = false;
+  for (const item of seq.items) {
+    if ((0, import_yaml2.isMap)(item)) {
+      item.flow = false;
+      forceBlockStyleForStepSequences(item);
+    } else {
+      forceBlockStyleForStepSequences(item);
+    }
+  }
+}
+function forceBlockStyleForStepSequences(node) {
+  if (!node) {
+    return;
+  }
+  if ((0, import_yaml2.isMap)(node)) {
+    for (const item of node.items) {
+      if (!(0, import_yaml2.isPair)(item)) {
+        continue;
+      }
+      const key = pairKey2(item);
+      if (key && BLOCK_LIST_KEYS.has(key) && (0, import_yaml2.isSeq)(item.value)) {
+        normalizeStepSequence(item.value);
+      } else {
+        forceBlockStyleForStepSequences(item.value);
+      }
+    }
+    return;
+  }
+  if ((0, import_yaml2.isSeq)(node)) {
+    for (const item of node.items) {
+      forceBlockStyleForStepSequences(item);
+    }
+  }
+}
+var import_yaml2, BLOCK_LIST_KEYS;
+var init_yamlBlockSteps = __esm({
+  "../core/src/yamlBlockSteps.ts"() {
+    "use strict";
+    import_yaml2 = require("yaml");
+    BLOCK_LIST_KEYS = /* @__PURE__ */ new Set(["steps", "stages", "flow", "else"]);
+  }
+});
+
 // ../core/src/markupConvertor.ts
 var markupConvertor_exports = {};
 __export(markupConvertor_exports, {
@@ -5319,12 +5730,14 @@ function packYaml(obj, originalYaml) {
           doc2.contents = merged;
         }
         applyKeywordScalarStyles(doc2.contents, obj);
+        forceBlockStyleForStepSequences(doc2.contents);
         return stringifyYamlDocument(doc2);
       }
     }
     const doc = new YAML4.Document();
     doc.contents = doc.createNode(normalized);
     applyKeywordScalarStyles(doc.contents, obj);
+    forceBlockStyleForStepSequences(doc.contents);
     return stringifyYamlDocument(doc);
   } catch (e) {
     return "";
@@ -5368,6 +5781,10 @@ function contentTypeForFormat(format) {
       return "application/octet-stream";
     case "multipart":
       return "multipart/form-data";
+    case "none":
+      return "";
+    case "html":
+      return "text/html";
     case "text":
     default:
       return "text/plain";
@@ -5420,14 +5837,81 @@ function parseUrlEncodedBody(body) {
   });
   return result;
 }
+function coerceBodyToStructuredObject(body) {
+  if (typeof body !== "string") {
+    return body;
+  }
+  const normalized = normalizeNewlines(body);
+  const trimmed = normalized.trimStart();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed.startsWith("<")) {
+    return body;
+  }
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(normalized);
+    } catch {
+    }
+  }
+  try {
+    const parsed = YAML4.parse(normalized);
+    if (parsed !== null && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  return normalized;
+}
 function formatXmlBody(body, pretty, expanded) {
-  const xmlObj = typeof body === "string" ? (0, import_xml_js.xml2js)(body, { compact: true }) : body;
-  return (0, import_xml_js.js2xml)(xmlObj, {
+  const coerced = coerceBodyToStructuredObject(body);
+  if (coerced === "") {
+    return "";
+  }
+  const xmlObj = typeof coerced === "string" ? (0, import_xml_js2.xml2js)(coerced, { compact: true }) : coerced;
+  return (0, import_xml_js2.js2xml)(xmlObj, {
     compact: true,
     spaces: pretty ? 2 : 0,
     fullTagEmptyElement: expanded
   });
 }
+function normalizeBodyToJsonObject(body) {
+  if (body === null || body === void 0) {
+    return body;
+  }
+  if (typeof body === "object") {
+    return flattenXmlObj(body);
+  }
+  const normalized = normalizeNewlines(body);
+  if (normalized.trim() === "") {
+    return "";
+  }
+  const coerced = coerceBodyToStructuredObject(normalized);
+  if (coerced === "") {
+    return "";
+  }
+  if (typeof coerced === "object") {
+    return flattenXmlObj(coerced);
+  }
+  const trimmed = coerced.trimStart();
+  if (trimmed.startsWith("<")) {
+    try {
+      return flattenXmlObj((0, import_xml_js2.xml2js)(coerced, { compact: true }));
+    } catch {
+      return coerced;
+    }
+  }
+  try {
+    return JSON.parse(coerced);
+  } catch {
+    try {
+      return YAML4.parse(coerced);
+    } catch {
+      return coerced;
+    }
+  }
+}
 function formatBody(format, body, pretty = true) {
   if (body === null || body === void 0) {
     return "";
@@ -5440,10 +5924,13 @@ function formatBody(format, body, pretty = true) {
   }
   try {
     if (format === "json") {
-      const obj = typeof body === "string" ? YAML4.parse(body) : body;
-      if (obj === null || obj === void 0) {
+      const obj = normalizeBodyToJsonObject(body);
+      if (obj === null || obj === void 0 || obj === "") {
         return "";
       }
+      if (typeof obj === "string") {
+        return obj;
+      }
       return pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj);
     }
     if (isXmlFormat(format)) {
@@ -5464,7 +5951,13 @@ function formatBody(format, body, pretty = true) {
       }
       return typeof body === "string" ? body : String(body ?? "");
     }
-    if (format === "text") {
+    if (format === "html") {
+      if (typeof body !== "string") {
+        return JSON.stringify(body, null, pretty ? 2 : 0);
+      }
+      return pretty ? formatHtmlBody(body) : body;
+    }
+    if (format === "text" || format === "none") {
       return typeof body === "string" ? body : JSON.stringify(body, null, pretty ? 2 : 0);
     }
     return typeof body === "string" ? body : YAML4.stringify(body);
@@ -5493,10 +5986,10 @@ function formattedBodyToYamlObject(format, body) {
   try {
     const text = normalizeNewlines(body);
     if (format === "json") {
-      return JSON.parse(text);
+      return normalizeBodyToJsonObject(text);
     }
     if (isXmlFormat(format)) {
-      const jsObj = (0, import_xml_js.xml2js)(text, { compact: true });
+      const jsObj = (0, import_xml_js2.xml2js)(text, { compact: true });
       return flattenXmlObj(jsObj);
     }
     if (format === "urlencoded") {
@@ -5512,7 +6005,7 @@ function formattedBodyToYamlObject(format, body) {
         return text;
       }
     }
-    if (format === "text") {
+    if (format === "text" || format === "html" || format === "none") {
       return text;
     }
     return YAML4.parse(text);
@@ -5536,7 +6029,7 @@ function packBodyForYamlCompare(yamlBody, uiBody, format) {
 }
 function beautify(format, value) {
   try {
-    if (format === "json") {
+    if (format === "json" || format === "multipart") {
       return JSON.stringify(JSON.parse(value), null, 2);
     }
     if (isXmlFormat(format)) {
@@ -5545,6 +6038,9 @@ function beautify(format, value) {
     if (format === "urlencoded") {
       return objectToUrlEncoded(parseUrlEncodedBody(value));
     }
+    if (format === "html") {
+      return formatHtmlBody(value);
+    }
   } catch {
     return value;
   }
@@ -5553,6 +6049,9 @@ function beautify(format, value) {
 function beautifyWithContentType(contentType, value) {
   const trimmedValue = value.trimStart();
   const ct = (contentType || "").toLowerCase();
+  if (ct.includes("html")) {
+    return formatHtmlBody(value);
+  }
   if (ct.includes("json") || trimmedValue.startsWith("{") || trimmedValue.startsWith("[")) {
     return beautify("json", value);
   }
@@ -5564,12 +6063,13 @@ function beautifyWithContentType(contentType, value) {
   }
   return value;
 }
-var import_xml_js, YAML4, markupConvertor_default;
+var import_xml_js2, YAML4, markupConvertor_default;
 var init_markupConvertor = __esm({
   "../core/src/markupConvertor.ts"() {
     "use strict";
-    import_xml_js = require("xml-js");
+    import_xml_js2 = require("xml-js");
     YAML4 = __toESM(require("yaml"));
+    init_htmlFormat();
     init_expectOperatorYaml();
     init_omitKeyword();
     init_omitKeyword();
@@ -5577,6 +6077,7 @@ var init_markupConvertor = __esm({
     init_multilineDescriptionYaml();
     init_textLines();
     init_yamlAstMerge();
+    init_yamlBlockSteps();
     markupConvertor_default = parseYaml;
   }
 });
@@ -6185,32 +6686,54 @@ function sectionToText(section, bodyText, headers, cookies, response) {
       return "";
   }
 }
+function inferExtractBodyType(response) {
+  const headersLower = Object.fromEntries(Object.entries(response.headers || {}).map(([k, v]) => [k.toLowerCase(), v]));
+  const ct = headersLower["content-type"];
+  if (typeof ct === "string") {
+    const lc = ct.toLowerCase();
+    if (lc.includes("json")) {
+      return "json";
+    }
+    if (lc.includes("xml") && !lc.includes("html")) {
+      return "xml";
+    }
+    return "text";
+  }
+  const body = typeof response.body === "string" ? response.body.trimStart() : "";
+  if (body.startsWith("<?xml")) {
+    return "xml";
+  }
+  if (/^<[a-zA-Z!?]/.test(body)) {
+    if (/^<!DOCTYPE\s+html/i.test(body) || /^<html[\s>]/i.test(body)) {
+      return "text";
+    }
+    return "xml";
+  }
+  if (body.startsWith("{") || body.startsWith("[")) {
+    return "json";
+  }
+  return "text";
+}
 function extractOutputs(response, outputsDef) {
   const result = {};
   const bodyText = typeof response.body === "string" ? response.body : JSON.stringify(response.body);
   let bodyObject = response.body;
   if (response.type === "auto") {
-    const headersLower = Object.fromEntries(Object.entries(response.headers || {}).map(([k, v]) => [k.toLowerCase(), v]));
-    const ct = headersLower["content-type"];
-    if (typeof ct === "string") {
-      response.type = ct.includes("xml") ? "xml" : "json";
-    } else {
-      response.type = response.body && response.body.startsWith && response.body.startsWith("<") ? "xml" : "json";
-    }
+    response.type = inferExtractBodyType(response);
   }
   if (response.type === "xml" && typeof response.body === "string") {
     try {
-      const jsObj = (0, import_xml_js2.xml2js)(response.body, { compact: true });
+      const jsObj = (0, import_xml_js3.xml2js)(response.body, { compact: true });
       bodyObject = xmlBodyToExtractable(jsObj);
-    } catch (e) {
-      console.warn("Failed to parse XML:", e);
+    } catch {
+      console.warn("Failed to parse XML");
       bodyObject = {};
     }
   } else if (response.type === "json" && typeof response.body === "string") {
     try {
       bodyObject = JSON.parse(response.body);
-    } catch (e) {
-      console.warn("Failed to parse JSON:", e);
+    } catch {
+      console.warn("Failed to parse JSON");
       bodyObject = {};
     }
   }
@@ -6296,11 +6819,11 @@ function extractOutputs(response, outputsDef) {
 function mergeWithDefaultExtractionRules(userOutputs) {
   return { ...DEFAULT_EXTRACTION_RULES, ...userOutputs || {} };
 }
-var import_xml_js2, DEFAULT_EXTRACTION_RULES, DEFAULT_OUTPUT_KEYS;
+var import_xml_js3, DEFAULT_EXTRACTION_RULES, DEFAULT_OUTPUT_KEYS;
 var init_outputExtractor = __esm({
   "../core/src/outputExtractor.ts"() {
     "use strict";
-    import_xml_js2 = require("xml-js");
+    import_xml_js3 = require("xml-js");
     init_omitKeyword();
     init_xmlPath();
     DEFAULT_EXTRACTION_RULES = {
@@ -6363,21 +6886,27 @@ __export(apiParsePack_exports, {
 });
 function parseFormatSpec(raw) {
   if (raw == null) {
-    return "json";
+    return void 0;
   }
   if (typeof raw === "string") {
+    if (raw === "auto") {
+      return { request: "auto", response: "auto" };
+    }
     return VALID_FORMAT_VALUES.has(raw) ? raw : "json";
   }
   if (typeof raw === "object" && !Array.isArray(raw)) {
-    const request2 = VALID_FORMAT_VALUES.has(raw.request) ? raw.request : void 0;
+    const request2 = VALID_REQUEST_FORMAT_VALUES.has(raw.request) ? raw.request : void 0;
     const responseRaw = raw.response ?? raw.respond;
-    const response = VALID_FORMAT_VALUES.has(responseRaw) ? responseRaw : void 0;
+    const response = VALID_RESPONSE_FORMAT_VALUES.has(responseRaw) ? responseRaw : void 0;
     if (!request2 && !response) {
-      return "json";
+      return void 0;
     }
-    return packFormatSpec({ request: request2, response }) || "json";
+    return packFormatSpec({
+      request: request2 ?? "auto",
+      response: response ?? "auto"
+    });
   }
-  return "json";
+  return void 0;
 }
 function parseGraphQLConfig(raw) {
   if (!raw || typeof raw !== "object") {
@@ -6737,7 +7266,7 @@ function apiToYaml(api, originalYaml) {
   ;
   return packYaml(yamlObj, originalYaml);
 }
-var VALID_API_ROOT_KEYS, VALID_GRPC_STREAM_VALUES, VALID_FORMAT_VALUES, VALID_AUTH_TYPES;
+var VALID_API_ROOT_KEYS, VALID_GRPC_STREAM_VALUES, VALID_FORMAT_VALUES, VALID_REQUEST_FORMAT_VALUES, VALID_RESPONSE_FORMAT_VALUES, VALID_AUTH_TYPES;
 var init_apiParsePack = __esm({
   "../core/src/apiParsePack.ts"() {
     "use strict";
@@ -6769,7 +7298,9 @@ var init_apiParsePack = __esm({
       "examples"
     ]);
     VALID_GRPC_STREAM_VALUES = /* @__PURE__ */ new Set(["server", "client", "bidi"]);
-    VALID_FORMAT_VALUES = /* @__PURE__ */ new Set(["json", "xml", "xmle", "text", "urlencoded", "binary", "multipart"]);
+    VALID_FORMAT_VALUES = new Set(FORMAT_VALUES);
+    VALID_REQUEST_FORMAT_VALUES = new Set(REQUEST_FORMAT_VALUES);
+    VALID_RESPONSE_FORMAT_VALUES = new Set(RESPONSE_FORMAT_VALUES);
     VALID_AUTH_TYPES = /* @__PURE__ */ new Set(["bearer", "basic", "api-key", "oauth2"]);
   }
 });
@@ -7922,6 +8453,7 @@ __export(testHelper_exports, {
   registerServer_: () => registerServer_,
   reportWithContext_: () => reportWithContext_,
   report_: () => report_,
+  resolveRequestFormat_: () => resolveRequestFormat,
   setAbortSignal_: () => setAbortSignal_,
   setFileLoader_: () => setFileLoader_,
   setServerRunner_: () => setServerRunner_,
@@ -8416,6 +8948,7 @@ var init_testHelper = __esm({
     init_judgeEngine();
     init_judgeEngineOllama();
     init_judgeEngineProviders();
+    init_formatResolve();
     TestAbortError = class extends Error {
       constructor() {
         super("Test run was stopped");
@@ -55173,8 +55706,8 @@ var require_axios = __commonJS({
       let mapped = key[0].toUpperCase() + key.slice(1);
       return {
         get: () => value,
-        set(headerValue2) {
-          this[mapped] = headerValue2;
+        set(headerValue3) {
+          this[mapped] = headerValue3;
         }
       };
     });
@@ -57441,6 +57974,19 @@ var require_axios = __commonJS({
 });
 
 // ../core/src/networkCore.ts
+function getHttpsAgentKey(hostname, port, protocol, config, opts) {
+  const skipValidation = opts?.skipCertificateValidation ?? false;
+  const clientId = opts?.fallbackClientCertId || findMatchingClientCertificate(config.clients, hostname, port, protocol)?.id || "";
+  return [
+    hostname,
+    port || "",
+    String(config.sslValidation),
+    String(skipValidation),
+    String(!!config.ca.enabled),
+    clientId,
+    opts?.forceTls12 ? "tls12" : "tls"
+  ].join(":");
+}
 function getLegacyRenegotiationSecureOptions() {
   let secureOptions = 0;
   const constants4 = crypto2.constants;
@@ -57503,10 +58049,15 @@ function trackSocketForAgent(socket, host, protocol) {
 }
 function createHttpsAgentWithCertificates(hostname, port, protocol, config, opts) {
   const skipValidation = opts?.skipCertificateValidation ?? false;
+  const agentKey = getHttpsAgentKey(hostname, port, protocol, config, opts);
+  const existingAgent = httpsAgentPool.get(agentKey);
+  if (existingAgent) {
+    return existingAgent;
+  }
   const rejectUnauthorized = skipValidation ? false : config.sslValidation;
   const agentOptions = {
     rejectUnauthorized,
-    keepAlive: false,
+    keepAlive: true,
     keepAliveMsecs: 3e4
   };
   applyTlsCompatibilityOptions(agentOptions, { forceTls12: opts?.forceTls12 });
@@ -57538,6 +58089,7 @@ function createHttpsAgentWithCertificates(hostname, port, protocol, config, opts
     trackSocketForAgent(socket, host, "https");
     return socket;
   };
+  httpsAgentPool.set(agentKey, agent);
   return agent;
 }
 function hasUsableClientCertificate(client) {
@@ -57710,9 +58262,10 @@ function sendHttp2Request(req, config, reqHeaders, parsedUrl, requestTimeout, sk
       clearTimeout(timer);
       settle2(() => {
         const status = Number(responseHeaders[":status"] || 0);
+        const headers2 = normalizeHttp2ResponseHeaders(responseHeaders);
         resolve2({
-          body: Buffer.concat(chunks).toString("utf8"),
-          headers: normalizeHttp2ResponseHeaders(responseHeaders),
+          body: normalizeHttpResponseBody(Buffer.concat(chunks), headers2),
+          headers: headers2,
           status,
           statusText: http3.STATUS_CODES[status] || "",
           duration: Date.now() - start,
@@ -57788,7 +58341,7 @@ function sendNativeHttpsRequest(req, config, reqHeaders, parsedUrl, requestTimeo
           }
         }
         resolve2({
-          body: Buffer.concat(chunks).toString("utf8"),
+          body: normalizeHttpResponseBody(Buffer.concat(chunks), headersOut),
           headers: headersOut,
           status: res.statusCode || 0,
           statusText: res.statusMessage || "",
@@ -57914,7 +58467,7 @@ async function sendHttpRequest(req, config) {
     withCredentials: true,
     headers: reqHeaders,
     timeout: requestTimeout,
-    responseType: "text",
+    responseType: "arraybuffer",
     transformResponse: [(data) => data]
   };
   const executeRequest = (skipValidation = false, fallbackClientCertId, opts) => {
@@ -57942,9 +58495,10 @@ async function sendHttpRequest(req, config) {
   const start = Date.now();
   const toSuccess = (response, warning) => {
     const duration = Date.now() - start;
+    const headers = normalizeAxiosHeaders(response.headers);
     return {
-      body: response.data,
-      headers: normalizeAxiosHeaders(response.headers),
+      body: normalizeHttpResponseBody(response.data, headers),
+      headers,
       status: response.status,
       statusText: response.statusText,
       duration,
@@ -57955,9 +58509,13 @@ async function sendHttpRequest(req, config) {
   const toError = (err, warning) => {
     const duration = Date.now() - start;
     if (err?.response) {
+      const headers = normalizeAxiosHeaders(err.response.headers);
       return {
-        body: err.response.data,
-        headers: normalizeAxiosHeaders(err.response.headers),
+        body: normalizeHttpResponseBody(
+          err.response.data ?? err.response.body ?? err.response.text,
+          headers
+        ),
+        headers,
         status: err.response.status,
         statusText: err.response.statusText,
         duration,
@@ -58079,9 +58637,10 @@ function extractBodyFromError(err) {
   }
   try {
     if (err.response) {
+      const headers = normalizeAxiosHeaders(err.response.headers || {});
       const d = err.response.data ?? err.response.body ?? err.response.text;
-      if (typeof d === "string") {
-        return d;
+      if (typeof d === "string" || d instanceof ArrayBuffer || d instanceof Uint8Array) {
+        return normalizeHttpResponseBody(d, headers);
       }
       try {
         return JSON.stringify(d);
@@ -58101,7 +58660,14 @@ function extractBodyFromError(err) {
         try {
           const bufs = state.buffer.map((b) => b.data).filter(Boolean);
           if (bufs.length > 0) {
-            return Buffer.concat(bufs).toString("utf8");
+            const headers = {};
+            const rawHeaders = reqRes.headers || {};
+            for (const [key, value] of Object.entries(rawHeaders)) {
+              if (value !== void 0) {
+                headers[key] = Array.isArray(value) ? value.join(", ") : String(value);
+              }
+            }
+            return normalizeHttpResponseBody(Buffer.concat(bufs), headers);
           }
         } catch {
         }
@@ -58371,7 +58937,7 @@ async function send(req) {
     throw new Error(`Unsupported protocol: ${protocol}`);
   }
 }
-var crypto2, http3, http22, https3, axios2, httpAgentPool, socketConnectionIds, trackedSockets, SELF_SIGNED_TLS_CODES, SELF_SIGNED_MESSAGE_FRAGMENTS, CLIENT_CERTIFICATE_REQUIRED_CODES, CLIENT_CERTIFICATE_REQUIRED_MESSAGE_FRAGMENTS, runnerNetworkConfig;
+var crypto2, http3, http22, https3, axios2, httpAgentPool, httpsAgentPool, socketConnectionIds, trackedSockets, SELF_SIGNED_TLS_CODES, SELF_SIGNED_MESSAGE_FRAGMENTS, CLIENT_CERTIFICATE_REQUIRED_CODES, CLIENT_CERTIFICATE_REQUIRED_MESSAGE_FRAGMENTS, runnerNetworkConfig;
 var init_networkCore = __esm({
   "../core/src/networkCore.ts"() {
     "use strict";
@@ -58380,12 +58946,14 @@ var init_networkCore = __esm({
     http22 = __toESM(require("http2"));
     https3 = __toESM(require("https"));
     init_wrapper();
+    init_binaryBody();
     init_connectionTracker();
     init_apiMethod();
     init_NetworkData();
     init_connectionTracker();
     axios2 = require_axios();
     httpAgentPool = /* @__PURE__ */ new Map();
+    httpsAgentPool = /* @__PURE__ */ new Map();
     socketConnectionIds = /* @__PURE__ */ new WeakMap();
     trackedSockets = /* @__PURE__ */ new WeakSet();
     SELF_SIGNED_TLS_CODES = /* @__PURE__ */ new Set([
@@ -65135,6 +65703,7 @@ __export(src_exports, {
   reportParser: () => reportParser_exports,
   resolveApiRequest: () => resolveApiRequest,
   runConfig: () => runConfig_exports,
+  runFileCache: () => runFileCache_exports,
   runner: () => runner_exports,
   setenvResolve: () => setenvResolve_exports,
   statusIcons: () => statusIcons_exports,
@@ -65177,8 +65746,10 @@ __export(JSer_exports, {
 // ../core/src/JSerAPI.ts
 init_apiMethod();
 init_CommonData();
+init_formatResolve();
 init_JSerHelper();
 init_markupConvertor();
+init_multipartBody();
 init_omitKeyword();
 init_outputExtractor();
 init_variableReplacer();
@@ -65198,7 +65769,12 @@ var apiToJSfunc = async (ctx) => {
     { resolveRuntimeTokens: false }
   );
   replaced = stripOmitFromRequest(replaced);
-  const reqFormatForBody = requestFormat(replaced.format);
+  const declaredReqFormat = requestFormat(replaced.format);
+  const reqFormatForBody = resolveRequestFormat(
+    declaredReqFormat,
+    replaced.headers || {},
+    replaced.method
+  );
   if (reqFormatForBody !== "binary" && replaced.body != null) {
     replaced = {
       ...replaced,
@@ -65261,7 +65837,8 @@ var apiToJSfunc = async (ctx) => {
   }
   const protocolExpr = isGraphQL ? `'graphql'` : explicitProtocol ? `'${explicitProtocol}'` : `protocolFromUrl_(__resolvedUrl)`;
   const effectiveMethod = isGraphQL ? "post" : resolveApiHttpMethod(replaced.method, replaced.body);
-  const reqFormat = requestFormat(replaced.format);
+  const reqFormat = reqFormatForBody;
+  const isNoneRequest = !isGraphQL && reqFormat === "none";
   const isBinaryRequest = !isGraphQL && reqFormat === "binary";
   const isMultipartRequest = !isGraphQL && reqFormat === "multipart";
   if (isGraphQL) {
@@ -65273,7 +65850,7 @@ var apiToJSfunc = async (ctx) => {
       replaced.headers["Content-Type"] = "application/json";
       headers = Object.entries(replaced.headers).map(([k, v]) => `"${k}": ${toTemplateWithEnvs(String(v))}`).join(", ");
     }
-  } else if (reqFormat === "urlencoded" || reqFormat === "binary") {
+  } else if (reqFormat === "urlencoded" || reqFormat === "binary" || reqFormat === "html") {
     const hasContentType = Object.keys(replaced.headers || {}).some(
       (k) => k.toLowerCase() === "content-type"
     );
@@ -65299,7 +65876,7 @@ var apiToJSfunc = async (ctx) => {
   const binaryPathSource = typeof replaced.body === "string" ? replaced.body.trim() : replaced.body == null ? "" : String(replaced.body);
   const binaryPathExpr = toTemplateWithEnvs(binaryPathSource);
   const multipartPartsExpr = isMultipartRequest ? multipartPartsToJs(replaced.body, toTemplateWithEnvs) : "[]";
-  const bodyExpr = isGraphQL && graphqlBodyExpr ? graphqlBodyExpr : isBinaryRequest ? "__binaryBody_" : isMultipartRequest ? "__multipartParts_" : toTemplateWithEnvs(formattedBody);
+  const bodyExpr = isGraphQL && graphqlBodyExpr ? graphqlBodyExpr : isNoneRequest ? "undefined" : isBinaryRequest ? "__binaryBody_" : isMultipartRequest ? "__multipartParts_" : toTemplateWithEnvs(formattedBody);
   const binaryLoadLines = isBinaryRequest ? `  const __binaryPath_ = ${binaryPathExpr};
   const __binaryBody_ = await readBinaryFile_(__binaryPath_);
 ` : "";
@@ -65324,7 +65901,8 @@ ${binaryLoadLines}${multipartPrepLines}  const req_ = {
     body: ${bodyExpr}
   };
 ${authCode}
-  applyOmitToRequest_(req_, '${reqFormat}');
+  ${declaredReqFormat === "auto" ? `const __reqFormat_ = resolveRequestFormat_('auto', req_.headers, req_.body);
+  applyOmitToRequest_(req_, __reqFormat_);` : `applyOmitToRequest_(req_, '${declaredReqFormat}');`}
 ${multipartBuildLines}  const res_ = await send_(req_);
 
   const __extractSource_ = {
@@ -65457,10 +66035,11 @@ ${authCode}
 };`;
 }
 function multipartPartsToJs(parts, toTpl) {
-  if (!Array.isArray(parts) || parts.length === 0) {
+  const coerced = coerceMultipartPartsInput(parts);
+  if (!Array.isArray(coerced) || coerced.length === 0) {
     return "[]";
   }
-  const entries = parts.map((raw) => {
+  const entries = coerced.map((raw) => {
     const part = raw;
     const fields = [`name: ${JSON.stringify(String(part.name ?? ""))}`];
     if (part.file != null && String(part.file).trim() !== "") {
@@ -66402,7 +66981,11 @@ function reorderStep(step) {
   const order = STEP_KEY_ORDER[stepType];
   let ordered = order ? reorderKeys(step, order) : { ...step };
   if (Array.isArray(ordered.steps)) {
-    ordered.steps = reorderSteps(ordered.steps);
+    if (ordered.steps.length > 0) {
+      ordered.steps = reorderSteps(ordered.steps);
+    } else if (stepType === "if" || stepType === "for" || stepType === "repeat" || stepType === "stage") {
+      delete ordered.steps;
+    }
   }
   if (Array.isArray(ordered.else)) {
     ordered.else = reorderSteps(ordered.else);
@@ -66957,7 +67540,7 @@ var collectVariables = (document2) => {
 };
 var inferFormat = (formatHint, headers, body) => {
   const hint = String(formatHint || "").toLowerCase();
-  if (hint === "json" || hint === "xml" || hint === "xmle" || hint === "text" || hint === "urlencoded") {
+  if (hint === "json" || hint === "xml" || hint === "xmle" || hint === "text" || hint === "html" || hint === "urlencoded") {
     return hint;
   }
   if (hint === "form-urlencoded" || hint === "form_urlencoded" || hint === "form") {
@@ -66968,6 +67551,9 @@ var inferFormat = (formatHint, headers, body) => {
   if (contentType.includes("json")) {
     return "json";
   }
+  if (contentType.includes("html")) {
+    return "html";
+  }
   if (contentType.includes("xml")) {
     return "xml";
   }
@@ -67382,6 +67968,9 @@ var inferFormat2 = (headers, body) => {
   if (contentType.includes("json")) {
     return "json";
   }
+  if (contentType.includes("html")) {
+    return "html";
+  }
   if (contentType.includes("xml")) {
     return "xml";
   }
@@ -67931,6 +68520,116 @@ function validateJudgeObject(obj) {
 // ../core/src/JSerImports.ts
 init_outputExtractor();
 init_variableReplacer();
+
+// ../core/src/runFileCache.ts
+var runFileCache_exports = {};
+__export(runFileCache_exports, {
+  CACHED_IMPORT_FN: () => CACHED_IMPORT_FN,
+  RunFileCache: () => RunFileCache,
+  bindCachedImportFn: () => bindCachedImportFn,
+  getRunFileCache: () => getRunFileCache,
+  resetRunFileCache: () => resetRunFileCache
+});
+var CACHED_IMPORT_FN = "__mmt_cached_fn__";
+function normalizePath2(p) {
+  return String(p ?? "").replace(/\\/g, "/");
+}
+function hashText(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function bindCachedImportFn(js, publicName) {
+  if (!js || !publicName) {
+    return js;
+  }
+  return js.split(CACHED_IMPORT_FN).join(publicName);
+}
+var RunFileCache = class {
+  constructor() {
+    this.text = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.importJs = /* @__PURE__ */ new Map();
+  }
+  reset() {
+    this.text.clear();
+    this.pending.clear();
+    this.importJs.clear();
+  }
+  /**
+   * Call at the start of a top-level run.
+   * With a stamp function, any changed cached file resets the whole cache.
+   * Without a stamp function we cannot know, so the cache is cleared.
+   */
+  async beginRun(stamp) {
+    this.stampFn = stamp;
+    if (!stamp) {
+      this.reset();
+      return;
+    }
+    for (const [path8, entry] of this.text.entries()) {
+      let next = "";
+      try {
+        next = String(await stamp(path8));
+      } catch {
+        next = "missing";
+      }
+      if (next !== entry.stamp) {
+        this.reset();
+        return;
+      }
+    }
+  }
+  wrap(loader) {
+    return async (requestedPath) => {
+      const key = normalizePath2(requestedPath);
+      const hit = this.text.get(key);
+      if (hit) {
+        return hit.content;
+      }
+      let pending = this.pending.get(key);
+      if (!pending) {
+        pending = (async () => {
+          const content = await loader(requestedPath);
+          let stamp = "";
+          if (this.stampFn) {
+            try {
+              stamp = String(await this.stampFn(requestedPath));
+            } catch {
+              stamp = "missing";
+            }
+          }
+          this.text.set(key, { content, stamp });
+          this.pending.delete(key);
+          return content;
+        })();
+        this.pending.set(key, pending);
+      }
+      return pending;
+    };
+  }
+  getImportJs(resolvedPath, content) {
+    return this.importJs.get(this.importKey(resolvedPath, content));
+  }
+  setImportJs(resolvedPath, content, entry) {
+    this.importJs.set(this.importKey(resolvedPath, content), entry);
+  }
+  importKey(resolvedPath, content) {
+    return `${normalizePath2(resolvedPath)}\0${hashText(content)}`;
+  }
+};
+var shared = new RunFileCache();
+function getRunFileCache() {
+  return shared;
+}
+function resetRunFileCache() {
+  shared.reset();
+}
+
+// ../core/src/JSerImports.ts
 var ImportCodeError = class extends Error {
   constructor(detail, path8) {
     const cleaned = String(detail ?? "").replace(/^Import error(?: in [^:]+)?:\s*/i, "");
@@ -68108,28 +68807,50 @@ var emitResolved = async (resolved, publicNameForPath, tracker, projectRoot) =>
           projectRoot,
           fileLoader: readFile
         });
+        const cache = getRunFileCache();
+        const cached = cache.getImportJs(resolvedPath, processedContent);
+        if (cached) {
+          if (cached.title) {
+            tracker.setFileTitle(resolvedPath, cached.title);
+          }
+          if (cached.inputKeys) {
+            tracker.setInputKeys(resolvedPath, cached.inputKeys);
+          }
+          if (cached.outputKeys) {
+            tracker.setOutputKeys(resolvedPath, cached.outputKeys);
+          }
+          results.push(bindCachedImportFn(cached.js, publicName) + "\n");
+          continue;
+        }
         const api = yamlToAPIStrict(processedContent);
         if (api.title) {
           tracker.setFileTitle(resolvedPath, api.title);
         }
-        if (api.inputs && typeof api.inputs === "object") {
-          tracker.setInputKeys(resolvedPath, Object.keys(api.inputs));
+        const inputKeys = api.inputs && typeof api.inputs === "object" ? Object.keys(api.inputs) : void 0;
+        if (inputKeys) {
+          tracker.setInputKeys(resolvedPath, inputKeys);
         }
+        let outputKeys;
         if (api.outputs && typeof api.outputs === "object") {
           const userKeys = Object.keys(api.outputs);
-          const allKeys = [.../* @__PURE__ */ new Set([...DEFAULT_OUTPUT_KEYS, ...userKeys])];
-          tracker.setOutputKeys(resolvedPath, allKeys);
+          outputKeys = [.../* @__PURE__ */ new Set([...DEFAULT_OUTPUT_KEYS, ...userKeys])];
         } else {
-          tracker.setOutputKeys(resolvedPath, [...DEFAULT_OUTPUT_KEYS]);
-        }
-        results.push(
-          await apiToJSfunc({
-            api,
-            name: publicName,
-            inputs: {},
-            envVars: {}
-          }) + "\n"
-        );
+          outputKeys = [...DEFAULT_OUTPUT_KEYS];
+        }
+        tracker.setOutputKeys(resolvedPath, outputKeys);
+        const js = await apiToJSfunc({
+          api,
+          name: CACHED_IMPORT_FN,
+          inputs: {},
+          envVars: {}
+        });
+        cache.setImportJs(resolvedPath, processedContent, {
+          js,
+          title: api.title,
+          inputKeys,
+          outputKeys
+        });
+        results.push(bindCachedImportFn(js, publicName) + "\n");
       } else if (type === "csv") {
         results.push(await csvToJSObj(content, publicName) + "\n");
       } else if (isDataImportPath(resolvedPath)) {
@@ -70664,9 +71385,9 @@ function buildCurlParts(input, certificates) {
     parts.push({ kind: "pair", flag: "-X", value: method });
   }
   Object.entries(input.headers || {}).forEach(([key, value]) => {
-    const headerValue2 = stringifyCurlValue(value);
-    if (headerValue2) {
-      parts.push({ kind: "pair", flag: "-H", value: `${key}: ${headerValue2}` });
+    const headerValue3 = stringifyCurlValue(value);
+    if (headerValue3) {
+      parts.push({ kind: "pair", flag: "-H", value: `${key}: ${headerValue3}` });
     }
   });
   const cookiePairs = Object.entries(input.cookies || {}).map(([key, value]) => {
@@ -70956,6 +71677,7 @@ init_variableReplacer();
 
 // ../core/src/resolveApiRequest.ts
 init_CommonData();
+init_formatResolve();
 init_apiParsePack();
 init_markupConvertor();
 init_omitKeyword();
@@ -70967,7 +71689,10 @@ function resolveApiRequest(api, inputs, envParameters, options = {}) {
     inputs,
     envParameters,
     /* @__PURE__ */ new Set(),
-    { refreshRuntimeTokens: options.refreshRuntimeTokens }
+    {
+      refreshRuntimeTokens: options.refreshRuntimeTokens,
+      resolveRuntimeTokens: options.preserveStructuredBody ? false : void 0
+    }
   );
   request2 = stripOmitFromRequest(request2);
   if (request2.auth) {
@@ -70982,8 +71707,13 @@ function resolveApiRequest(api, inputs, envParameters, options = {}) {
     }
     delete request2.auth;
   }
-  if (request2.body && typeof request2.body !== "string") {
-    request2.body = formatBody(requestFormat(request2.format), request2.body ?? "");
+  const reqFormat = resolveRequestFormat(
+    requestFormat(request2.format),
+    request2.headers,
+    request2.method
+  );
+  if (!options.preserveStructuredBody && request2.body && typeof request2.body !== "string" && reqFormat !== "multipart") {
+    request2.body = formatBody(reqFormat, request2.body ?? "");
   }
   return request2;
 }
@@ -73522,6 +74252,7 @@ __export(postmanConvertor_exports, {
   postmanToAPI: () => postmanToAPI,
   translatePostmanTemplate: () => translatePostmanTemplate
 });
+init_CommonData();
 init_omitKeyword();
 init_Random();
 var POSTMAN_RANDOM_MAP = {
@@ -73579,6 +74310,44 @@ function translatePostmanTemplate(str) {
 function replacePostmanVars(str) {
   return translatePostmanTemplate(str);
 }
+function headerValue(headers, name) {
+  if (!headers) {
+    return void 0;
+  }
+  const key = Object.keys(headers).find(
+    (entry) => entry.toLowerCase() === name.toLowerCase()
+  );
+  const value = key ? headers[key] : void 0;
+  return typeof value === "string" ? value : void 0;
+}
+function formatFromMediaType(value) {
+  if (!value) {
+    return void 0;
+  }
+  const lc = value.toLowerCase();
+  if (lc.includes("json")) {
+    return "json";
+  }
+  if (lc.includes("xml") && !lc.includes("html")) {
+    return "xml";
+  }
+  if (lc.includes("urlencoded")) {
+    return "urlencoded";
+  }
+  if (lc.includes("multipart")) {
+    return "multipart";
+  }
+  if (lc.includes("octet-stream") || lc.includes("protobuf") || lc.includes("application/pdf") || lc.startsWith("image/") || lc.startsWith("audio/") || lc.startsWith("video/")) {
+    return "binary";
+  }
+  if (lc.includes("html")) {
+    return "html";
+  }
+  if (lc.includes("text") || lc.includes("javascript")) {
+    return "text";
+  }
+  return void 0;
+}
 function reviveUnquotedMmtTokens(value) {
   if (typeof value === "string") {
     const match = /^__MMT_UNQUOTED_(.+?)__$/.exec(value);
@@ -73920,16 +74689,21 @@ function postmanToAPI(postmanJson) {
     } else if (request2.body?.mode === "file") {
       format = { request: "binary", response: "json" };
     } else {
-      const contentType = headers?.["content-type"] ?? headers?.["Content-Type"];
-      if (typeof contentType === "string") {
-        const lc = contentType.toLowerCase();
-        if (lc.includes("xml")) {
-          format = "xml";
-        } else if (lc.includes("urlencoded") || lc.includes("x-www-form-urlencoded")) {
-          format = "urlencoded";
-        } else if (lc.includes("text")) {
-          format = "text";
-        }
+      const contentType = headerValue(headers, "content-type");
+      const fromContentType = formatFromMediaType(contentType);
+      if (fromContentType) {
+        format = fromContentType;
+      }
+    }
+    const acceptFormat = formatFromMediaType(headerValue(headers, "accept"));
+    if (acceptFormat) {
+      if (!request2.body) {
+        format = acceptFormat === "binary" || acceptFormat === "multipart" ? packFormatSpec({ request: "json", response: acceptFormat }) || acceptFormat : acceptFormat;
+      } else {
+        format = packFormatSpec({
+          request: requestFormat(format),
+          response: toResponseFormat(acceptFormat)
+        }) || acceptFormat;
       }
     }
     let protocol = void 0;
@@ -75125,8 +75899,7 @@ function convertHttpToMmt(rawFile, options) {
     const stepId = safeStepIdFromAlias(alias);
     const step = {
       call: alias,
-      id: stepId,
-      debug: true
+      id: stepId
     };
     const { expect, setenv } = httpRequestCallExtras(request2, stepId);
     if (expect && Object.keys(expect).length > 0) {
@@ -75178,8 +75951,7 @@ function convertBrunoToMmt(rawFile, options) {
     const inlineStep = test2.steps?.[0];
     const step = {
       call: alias,
-      id: safeStepIdFromAlias(alias),
-      debug: true
+      id: safeStepIdFromAlias(alias)
     };
     if (inlineStep && "expect" in inlineStep && inlineStep.expect && Object.keys(inlineStep.expect).length > 0) {
       step.expect = inlineStep.expect;
@@ -75374,8 +76146,7 @@ function buildPostmanTests(requestFiles, scriptMode, warnings, useProjectRootImp
       }
       const step = {
         call: requestFile.alias,
-        id: safeStepIdFromAlias(requestFile.alias),
-        debug: true
+        id: safeStepIdFromAlias(requestFile.alias)
       };
       const expect = buildPostmanExpect(requestFile.item, scriptMode, warnings);
       if (expect && Object.keys(expect).length > 0) {
@@ -76040,6 +76811,10 @@ var CREATE_API_LOG_HELPERS_SOURCE = `function createApiLogHelpers() {
         if (body === null || body === undefined || body === '') {
             return '';
         }
+        if (body && typeof body === 'object' && body.__mmtBinary === true &&
+            typeof body.byteLength === 'number') {
+            return \`<binary \${body.byteLength} bytes>\`;
+        }
         if (typeof Buffer !== 'undefined' && Buffer.isBuffer(body)) {
             return \`<binary \${body.length} bytes>\`;
         }
@@ -76267,10 +77042,16 @@ async function runGeneratedJs(runId, js, name, logger, jsRunner, stepReporter, i
     };
   }
 }
-function resolveRelativeTo(targetPath, baseFilePath) {
+function resolveRelativeTo(targetPath, baseFilePath, projectRoot) {
   if (!targetPath) {
     return targetPath;
   }
+  if (isProjectRootImport(targetPath)) {
+    if (projectRoot) {
+      return resolveProjectRootImport(targetPath, projectRoot);
+    }
+    return targetPath;
+  }
   if (targetPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(targetPath)) {
     return targetPath;
   }
@@ -76866,7 +77647,7 @@ async function executeApi(prepared, options, preLogs) {
     prepared.filePath ? prepared.filePath.split(/[/\\]/).slice(0, -1).join("/") : void 0,
     void 0,
     void 0,
-    void 0,
+    options.checkLogMode,
     "API",
     options.binaryFileLoader
   );
@@ -77136,6 +77917,9 @@ function createReportCollector() {
 // ../core/src/suiteBundleRunner.ts
 init_runLog();
 init_testHelper();
+function resolveSuitePath(targetPath, baseFilePath, options) {
+  return resolveRelativeTo(targetPath, baseFilePath, options.projectRoot);
+}
 async function startListedServers(params) {
   const { servers, baseFilePath, options, suiteLogger } = params;
   for (const serverPath of servers) {
@@ -77143,7 +77927,7 @@ async function startListedServers(params) {
       suiteLogger("warn", "Suite run cancelled before servers could start.");
       return false;
     }
-    const resolvedPath = resolveRelativeTo(serverPath, baseFilePath);
+    const resolvedPath = resolveSuitePath(serverPath, baseFilePath, options);
     const display = basename3(resolvedPath || serverPath);
     if (!options.serverRunner) {
       suiteLogger("error", `Cannot start server '${display}': no server runner provided`);
@@ -77242,7 +78026,7 @@ function reportSkippedBundleNode(params) {
   const { node, bundle, options, nextIndex } = params;
   const currentIndex = nextIndex();
   const suiteRunNonce = typeof options.suiteRunId === "string" ? options.suiteRunId : "";
-  const filePath = node.kind === "group" ? bundle.rootSuitePath : resolveRelativeTo(node.path, bundle.rootSuitePath);
+  const filePath = node.kind === "group" ? bundle.rootSuitePath : resolveSuitePath(node.path, bundle.rootSuitePath, options);
   const title = node.kind === "group" ? typeof node.label === "string" && node.label.trim() ? node.label.trim() : node.id : typeof node.title === "string" && node.title.trim() ? node.title.trim() : basename3(filePath || node.path);
   const runId = `suite:${sanitizeIdentifier(bundle.rootSuitePath)}:${suiteRunNonce}:${currentIndex}:${sanitizeIdentifier(node.id)}`;
   options.reporter && options.reporter({
@@ -77288,7 +78072,7 @@ async function runSuiteBundleNode(params) {
     return reportSkippedBundleNode({ node, bundle, options, nextIndex });
   }
   const currentIndex = nextIndex();
-  const childFilePath = resolveRelativeTo(node.path, bundle.rootSuitePath);
+  const childFilePath = resolveSuitePath(node.path, bundle.rootSuitePath, options);
   const nodeTitle = typeof node.title === "string" && node.title.trim() ? node.title.trim() : void 0;
   const display = nodeTitle || basename3(childFilePath || node.path);
   const suiteRunNonce = typeof options.suiteRunId === "string" ? options.suiteRunId : "";
@@ -77309,11 +78093,11 @@ async function runSuiteBundleNode(params) {
     const childDocType = detectDocType(childFilePath, childRawText);
     childLogger("debug", `Running suite item: ${display}`);
     const childFileLoader = async (requestedPath) => {
-      const resolved = resolveRelativeTo(requestedPath, childFilePath);
+      const resolved = resolveSuitePath(requestedPath, childFilePath, options);
       return await baseFileLoader(resolved);
     };
     const childBinaryFileLoader = options.binaryFileLoader ? async (requestedPath) => {
-      const resolved = resolveRelativeTo(requestedPath, childFilePath);
+      const resolved = resolveSuitePath(requestedPath, childFilePath, options);
       return await options.binaryFileLoader(resolved);
     } : void 0;
     options.reporter && options.reporter({
@@ -77468,7 +78252,7 @@ async function runSuiteGroup(params) {
         statuses: serverStatuses
       };
     }
-    const nestedPath = resolveRelativeTo(child.path, bundle.rootSuitePath) || child.path;
+    const nestedPath = resolveSuitePath(child.path, bundle.rootSuitePath, options) || child.path;
     const started = await startListedServers({
       servers: child.servers,
       baseFilePath: nestedPath,
@@ -77561,7 +78345,7 @@ async function runSuiteGroup(params) {
 }
 async function startServerNode(params) {
   const { node, bundle, options, suiteLogger } = params;
-  const serverFilePath = resolveRelativeTo(node.path, bundle.rootSuitePath);
+  const serverFilePath = resolveSuitePath(node.path, bundle.rootSuitePath, options);
   const display = basename3(serverFilePath || node.path);
   if (!options.serverRunner) {
     suiteLogger("error", `Cannot start server '${node.path}': no server runner provided`);
@@ -77740,7 +78524,7 @@ async function executeSuiteBundle(params) {
         const suiteRunNonce = typeof effectiveOptions.suiteRunId === "string" ? effectiveOptions.suiteRunId : "";
         const targetRunId = `suite:${sanitizeIdentifier(bundle.rootSuitePath)}:${suiteRunNonce}:target:${sanitizeIdentifier(root.id)}`;
         const targetTitle = root.kind === "suite" ? typeof root.title === "string" && root.title.trim() ? root.title.trim() : basename3(root.path) : typeof root.label === "string" && root.label.trim() ? root.label.trim() : root.id;
-        const targetFilePath = root.kind === "suite" ? resolveRelativeTo(root.path, bundle.rootSuitePath) : bundle.rootSuitePath;
+        const targetFilePath = root.kind === "suite" ? resolveSuitePath(root.path, bundle.rootSuitePath, effectiveOptions) : bundle.rootSuitePath;
         const targetEntry = root.kind === "suite" ? root.path : root.label;
         effectiveOptions.reporter && effectiveOptions.reporter({
           scope: "suite-item",
@@ -78345,7 +79129,7 @@ function optionalTags(tags) {
   return out.length ? out : void 0;
 }
 async function buildSuiteHierarchyFromSuiteFile(params) {
-  const { suiteFilePath, suiteRawText, fileLoader, leafPrefix } = params;
+  const { suiteFilePath, suiteRawText, fileLoader, leafPrefix, projectRoot } = params;
   const convertSuiteToHierarchy = async (targetFilePath, rawText, indexPath, ancestors) => {
     const suiteDoc = yamlToSuite(rawText);
     const nextAncestors = new Set(ancestors);
@@ -78423,7 +79207,7 @@ async function buildSuiteHierarchyFromSuiteFile(params) {
     if (!trimmed || trimmed === "then") {
       return null;
     }
-    const resolvedPath = resolveRelativeTo(trimmed, ownerFilePath) || trimmed;
+    const resolvedPath = resolveRelativeTo(trimmed, ownerFilePath, projectRoot) || trimmed;
     let raw = "";
     try {
       raw = await fileLoader(resolvedPath);
@@ -78700,7 +79484,7 @@ async function executeTest(prepared, options, preLogs) {
     prepared.filePath ? prepared.filePath.split(/[/\\]/).slice(0, -1).join("/") : void 0,
     options.__mmtIsSuiteBundleChildRun === true,
     void 0,
-    void 0,
+    options.checkLogMode,
     "Test",
     options.binaryFileLoader
   );
@@ -78892,7 +79676,7 @@ async function executeLoadTestBody(prepared, options, preLogs, runFile2) {
   const envVars = prepared.envVarsUsed || options.envvar || {};
   const displayName = prepared.title || prepared.baseName;
   const identifier = sanitizeIdentifier(displayName);
-  const childFilePath = resolveRelativeTo(loadtest.test, prepared.filePath);
+  const childFilePath = resolveRelativeTo(loadtest.test, prepared.filePath, options.projectRoot);
   const childDisplayName = basename3(childFilePath || loadtest.test);
   const threads = Math.max(1, Math.floor(loadtest.threads || 1));
   const repeatIterations = parsePositiveInteger(loadtest.repeat);
@@ -79077,7 +79861,7 @@ async function executeLoadTestBody(prepared, options, preLogs, runFile2) {
     throw new Error(`Failed to load loadtest target ${loadtest.test}: ${e?.message || String(e)}`);
   }
   const childFileLoader = async (requestedPath) => {
-    const resolved = resolveRelativeTo(requestedPath, childFilePath);
+    const resolved = resolveRelativeTo(requestedPath, childFilePath, options.projectRoot);
     return await options.fileLoader(resolved);
   };
   try {
@@ -79143,7 +79927,7 @@ async function executeLoadTestBody(prepared, options, preLogs, runFile2) {
     };
     try {
       const childBinaryFileLoader = options.binaryFileLoader ? async (requestedPath) => {
-        const resolved = resolveRelativeTo(requestedPath, childFilePath);
+        const resolved = resolveRelativeTo(requestedPath, childFilePath, options.projectRoot);
         return await options.binaryFileLoader(resolved);
       } : void 0;
       const childResult = await runGeneratedJs(
@@ -79362,6 +80146,13 @@ async function prepareRunFromOptions(options, log = () => {
 async function runFile(options) {
   resetCurrentTokenCache();
   resetRandomTokenCache();
+  if (!options.__mmtIsSuiteBundleChildRun) {
+    const cache = getRunFileCache();
+    await cache.beginRun(options.fileStamp);
+    if (typeof options.fileLoader === "function") {
+      options = { ...options, fileLoader: cache.wrap(options.fileLoader) };
+    }
+  }
   const preLogs = [];
   const note = (level, message) => {
     preLogs.push({ level, message });
@@ -79406,7 +80197,8 @@ async function runFile(options) {
       const tree = await buildSuiteHierarchyFromSuiteFile({
         suiteFilePath: prepared.filePath,
         suiteRawText: prepared.rawText,
-        fileLoader: options.fileLoader
+        fileLoader: options.fileLoader,
+        projectRoot: options.projectRoot
       });
       bundle = createSuiteBundle({
         rootSuitePath: prepared.filePath,
@@ -80144,7 +80936,7 @@ var mmtReport_exports = {};
 __export(mmtReport_exports, {
   generateMmtReport: () => generateMmtReport
 });
-var import_yaml2 = __toESM(require("yaml"));
+var import_yaml3 = __toESM(require("yaml"));
 init_CommonData();
 function displayValue3(v) {
   if (v === null || v === void 0) {
@@ -80325,7 +81117,7 @@ function generateMmtReport(results, options) {
   if (!isLoad) {
     report.checks = runs.map(buildCheckEntry);
   }
-  return import_yaml2.default.stringify(report, { lineWidth: 0 });
+  return import_yaml3.default.stringify(report, { lineWidth: 0 });
 }
 
 // ../core/src/reportHtml.ts
@@ -81355,7 +82147,7 @@ __export(reportMarkdown_exports, {
 init_CommonData();
 init_markupConvertor();
 init_omitKeyword();
-function headerValue(headers, name) {
+function headerValue2(headers, name) {
   if (!headers) {
     return void 0;
   }
@@ -81368,7 +82160,7 @@ function headerValue(headers, name) {
   return void 0;
 }
 function detectBodyFormat(body, headers) {
-  const contentType = (headerValue(headers, "content-type") || "").toLowerCase();
+  const contentType = (headerValue2(headers, "content-type") || "").toLowerCase();
   if (contentType.includes("json")) {
     return "json";
   }
@@ -81420,7 +82212,7 @@ function formatBodyValue(value, headers) {
     }
   }
   const format = detectBodyFormat(value, headers);
-  const contentType = headerValue(headers, "content-type") || "";
+  const contentType = headerValue2(headers, "content-type") || "";
   if (format === "urlencoded") {
     try {
       return { text: prettyUrlEncoded(value), format };
@@ -82862,21 +83654,21 @@ async function buildCliRunArgs(file, opts) {
     envvar = mergeEnv2({ envvar: void 0, manualEnvvars });
   }
   if (suiteEnvConfig) {
-    const projectRoot = findProjectRootForCli(full);
+    const projectRoot2 = findProjectRootForCli(full);
     let suitePresetEnv = {};
     if (suiteEnvConfig.preset) {
       let suiteEnvFilePath;
       if (suiteEnvConfig.file) {
         if (suiteEnvConfig.file.startsWith("+/")) {
-          suiteEnvFilePath = projectRoot ? import_path2.default.join(projectRoot, suiteEnvConfig.file.slice(2)) : void 0;
+          suiteEnvFilePath = projectRoot2 ? import_path2.default.join(projectRoot2, suiteEnvConfig.file.slice(2)) : void 0;
         } else {
           suiteEnvFilePath = import_path2.default.resolve(dir, suiteEnvConfig.file);
         }
-      } else if (projectRoot) {
-        suiteEnvFilePath = import_path2.default.join(projectRoot, "multimeter.mmt");
+      } else if (projectRoot2) {
+        suiteEnvFilePath = import_path2.default.join(projectRoot2, "multimeter.mmt");
       }
       if (suiteEnvFilePath && import_fs2.default.existsSync(suiteEnvFilePath)) {
-        const suiteEnvDoc = await loadEnvDoc(suiteEnvFilePath, projectRoot || void 0);
+        const suiteEnvDoc = await loadEnvDoc(suiteEnvFilePath, projectRoot2 || void 0);
         suitePresetEnv = resolvePresetsEnv2(suiteEnvDoc, suiteEnvConfig.preset);
       }
     }
@@ -82887,6 +83679,13 @@ async function buildCliRunArgs(file, opts) {
     const suiteVariables = suiteEnvConfig.variables ? { ...suiteEnvConfig.variables } : {};
     envvar = { ...baseEnv, ...suitePresetEnv, ...suiteVariables, ...manualEnvvars };
   }
+  const projectRoot = findProjectRootForCli(full);
+  const resolveCliFilePath = (requested) => {
+    if (isProjectRootImport(requested) && projectRoot) {
+      return resolveProjectRootImport(requested, projectRoot);
+    }
+    return (0, import_pathNormalize.resolveUserPath)(requested, dir, import_path2.default);
+  };
   const runFileOptions = {
     file: rawText,
     fileType: "raw",
@@ -82897,14 +83696,23 @@ async function buildCliRunArgs(file, opts) {
     envvar,
     manualEnvvars,
     fileLoader: async (p) => {
-      const rel = (0, import_pathNormalize.resolveUserPath)(p, dir, import_path2.default);
+      const rel = resolveCliFilePath(p);
       if (!import_fs2.default.existsSync(rel)) {
         return "";
       }
       return import_fs2.default.readFileSync(rel, "utf8");
     },
+    fileStamp: async (p) => {
+      const rel = resolveCliFilePath(p);
+      try {
+        const st = import_fs2.default.statSync(rel);
+        return `${st.size}:${st.mtimeMs}`;
+      } catch {
+        return "missing";
+      }
+    },
     binaryFileLoader: async (p) => {
-      const rel = (0, import_pathNormalize.resolveUserPath)(p, dir, import_path2.default);
+      const rel = resolveCliFilePath(p);
       return import_fs2.default.promises.readFile(rel);
     },
     jsRunner: async () => {
@@ -82918,7 +83726,8 @@ async function buildCliRunArgs(file, opts) {
     },
     reporter: (_message) => {
     },
-    projectRoot: findProjectRootForCli(full)
+    projectRoot,
+    checkLogMode: opts.quiet ? "none" : "default"
   };
   const onlyTags = Array.isArray(opts.tag) ? opts.tag : [];
   const skipTags = Array.isArray(opts.skipTag) ? opts.skipTag : [];
@@ -84235,8 +85044,8 @@ utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
   let mapped = key[0].toUpperCase() + key.slice(1);
   return {
     get: () => value,
-    set(headerValue2) {
-      this[mapped] = headerValue2;
+    set(headerValue3) {
+      this[mapped] = headerValue3;
     }
   };
 });