norn-cli 2.4.0 → 2.6.0

package/dist/cli.js

@@ -101832,6 +101832,123 @@ var path19 = __toESM(require("path"));
 // src/parser.ts
 var path = __toESM(require("path"));
 
+// src/quotedString.ts
+function decodeQuotedStringLiteral(literal2) {
+  if (isVerbatimStringLiteral(literal2)) {
+    return decodeVerbatimStringLiteral(literal2);
+  }
+  if (!isQuotedStringLiteral(literal2)) {
+    return literal2;
+  }
+  const quoteChar = literal2[0];
+  const inner = literal2.slice(1, -1);
+  let decoded = "";
+  for (let i = 0; i < inner.length; i++) {
+    const char = inner[i];
+    if (char !== "\\" || i === inner.length - 1) {
+      decoded += char;
+      continue;
+    }
+    const nextChar = inner[i + 1];
+    if (nextChar === "\\" || nextChar === quoteChar) {
+      decoded += nextChar;
+      i++;
+      continue;
+    }
+    decoded += char;
+  }
+  return decoded;
+}
+function isQuotedStringLiteral(literal2) {
+  if (isVerbatimStringLiteral(literal2)) {
+    return true;
+  }
+  if (literal2.length < 2) {
+    return false;
+  }
+  const quoteChar = literal2[0];
+  return (quoteChar === '"' || quoteChar === "'") && literal2[literal2.length - 1] === quoteChar;
+}
+function isVerbatimStringLiteral(literal2) {
+  return literal2.length >= 3 && literal2.startsWith('@"') && literal2.endsWith('"');
+}
+function mapOutsideVerbatimStrings(text, transform2) {
+  let output2 = "";
+  let segmentStart = 0;
+  let inStandardQuote = false;
+  let standardQuoteChar = "";
+  let escapeNext = false;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const nextChar = i + 1 < text.length ? text[i + 1] : "";
+    if (inStandardQuote) {
+      if (escapeNext) {
+        escapeNext = false;
+        continue;
+      }
+      if (char === "\\") {
+        escapeNext = true;
+        continue;
+      }
+      if (char === standardQuoteChar) {
+        inStandardQuote = false;
+        standardQuoteChar = "";
+      }
+      continue;
+    }
+    if (char === "@" && nextChar === '"') {
+      const end = findVerbatimStringEnd(text, i);
+      output2 += transform2(text.substring(segmentStart, i));
+      output2 += text.substring(i, end);
+      segmentStart = end;
+      i = end - 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inStandardQuote = true;
+      standardQuoteChar = char;
+      escapeNext = false;
+    }
+  }
+  output2 += transform2(text.substring(segmentStart));
+  return output2;
+}
+function findVerbatimStringEnd(text, start) {
+  let i = start + 2;
+  while (i < text.length) {
+    const char = text[i];
+    const nextChar = i + 1 < text.length ? text[i + 1] : "";
+    if (char === '"' && nextChar === '"') {
+      i += 2;
+      continue;
+    }
+    if (char === '"' && isLikelyVerbatimStringTerminator(text, i)) {
+      return i + 1;
+    }
+    i++;
+  }
+  return text.length;
+}
+function isLikelyVerbatimStringTerminator(text, quoteIndex) {
+  const remainder = text.substring(quoteIndex + 1).trimStart();
+  return remainder === "" || remainder.startsWith("|") || remainder.startsWith("#") || remainder.startsWith(",") || remainder.startsWith(")") || remainder.startsWith("]") || remainder.startsWith("}");
+}
+function decodeVerbatimStringLiteral(literal2) {
+  const inner = literal2.slice(2, -1);
+  let decoded = "";
+  for (let i = 0; i < inner.length; i++) {
+    const char = inner[i];
+    const nextChar = i + 1 < inner.length ? inner[i + 1] : "";
+    if (char === '"' && nextChar === '"') {
+      decoded += '"';
+      i++;
+      continue;
+    }
+    decoded += char;
+  }
+  return decoded;
+}
+
 // src/nornapiParser.ts
 function extractPathParameters(path20) {
   const params = [];
@@ -102003,8 +102120,8 @@ function parseApiRequest(requestContent, endpoints, headerGroups) {
     const headerMatch = line2.match(/^([a-zA-Z][a-zA-Z0-9\-]*)\s*:\s*(.+)$/);
     if (headerMatch) {
       let headerValue = headerMatch[2].trim();
-      if (headerValue.startsWith('"') && headerValue.endsWith('"') || headerValue.startsWith("'") && headerValue.endsWith("'")) {
-        headerValue = headerValue.slice(1, -1);
+      if (isQuotedStringLiteral(headerValue)) {
+        headerValue = decodeQuotedStringLiteral(headerValue);
       }
       inlineHeaders[headerMatch[1]] = headerValue;
       continue;
@@ -102049,8 +102166,8 @@ function parseParamTokens(paramsStr) {
   return tokens;
 }
 function unquote(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
+  if (isQuotedStringLiteral(value)) {
+    return decodeQuotedStringLiteral(value);
   }
   return value;
 }
@@ -102367,14 +102484,21 @@ function getNestedPathValue(obj, path20) {
 function stripInlineComment(line2) {
   let inSingleQuote = false;
   let inDoubleQuote = false;
+  let inVerbatimString = false;
   for (let index = 0; index < line2.length; index++) {
     const char = line2[index];
     const previousChar = index > 0 ? line2[index - 1] : "";
-    if (previousChar === "\\") {
+    const nextChar = index + 1 < line2.length ? line2[index + 1] : "";
+    if (inDoubleQuote && inVerbatimString && char === '"' && nextChar === '"') {
+      index++;
+      continue;
+    }
+    if (!inVerbatimString && previousChar === "\\") {
       continue;
     }
     if (char === '"' && !inSingleQuote) {
       inDoubleQuote = !inDoubleQuote;
+      inVerbatimString = inDoubleQuote && previousChar === "@";
     } else if (char === "'" && !inDoubleQuote) {
       inSingleQuote = !inSingleQuote;
     } else if (char === "#" && !inSingleQuote && !inDoubleQuote) {
@@ -102491,8 +102615,8 @@ function extractFileLevelVariables(text) {
         if (isRuntimeComputedVariableValue(value)) {
           continue;
         }
-        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-          value = value.slice(1, -1);
+        if (isQuotedStringLiteral(value)) {
+          value = decodeQuotedStringLiteral(value);
         }
         variables[match[1]] = value;
       }
@@ -102598,8 +102722,8 @@ function parserHttpRequest(text, variables = {}) {
   requestLine = cleanedLine;
   const [method, ...urlParts] = requestLine.split(" ");
   let url3 = urlParts.join(" ");
-  if (url3.startsWith('"') && url3.endsWith('"') || url3.startsWith("'") && url3.endsWith("'")) {
-    url3 = url3.slice(1, -1);
+  if (isQuotedStringLiteral(url3)) {
+    url3 = decodeQuotedStringLiteral(url3);
   }
   const headers = {};
   let bodyStartIndex = -1;
@@ -108714,12 +108838,46 @@ function isNornError(error2) {
 
 // src/httpRuntimeOptions.ts
 var verifyTlsCertificates = true;
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
 function setVerifyTlsCertificates(enabled) {
   verifyTlsCertificates = enabled;
 }
 function getVerifyTlsCertificates() {
   return verifyTlsCertificates;
 }
+function setRequestTimeoutMs(timeoutMs) {
+  if (timeoutMs === void 0) {
+    requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+    return;
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error(`Request timeout must be greater than 0 ms.`);
+  }
+  requestTimeoutMs = Math.ceil(timeoutMs);
+}
+function getRequestTimeoutMs() {
+  return requestTimeoutMs;
+}
+function parseDurationToMs(rawValue, defaultUnit = "ms") {
+  const trimmed = rawValue.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(ms|milliseconds?|s|sec|secs|seconds?|m|min|mins|minutes?)?$/);
+  if (!match) {
+    return void 0;
+  }
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return void 0;
+  }
+  const unit = match[2] ?? defaultUnit;
+  if (unit === "ms" || unit === "millisecond" || unit === "milliseconds") {
+    return Math.ceil(amount);
+  }
+  if (unit === "m" || unit === "min" || unit === "mins" || unit === "minute" || unit === "minutes") {
+    return Math.ceil(amount * 6e4);
+  }
+  return Math.ceil(amount * 1e3);
+}
 
 // src/formUrlEncoded.ts
 function parseEqualsField(segment) {
@@ -108910,7 +109068,7 @@ async function sendRequestWithJar(request, jar, retryOptions) {
           adapter: "http",
           headers,
           data,
-          timeout: 3e4,
+          timeout: getRequestTimeoutMs(),
           maxRedirects: 0,
           validateStatus: () => true,
           httpsAgent: getHttpsAgent()
@@ -109661,34 +109819,6 @@ function validateAgainstSchemaObjectDetailed(value, schema) {
   }
 }
 
-// src/quotedString.ts
-function decodeQuotedStringLiteral(literal2) {
-  if (literal2.length < 2) {
-    return literal2;
-  }
-  const quoteChar = literal2[0];
-  if (quoteChar !== '"' && quoteChar !== "'" || literal2[literal2.length - 1] !== quoteChar) {
-    return literal2;
-  }
-  const inner = literal2.slice(1, -1);
-  let decoded = "";
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i];
-    if (char !== "\\" || i === inner.length - 1) {
-      decoded += char;
-      continue;
-    }
-    const nextChar = inner[i + 1];
-    if (nextChar === "\\" || nextChar === quoteChar) {
-      decoded += nextChar;
-      i++;
-      continue;
-    }
-    decoded += char;
-  }
-  return decoded;
-}
-
 // src/assertionRunner.ts
 function isAssertCommand(line2) {
   return /^assert\s+/i.test(line2.trim());
@@ -109704,17 +109834,25 @@ function parseAssertCommand(line2) {
   const pipeIndex = findUnquotedPipe(content);
   if (pipeIndex !== -1) {
     message = content.substring(pipeIndex + 1).trim();
-    if (message.startsWith('"') && message.endsWith('"') || message.startsWith("'") && message.endsWith("'")) {
+    if (isQuotedStringLiteral(message)) {
+      const messageWasVerbatim = isVerbatimStringLiteral(message);
       message = decodeQuotedStringLiteral(message);
+      if (messageWasVerbatim) {
+        return parseAssertContent(content.substring(0, pipeIndex).trim(), message, true);
+      }
     }
     content = content.substring(0, pipeIndex).trim();
   }
+  return parseAssertContent(content, message, false);
+}
+function parseAssertContent(content, message, messageIsVerbatim) {
   const existsMatch = content.match(/^(.+?)\s+(exists|!exists)$/i);
   if (existsMatch) {
     return {
       leftExpr: existsMatch[1].trim(),
       operator: existsMatch[2].toLowerCase(),
-      message
+      message,
+      messageIsVerbatim
     };
   }
   const binaryOperators = [
@@ -109722,14 +109860,14 @@ function parseAssertCommand(line2) {
     { pattern: /^(.+?)\s*<=\s*(.+)$/, op: "<=" },
     { pattern: /^(.+?)\s*==\s*(.+)$/, op: "==" },
     { pattern: /^(.+?)\s*!=\s*(.+)$/, op: "!=" },
-    { pattern: /^(.+?)\s*>\s*(.+)$/, op: ">" },
-    { pattern: /^(.+?)\s*<\s*(.+)$/, op: "<" },
     { pattern: /^(.+?)\s+contains\s+(.+)$/i, op: "contains" },
     { pattern: /^(.+?)\s+startsWith\s+(.+)$/i, op: "startsWith" },
     { pattern: /^(.+?)\s+endsWith\s+(.+)$/i, op: "endsWith" },
-    { pattern: /^(.+?)\s+matches\s+(.+)$/i, op: "matches" },
     { pattern: /^(.+?)\s+matchesSchema\s+(.+)$/i, op: "matchesSchema" },
-    { pattern: /^(.+?)\s+isType\s+(.+)$/i, op: "isType" }
+    { pattern: /^(.+?)\s+matches\s+(.+)$/i, op: "matches" },
+    { pattern: /^(.+?)\s+isType\s+(.+)$/i, op: "isType" },
+    { pattern: /^(.+?)\s*>\s*(.+)$/, op: ">" },
+    { pattern: /^(.+?)\s*<\s*(.+)$/, op: "<" }
   ];
   for (const { pattern, op } of binaryOperators) {
     const binaryMatch = content.match(pattern);
@@ -109738,7 +109876,8 @@ function parseAssertCommand(line2) {
         leftExpr: binaryMatch[1].trim(),
         operator: op,
         rightExpr: binaryMatch[2].trim(),
-        message
+        message,
+        messageIsVerbatim
       };
     }
   }
@@ -109748,28 +109887,44 @@ function findUnquotedPipe(str) {
   let inQuote = false;
   let quoteChar = "";
   let escapeNext = false;
+  let inVerbatimString = false;
   for (let i = 0; i < str.length; i++) {
     const char = str[i];
+    if (inQuote && inVerbatimString && char === '"') {
+      if (str[i + 1] === '"') {
+        i++;
+        continue;
+      }
+      if (!isVerbatimAssertionStringTerminator(str, i)) {
+        continue;
+      }
+    }
     if (escapeNext) {
       escapeNext = false;
       continue;
     }
-    if (inQuote && char === "\\") {
+    if (inQuote && !inVerbatimString && char === "\\") {
       escapeNext = true;
       continue;
     }
     if ((char === '"' || char === "'") && !inQuote) {
       inQuote = true;
       quoteChar = char;
+      inVerbatimString = char === '"' && i > 0 && str[i - 1] === "@";
     } else if (char === quoteChar && inQuote) {
       inQuote = false;
       quoteChar = "";
+      inVerbatimString = false;
     } else if (char === "|" && !inQuote) {
       return i;
     }
   }
   return -1;
 }
+function isVerbatimAssertionStringTerminator(str, quoteIndex) {
+  const remainder = str.substring(quoteIndex + 1).trimStart();
+  return remainder === "" || remainder.startsWith("|");
+}
 function resolveValue(expr, responses, variables, getValueByPath2, responseIndexToVariable) {
   const trimmed = expr.trim();
   const wrappedResponseRefMatch = trimmed.match(/^\{\{(\$\d+(?:\..+)?)\}\}$/);
@@ -109875,8 +110030,9 @@ function resolveValue(expr, responses, variables, getValueByPath2, responseIndex
     }
     return { value: void 0, error: `Variable {{${varName}}} is not defined` };
   }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return { value: substituteVariables(decodeQuotedStringLiteral(trimmed), variables) };
+  if (isQuotedStringLiteral(trimmed)) {
+    const decoded = decodeQuotedStringLiteral(trimmed);
+    return { value: isVerbatimStringLiteral(trimmed) ? decoded : substituteVariables(decoded, variables) };
   }
   if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
     return { value: parseFloat(trimmed) };
@@ -109949,7 +110105,7 @@ function areValuesEqual(leftValue, rightValue) {
 }
 function evaluateAssertion(assertion, responses, variables, getValueByPath2, responseIndexToVariable, basePath) {
   const leftResult = resolveValue(assertion.leftExpr, responses, variables, getValueByPath2, responseIndexToVariable);
-  const message = assertion.message === void 0 ? void 0 : substituteVariables(assertion.message, variables);
+  const message = assertion.message === void 0 ? void 0 : assertion.messageIsVerbatim ? assertion.message : substituteVariables(assertion.message, variables);
   const expression = formatExpression(assertion, variables);
   const buildFailureContext = () => ({
     responseIndex: leftResult.responseIndex,
@@ -110032,10 +110188,14 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2, res
   }
   if (assertion.operator === "matchesSchema") {
     let schemaPath = assertion.rightExpr;
-    if (schemaPath.startsWith('"') && schemaPath.endsWith('"') || schemaPath.startsWith("'") && schemaPath.endsWith("'")) {
-      schemaPath = schemaPath.slice(1, -1);
+    let schemaPathIsVerbatim = false;
+    if (isQuotedStringLiteral(schemaPath)) {
+      schemaPathIsVerbatim = isVerbatimStringLiteral(schemaPath);
+      schemaPath = decodeQuotedStringLiteral(schemaPath);
+    }
+    if (!schemaPathIsVerbatim) {
+      schemaPath = substituteVariables(schemaPath, variables);
     }
-    schemaPath = substituteVariables(schemaPath, variables);
     const validationResult = validateAgainstSchemaDetailed(leftValue, schemaPath, basePath);
     const passed2 = validationResult.valid;
     return {
@@ -110102,15 +110262,8 @@ function evaluateAssertion(assertion, responses, variables, getValueByPath2, res
       break;
     case "matches":
       try {
-        let pattern = String(rightValue);
-        if (pattern.startsWith("/") && pattern.lastIndexOf("/") > 0) {
-          const lastSlash = pattern.lastIndexOf("/");
-          const flags = pattern.substring(lastSlash + 1);
-          pattern = pattern.substring(1, lastSlash);
-          passed = new RegExp(pattern, flags).test(String(leftValue));
-        } else {
-          passed = new RegExp(pattern).test(String(leftValue));
-        }
+        const pattern = String(rightValue);
+        passed = new RegExp(pattern).test(String(leftValue));
       } catch (e) {
         return {
           passed: false,
@@ -110146,7 +110299,7 @@ function formatExpression(assertion, variables) {
   return substituteAssertionDisplayTemplates(`${assertion.leftExpr} ${assertion.operator}`, variables);
 }
 function substituteAssertionDisplayTemplates(expression, variables) {
-  return variables ? substituteVariables(expression, variables) : expression;
+  return variables ? mapOutsideVerbatimStrings(expression, (segment) => substituteVariables(segment, variables)) : expression;
 }
 
 // src/jsonFileReader.ts
@@ -110163,8 +110316,8 @@ function parseJsonCommand(line2) {
     return null;
   }
   let filePath = match[2].trim();
-  if (filePath.startsWith('"') && filePath.endsWith('"') || filePath.startsWith("'") && filePath.endsWith("'")) {
-    filePath = filePath.slice(1, -1);
+  if (isQuotedStringLiteral(filePath)) {
+    filePath = decodeQuotedStringLiteral(filePath);
   }
   return {
     varName: match[1],
@@ -110546,6 +110699,18 @@ function isStringRecord(value) {
 function isKnownSection(value) {
   return value === void 0 || isObjectRecord(value);
 }
+function isNornHttpConfig(value) {
+  if (value === void 0) {
+    return true;
+  }
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  if (value._comment !== void 0 && typeof value._comment !== "string" && (!Array.isArray(value._comment) || !value._comment.every((item) => typeof item === "string"))) {
+    return false;
+  }
+  return value.timeoutMs === void 0 || typeof value.timeoutMs === "number" && Number.isFinite(value.timeoutMs) && value.timeoutMs > 0;
+}
 function isNornProjectConfig(value) {
   if (!isObjectRecord(value)) {
     return false;
@@ -110553,7 +110718,7 @@ function isNornProjectConfig(value) {
   if (value.version !== 1) {
     return false;
   }
-  return isKnownSection(value.sql) && isKnownSection(value.mcp);
+  return isNornHttpConfig(value.http) && isKnownSection(value.sql) && isKnownSection(value.mcp);
 }
 function loadNornConfig(startPath) {
   const filePath = findNearestConfigFile(startPath, NORN_CONFIG_FILENAME);
@@ -128016,7 +128181,7 @@ function parseRunArguments(argsStr) {
   if (!argsStr || !argsStr.trim()) {
     return args;
   }
-  const parts = argsStr.split(/,(?=(?:[^"]*"[^"]*")*(?:[^{]*\{\{[^}]*\}\})*[^"]*$)/);
+  const parts = splitNamedArgumentList(argsStr);
   for (const part of parts) {
     const trimmed = part.trim();
     if (!trimmed) {
@@ -128025,7 +128190,7 @@ function parseRunArguments(argsStr) {
     const namedMatch = trimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
     if (namedMatch) {
       let value = namedMatch[2].trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      if (isQuotedStringLiteral(value)) {
         value = decodeQuotedStringLiteral(value);
       }
       args.push({
@@ -128034,7 +128199,7 @@ function parseRunArguments(argsStr) {
       });
     } else {
       let value = trimmed;
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      if (isQuotedStringLiteral(value)) {
         value = decodeQuotedStringLiteral(value);
       }
       args.push({ value });
@@ -128046,6 +128211,7 @@ function splitNamedArgumentList(argsStr) {
   const parts = [];
   let current = "";
   let quoteChar = null;
+  let inVerbatimString = false;
   let templateDepth = 0;
   let bracketDepth = 0;
   for (let i = 0; i < argsStr.length; i++) {
@@ -128054,13 +128220,20 @@ function splitNamedArgumentList(argsStr) {
     const prev = i > 0 ? argsStr[i - 1] : "";
     if (quoteChar) {
       current += char;
+      if (inVerbatimString && char === '"' && next === '"') {
+        current += next;
+        i++;
+        continue;
+      }
       if (char === quoteChar && prev !== "\\") {
         quoteChar = null;
+        inVerbatimString = false;
       }
       continue;
     }
     if (char === '"' || char === "'") {
       quoteChar = char;
+      inVerbatimString = char === '"' && prev === "@";
       current += char;
       continue;
     }
@@ -128520,7 +128693,7 @@ function parseSequenceParameters(line2) {
   if (!paramsStr) {
     return params;
   }
-  const paramParts = paramsStr.split(/,(?=(?:[^"]*"[^"]*")*[^"]*$)/);
+  const paramParts = splitNamedArgumentList(paramsStr);
   let hasSeenDefault = false;
   for (const part of paramParts) {
     const trimmed = part.trim();
@@ -128531,7 +128704,7 @@ function parseSequenceParameters(line2) {
     if (defaultMatch) {
       hasSeenDefault = true;
       let defaultValue = defaultMatch[2].trim();
-      if (defaultValue.startsWith('"') && defaultValue.endsWith('"') || defaultValue.startsWith("'") && defaultValue.endsWith("'")) {
+      if (isQuotedStringLiteral(defaultValue)) {
         defaultValue = decodeQuotedStringLiteral(defaultValue);
       }
       params.push({
@@ -128608,14 +128781,21 @@ function parseDataValues(valuesStr) {
   const values = [];
   let current = "";
   let inQuote = null;
+  let inVerbatimString = false;
   let i = 0;
   while (i < valuesStr.length) {
     const char = valuesStr[i];
     if (inQuote) {
+      if (inVerbatimString && char === '"' && valuesStr[i + 1] === '"') {
+        current += '""';
+        i += 2;
+        continue;
+      }
       if (char === inQuote) {
-        values.push(current);
+        values.push(inVerbatimString ? decodeQuotedStringLiteral(`@"${current}"`) : current);
         current = "";
         inQuote = null;
+        inVerbatimString = false;
         i++;
         while (i < valuesStr.length && valuesStr[i] !== ",") {
           i++;
@@ -128626,8 +128806,15 @@ function parseDataValues(valuesStr) {
         current += char;
       }
     } else {
-      if (char === '"' || char === "'") {
+      if (char === "@" && valuesStr[i + 1] === '"') {
+        inQuote = '"';
+        inVerbatimString = true;
+        current = "";
+        i += 2;
+        continue;
+      } else if (char === '"' || char === "'") {
         inQuote = char;
+        inVerbatimString = false;
         current = "";
       } else if (char === ",") {
         const trimmed = current.trim();
@@ -128664,7 +128851,7 @@ function parseTypedValue(value) {
   if (/^-?\d+(\.\d+)?$/.test(value)) {
     return parseFloat(value);
   }
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+  if (isQuotedStringLiteral(value)) {
     return decodeQuotedStringLiteral(value);
   }
   return value;
@@ -128790,9 +128977,9 @@ function parseVarAssignCommand(line2) {
 }
 function evaluateValueExpression(expr, runtimeVariables) {
   const trimmed = expr.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+  if (isQuotedStringLiteral(trimmed)) {
     const inner = decodeQuotedStringLiteral(trimmed);
-    const substituted = substituteVariables(inner, runtimeVariables);
+    const substituted = isVerbatimStringLiteral(trimmed) ? inner : substituteVariables(inner, runtimeVariables);
     return { value: substituted };
   }
   if (trimmed === "true" || trimmed === "false" || trimmed === "null") {
@@ -128840,9 +129027,9 @@ function evaluateSqlArgumentExpression(expr, runtimeVariables) {
   if (!trimmed) {
     return { value: "" };
   }
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+  if (isQuotedStringLiteral(trimmed)) {
     const inner = decodeQuotedStringLiteral(trimmed);
-    return { value: substituteVariables(inner, runtimeVariables) };
+    return { value: isVerbatimStringLiteral(trimmed) ? inner : substituteVariables(inner, runtimeVariables) };
   }
   if (trimmed.startsWith("{{") && trimmed.endsWith("}}")) {
     return evaluateSqlArgumentExpression(trimmed.slice(2, -2).trim(), runtimeVariables);
@@ -128952,7 +129139,7 @@ function resolveBareVariables(text, variables) {
     const parts = splitExpressionParts(text);
     const resolvedParts = parts.map((part) => {
       const partTrimmed = part.trim();
-      if (partTrimmed.startsWith('"') && partTrimmed.endsWith('"') || partTrimmed.startsWith("'") && partTrimmed.endsWith("'")) {
+      if (isQuotedStringLiteral(partTrimmed)) {
         return decodeQuotedStringLiteral(partTrimmed);
       }
       const varMatch = partTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
@@ -128980,6 +129167,7 @@ function splitExpressionParts(expr) {
   let inString = false;
   let stringChar = "";
   let escapeNext = false;
+  let inVerbatimString = false;
   for (let i = 0; i < expr.length; i++) {
     const char = expr[i];
     if (escapeNext) {
@@ -128987,7 +129175,12 @@ function splitExpressionParts(expr) {
       escapeNext = false;
       continue;
     }
-    if (inString && char === "\\") {
+    if (inString && inVerbatimString && char === '"' && i + 1 < expr.length && expr[i + 1] === '"') {
+      current += char + expr[i + 1];
+      i++;
+      continue;
+    }
+    if (inString && !inVerbatimString && char === "\\") {
       current += char;
       escapeNext = true;
       continue;
@@ -128995,9 +129188,11 @@ function splitExpressionParts(expr) {
     if (!inString && (char === '"' || char === "'")) {
       inString = true;
       stringChar = char;
+      inVerbatimString = char === '"' && i > 0 && expr[i - 1] === "@";
       current += char;
     } else if (inString && char === stringChar) {
       inString = false;
+      inVerbatimString = false;
       current += char;
     } else if (!inString && char === "+") {
       parts.push(current);
@@ -131444,7 +131639,8 @@ function formatAssertion(assertion, options) {
     if (assertion.error) {
       lines.push(`    ${colors.error(`Error: ${assertion.error}`)}`);
     } else if (!assertion.passed) {
-      lines.push(`    ${colors.dim("Expected:")} ${formatValue(assertion.rightExpression ?? assertion.operator)}`);
+      const expectedValue = assertion.rightValue !== void 0 ? assertion.rightValue : assertion.rightExpression ?? assertion.operator;
+      lines.push(`    ${colors.dim("Expected:")} ${formatValue(expectedValue)}`);
       lines.push(`    ${colors.dim("Actual:")} ${formatValue(assertion.leftValue)}`);
       if (verbose && assertion.leftExpression !== String(assertion.leftValue)) {
         lines.push(`    ${colors.dim("Expression:")} ${assertion.leftExpression}`);
@@ -131738,12 +131934,13 @@ function generateTestCase(sequenceName, assertion, redaction) {
   let xml = `    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}">
 `;
   if (!assertion.passed) {
-    const message = assertion.error || `Expected ${assertion.rightExpression || assertion.rightValue}, got ${JSON.stringify(assertion.leftValue)}`;
+    const expectedValue = assertion.rightValue !== void 0 ? assertion.rightValue : assertion.rightExpression;
+    const message = assertion.error || `Expected ${JSON.stringify(expectedValue)}, got ${JSON.stringify(assertion.leftValue)}`;
     xml += `      <failure message="${escapeXml(redactString(message, redaction))}" type="AssertionError">
 `;
     xml += `<![CDATA[Expression: ${assertion.expression}
 `;
-    xml += `Expected: ${JSON.stringify(assertion.rightValue)}
+    xml += `Expected: ${JSON.stringify(expectedValue)}
 `;
     xml += `Actual: ${JSON.stringify(assertion.leftValue)}]]>
 `;
@@ -132115,11 +132312,13 @@ function generateAssertionHtml(step, redaction) {
     } else {
       actualDisplay = String(assertion.leftValue);
     }
+    const expectedValue = assertion.rightValue !== void 0 ? assertion.rightValue : assertion.rightExpression;
+    const expectedDisplay = typeof expectedValue === "object" ? JSON.stringify(expectedValue, null, 2) : String(expectedValue);
     const pathInfo = assertion.jsonPath ? `<div class="assertion-path"><strong>Path:</strong> <code>${escapeHtml(assertion.jsonPath)}</code></div>` : "";
     detailsHtml = `
             <div class="assertion-details">
                 ${pathInfo}
-                <div><strong>Expected:</strong> <code>${escapeHtml(String(assertion.rightExpression || assertion.rightValue))}</code></div>
+                <div><strong>Expected:</strong> <code>${escapeHtml(expectedDisplay)}</code></div>
                 <div><strong>Actual:</strong> <code>${escapeHtml(actualDisplay)}</code></div>
                 ${assertion.error ? `<div class="error"><strong>Error:</strong> ${escapeHtml(redactString(assertion.error, redaction))}</div>` : ""}
             </div>`;
@@ -134058,6 +134257,32 @@ function applyRegionRefactorToText(text, pattern) {
 ` : result;
 }
 
+// src/requestTimeoutConfig.ts
+function getProjectRequestTimeoutMs(startPath) {
+  if (!findNearestConfigFile(startPath, NORN_CONFIG_FILENAME)) {
+    return void 0;
+  }
+  const { config: config2 } = loadNornConfig(startPath);
+  return config2.http?.timeoutMs;
+}
+function resolveRequestTimeoutMs(startPath, overrideMs) {
+  if (overrideMs !== void 0) {
+    return overrideMs;
+  }
+  if (startPath) {
+    const projectTimeoutMs = getProjectRequestTimeoutMs(startPath);
+    if (projectTimeoutMs !== void 0) {
+      return projectTimeoutMs;
+    }
+  }
+  return DEFAULT_REQUEST_TIMEOUT_MS;
+}
+function applyRequestTimeoutForPath(startPath, overrideMs) {
+  const timeoutMs = resolveRequestTimeoutMs(startPath, overrideMs);
+  setRequestTimeoutMs(timeoutMs);
+  return timeoutMs;
+}
+
 // src/cli.ts
 function handleImportResolutionErrors(errors, colors) {
   const { blockingErrors, warningErrors } = splitImportResolutionErrors(errors);
@@ -134146,6 +134371,14 @@ function buildCliEnvironmentValidationContext(resolvedEnv, selectedEnv) {
     availableEnvironments: resolvedEnv.availableEnvironments
   };
 }
+function applyCliRequestTimeout(filePath, options, colors) {
+  try {
+    applyRequestTimeoutForPath(filePath, options.timeoutMs);
+  } catch (error2) {
+    console.error(colors.error(`Invalid request timeout configuration: ${error2 instanceof Error ? error2.message : String(error2)}`));
+    process.exit(1);
+  }
+}
 function generateTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
@@ -134189,7 +134422,17 @@ function parseArgs(args) {
     } else if (arg === "--env" || arg === "-e") {
       options.env = args[++i];
     } else if (arg === "--timeout" || arg === "-t") {
-      options.timeout = parseInt(args[++i], 10) * 1e3;
+      const rawTimeout = args[++i];
+      if (!rawTimeout) {
+        console.error("Error: --timeout requires a value, e.g. 180s, 3m, or 300000ms.");
+        process.exit(1);
+      }
+      const timeoutMs = parseDurationToMs(rawTimeout, "s");
+      if (timeoutMs === void 0) {
+        console.error(`Error: Invalid timeout '${rawTimeout}'. Use values like 180s, 3m, or 300000ms.`);
+        process.exit(1);
+      }
+      options.timeoutMs = timeoutMs;
     } else if (arg === "--insecure") {
       options.insecure = true;
     } else if (arg === "--refactor-region-pattern" || arg === "--refactor-nornenv-region-pattern") {
@@ -134240,7 +134483,7 @@ Options:
   -s, --sequence <name>  Run a specific sequence by name (single file only)
   -r, --request <name>   Run a specific named request (single file only)
   -e, --env <name>       Use environment from .nornenv (e.g., dev, prod)
-  -t, --timeout <sec>    Request timeout in seconds (default: no timeout)
+  -t, --timeout <time>   Request timeout override (e.g. 180s, 3m, 300000ms; default: norn.config.json or 30s)
   --insecure             Disable TLS certificate verification (dev/self-signed only)
   -j, --json             Output results as JSON (for CI/CD)
   -v, --verbose          Show detailed output (headers, request/response bodies)
@@ -134565,6 +134808,7 @@ async function main() {
   }
   if (options.sequence || options.request) {
     const filePath = filesToRun[0];
+    applyCliRequestTimeout(filePath, options, colors);
     const secretUnlockResult = await ensureCliSecretsUnlocked(filePath);
     if (!secretUnlockResult.ok) {
       if (secretUnlockResult.errors.length > 0) {
@@ -134769,6 +135013,7 @@ ${fileContent}` : fileContent;
     console.log("");
   }
   for (const filePath of filesToRun) {
+    applyCliRequestTimeout(filePath, options, colors);
     const secretUnlockResult = await ensureCliSecretsUnlocked(filePath);
     if (!secretUnlockResult.ok) {
       if (secretUnlockResult.errors.length > 0) {