norn-cli 2.3.0 → 2.5.0

package/AGENTS.md

@@ -63,8 +63,8 @@ Skills should capture lessons learned and patterns discovered during implementat
    - no docs changes were needed because the release is only bug fixes, refactors, or design/styling work
 
 The Test Verification agent runs:
-- `npm run compile` (must have 0 errors)
-- `node ./dist/cli.js ./tests/Regression/ -e prelive` (all tests must pass)
+- `npm test` (must pass compile/lint, Extension Host editor diagnostics, Test Explorer support, and runtime-negative automation)
+- `npm run test:regression` (local CLI Regression suite; all tests must pass)
 
 The Website Documentation Review agent:
 - reviews release changes in `/Users/petercrest/Worktable/Projects/vsApi`

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 All notable changes to the "Norn" extension will be documented in this file.
 
+## [2.5.0] - 2026-05-27
+
+### Added
+- **Verbatim string literals** — added C#-style `@"..."` strings for Norn values, assertions, regex patterns, request URLs, sequence arguments/defaults, SQL arguments, schema paths, assertion messages, and `@data` values. Backslashes are literal, doubled quotes decode to a single quote, and `{{...}}` tokens inside verbatim strings are not interpolated.
+- **Escape-aware highlighting** — `.norn` syntax highlighting now distinguishes decoded escapes from ordinary backslash text, including escaped quotes/backslashes in normal strings, regex escapes in `matches` patterns, doubled quotes in verbatim strings, and valid JSON escapes in request bodies.
+
+### Changed
+- **Regex assertion authoring** — `matches` patterns are now guided toward quoted string patterns, with `@"..."` recommended for regexes that contain many backslashes or literal quotes.
+
+### Fixed
+- **Quoted string handling** — escaped quotes and backslashes are decoded consistently across variables, request URLs, run arguments, sequence defaults, SQL arguments, `@data` values, `matchesSchema` paths, and assertion messages while preserving unknown escapes such as `\A` as literal text.
+- **Editor assistance with verbatim strings** — diagnostics, inlay hints, and hover providers no longer treat `{{...}}` inside verbatim strings as interpolated Norn variables.
+- **Sequence tag diagnostics** — `@smoke`, `@team(...)`, and other sequence tags are recognized by editor diagnostics again instead of being reported as unknown statements.
+- **Failure output expected values** — CLI, HTML/JUnit reports, and the response panel now prefer the resolved expected value for failed assertions instead of falling back to the raw expression text.
+- **Test Explorer environment resolution** — Test Explorer now uses the only available `.nornenv` environment for isolated single-env fixtures when no active environment has been selected, fixing nested regression cases such as encrypted env imports.
+
+### Testing
+- **Editor diagnostics automation** — added an Extension Host suite that discovers `tests/EditorDiagnostics/valid` and `tests/EditorDiagnostics/negative`, keeping clean fixtures at zero diagnostics and intentional error fixtures at exact expected counts.
+- **Runtime negative automation** — converted former manual runtime error cases into `tests/RuntimeNegative` scenarios that assert CLI exit codes and stable error guidance.
+- **Test Explorer automation** — added Extension Host checks for Test Explorer fixture exclusion patterns and single-env `.nornenv` resolution.
+- **Pre-release verification** — added `npm run test:prerelease` and updated release verification to run Extension Host automation plus the local CLI Regression suite.
+- **Test suite cleanup** — moved reusable `.nornenv` import and contract fixtures into Regression, moved API coverage fixtures into `tests/ApiCoverage`, and removed stale scratch/demo test folders.
+
+## [2.4.0] - 2026-05-25
+
+### Added
+- **Per-folder and persisted active environment** — the active env is now tracked per `.nornenv` file (keyed by absolute path) and persisted to the workspace memento. In monorepos each folder remembers its own selection, and selections survive VS Code restart. The status bar shows the env for the current editor's nearest `.nornenv`. Stale entries (deleted `.nornenv` files) are pruned on load.
+- **Region-pattern refactor** — when a `.nornenv` contains a flat `[env:STAGE_REGION]` matrix (e.g. `dev_us`, `dev_uk`, `prod_us`, `prod_uk`), the top of the file shows a "Refactor N envs into S+R templates" CodeLens. Clicking it classifies each variable by axis (stage / region / leaf-specific) and lifts shared values into `[template:STAGE]` + `[template:REGION]` blocks, leaving only true leaf-specific overrides in the env sections. Missing values and `connectionString` declarations stay leaf-specific, per-declaration `secret` keywords are preserved, and the same generator is available in the CLI via `--refactor-region-pattern` / `--write`. The VS Code refactor is one `WorkspaceEdit` so a single Cmd+Z reverses it.
+
 ## [2.3.0] - 2026-05-20
 
 ### Added
@@ -422,7 +451,7 @@ All notable changes to the "Norn" extension will be documented in this file.
 
 ### Added
 - **Regression Fixture (Coverage Scope)**:
-  - Added `tests/Random/coverage-scope/template-version.nornapi` and `tests/Random/coverage-scope/template-version-covered.norn` to lock in template-path coverage behavior.
+  - Added `tests/ApiCoverage/coverage-scope/template-version.nornapi` and `tests/ApiCoverage/coverage-scope/template-version-covered.norn` to lock in template-path coverage behavior.
 
 ## [1.4.1] - 2026-02-21
 

package/demos/nornenv-region-refactor/README.md

@@ -0,0 +1,64 @@
+# Region-pattern refactor showcase
+
+A flat `[env:STAGE_REGION]` matrix that the Norn extension can refactor into the templates + extends shape in one click.
+
+## How to use
+
+1. Open [.nornenv](./.nornenv) in VS Code.
+2. A `$(sparkle) Refactor 4 envs into 2+2 templates` CodeLens appears at the top of the file.
+3. Click it. A confirmation dialog summarises what will change:
+   - 2 vars (`baseUrl`, `apiKey`) lifted to stage templates (`dev`, `prod`)
+   - 2 vars (`dbHost`, `bucket`) lifted to region templates (`us`, `uk`)
+   - 1 var (`failoverHost`) kept as leaf-specific on `prod_uk`
+4. Confirm. The flat 4-env matrix is replaced with templates + extending envs:
+
+   ```nornenv
+   [template:dev]
+       var baseUrl = https://dev.example.com
+       var apiKey = dev-key-123
+
+   [template:prod]
+       var baseUrl = https://api.example.com
+       secret apiKey = prod-key-789
+
+   [template:us]
+       var dbHost = db.us.example.com
+       var bucket = data-us
+
+   [template:uk]
+       var dbHost = db.uk.example.com
+       var bucket = data-uk
+
+   [env:dev_us extends dev, us]
+
+   [env:dev_uk extends dev, uk]
+
+   [env:prod_us extends prod, us]
+
+   [env:prod_uk extends prod, uk]
+       var failoverHost = api-failover.uk.example.com
+   ```
+
+5. The `secret` keyword on `apiKey` is preserved when the var is lifted to a template.
+
+## CLI
+
+The same generator is available from the local CLI:
+
+```bash
+node ./dist/cli.js demos/nornenv-region-refactor/.nornenv --refactor-region-pattern
+node ./dist/cli.js demos/nornenv-region-refactor/.nornenv --refactor-region-pattern --write
+```
+
+## When the refactor fires
+
+The CodeLens appears only when **all** of these are true:
+- At least 2 stages × 2 regions
+- At least 3 populated cells
+- All matrix envs are flat (no existing `extends` clause)
+
+It does not touch envs that already use `extends`, envs with names that don't match the `STAGE_REGION` shape, or `connectionString` declarations (those are left in their leaves — refactor manually).
+
+## Cmd+Z
+
+Everything goes through a single `WorkspaceEdit`, so a single Cmd+Z undoes the whole refactor.

package/dist/cli.js

@@ -101832,6 +101832,119 @@ 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 === '"') {
+      return i + 1;
+    }
+    i++;
+  }
+  return text.length;
+}
+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 +102116,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 +102162,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 +102480,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 +102611,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 +102718,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;
@@ -109661,34 +109781,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 +109796,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 = [
@@ -109738,7 +109838,8 @@ function parseAssertCommand(line2) {
         leftExpr: binaryMatch[1].trim(),
         operator: op,
         rightExpr: binaryMatch[2].trim(),
-        message
+        message,
+        messageIsVerbatim
       };
     }
   }
@@ -109748,22 +109849,29 @@ 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 === '"' && str[i + 1] === '"') {
+      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;
     }
@@ -109875,8 +109983,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 +110058,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 +110141,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 +110215,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 +110252,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 +110269,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],
@@ -128016,7 +128122,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 +128131,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 +128140,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 +128152,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 +128161,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 +128634,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 +128645,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 +128722,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 +128747,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 +128792,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 +128918,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 +128968,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 +129080,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 +129108,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 +129116,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 +129129,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 +131580,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 +131875,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 +132253,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>`;
@@ -133770,6 +133910,294 @@ function splitImportResolutionErrors(errors) {
   return { blockingErrors, warningErrors };
 }
 
+// src/nornenvLanguageModel.ts
+var SECTION_HEADER_REGEX = /^\s*\[(env|template):([a-zA-Z_][a-zA-Z0-9_-]*)(?:\s+extends\s+([^\]]+))?\]\s*$/i;
+function parseParentList(clause) {
+  if (!clause) {
+    return [];
+  }
+  return clause.split(",").map((parent) => parent.trim()).filter((parent) => /^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(parent));
+}
+function parseNornenvDocumentModel(text) {
+  const sections = [];
+  const declarations = [];
+  const lines = text.split("\n");
+  let currentSection;
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+    const line2 = lines[lineNumber];
+    const sectionMatch = line2.trim().match(SECTION_HEADER_REGEX);
+    if (sectionMatch) {
+      currentSection = {
+        kind: sectionMatch[1].toLowerCase(),
+        name: sectionMatch[2],
+        parents: parseParentList(sectionMatch[3]),
+        lineNumber
+      };
+      sections.push(currentSection);
+      continue;
+    }
+    const connectionMatch = line2.match(/^(\s*)(secret\s+)?connectionString\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (connectionMatch) {
+      const displayName = connectionMatch[3];
+      const name = `${displayName}_connectionString`;
+      const nameStart = line2.indexOf(displayName);
+      const value = connectionMatch[4];
+      const valueStart = line2.length - value.length;
+      declarations.push({
+        name,
+        displayName,
+        value,
+        secret: Boolean(connectionMatch[2]),
+        sectionKind: currentSection?.kind,
+        sectionName: currentSection?.name,
+        lineNumber,
+        nameStart,
+        nameEnd: nameStart + displayName.length,
+        valueStart,
+        valueEnd: line2.length
+      });
+      continue;
+    }
+    const variableMatch = line2.match(/^(\s*)(secret|var)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/i);
+    if (variableMatch) {
+      const name = variableMatch[3];
+      const nameStart = line2.indexOf(name);
+      const value = variableMatch[4];
+      const valueStart = line2.length - value.length;
+      declarations.push({
+        name,
+        displayName: name,
+        value,
+        secret: variableMatch[2].toLowerCase() === "secret",
+        sectionKind: currentSection?.kind,
+        sectionName: currentSection?.name,
+        lineNumber,
+        nameStart,
+        nameEnd: nameStart + name.length,
+        valueStart,
+        valueEnd: line2.length
+      });
+    }
+  }
+  return { sections, declarations };
+}
+
+// src/nornenvRegionRefactor.ts
+var MATRIX_ENV_NAME_REGEX = /^([a-zA-Z][a-zA-Z0-9-]*)_([a-zA-Z][a-zA-Z0-9-]*)$/;
+var MIN_STAGES = 2;
+var MIN_REGIONS = 2;
+var MIN_CELLS = 3;
+function isConnectionStringVar(name) {
+  return name.endsWith("_connectionString");
+}
+function inferDeclarationKind(name) {
+  return isConnectionStringVar(name) ? "connectionString" : "var";
+}
+function inferDisplayName(name) {
+  return isConnectionStringVar(name) ? name.slice(0, -"_connectionString".length) : name;
+}
+function declarationKind(declaration) {
+  return declaration.name.endsWith("_connectionString") && declaration.displayName !== declaration.name ? "connectionString" : "var";
+}
+function buildDeclarationMap(text) {
+  const model = parseNornenvDocumentModel(text);
+  const byEnv = /* @__PURE__ */ new Map();
+  for (const declaration of model.declarations) {
+    if (declaration.sectionKind !== "env" || !declaration.sectionName) {
+      continue;
+    }
+    if (!byEnv.has(declaration.sectionName)) {
+      byEnv.set(declaration.sectionName, /* @__PURE__ */ new Map());
+    }
+    byEnv.get(declaration.sectionName).set(declaration.name, declaration);
+  }
+  return byEnv;
+}
+function getCellValue(cell, name, declarationsByEnv, config2) {
+  const value = cell.env.variables[name];
+  if (value === void 0) {
+    return void 0;
+  }
+  const declaration = declarationsByEnv.get(cell.envName)?.get(name);
+  return {
+    value,
+    secret: declaration?.secret ?? config2.secretNames.has(name),
+    kind: declaration ? declarationKind(declaration) : inferDeclarationKind(name),
+    displayName: declaration?.displayName ?? inferDisplayName(name)
+  };
+}
+function classifyByAxis(name, cells, axisKeys, getAxisKey, declarationsByEnv, config2) {
+  const byKey = /* @__PURE__ */ new Map();
+  let presentCells = 0;
+  for (const key of axisKeys) {
+    const axisCells = cells.filter((cell) => getAxisKey(cell) === key);
+    const presentValues = axisCells.map((cell) => getCellValue(cell, name, declarationsByEnv, config2)).filter((value) => value !== void 0);
+    if (presentValues.length === 0) {
+      continue;
+    }
+    presentCells += presentValues.length;
+    if (presentValues.length !== axisCells.length) {
+      return void 0;
+    }
+    const first = presentValues[0];
+    if (presentValues.some((value) => value.value !== first.value)) {
+      return void 0;
+    }
+    byKey.set(key, {
+      value: first.value,
+      secret: presentValues.some((value) => value.secret),
+      kind: first.kind,
+      displayName: first.displayName
+    });
+  }
+  return byKey.size > 0 && presentCells >= 2 ? byKey : void 0;
+}
+function detectRegionPattern(config2, text) {
+  const cells = [];
+  for (const env3 of config2.environments) {
+    const match = env3.name.match(MATRIX_ENV_NAME_REGEX);
+    if (!match) {
+      continue;
+    }
+    if (env3.parents.length > 0) {
+      return void 0;
+    }
+    cells.push({ stage: match[1], region: match[2], envName: env3.name, env: env3 });
+  }
+  const stages = Array.from(new Set(cells.map((c) => c.stage)));
+  const regions = Array.from(new Set(cells.map((c) => c.region)));
+  if (stages.length < MIN_STAGES || regions.length < MIN_REGIONS || cells.length < MIN_CELLS) {
+    return void 0;
+  }
+  if ((/* @__PURE__ */ new Set([...stages, ...regions])).size !== stages.length + regions.length) {
+    return void 0;
+  }
+  const existingTemplates = new Set(config2.templates.map((template) => template.name));
+  if ([...stages, ...regions].some((name) => existingTemplates.has(name))) {
+    return void 0;
+  }
+  const allVarNames = /* @__PURE__ */ new Set();
+  for (const cell of cells) {
+    for (const name of Object.keys(cell.env.variables)) {
+      allVarNames.add(name);
+    }
+  }
+  let liftedToStage = 0;
+  let liftedToRegion = 0;
+  let leafSpecific = 0;
+  let skippedConnectionStrings = 0;
+  const assignments = [];
+  const declarationsByEnv = buildDeclarationMap(text);
+  for (const name of allVarNames) {
+    if (isConnectionStringVar(name)) {
+      skippedConnectionStrings++;
+    }
+    const stageValues = isConnectionStringVar(name) ? void 0 : classifyByAxis(name, cells, stages, (cell) => cell.stage, declarationsByEnv, config2);
+    const regionValues = isConnectionStringVar(name) ? void 0 : classifyByAxis(name, cells, regions, (cell) => cell.region, declarationsByEnv, config2);
+    if (stageValues) {
+      assignments.push({ name, axis: "stage", byKey: stageValues });
+      liftedToStage++;
+    } else if (regionValues) {
+      assignments.push({ name, axis: "region", byKey: regionValues });
+      liftedToRegion++;
+    } else {
+      const byKey = /* @__PURE__ */ new Map();
+      for (const cell of cells) {
+        const value = getCellValue(cell, name, declarationsByEnv, config2);
+        if (value !== void 0) {
+          byKey.set(cell.envName, value);
+        }
+      }
+      if (byKey.size > 0) {
+        assignments.push({ name, axis: "leaf", byKey });
+        leafSpecific++;
+      }
+    }
+  }
+  const model = parseNornenvDocumentModel(text);
+  const matrixNames = new Set(cells.map((c) => c.envName));
+  const matrixSectionLines = model.sections.filter((s) => s.kind === "env" && matrixNames.has(s.name)).map((s) => s.lineNumber).sort((a, b) => a - b);
+  if (matrixSectionLines.length === 0) {
+    return void 0;
+  }
+  const firstLine = matrixSectionLines[0];
+  const lastMatrixHeaderLine = matrixSectionLines[matrixSectionLines.length - 1];
+  const sectionsInReplacementRange = model.sections.filter(
+    (section) => section.lineNumber >= firstLine && section.lineNumber <= lastMatrixHeaderLine
+  );
+  if (sectionsInReplacementRange.some((section) => section.kind !== "env" || !matrixNames.has(section.name))) {
+    return void 0;
+  }
+  const lineCount = text.split("\n").length;
+  const sectionsAfter = model.sections.filter((s) => s.lineNumber > lastMatrixHeaderLine).map((s) => s.lineNumber).sort((a, b) => a - b);
+  const lastLine = sectionsAfter.length > 0 ? sectionsAfter[0] - 1 : lineCount - 1;
+  return {
+    stages,
+    regions,
+    cells,
+    assignments,
+    replaceRange: { startLine: firstLine, endLine: lastLine },
+    summary: { liftedToStage, liftedToRegion, leafSpecific, skippedConnectionStrings }
+  };
+}
+function generateRegionRefactor(pattern) {
+  const blocks = [];
+  const fmtVar = (assignment, value) => {
+    if (value.kind === "connectionString") {
+      const secretPrefix = value.secret ? "secret " : "";
+      return `    ${secretPrefix}connectionString ${value.displayName} = ${value.value}`;
+    }
+    const keyword = value.secret ? "secret" : "var";
+    return `    ${keyword} ${assignment.name} = ${value.value}`;
+  };
+  for (const stage of pattern.stages) {
+    const stageVars = pattern.assignments.filter((a) => a.axis === "stage" && a.byKey.has(stage));
+    if (stageVars.length === 0) {
+      continue;
+    }
+    const lines = [`[template:${stage}]`];
+    for (const v of stageVars) {
+      lines.push(fmtVar(v, v.byKey.get(stage)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  for (const region of pattern.regions) {
+    const regionVars = pattern.assignments.filter((a) => a.axis === "region" && a.byKey.has(region));
+    if (regionVars.length === 0) {
+      continue;
+    }
+    const lines = [`[template:${region}]`];
+    for (const v of regionVars) {
+      lines.push(fmtVar(v, v.byKey.get(region)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  for (const cell of pattern.cells) {
+    const leafVars = pattern.assignments.filter((a) => a.axis === "leaf" && a.byKey.has(cell.envName));
+    const header = `[env:${cell.envName} extends ${cell.stage}, ${cell.region}]`;
+    if (leafVars.length === 0) {
+      blocks.push(header);
+      continue;
+    }
+    const lines = [header];
+    for (const v of leafVars) {
+      lines.push(fmtVar(v, v.byKey.get(cell.envName)));
+    }
+    blocks.push(lines.join("\n"));
+  }
+  return blocks.join("\n\n");
+}
+function applyRegionRefactorToText(text, pattern) {
+  const lines = text.split("\n");
+  const startLine = pattern.replaceRange.startLine;
+  const endLine = Math.min(pattern.replaceRange.endLine, lines.length - 1);
+  const replacementLines = generateRegionRefactor(pattern).split("\n");
+  lines.splice(startLine, endLine - startLine + 1, ...replacementLines);
+  const result = lines.join("\n");
+  return text.endsWith("\n") && !result.endsWith("\n") ? `${result}
+` : result;
+}
+
 // src/cli.ts
 function handleImportResolutionErrors(errors, colors) {
   const { blockingErrors, warningErrors } = splitImportResolutionErrors(errors);
@@ -133884,7 +134312,9 @@ function parseArgs(args) {
     noRedact: false,
     tagFilters: [],
     tagsFilter: [],
-    insecure: false
+    insecure: false,
+    refactorRegionPattern: false,
+    writeRefactor: false
   };
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -133902,6 +134332,10 @@ function parseArgs(args) {
       options.timeout = parseInt(args[++i], 10) * 1e3;
     } else if (arg === "--insecure") {
       options.insecure = true;
+    } else if (arg === "--refactor-region-pattern" || arg === "--refactor-nornenv-region-pattern") {
+      options.refactorRegionPattern = true;
+    } else if (arg === "--write") {
+      options.writeRefactor = true;
     } else if (arg === "--no-fail") {
       options.failOnError = false;
     } else if (arg === "--no-redact") {
@@ -133957,6 +134391,9 @@ Options:
   -o, --output-dir <dir> Output directory for reports (auto-generates timestamped files)
   --tag <filter>         Filter sequences by tag (AND logic, can be repeated)
   --tags <filters>       Filter sequences by tags (OR logic, comma-separated)
+  --refactor-region-pattern
+                          Refactor a flat .nornenv STAGE_REGION matrix to templates
+  --write                 Apply --refactor-region-pattern instead of printing result
   -h, --help             Show this help message
 
 Report Generation:
@@ -134000,11 +134437,62 @@ Examples:
   norn api-tests.norn --html report.html    # Generate HTML report (explicit)
   norn api-tests.norn --insecure            # Allow self-signed/local TLS certs
   norn api-tests.norn --no-redact           # Show all data (no redaction)
+  norn .nornenv --refactor-region-pattern   # Print refactored .nornenv
+  norn .nornenv --refactor-region-pattern --write
   norn secrets keygen --name team-main      # Generate shared key and cache locally
   norn secrets import-key --kid team-main   # Save shared key from your vault
   norn secrets audit .                       # Fail if plaintext secrets are committed
 `);
 }
+function formatRegionPatternSummary(pattern) {
+  const { liftedToStage, liftedToRegion, leafSpecific, skippedConnectionStrings } = pattern.summary;
+  const lines = [
+    `Detected ${pattern.cells.length} envs across ${pattern.stages.length} stages x ${pattern.regions.length} regions.`,
+    `Lifted ${liftedToStage} vars to stage templates (${pattern.stages.join(", ")}).`,
+    `Lifted ${liftedToRegion} vars to region templates (${pattern.regions.join(", ")}).`,
+    `Kept ${leafSpecific} vars leaf-specific.`
+  ];
+  if (skippedConnectionStrings > 0) {
+    lines.push(`Kept ${skippedConnectionStrings} connection-string var${skippedConnectionStrings === 1 ? "" : "s"} in leaf envs.`);
+  }
+  return lines;
+}
+function runNornenvRegionRefactor(filePath, options) {
+  const content = fs19.readFileSync(filePath, "utf-8");
+  const config2 = parseEnvFile(content, filePath);
+  const pattern = detectRegionPattern(config2, content);
+  if (!pattern) {
+    if (options.output === "json") {
+      console.log(JSON.stringify({ success: false, changed: false, error: "No region pattern detected" }, null, 2));
+    } else {
+      console.error("No region pattern detected in this .nornenv file.");
+    }
+    process.exit(1);
+  }
+  const refactored = applyRegionRefactorToText(content, pattern);
+  if (options.writeRefactor) {
+    fs19.writeFileSync(filePath, refactored, "utf-8");
+  }
+  if (options.output === "json") {
+    console.log(JSON.stringify({
+      success: true,
+      changed: refactored !== content,
+      file: filePath,
+      summary: pattern.summary,
+      stages: pattern.stages,
+      regions: pattern.regions,
+      output: options.writeRefactor ? void 0 : refactored
+    }, null, 2));
+  } else if (options.writeRefactor) {
+    for (const line2 of formatRegionPatternSummary(pattern)) {
+      console.log(line2);
+    }
+    console.log(`Refactored ${filePath}`);
+  } else {
+    console.log(refactored);
+  }
+  process.exit(0);
+}
 async function runSingleRequest(fileContent, variables, cookieJar, apiDefinitions, filePath, envContext) {
   const lines = fileContent.split("\n");
   const requestLines = [];
@@ -134169,6 +134657,17 @@ async function main() {
     process.exit(1);
   }
   const isDirectory = fs19.statSync(inputPath).isDirectory();
+  if (options.writeRefactor && !options.refactorRegionPattern) {
+    console.error("Error: --write can only be used with --refactor-region-pattern");
+    process.exit(1);
+  }
+  if (options.refactorRegionPattern) {
+    if (isDirectory) {
+      console.error("Error: --refactor-region-pattern requires a specific .nornenv file, not a directory");
+      process.exit(1);
+    }
+    runNornenvRegionRefactor(inputPath, options);
+  }
   let filesToRun;
   if (isDirectory) {
     filesToRun = discoverNornFiles(inputPath);

package/package.json

@@ -2,7 +2,7 @@
   "name": "norn-cli",
   "displayName": "Norn — API Tests in Your Repo",
   "description": "Version-controlled API tests your team can keep. Author and debug HTTP sequences in VS Code, then run the same files in CI.",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "publisher": "Norn-PeterKrustanov",
   "author": {
     "name": "Peter Krastanov"
@@ -103,6 +103,11 @@
         "title": "Peek Inherited Norn Environment Variables",
         "category": "Norn"
       },
+      {
+        "command": "norn.nornenv.refactorRegionPattern",
+        "title": "Refactor Region Pattern To Templates",
+        "category": "Norn"
+      },
       {
         "command": "norn.showCoverage",
         "title": "Show API Coverage",
@@ -410,6 +415,14 @@
           "type": "boolean",
           "default": true,
           "description": "Verify SSL/TLS certificates for HTTPS requests and Swagger/OpenAPI fetches. Disable only for local development with self-signed certificates."
+        },
+        "norn.testExplorer.exclude": {
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "string"
+          },
+          "description": "Workspace-relative glob patterns for .norn files or folders to hide from the Norn Test Explorer. Useful for negative fixtures, live-only tests, or documentation demos."
         }
       }
     },
@@ -440,7 +453,7 @@
     "watch:esbuild": "node esbuild.js --watch",
     "watch:tsc": "tsc --noEmit --watch --project tsconfig.json",
     "package": "npm run check-types && npm run lint && node esbuild.js --production",
-    "compile-tests": "tsc -p . --outDir out",
+    "compile-tests": "node -e \"require('fs').rmSync('out/test',{recursive:true,force:true})\" && tsc -p . --outDir out",
     "watch-tests": "tsc -p . -w --outDir out",
     "pretest": "npm run compile-tests && npm run compile && npm run lint",
     "check-types": "tsc --noEmit",
@@ -448,7 +461,8 @@
     "validate:skills": "node ./scripts/validate-skills.mjs",
     "test": "vscode-test",
     "test:regression": "node ./dist/cli.js ./tests/Regression/ -e prelive",
-    "publish:npm": "node -e \"const p=require('./package.json');p.name='norn-cli';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2))\" && npm publish && node -e \"const p=require('./package.json');p.name='norn';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2))\"",
+    "test:prerelease": "npm test && npm run test:regression",
+    "publish:npm": "node -e \"const fs=require('fs');const p=require('./package.json');p.name='norn-cli';fs.writeFileSync('package.json',JSON.stringify(p,null,2)+'\\n')\" && npm publish; exit_code=$?; node -e \"const fs=require('fs');const p=require('./package.json');p.name='norn';fs.writeFileSync('package.json',JSON.stringify(p,null,2)+'\\n')\"; exit $exit_code",
     "publish:vsce": "node -e \"const p=require('./package.json');p.name='norn';require('fs').writeFileSync('package.json',JSON.stringify(p,null,2))\" && npx vsce publish",
     "publish:all": "npm run publish:npm && npm run publish:vsce"
   },
@@ -480,4 +494,4 @@
   "bin": {
     "norn": "./dist/cli.js"
   }
-}
+}

package/.claude/settings.local.json

@@ -1,18 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run *)",
-      "WebSearch",
-      "Bash(git checkout *)",
-      "Bash(node ./dist/cli.js tests/Regression/nornenv-templates/extends-resolution.norn -s PrintResolvedValues -e prod_uk)",
-      "Bash(node ./dist/cli.js tests/Regression/nornenv-templates/extends-resolution.norn -s PrintResolvedValues -e prod_us)",
-      "Bash(node ./dist/cli.js tests/Regression/nornenv-templates/extends-resolution.norn -s PrintResolvedValues -e diamond)",
-      "Bash(node ./dist/cli.js tests/Regression/nornenv-templates/extends-resolution.norn -s PrintResolvedValues -e base)",
-      "Bash(mv .nornenv .nornenv.bak)",
-      "Bash(cp cycle.nornenv .nornenv)",
-      "Bash(timeout 10 node ../../../dist/cli.js extends-resolution.norn -s PrintResolvedValues -e c)",
-      "Bash(time node ../../../dist/cli.js extends-resolution.norn -s PrintResolvedValues -e c)",
-      "Bash(time node /Users/petercrest/Worktable/Projects/vsApi/dist/cli.js extends-resolution.norn -s PrintResolvedValues -e c)"
-    ]
-  }
-}