norn-cli 1.5.4 → 1.6.1

package/dist/cli.js

@@ -28203,7 +28203,7 @@ function getValueByPath(response, path10) {
       return void 0;
   }
 }
-async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, executionContext) {
+async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, workingDir, fullDocumentText, onProgress, callStack, sequenceArgs, apiDefinitions, tagFilterOptions, sequenceSources, executionContext, debugHooks) {
   const startTime = Date.now();
   const responses = [];
   const scriptResults = [];
@@ -28246,566 +28246,987 @@ async function runSequenceWithJar(sequenceContent, fileVariables, cookieJar, wor
   let requestIndex = 0;
   const ifStack = [];
   const shouldSkip = () => ifStack.length > 0 && ifStack.some((v) => !v);
-  for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
-    const step = steps[stepIdx];
-    if (step.type === "if") {
-      if (shouldSkip()) {
-        ifStack.push(false);
-      } else {
-        const conditionMet = evaluateIfCondition(step.content, responses, runtimeVariables, getValueByPath);
-        ifStack.push(conditionMet);
-        const stepResult = {
-          type: "print",
-          stepIndex: stepIdx,
-          print: {
-            title: `if ${step.content}: ${conditionMet ? "true" : "false"}`,
-            timestamp: Date.now() - startTime
-          }
-        };
-        orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "if", `if ${step.content} \u2192 ${conditionMet}`, stepResult);
-      }
-      continue;
-    }
-    if (step.type === "endif") {
-      if (ifStack.length > 0) {
-        ifStack.pop();
-      }
-      continue;
+  const resolveDebugStepLocation = (step) => {
+    const sequenceName = executionContext?.sequenceName;
+    const indexed = sequenceName ? executionContext?.sequenceLocationIndex?.get(sequenceName.toLowerCase()) : void 0;
+    const startLine = executionContext?.sequenceStartLine ?? indexed?.startLine;
+    return {
+      filePath: executionContext?.filePath ?? indexed?.filePath,
+      sequenceName,
+      declarationLine: indexed?.declarationLine ?? executionContext?.sequenceStartLine,
+      absoluteLine: startLine !== void 0 ? startLine + 1 + step.lineNumber : void 0,
+      relativeLine: step.lineNumber,
+      nestingDepth
+    };
+  };
+  const emitBeforeStep = async (step, stepIdx) => {
+    if (!debugHooks?.beforeStep) {
+      return;
     }
-    if (shouldSkip()) {
-      continue;
+    await debugHooks.beforeStep({
+      stepType: step.type,
+      stepContent: step.content,
+      stepIndex: stepIdx,
+      totalSteps,
+      location: resolveDebugStepLocation(step),
+      runtimeVariables,
+      responses
+    });
+  };
+  const emitAfterStep = async (step, stepIdx) => {
+    if (!debugHooks?.afterStep) {
+      return;
     }
-    if (step.type === "assertion") {
-      const parsed = parseAssertCommand(substituteVariables(step.content, runtimeVariables));
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid assert command: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const result = evaluateAssertion(parsed, responses, runtimeVariables, getValueByPath, responseIndexToVariable, workingDir);
-      assertionResults.push(result);
-      const stepResult = {
-        type: "assertion",
-        stepIndex: stepIdx,
-        assertion: result,
-        lineNumber: step.lineNumber
-      };
-      orderedSteps.push(stepResult);
-      const statusIcon = result.passed ? "\u2713" : "\u2717";
-      reportProgress(stepIdx, "assertion", `${statusIcon} assert ${result.expression}`, stepResult);
-      if (!result.passed) {
-        const failMessage = result.message ? `Assertion failed: ${result.message}` : `Assertion failed: ${result.expression}`;
-        errors.push(failMessage);
-        if (result.error) {
-          errors.push(`  Error: ${result.error}`);
-        } else {
-          errors.push(`  Expected: ${result.rightExpression ?? result.operator}`);
-          errors.push(`  Actual: ${JSON.stringify(result.leftValue)}`);
-        }
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      continue;
+    await debugHooks.afterStep({
+      stepType: step.type,
+      stepContent: step.content,
+      stepIndex: stepIdx,
+      totalSteps,
+      location: resolveDebugStepLocation(step),
+      runtimeVariables,
+      responses
+    });
+  };
+  const emitFailure = async (message, step, stepIdx) => {
+    if (!debugHooks?.onFailure) {
+      return;
     }
-    if (step.type === "print") {
-      const parsed = parsePrintCommand(step.content);
-      const titleResolved = resolveBareVariables(parsed.title, runtimeVariables);
-      const title = substituteVariables(titleResolved, runtimeVariables);
-      const bodyResolved = parsed.body ? resolveBareVariables(parsed.body, runtimeVariables) : void 0;
-      const body = bodyResolved ? substituteVariables(bodyResolved, runtimeVariables) : void 0;
-      const stepResult = {
-        type: "print",
-        stepIndex: stepIdx,
-        print: {
-          title,
-          body,
-          timestamp: Date.now() - startTime
+    await debugHooks.onFailure({
+      message,
+      stepIndex: stepIdx,
+      location: step ? resolveDebugStepLocation(step) : void 0,
+      runtimeVariables,
+      responses
+    });
+  };
+  if (debugHooks?.onSequenceEnter) {
+    await debugHooks.onSequenceEnter({
+      sequenceName: executionContext?.sequenceName,
+      filePath: executionContext?.filePath,
+      declarationLine: executionContext?.sequenceStartLine,
+      nestingDepth,
+      runtimeVariables,
+      responses
+    });
+  }
+  try {
+    for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
+      const step = steps[stepIdx];
+      await emitBeforeStep(step, stepIdx);
+      try {
+        if (step.type === "if") {
+          if (shouldSkip()) {
+            ifStack.push(false);
+          } else {
+            const conditionMet = evaluateIfCondition(step.content, responses, runtimeVariables, getValueByPath);
+            ifStack.push(conditionMet);
+            const stepResult = {
+              type: "print",
+              stepIndex: stepIdx,
+              print: {
+                title: `if ${step.content}: ${conditionMet ? "true" : "false"}`,
+                timestamp: Date.now() - startTime
+              }
+            };
+            orderedSteps.push(stepResult);
+            reportProgress(stepIdx, "if", `if ${step.content} \u2192 ${conditionMet}`, stepResult);
+          }
+          continue;
         }
-      };
-      orderedSteps.push(stepResult);
-      reportProgress(stepIdx, "print", `print: ${title}`, stepResult);
-      continue;
-    }
-    if (step.type === "wait") {
-      const durationMs = parseWaitCommand(step.content);
-      reportProgress(stepIdx, "wait", `wait: ${durationMs}ms`);
-      await sleep2(durationMs);
-      const stepResult = {
-        type: "print",
-        stepIndex: stepIdx,
-        print: {
-          title: `Waited ${durationMs >= 1e3 ? durationMs / 1e3 + "s" : durationMs + "ms"}`,
-          timestamp: Date.now() - startTime
+        if (step.type === "endif") {
+          if (ifStack.length > 0) {
+            ifStack.pop();
+          }
+          continue;
         }
-      };
-      orderedSteps.push(stepResult);
-      continue;
-    }
-    if (step.type === "json") {
-      const bareResolved = resolveBareVariables(step.content, runtimeVariables);
-      const parsed = parseJsonCommand(substituteVariables(bareResolved, runtimeVariables));
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid json command: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const result = readJsonFile(parsed.filePath, workingDir);
-      const stepResult = {
-        type: "json",
-        stepIndex: stepIdx,
-        json: {
-          varName: parsed.varName,
-          filePath: result.filePath,
-          success: result.success,
-          error: result.error,
-          timestamp: Date.now() - startTime
+        if (shouldSkip()) {
+          continue;
         }
-      };
-      orderedSteps.push(stepResult);
-      if (!result.success) {
-        errors.push(`Failed to load JSON file: ${result.error}`);
-        reportProgress(stepIdx, "json", `json: ${parsed.varName} \u2717 ${result.error}`, stepResult);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      runtimeVariables[parsed.varName] = JSON.stringify(result.data);
-      reportProgress(stepIdx, "json", `json: ${parsed.varName} = ${parsed.filePath}`, stepResult);
-      continue;
-    }
-    if (step.type === "propAssign") {
-      const parsed = parsePropertyAssignment(step.content);
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid property assignment: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      if (!(parsed.varName in runtimeVariables)) {
-        errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not defined`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      let jsonObj;
-      try {
-        jsonObj = JSON.parse(runtimeVariables[parsed.varName]);
-      } catch {
-        errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not a valid JSON object`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const valueTrimmed = parsed.value.trim();
-      const bareVarMatch = valueTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
-      let newValue;
-      if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
-        const varName = bareVarMatch[1];
-        const pathPart = bareVarMatch[2] || "";
-        let value = runtimeVariables[varName];
-        if (typeof value === "string") {
-          try {
-            const parsed2 = JSON.parse(value);
-            if (typeof parsed2 === "object" && parsed2 !== null) {
-              value = parsed2;
+        if (step.type === "assertion") {
+          const parsed = parseAssertCommand(substituteVariables(step.content, runtimeVariables));
+          if (!parsed) {
+            const invalidAssertMessage = `Step ${stepIdx + 1}: Invalid assert command: ${step.content}`;
+            errors.push(invalidAssertMessage);
+            await emitFailure(invalidAssertMessage, step, stepIdx);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const result = evaluateAssertion(parsed, responses, runtimeVariables, getValueByPath, responseIndexToVariable, workingDir);
+          assertionResults.push(result);
+          const stepResult = {
+            type: "assertion",
+            stepIndex: stepIdx,
+            assertion: result,
+            lineNumber: step.lineNumber
+          };
+          orderedSteps.push(stepResult);
+          const statusIcon = result.passed ? "\u2713" : "\u2717";
+          reportProgress(stepIdx, "assertion", `${statusIcon} assert ${result.expression}`, stepResult);
+          if (!result.passed) {
+            const failMessage = result.message ? `Assertion failed: ${result.message}` : `Assertion failed: ${result.expression}`;
+            errors.push(failMessage);
+            if (result.error) {
+              errors.push(`  Error: ${result.error}`);
+            } else {
+              errors.push(`  Expected: ${result.rightExpression ?? result.operator}`);
+              errors.push(`  Actual: ${JSON.stringify(result.leftValue)}`);
             }
-          } catch {
+            await emitFailure(failMessage, step, stepIdx);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
+          continue;
         }
-        if (pathPart) {
-          const path10 = pathPart.replace(/^\./, "");
-          newValue = getNestedValueFromObject(value, path10);
-        } else {
-          newValue = value;
-        }
-      } else {
-        const bareResolvedValue = resolveBareVariables(parsed.value, runtimeVariables);
-        const resolvedValue = substituteVariables(bareResolvedValue, runtimeVariables);
-        newValue = resolvedValue;
-        try {
-          newValue = JSON.parse(resolvedValue);
-        } catch {
+        if (step.type === "print") {
+          const parsed = parsePrintCommand(step.content);
+          const titleResolved = resolveBareVariables(parsed.title, runtimeVariables);
+          const title = substituteVariables(titleResolved, runtimeVariables);
+          const bodyResolved = parsed.body ? resolveBareVariables(parsed.body, runtimeVariables) : void 0;
+          const body = bodyResolved ? substituteVariables(bodyResolved, runtimeVariables) : void 0;
+          const stepResult = {
+            type: "print",
+            stepIndex: stepIdx,
+            print: {
+              title,
+              body,
+              timestamp: Date.now() - startTime
+            }
+          };
+          orderedSteps.push(stepResult);
+          reportProgress(stepIdx, "print", `print: ${title}`, stepResult);
+          continue;
         }
-      }
-      const success = setNestedValue(jsonObj, parsed.propertyPath, newValue);
-      if (!success) {
-        errors.push(`Step ${stepIdx + 1}: Failed to set property '${parsed.propertyPath}' on '${parsed.varName}'`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      runtimeVariables[parsed.varName] = JSON.stringify(jsonObj);
-      reportProgress(stepIdx, "propAssign", `${parsed.varName}.${parsed.propertyPath} = ${parsed.value}`, void 0);
-      continue;
-    }
-    if (step.type === "varAssign") {
-      const parsed = parseVarAssignCommand(step.content);
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid variable assignment: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const result = evaluateValueExpression(parsed.valueExpr, runtimeVariables);
-      if (result.error) {
-        errors.push(`Step ${stepIdx + 1}: ${result.error}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      runtimeVariables[parsed.varName] = result.value;
-      reportProgress(stepIdx, "propAssign", `var ${parsed.varName} = ${result.value}`, void 0);
-      continue;
-    }
-    if (step.type === "varRequest") {
-      const commandLine = step.content.split("\n")[0];
-      const parsed = parseVarRequestCommand(commandLine);
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid variable request: ${commandLine}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      requestIndex++;
-      let resolvedUrl = "";
-      let resolvedHeaders = {};
-      let requestDescription = `${parsed.method} ${parsed.url}`;
-      try {
-        const endpointMatch = parsed.url.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]*)\))?(\s+.*)?$/);
-        const potentialEndpointName = endpointMatch ? endpointMatch[1] : null;
-        const endpoint = apiDefinitions && potentialEndpointName ? getEndpoint({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, potentialEndpointName) : void 0;
-        if (endpoint && apiDefinitions) {
-          const paramsStr = endpointMatch[2] || "";
-          const headerGroupsStr = endpointMatch[3]?.trim() || "";
-          const paramTokens = paramsStr ? paramsStr.split(",").map((p) => p.trim()) : [];
-          const params = {};
-          const isNamedSyntax = paramTokens.length > 0 && paramTokens[0].includes(":");
-          if (isNamedSyntax) {
-            for (const token of paramTokens) {
-              const kvMatch = token.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
-              if (kvMatch) {
-                const paramName = kvMatch[1];
-                let paramValue = kvMatch[2].trim().replace(/^["']|["']$/g, "");
-                const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
-                params[paramName] = substituteVariables(bareResolved, runtimeVariables);
-              }
+        if (step.type === "wait") {
+          const durationMs = parseWaitCommand(step.content);
+          reportProgress(stepIdx, "wait", `wait: ${durationMs}ms`);
+          await sleep2(durationMs);
+          const stepResult = {
+            type: "print",
+            stepIndex: stepIdx,
+            print: {
+              title: `Waited ${durationMs >= 1e3 ? durationMs / 1e3 + "s" : durationMs + "ms"}`,
+              timestamp: Date.now() - startTime
             }
-          } else {
-            endpoint.parameters.forEach((paramName, idx) => {
-              if (paramTokens[idx] !== void 0) {
-                let paramValue = paramTokens[idx].replace(/^["']|["']$/g, "");
-                const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
-                params[paramName] = substituteVariables(bareResolved, runtimeVariables);
-              }
-            });
+          };
+          orderedSteps.push(stepResult);
+          continue;
+        }
+        if (step.type === "json") {
+          const bareResolved = resolveBareVariables(step.content, runtimeVariables);
+          const parsed = parseJsonCommand(substituteVariables(bareResolved, runtimeVariables));
+          if (!parsed) {
+            errors.push(`Step ${stepIdx + 1}: Invalid json command: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
-          let pathWithVars = substituteVariables(endpoint.path, runtimeVariables);
-          for (const paramName of endpoint.parameters) {
-            const value = params[paramName];
-            if (value !== void 0) {
-              pathWithVars = pathWithVars.replace(`{${paramName}}`, value);
+          const result = readJsonFile(parsed.filePath, workingDir);
+          const stepResult = {
+            type: "json",
+            stepIndex: stepIdx,
+            json: {
+              varName: parsed.varName,
+              filePath: result.filePath,
+              success: result.success,
+              error: result.error,
+              timestamp: Date.now() - startTime
             }
+          };
+          orderedSteps.push(stepResult);
+          if (!result.success) {
+            errors.push(`Failed to load JSON file: ${result.error}`);
+            reportProgress(stepIdx, "json", `json: ${parsed.varName} \u2717 ${result.error}`, stepResult);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
-          resolvedUrl = pathWithVars;
-          if (headerGroupsStr) {
-            const headerGroupNames = headerGroupsStr.split(/\s+/).filter((n) => n);
-            for (const groupName of headerGroupNames) {
-              const group = getHeaderGroup(
-                { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
-                groupName
-              );
-              if (group) {
-                const groupHeaders = resolveHeaderValues(group, runtimeVariables);
-                Object.assign(resolvedHeaders, groupHeaders);
+          runtimeVariables[parsed.varName] = JSON.stringify(result.data);
+          reportProgress(stepIdx, "json", `json: ${parsed.varName} = ${parsed.filePath}`, stepResult);
+          continue;
+        }
+        if (step.type === "propAssign") {
+          const parsed = parsePropertyAssignment(step.content);
+          if (!parsed) {
+            errors.push(`Step ${stepIdx + 1}: Invalid property assignment: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          if (!(parsed.varName in runtimeVariables)) {
+            errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not defined`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          let jsonObj;
+          try {
+            jsonObj = JSON.parse(runtimeVariables[parsed.varName]);
+          } catch {
+            errors.push(`Step ${stepIdx + 1}: Variable '${parsed.varName}' is not a valid JSON object`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const valueTrimmed = parsed.value.trim();
+          const bareVarMatch = valueTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)((?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*)$/);
+          let newValue;
+          if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
+            const varName = bareVarMatch[1];
+            const pathPart = bareVarMatch[2] || "";
+            let value = runtimeVariables[varName];
+            if (typeof value === "string") {
+              try {
+                const parsed2 = JSON.parse(value);
+                if (typeof parsed2 === "object" && parsed2 !== null) {
+                  value = parsed2;
+                }
+              } catch {
               }
             }
-          }
-          requestDescription = `${potentialEndpointName}(${paramTokens.join(", ")}) \u2192 ${parsed.method} ${resolvedUrl}`;
-        } else {
-          resolvedUrl = substituteVariables(parsed.url, runtimeVariables);
-          requestDescription = `${parsed.method} ${resolvedUrl}`;
-        }
-        let requestText = `${parsed.method} ${resolvedUrl}`;
-        if (Object.keys(resolvedHeaders).length > 0) {
-          const headerLines = Object.entries(resolvedHeaders).map(([k, v]) => `${k}: ${v}`);
-          requestText += "\n" + headerLines.join("\n");
-        }
-        const contentLines = step.content.split("\n");
-        if (contentLines.length > 1) {
-          const extraLines = contentLines.slice(1).map((line2) => substituteVariables(line2, runtimeVariables));
-          const hasExplicitBlank = extraLines.some((line2) => line2.trim() === "");
-          const firstNonEmpty = extraLines.find((line2) => line2.trim() !== "");
-          const startsWithHeader = firstNonEmpty ? /^[A-Za-z0-9\-_]+\s*:/.test(firstNonEmpty.trim()) : false;
-          if (hasExplicitBlank || startsWithHeader) {
-            requestText += "\n" + extraLines.join("\n");
+            if (pathPart) {
+              const path10 = pathPart.replace(/^\./, "");
+              newValue = getNestedValueFromObject(value, path10);
+            } else {
+              newValue = value;
+            }
           } else {
-            requestText += "\n\n" + extraLines.join("\n");
+            const bareResolvedValue = resolveBareVariables(parsed.value, runtimeVariables);
+            const resolvedValue = substituteVariables(bareResolvedValue, runtimeVariables);
+            newValue = resolvedValue;
+            try {
+              newValue = JSON.parse(resolvedValue);
+            } catch {
+            }
+          }
+          const success = setNestedValue(jsonObj, parsed.propertyPath, newValue);
+          if (!success) {
+            errors.push(`Step ${stepIdx + 1}: Failed to set property '${parsed.propertyPath}' on '${parsed.varName}'`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
+          runtimeVariables[parsed.varName] = JSON.stringify(jsonObj);
+          reportProgress(stepIdx, "propAssign", `${parsed.varName}.${parsed.propertyPath} = ${parsed.value}`, void 0);
+          continue;
         }
-        const requestParsed = parserHttpRequest(requestText, runtimeVariables);
-        validatePreparedRequest(
-          requestParsed,
-          buildRequestValidationContext(stepIdx + 1, requestParsed.method, requestParsed.url, `var ${parsed.varName}`)
-        );
-        const retryOpts = parsed.retryCount ? {
-          retryCount: parsed.retryCount,
-          backoffMs: parsed.backoffMs || 1e3,
-          onRetry: (attempt, total, error, waitMs) => {
-            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
+        if (step.type === "varAssign") {
+          const parsed = parseVarAssignCommand(step.content);
+          if (!parsed) {
+            errors.push(`Step ${stepIdx + 1}: Invalid variable assignment: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
-        } : void 0;
-        const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
-        addResponse(response);
-        responseIndexToVariable.set(responses.length, parsed.varName);
-        runtimeVariables[parsed.varName] = response;
-        const stepResult = {
-          type: "request",
-          stepIndex: stepIdx,
-          response,
-          requestMethod: parsed.method,
-          requestUrl: resolvedUrl,
-          variableName: parsed.varName
-        };
-        orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "request", `var ${parsed.varName} = ${requestDescription}`, stepResult);
-        const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
-        for (const capture of relevantCaptures) {
-          const value = getValueByPath(response, capture.path);
-          if (value !== void 0) {
-            runtimeVariables[capture.varName] = value;
-          } else {
-            errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+          const result = evaluateValueExpression(parsed.valueExpr, runtimeVariables);
+          if (result.error) {
+            errors.push(`Step ${stepIdx + 1}: ${result.error}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
+          runtimeVariables[parsed.varName] = result.value;
+          reportProgress(stepIdx, "propAssign", `var ${parsed.varName} = ${result.value}`, void 0);
+          continue;
         }
-      } catch (error) {
-        const userMessage = formatUserFacingError(
-          error,
-          buildRequestValidationContext(stepIdx + 1, void 0, void 0, `var ${parsed.varName}`)
-        );
-        let errorDetails = `Request failed for var ${parsed.varName}:
+        if (step.type === "varRequest") {
+          const commandLine = step.content.split("\n")[0];
+          const parsed = parseVarRequestCommand(commandLine);
+          if (!parsed) {
+            errors.push(`Step ${stepIdx + 1}: Invalid variable request: ${commandLine}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          requestIndex++;
+          let resolvedUrl = "";
+          let resolvedHeaders = {};
+          let requestDescription = `${parsed.method} ${parsed.url}`;
+          try {
+            const endpointMatch = parsed.url.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\(([^)]*)\))?(\s+.*)?$/);
+            const potentialEndpointName = endpointMatch ? endpointMatch[1] : null;
+            const endpoint = apiDefinitions && potentialEndpointName ? getEndpoint({ headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints }, potentialEndpointName) : void 0;
+            if (endpoint && apiDefinitions) {
+              const paramsStr = endpointMatch[2] || "";
+              const headerGroupsStr = endpointMatch[3]?.trim() || "";
+              const paramTokens = paramsStr ? paramsStr.split(",").map((p) => p.trim()) : [];
+              const params = {};
+              const isNamedSyntax = paramTokens.length > 0 && paramTokens[0].includes(":");
+              if (isNamedSyntax) {
+                for (const token of paramTokens) {
+                  const kvMatch = token.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+)$/);
+                  if (kvMatch) {
+                    const paramName = kvMatch[1];
+                    let paramValue = kvMatch[2].trim().replace(/^["']|["']$/g, "");
+                    const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
+                    params[paramName] = substituteVariables(bareResolved, runtimeVariables);
+                  }
+                }
+              } else {
+                endpoint.parameters.forEach((paramName, idx) => {
+                  if (paramTokens[idx] !== void 0) {
+                    let paramValue = paramTokens[idx].replace(/^["']|["']$/g, "");
+                    const bareResolved = resolveBareVariables(paramValue, runtimeVariables);
+                    params[paramName] = substituteVariables(bareResolved, runtimeVariables);
+                  }
+                });
+              }
+              let pathWithVars = substituteVariables(endpoint.path, runtimeVariables);
+              for (const paramName of endpoint.parameters) {
+                const value = params[paramName];
+                if (value !== void 0) {
+                  pathWithVars = pathWithVars.replace(`{${paramName}}`, value);
+                }
+              }
+              resolvedUrl = pathWithVars;
+              if (headerGroupsStr) {
+                const headerGroupNames = headerGroupsStr.split(/\s+/).filter((n) => n);
+                for (const groupName of headerGroupNames) {
+                  const group = getHeaderGroup(
+                    { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
+                    groupName
+                  );
+                  if (group) {
+                    const groupHeaders = resolveHeaderValues(group, runtimeVariables);
+                    Object.assign(resolvedHeaders, groupHeaders);
+                  }
+                }
+              }
+              requestDescription = `${potentialEndpointName}(${paramTokens.join(", ")}) \u2192 ${parsed.method} ${resolvedUrl}`;
+            } else {
+              resolvedUrl = substituteVariables(parsed.url, runtimeVariables);
+              requestDescription = `${parsed.method} ${resolvedUrl}`;
+            }
+            let requestText = `${parsed.method} ${resolvedUrl}`;
+            if (Object.keys(resolvedHeaders).length > 0) {
+              const headerLines = Object.entries(resolvedHeaders).map(([k, v]) => `${k}: ${v}`);
+              requestText += "\n" + headerLines.join("\n");
+            }
+            const contentLines = step.content.split("\n");
+            if (contentLines.length > 1) {
+              const extraLines = contentLines.slice(1).map((line2) => substituteVariables(line2, runtimeVariables));
+              const hasExplicitBlank = extraLines.some((line2) => line2.trim() === "");
+              const firstNonEmpty = extraLines.find((line2) => line2.trim() !== "");
+              const startsWithHeader = firstNonEmpty ? /^[A-Za-z0-9\-_]+\s*:/.test(firstNonEmpty.trim()) : false;
+              if (hasExplicitBlank || startsWithHeader) {
+                requestText += "\n" + extraLines.join("\n");
+              } else {
+                requestText += "\n\n" + extraLines.join("\n");
+              }
+            }
+            const requestParsed = parserHttpRequest(requestText, runtimeVariables);
+            validatePreparedRequest(
+              requestParsed,
+              buildRequestValidationContext(stepIdx + 1, requestParsed.method, requestParsed.url, `var ${parsed.varName}`)
+            );
+            const retryOpts = parsed.retryCount ? {
+              retryCount: parsed.retryCount,
+              backoffMs: parsed.backoffMs || 1e3,
+              onRetry: (attempt, total, error, waitMs) => {
+                reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
+              }
+            } : void 0;
+            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+            addResponse(response);
+            responseIndexToVariable.set(responses.length, parsed.varName);
+            runtimeVariables[parsed.varName] = response;
+            const stepResult = {
+              type: "request",
+              stepIndex: stepIdx,
+              response,
+              requestMethod: parsed.method,
+              requestUrl: resolvedUrl,
+              variableName: parsed.varName
+            };
+            orderedSteps.push(stepResult);
+            reportProgress(stepIdx, "request", `var ${parsed.varName} = ${requestDescription}`, stepResult);
+            const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
+            for (const capture of relevantCaptures) {
+              const value = getValueByPath(response, capture.path);
+              if (value !== void 0) {
+                runtimeVariables[capture.varName] = value;
+              } else {
+                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+              }
+            }
+          } catch (error) {
+            const userMessage = formatUserFacingError(
+              error,
+              buildRequestValidationContext(stepIdx + 1, void 0, void 0, `var ${parsed.varName}`)
+            );
+            let errorDetails = `Request failed for var ${parsed.varName}:
 ${indentMultiline(userMessage)}`;
-        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
-          errorDetails += `
+            if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
+              errorDetails += `
   Request: ${requestDescription}`;
+            }
+            errors.push(errorDetails);
+            await emitFailure(errorDetails, step, stepIdx);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          continue;
         }
-        errors.push(errorDetails);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      continue;
-    }
-    if (step.type === "script") {
-      const parsed = parseRunCommand(substituteVariables(step.content, runtimeVariables));
-      if (!parsed) {
-        errors.push(`Step ${stepIdx + 1}: Invalid run command: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const substitutedArgs = parsed.args.map((arg) => {
-        const bareResolved = resolveBareVariables(arg, runtimeVariables);
-        return substituteVariables(bareResolved, runtimeVariables);
-      });
-      const substitutedPath = substituteVariables(parsed.scriptPath, runtimeVariables);
-      try {
-        const result = await runScript(
-          parsed.type,
-          substitutedPath,
-          substitutedArgs,
-          workingDir || process.cwd(),
-          runtimeVariables,
-          parsed.captureAs
-        );
-        scriptResults.push(result);
-        const stepResult = {
-          type: "script",
-          stepIndex: stepIdx,
-          script: result
-        };
-        orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "script", `run ${parsed.type} ${substitutedPath}`, stepResult);
-        if (!result.success) {
-          errors.push(`Script failed (exit ${result.exitCode}): ${result.error || result.output}`);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime
-          };
-        }
-        if (parsed.captureAs) {
-          let outputValue = result.output;
+        if (step.type === "script") {
+          const parsed = parseRunCommand(substituteVariables(step.content, runtimeVariables));
+          if (!parsed) {
+            errors.push(`Step ${stepIdx + 1}: Invalid run command: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const substitutedArgs = parsed.args.map((arg) => {
+            const bareResolved = resolveBareVariables(arg, runtimeVariables);
+            return substituteVariables(bareResolved, runtimeVariables);
+          });
+          const substitutedPath = substituteVariables(parsed.scriptPath, runtimeVariables);
           try {
-            const jsonParsed = JSON.parse(result.output);
-            outputValue = jsonParsed;
-          } catch {
+            const result = await runScript(
+              parsed.type,
+              substitutedPath,
+              substitutedArgs,
+              workingDir || process.cwd(),
+              runtimeVariables,
+              parsed.captureAs
+            );
+            scriptResults.push(result);
+            const stepResult = {
+              type: "script",
+              stepIndex: stepIdx,
+              script: result
+            };
+            orderedSteps.push(stepResult);
+            reportProgress(stepIdx, "script", `run ${parsed.type} ${substitutedPath}`, stepResult);
+            if (!result.success) {
+              errors.push(`Script failed (exit ${result.exitCode}): ${result.error || result.output}`);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime
+              };
+            }
+            if (parsed.captureAs) {
+              let outputValue = result.output;
+              try {
+                const jsonParsed = JSON.parse(result.output);
+                outputValue = jsonParsed;
+              } catch {
+              }
+              runtimeVariables[parsed.captureAs] = outputValue;
+            }
+          } catch (error) {
+            errors.push(`Script execution error: ${error.message}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
           }
-          runtimeVariables[parsed.captureAs] = outputValue;
-        }
-      } catch (error) {
-        errors.push(`Script execution error: ${error.message}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-    } else if (step.type === "namedRequest") {
-      const parsed = parseRunNamedRequestCommand(step.content);
-      if (!parsed) {
-        errors.push(`Invalid run command: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const { name: targetName, args: runArgs } = parsed;
-      if (!fullDocumentText) {
-        errors.push(`Cannot run "${targetName}": full document text not provided`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const allSequences = extractSequences(fullDocumentText);
-      const targetSequence = allSequences.find((s) => s.name === targetName);
-      if (targetSequence) {
-        const currentCallStack = callStack || [];
-        if (currentCallStack.includes(targetName)) {
-          errors.push(`Circular reference detected: ${[...currentCallStack, targetName].join(" \u2192 ")}`);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime
-          };
-        }
-        let sequenceArgs2 = {};
-        if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
-          const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
-          if ("error" in bindResult) {
-            errors.push(`Error calling sequence "${targetName}": ${bindResult.error}`);
+        } else if (step.type === "namedRequest") {
+          const parsed = parseRunNamedRequestCommand(step.content);
+          if (!parsed) {
+            errors.push(`Invalid run command: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const { name: targetName, args: runArgs } = parsed;
+          if (!fullDocumentText) {
+            errors.push(`Cannot run "${targetName}": full document text not provided`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const allSequences = extractSequences(fullDocumentText);
+          const targetSequence = allSequences.find((s) => s.name === targetName);
+          if (targetSequence) {
+            const currentCallStack = callStack || [];
+            if (currentCallStack.includes(targetName)) {
+              errors.push(`Circular reference detected: ${[...currentCallStack, targetName].join(" \u2192 ")}`);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime
+              };
+            }
+            let sequenceArgs2 = {};
+            if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
+              const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
+              if ("error" in bindResult) {
+                errors.push(`Error calling sequence "${targetName}": ${bindResult.error}`);
+                return {
+                  name: "",
+                  success: false,
+                  responses,
+                  scriptResults,
+                  assertionResults,
+                  steps: orderedSteps,
+                  errors,
+                  duration: Date.now() - startTime
+                };
+              }
+              sequenceArgs2 = bindResult.variables;
+            }
+            if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
+              if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
+                continue;
+              }
+            }
+            reportProgress(stepIdx, "sequenceStart", `Starting sequence ${targetName}`, void 0, targetName);
+            let subWorkingDir = workingDir;
+            if (sequenceSources) {
+              const sourceFile = sequenceSources.get(targetName.toLowerCase());
+              if (sourceFile) {
+                const path10 = await import("path");
+                subWorkingDir = path10.dirname(sourceFile);
+              }
+            }
+            const targetLocation = executionContext?.sequenceLocationIndex?.get(targetName.toLowerCase());
+            const childExecutionContext = {
+              filePath: targetLocation?.filePath ?? executionContext?.filePath,
+              sequenceName: targetName,
+              environment: executionContext?.environment,
+              sequenceStartLine: targetLocation?.startLine ?? targetSequence.startLine,
+              sequenceLocationIndex: executionContext?.sequenceLocationIndex
+            };
+            const subResult = await runSequenceWithJar(
+              targetSequence.content,
+              runtimeVariables,
+              // Pass current runtime variables (includes file vars + any captured)
+              cookieJar,
+              subWorkingDir,
+              fullDocumentText,
+              onProgress,
+              // Pass through progress callback
+              [...currentCallStack, targetName],
+              // Add to call stack for circular detection
+              sequenceArgs2,
+              // Pass bound arguments as initial scope variables
+              apiDefinitions,
+              // Pass API definitions for endpoint resolution
+              tagFilterOptions,
+              // Pass tag filter options for nested sequence filtering
+              sequenceSources,
+              // Pass sequence sources for nested sequences
+              childExecutionContext,
+              debugHooks
+            );
+            reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${targetName}`, void 0, targetName);
+            for (const subResponse of subResult.responses) {
+              addResponse(subResponse);
+            }
+            scriptResults.push(...subResult.scriptResults);
+            assertionResults.push(...subResult.assertionResults);
+            for (const subStep of subResult.steps) {
+              orderedSteps.push({
+                ...subStep,
+                stepIndex: orderedSteps.length
+              });
+            }
+            requestIndex += subResult.responses.length;
+            if (!subResult.success) {
+              errors.push(`Sequence "${targetName}" failed`);
+              errors.push(...subResult.errors);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime,
+                variables: runtimeVariables
+              };
+            }
+            continue;
+          }
+          const namedRequest = getNamedRequest(fullDocumentText, targetName);
+          if (!namedRequest) {
+            errors.push(`"${targetName}" is not a named request or sequence`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          requestIndex++;
+          let requestUrl = "";
+          let requestMethod = "";
+          try {
+            let requestParsed;
+            if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(namedRequest.content, apiDefinitions.endpoints)) {
+              const apiRequest = parseApiRequest(
+                namedRequest.content,
+                apiDefinitions.endpoints,
+                apiDefinitions.headerGroups
+              );
+              if (apiRequest) {
+                const endpoint = getEndpoint(
+                  { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
+                  apiRequest.endpointName
+                );
+                if (endpoint) {
+                  let resolvedPath = endpoint.path;
+                  resolvedPath = resolvedPath.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
+                    return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
+                  });
+                  for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
+                    let resolvedValue = paramValue;
+                    if (runtimeVariables[paramValue] !== void 0) {
+                      resolvedValue = String(runtimeVariables[paramValue]);
+                    } else if (paramValue.startsWith("{{") && paramValue.endsWith("}}")) {
+                      const varName = paramValue.slice(2, -2);
+                      if (runtimeVariables[varName] !== void 0) {
+                        resolvedValue = String(runtimeVariables[varName]);
+                      }
+                    }
+                    resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
+                  }
+                  const combinedHeaders = {};
+                  for (const groupName of apiRequest.headerGroupNames) {
+                    const group = getHeaderGroup(apiDefinitions, groupName);
+                    if (group) {
+                      const resolvedHeaders = resolveHeaderValues(group, runtimeVariables);
+                      Object.assign(combinedHeaders, resolvedHeaders);
+                    }
+                  }
+                  for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
+                    let resolved = headerValue;
+                    resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
+                      return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
+                    });
+                    combinedHeaders[headerName] = resolved;
+                  }
+                  const bodyParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+                  requestParsed = {
+                    method: apiRequest.method,
+                    url: resolvedPath,
+                    headers: combinedHeaders,
+                    body: bodyParsed.body
+                  };
+                } else {
+                  throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
+                }
+              } else {
+                requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+              }
+            } else {
+              requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+              if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
+                requestParsed = applyHeaderGroupsToRequest(requestParsed, namedRequest.content, apiDefinitions.headerGroups, runtimeVariables);
+              }
+            }
+            requestUrl = requestParsed.url;
+            requestMethod = requestParsed.method;
+            validatePreparedRequest(
+              requestParsed,
+              buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, targetName)
+            );
+            const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+            const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
+            const retryOpts = effectiveRetryCount ? {
+              retryCount: effectiveRetryCount,
+              backoffMs: effectiveBackoffMs,
+              onRetry: (attempt, total, error, waitMs) => {
+                reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] run ${targetName} - waiting ${waitMs}ms`, void 0);
+              }
+            } : void 0;
+            const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+            addResponse(response);
+            const stepResult = {
+              type: "request",
+              stepIndex: stepIdx,
+              response,
+              requestMethod: requestParsed.method,
+              requestUrl: requestParsed.url
+            };
+            orderedSteps.push(stepResult);
+            reportProgress(stepIdx, "namedRequest", `run ${targetName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
+            const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
+            for (const capture of relevantCaptures) {
+              const value = getValueByPath(response, capture.path);
+              if (value !== void 0) {
+                runtimeVariables[capture.varName] = value;
+              } else {
+                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+              }
+            }
+          } catch (error) {
+            const userMessage = formatUserFacingError(
+              error,
+              buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, targetName)
+            );
+            let errorDetails = `Named request "${targetName}" failed:
+${indentMultiline(userMessage)}`;
+            if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
+              errorDetails += `
+  Request: ${requestMethod} ${requestUrl}`;
+            }
+            errors.push(errorDetails);
+            await emitFailure(errorDetails, step, stepIdx);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+        } else if (step.type === "varRunSequence") {
+          const parsed = parseVarRunSequenceCommand(step.content);
+          if (!parsed) {
+            errors.push(`Invalid var run sequence command: ${step.content}`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const { varName, sequenceName, args: runArgs } = parsed;
+          if (!fullDocumentText) {
+            errors.push(`Cannot run sequence "${sequenceName}": full document text not provided`);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
+          const allSequences = extractSequences(fullDocumentText);
+          const targetSequence = allSequences.find((s) => s.name === sequenceName);
+          if (!targetSequence) {
+            const namedRequest = getNamedRequest(fullDocumentText, sequenceName);
+            if (!namedRequest) {
+              errors.push(`"${sequenceName}" is not a named request or sequence`);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime
+              };
+            }
+            requestIndex++;
+            let requestUrl = "";
+            let requestMethod = "";
+            try {
+              const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
+              requestUrl = requestParsed.url;
+              requestMethod = requestParsed.method;
+              validatePreparedRequest(
+                requestParsed,
+                buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, `${varName} = run ${sequenceName}`)
+              );
+              const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
+              const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
+              const retryOpts = effectiveRetryCount ? {
+                retryCount: effectiveRetryCount,
+                backoffMs: effectiveBackoffMs,
+                onRetry: (attempt, total, error, waitMs) => {
+                  reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] var ${varName} = run ${sequenceName} - waiting ${waitMs}ms`, void 0);
+                }
+              } : void 0;
+              const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
+              addResponse(response);
+              responseIndexToVariable.set(responses.length, varName);
+              const stepResult = {
+                type: "request",
+                stepIndex: stepIdx,
+                response,
+                requestMethod: requestParsed.method,
+                requestUrl: requestParsed.url,
+                variableName: varName
+              };
+              orderedSteps.push(stepResult);
+              reportProgress(stepIdx, "namedRequest", `var ${varName} = run ${sequenceName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
+              const capturedResponse = {
+                status: response.status,
+                statusText: response.statusText,
+                body: response.body,
+                headers: response.headers
+              };
+              runtimeVariables[varName] = JSON.stringify(capturedResponse);
+              const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
+              for (const capture of relevantCaptures) {
+                const value = getValueByPath(response, capture.path);
+                if (value !== void 0) {
+                  runtimeVariables[capture.varName] = value;
+                } else {
+                  errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+                }
+              }
+            } catch (error) {
+              const userMessage = formatUserFacingError(
+                error,
+                buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, `${varName} = run ${sequenceName}`)
+              );
+              let errorDetails = `Named request "${sequenceName}" failed:
+${indentMultiline(userMessage)}`;
+              if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
+                errorDetails += `
+  Request: ${requestMethod} ${requestUrl}`;
+              }
+              errors.push(errorDetails);
+              await emitFailure(errorDetails, step, stepIdx);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime
+              };
+            }
+            continue;
+          }
+          const currentCallStack = callStack || [];
+          if (currentCallStack.includes(sequenceName)) {
+            errors.push(`Circular reference detected: ${[...currentCallStack, sequenceName].join(" \u2192 ")}`);
             return {
               name: "",
               success: false,
@@ -28817,600 +29238,285 @@ ${indentMultiline(userMessage)}`;
               duration: Date.now() - startTime
             };
           }
-          sequenceArgs2 = bindResult.variables;
-        }
-        if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
-          if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
-            continue;
-          }
-        }
-        reportProgress(stepIdx, "sequenceStart", `Starting sequence ${targetName}`, void 0, targetName);
-        let subWorkingDir = workingDir;
-        if (sequenceSources) {
-          const sourceFile = sequenceSources.get(targetName.toLowerCase());
-          if (sourceFile) {
-            const path10 = await import("path");
-            subWorkingDir = path10.dirname(sourceFile);
-          }
-        }
-        const subResult = await runSequenceWithJar(
-          targetSequence.content,
-          runtimeVariables,
-          // Pass current runtime variables (includes file vars + any captured)
-          cookieJar,
-          subWorkingDir,
-          fullDocumentText,
-          onProgress,
-          // Pass through progress callback
-          [...currentCallStack, targetName],
-          // Add to call stack for circular detection
-          sequenceArgs2,
-          // Pass bound arguments as initial scope variables
-          apiDefinitions,
-          // Pass API definitions for endpoint resolution
-          tagFilterOptions,
-          // Pass tag filter options for nested sequence filtering
-          sequenceSources,
-          // Pass sequence sources for nested sequences
-          executionContext
-        );
-        reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${targetName}`, void 0, targetName);
-        for (const subResponse of subResult.responses) {
-          addResponse(subResponse);
-        }
-        scriptResults.push(...subResult.scriptResults);
-        assertionResults.push(...subResult.assertionResults);
-        for (const subStep of subResult.steps) {
-          orderedSteps.push({
-            ...subStep,
-            stepIndex: orderedSteps.length
-          });
-        }
-        requestIndex += subResult.responses.length;
-        if (!subResult.success) {
-          errors.push(`Sequence "${targetName}" failed`);
-          errors.push(...subResult.errors);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime,
-            variables: runtimeVariables
-          };
-        }
-        continue;
-      }
-      const namedRequest = getNamedRequest(fullDocumentText, targetName);
-      if (!namedRequest) {
-        errors.push(`"${targetName}" is not a named request or sequence`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      requestIndex++;
-      let requestUrl = "";
-      let requestMethod = "";
-      try {
-        let requestParsed;
-        if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(namedRequest.content, apiDefinitions.endpoints)) {
-          const apiRequest = parseApiRequest(
-            namedRequest.content,
-            apiDefinitions.endpoints,
-            apiDefinitions.headerGroups
-          );
-          if (apiRequest) {
-            const endpoint = getEndpoint(
-              { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
-              apiRequest.endpointName
-            );
-            if (endpoint) {
-              let resolvedPath = endpoint.path;
-              resolvedPath = resolvedPath.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
-              });
-              for (const [paramName, paramValue] of Object.entries(apiRequest.params)) {
-                let resolvedValue = paramValue;
-                if (runtimeVariables[paramValue] !== void 0) {
-                  resolvedValue = String(runtimeVariables[paramValue]);
-                } else if (paramValue.startsWith("{{") && paramValue.endsWith("}}")) {
-                  const varName = paramValue.slice(2, -2);
-                  if (runtimeVariables[varName] !== void 0) {
-                    resolvedValue = String(runtimeVariables[varName]);
-                  }
-                }
-                resolvedPath = resolvedPath.replace(`{${paramName}}`, resolvedValue);
-              }
-              const combinedHeaders = {};
-              for (const groupName of apiRequest.headerGroupNames) {
-                const group = getHeaderGroup(apiDefinitions, groupName);
-                if (group) {
-                  const resolvedHeaders = resolveHeaderValues(group, runtimeVariables);
-                  Object.assign(combinedHeaders, resolvedHeaders);
-                }
-              }
-              for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-                let resolved = headerValue;
-                resolved = resolved.replace(/\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g, (_, varName) => {
-                  return runtimeVariables[varName] !== void 0 ? String(runtimeVariables[varName]) : `{{${varName}}}`;
-                });
-                combinedHeaders[headerName] = resolved;
-              }
-              const bodyParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-              requestParsed = {
-                method: apiRequest.method,
-                url: resolvedPath,
-                headers: combinedHeaders,
-                body: bodyParsed.body
+          let sequenceArgs2 = {};
+          if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
+            const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
+            if ("error" in bindResult) {
+              errors.push(`Error calling sequence "${sequenceName}": ${bindResult.error}`);
+              return {
+                name: "",
+                success: false,
+                responses,
+                scriptResults,
+                assertionResults,
+                steps: orderedSteps,
+                errors,
+                duration: Date.now() - startTime
               };
-            } else {
-              throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
             }
-          } else {
-            requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-          }
-        } else {
-          requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-          if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-            requestParsed = applyHeaderGroupsToRequest(requestParsed, namedRequest.content, apiDefinitions.headerGroups, runtimeVariables);
+            sequenceArgs2 = bindResult.variables;
           }
-        }
-        requestUrl = requestParsed.url;
-        requestMethod = requestParsed.method;
-        validatePreparedRequest(
-          requestParsed,
-          buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, targetName)
-        );
-        const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
-        const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
-        const retryOpts = effectiveRetryCount ? {
-          retryCount: effectiveRetryCount,
-          backoffMs: effectiveBackoffMs,
-          onRetry: (attempt, total, error, waitMs) => {
-            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] run ${targetName} - waiting ${waitMs}ms`, void 0);
+          if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
+            if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
+              continue;
+            }
           }
-        } : void 0;
-        const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
-        addResponse(response);
-        const stepResult = {
-          type: "request",
-          stepIndex: stepIdx,
-          response,
-          requestMethod: requestParsed.method,
-          requestUrl: requestParsed.url
-        };
-        orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "namedRequest", `run ${targetName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
-        const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
-        for (const capture of relevantCaptures) {
-          const value = getValueByPath(response, capture.path);
-          if (value !== void 0) {
-            runtimeVariables[capture.varName] = value;
-          } else {
-            errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
+          reportProgress(stepIdx, "sequenceStart", `Starting sequence ${sequenceName}`, void 0, sequenceName);
+          let subWorkingDir = workingDir;
+          if (sequenceSources) {
+            const sourceFile = sequenceSources.get(sequenceName.toLowerCase());
+            if (sourceFile) {
+              const path10 = await import("path");
+              subWorkingDir = path10.dirname(sourceFile);
+            }
           }
-        }
-      } catch (error) {
-        const userMessage = formatUserFacingError(
-          error,
-          buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, targetName)
-        );
-        let errorDetails = `Named request "${targetName}" failed:
-${indentMultiline(userMessage)}`;
-        if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
-          errorDetails += `
-  Request: ${requestMethod} ${requestUrl}`;
-        }
-        errors.push(errorDetails);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-    } else if (step.type === "varRunSequence") {
-      const parsed = parseVarRunSequenceCommand(step.content);
-      if (!parsed) {
-        errors.push(`Invalid var run sequence command: ${step.content}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const { varName, sequenceName, args: runArgs } = parsed;
-      if (!fullDocumentText) {
-        errors.push(`Cannot run sequence "${sequenceName}": full document text not provided`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      const allSequences = extractSequences(fullDocumentText);
-      const targetSequence = allSequences.find((s) => s.name === sequenceName);
-      if (!targetSequence) {
-        const namedRequest = getNamedRequest(fullDocumentText, sequenceName);
-        if (!namedRequest) {
-          errors.push(`"${sequenceName}" is not a named request or sequence`);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime
+          const targetLocation = executionContext?.sequenceLocationIndex?.get(sequenceName.toLowerCase());
+          const childExecutionContext = {
+            filePath: targetLocation?.filePath ?? executionContext?.filePath,
+            sequenceName,
+            environment: executionContext?.environment,
+            sequenceStartLine: targetLocation?.startLine ?? targetSequence.startLine,
+            sequenceLocationIndex: executionContext?.sequenceLocationIndex
           };
-        }
-        requestIndex++;
-        let requestUrl = "";
-        let requestMethod = "";
-        try {
-          const requestParsed = parserHttpRequest(namedRequest.content, runtimeVariables);
-          requestUrl = requestParsed.url;
-          requestMethod = requestParsed.method;
-          validatePreparedRequest(
-            requestParsed,
-            buildRequestValidationContext(stepIdx + 1, requestMethod, requestUrl, `${varName} = run ${sequenceName}`)
+          const subResult = await runSequenceWithJar(
+            targetSequence.content,
+            runtimeVariables,
+            cookieJar,
+            subWorkingDir,
+            fullDocumentText,
+            onProgress,
+            [...currentCallStack, sequenceName],
+            sequenceArgs2,
+            // Pass bound arguments
+            apiDefinitions,
+            // Pass API definitions for endpoint resolution
+            tagFilterOptions,
+            // Pass tag filter options for nested sequence filtering
+            sequenceSources,
+            // Pass sequence sources for nested sequences
+            childExecutionContext,
+            debugHooks
           );
-          const effectiveRetryCount = parsed.retryCount ?? requestParsed.retryCount;
-          const effectiveBackoffMs = parsed.backoffMs ?? requestParsed.backoffMs ?? 1e3;
-          const retryOpts = effectiveRetryCount ? {
-            retryCount: effectiveRetryCount,
-            backoffMs: effectiveBackoffMs,
-            onRetry: (attempt, total, error, waitMs) => {
-              reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] var ${varName} = run ${sequenceName} - waiting ${waitMs}ms`, void 0);
-            }
-          } : void 0;
-          const response = cookieJar ? await sendRequestWithJar(requestParsed, cookieJar, retryOpts) : await sendRequest(requestParsed, retryOpts);
-          addResponse(response);
-          responseIndexToVariable.set(responses.length, varName);
-          const stepResult = {
-            type: "request",
-            stepIndex: stepIdx,
-            response,
-            requestMethod: requestParsed.method,
-            requestUrl: requestParsed.url,
-            variableName: varName
-          };
-          orderedSteps.push(stepResult);
-          reportProgress(stepIdx, "namedRequest", `var ${varName} = run ${sequenceName} \u2192 ${requestParsed.method} ${requestParsed.url}`, stepResult);
-          const capturedResponse = {
-            status: response.status,
-            statusText: response.statusText,
-            body: response.body,
-            headers: response.headers
-          };
-          runtimeVariables[varName] = JSON.stringify(capturedResponse);
-          const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
-          for (const capture of relevantCaptures) {
-            const value = getValueByPath(response, capture.path);
-            if (value !== void 0) {
-              runtimeVariables[capture.varName] = value;
-            } else {
-              errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
-            }
+          reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${sequenceName}`, void 0, sequenceName);
+          for (const subResponse of subResult.responses) {
+            addResponse(subResponse);
           }
-        } catch (error) {
-          const userMessage = formatUserFacingError(
-            error,
-            buildRequestValidationContext(stepIdx + 1, requestMethod || void 0, requestUrl || void 0, `${varName} = run ${sequenceName}`)
-          );
-          let errorDetails = `Named request "${sequenceName}" failed:
-${indentMultiline(userMessage)}`;
-          if (requestUrl && !/\nRequest:\s/.test(userMessage)) {
-            errorDetails += `
-  Request: ${requestMethod} ${requestUrl}`;
+          scriptResults.push(...subResult.scriptResults);
+          assertionResults.push(...subResult.assertionResults);
+          for (const subStep of subResult.steps) {
+            orderedSteps.push({
+              ...subStep,
+              stepIndex: orderedSteps.length
+            });
           }
-          errors.push(errorDetails);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime
-          };
-        }
-        continue;
-      }
-      const currentCallStack = callStack || [];
-      if (currentCallStack.includes(sequenceName)) {
-        errors.push(`Circular reference detected: ${[...currentCallStack, sequenceName].join(" \u2192 ")}`);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
-      }
-      let sequenceArgs2 = {};
-      if (targetSequence.parameters.length > 0 || runArgs.length > 0) {
-        const bindResult = bindSequenceArguments(targetSequence.parameters, runArgs, runtimeVariables);
-        if ("error" in bindResult) {
-          errors.push(`Error calling sequence "${sequenceName}": ${bindResult.error}`);
-          return {
-            name: "",
-            success: false,
-            responses,
-            scriptResults,
-            assertionResults,
-            steps: orderedSteps,
-            errors,
-            duration: Date.now() - startTime
-          };
-        }
-        sequenceArgs2 = bindResult.variables;
-      }
-      if (tagFilterOptions && tagFilterOptions.filters.length > 0) {
-        if (!sequenceMatchesTags(targetSequence, tagFilterOptions)) {
-          continue;
-        }
-      }
-      reportProgress(stepIdx, "sequenceStart", `Starting sequence ${sequenceName}`, void 0, sequenceName);
-      let subWorkingDir = workingDir;
-      if (sequenceSources) {
-        const sourceFile = sequenceSources.get(sequenceName.toLowerCase());
-        if (sourceFile) {
-          const path10 = await import("path");
-          subWorkingDir = path10.dirname(sourceFile);
-        }
-      }
-      const subResult = await runSequenceWithJar(
-        targetSequence.content,
-        runtimeVariables,
-        cookieJar,
-        subWorkingDir,
-        fullDocumentText,
-        onProgress,
-        [...currentCallStack, sequenceName],
-        sequenceArgs2,
-        // Pass bound arguments
-        apiDefinitions,
-        // Pass API definitions for endpoint resolution
-        tagFilterOptions,
-        // Pass tag filter options for nested sequence filtering
-        sequenceSources,
-        // Pass sequence sources for nested sequences
-        executionContext
-      );
-      reportProgress(stepIdx, "sequenceEnd", `Finished sequence ${sequenceName}`, void 0, sequenceName);
-      for (const subResponse of subResult.responses) {
-        addResponse(subResponse);
-      }
-      scriptResults.push(...subResult.scriptResults);
-      assertionResults.push(...subResult.assertionResults);
-      for (const subStep of subResult.steps) {
-        orderedSteps.push({
-          ...subStep,
-          stepIndex: orderedSteps.length
-        });
-      }
-      const returnExpressions = extractReturnVariables(targetSequence.content);
-      if (returnExpressions && returnExpressions.length > 0 && subResult.variables) {
-        if (returnExpressions.length === 1) {
-          const resolved = resolveReturnExpression(returnExpressions[0], subResult.variables);
-          if (resolved) {
-            runtimeVariables[varName] = resolved.value;
+          const returnExpressions = extractReturnVariables(targetSequence.content);
+          if (returnExpressions && returnExpressions.length > 0 && subResult.variables) {
+            if (returnExpressions.length === 1) {
+              const resolved = resolveReturnExpression(returnExpressions[0], subResult.variables);
+              if (resolved) {
+                runtimeVariables[varName] = resolved.value;
+              } else {
+                runtimeVariables[varName] = "";
+              }
+            } else {
+              const returnedObj = {};
+              for (const expr of returnExpressions) {
+                const resolved = resolveReturnExpression(expr, subResult.variables);
+                if (resolved) {
+                  returnedObj[resolved.key] = resolved.value;
+                }
+              }
+              runtimeVariables[varName] = JSON.stringify(returnedObj);
+            }
           } else {
             runtimeVariables[varName] = "";
           }
-        } else {
-          const returnedObj = {};
-          for (const expr of returnExpressions) {
-            const resolved = resolveReturnExpression(expr, subResult.variables);
-            if (resolved) {
-              returnedObj[resolved.key] = resolved.value;
-            }
+          requestIndex += subResult.responses.length;
+          if (!subResult.success) {
+            errors.push(`Sequence "${sequenceName}" failed`);
+            errors.push(...subResult.errors);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime,
+              variables: runtimeVariables
+            };
           }
-          runtimeVariables[varName] = JSON.stringify(returnedObj);
-        }
-      } else {
-        runtimeVariables[varName] = "";
-      }
-      requestIndex += subResult.responses.length;
-      if (!subResult.success) {
-        errors.push(`Sequence "${sequenceName}" failed`);
-        errors.push(...subResult.errors);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime,
-          variables: runtimeVariables
-        };
-      }
-      continue;
-    } else {
-      requestIndex++;
-      let parsed;
-      let requestDescription = "";
-      try {
-        if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(step.content, apiDefinitions.endpoints)) {
-          const apiRequest = parseApiRequest(
-            step.content,
-            apiDefinitions.endpoints,
-            apiDefinitions.headerGroups
-          );
-          if (apiRequest) {
-            const endpoint = getEndpoint(
-              { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
-              apiRequest.endpointName
-            );
-            if (!endpoint) {
-              throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
-            }
-            const pathWithVars = substituteVariables(endpoint.path, runtimeVariables);
-            const resolvedParams = {};
-            for (const [key, value] of Object.entries(apiRequest.params)) {
-              const bareResolved = resolveBareVariables(value, runtimeVariables);
-              resolvedParams[key] = substituteVariables(bareResolved, runtimeVariables);
-            }
-            let resolvedPath = pathWithVars;
-            for (const paramName of endpoint.parameters) {
-              const value = resolvedParams[paramName];
-              if (value !== void 0) {
-                resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
-              }
-            }
-            const combinedHeaders = {};
-            for (const groupName of apiRequest.headerGroupNames) {
-              const group = getHeaderGroup(
-                { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
-                groupName
+          continue;
+        } else {
+          requestIndex++;
+          let parsed;
+          let requestDescription = "";
+          try {
+            if (apiDefinitions && apiDefinitions.endpoints.length > 0 && isApiRequestLine(step.content, apiDefinitions.endpoints)) {
+              const apiRequest = parseApiRequest(
+                step.content,
+                apiDefinitions.endpoints,
+                apiDefinitions.headerGroups
               );
-              if (group) {
-                const resolvedHeaders = resolveHeaderValues(group, runtimeVariables);
-                Object.assign(combinedHeaders, resolvedHeaders);
+              if (apiRequest) {
+                const endpoint = getEndpoint(
+                  { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
+                  apiRequest.endpointName
+                );
+                if (!endpoint) {
+                  throw new Error(`Unknown endpoint: ${apiRequest.endpointName}`);
+                }
+                const pathWithVars = substituteVariables(endpoint.path, runtimeVariables);
+                const resolvedParams = {};
+                for (const [key, value] of Object.entries(apiRequest.params)) {
+                  const bareResolved = resolveBareVariables(value, runtimeVariables);
+                  resolvedParams[key] = substituteVariables(bareResolved, runtimeVariables);
+                }
+                let resolvedPath = pathWithVars;
+                for (const paramName of endpoint.parameters) {
+                  const value = resolvedParams[paramName];
+                  if (value !== void 0) {
+                    resolvedPath = resolvedPath.replace(`{${paramName}}`, value);
+                  }
+                }
+                const combinedHeaders = {};
+                for (const groupName of apiRequest.headerGroupNames) {
+                  const group = getHeaderGroup(
+                    { headerGroups: apiDefinitions.headerGroups, endpoints: apiDefinitions.endpoints },
+                    groupName
+                  );
+                  if (group) {
+                    const resolvedHeaders = resolveHeaderValues(group, runtimeVariables);
+                    Object.assign(combinedHeaders, resolvedHeaders);
+                  }
+                }
+                for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
+                  combinedHeaders[headerName] = substituteVariables(headerValue, runtimeVariables);
+                }
+                let resolvedBody;
+                if (apiRequest.body) {
+                  resolvedBody = substituteVariables(apiRequest.body, runtimeVariables);
+                }
+                parsed = {
+                  method: apiRequest.method,
+                  url: resolvedPath,
+                  headers: combinedHeaders,
+                  body: resolvedBody
+                };
+                requestDescription = `${apiRequest.endpointName}(${Object.values(resolvedParams).join(", ")}) \u2192 ${parsed.method} ${parsed.url}`;
+              } else {
+                parsed = parserHttpRequest(step.content, runtimeVariables);
+                requestDescription = `${parsed.method} ${parsed.url}`;
+                if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
+                  parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
+                }
+              }
+            } else {
+              parsed = parserHttpRequest(step.content, runtimeVariables);
+              requestDescription = `${parsed.method} ${parsed.url}`;
+              if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
+                parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
+              }
+              if (parsed.body) {
+                const bodyTrimmed = parsed.body.trim();
+                const bareVarMatch = bodyTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
+                if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
+                  const varValue = runtimeVariables[bareVarMatch[1]];
+                  if (typeof varValue === "object" && varValue !== null) {
+                    parsed.body = JSON.stringify(varValue);
+                  } else if (typeof varValue === "string") {
+                    parsed.body = varValue;
+                  } else {
+                    parsed.body = String(varValue);
+                  }
+                }
               }
             }
-            for (const [headerName, headerValue] of Object.entries(apiRequest.inlineHeaders)) {
-              combinedHeaders[headerName] = substituteVariables(headerValue, runtimeVariables);
-            }
-            let resolvedBody;
-            if (apiRequest.body) {
-              resolvedBody = substituteVariables(apiRequest.body, runtimeVariables);
-            }
-            parsed = {
-              method: apiRequest.method,
-              url: resolvedPath,
-              headers: combinedHeaders,
-              body: resolvedBody
+            const { retryCount, backoffMs } = extractRetryOptions(step.content);
+            validatePreparedRequest(
+              parsed,
+              buildRequestValidationContext(stepIdx + 1, parsed.method, parsed.url)
+            );
+            const retryOpts = retryCount ?? parsed.retryCount ? {
+              retryCount: retryCount ?? parsed.retryCount ?? 0,
+              backoffMs: backoffMs ?? parsed.backoffMs ?? 1e3,
+              onRetry: (attempt, total, error, waitMs) => {
+                reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
+              }
+            } : void 0;
+            const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar, retryOpts) : await sendRequest(parsed, retryOpts);
+            addResponse(response);
+            const stepResult = {
+              type: "request",
+              stepIndex: stepIdx,
+              response,
+              requestMethod: parsed.method,
+              requestUrl: parsed.url
             };
-            requestDescription = `${apiRequest.endpointName}(${Object.values(resolvedParams).join(", ")}) \u2192 ${parsed.method} ${parsed.url}`;
-          } else {
-            parsed = parserHttpRequest(step.content, runtimeVariables);
-            requestDescription = `${parsed.method} ${parsed.url}`;
-            if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-              parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
-            }
-          }
-        } else {
-          parsed = parserHttpRequest(step.content, runtimeVariables);
-          requestDescription = `${parsed.method} ${parsed.url}`;
-          if (apiDefinitions && apiDefinitions.headerGroups.length > 0) {
-            parsed = applyHeaderGroupsToRequest(parsed, step.content, apiDefinitions.headerGroups, runtimeVariables);
-          }
-          if (parsed.body) {
-            const bodyTrimmed = parsed.body.trim();
-            const bareVarMatch = bodyTrimmed.match(/^([a-zA-Z_][a-zA-Z0-9_]*)$/);
-            if (bareVarMatch && bareVarMatch[1] in runtimeVariables) {
-              const varValue = runtimeVariables[bareVarMatch[1]];
-              if (typeof varValue === "object" && varValue !== null) {
-                parsed.body = JSON.stringify(varValue);
-              } else if (typeof varValue === "string") {
-                parsed.body = varValue;
+            orderedSteps.push(stepResult);
+            reportProgress(stepIdx, "request", requestDescription, stepResult);
+            const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
+            for (const capture of relevantCaptures) {
+              const value = getValueByPath(response, capture.path);
+              if (value !== void 0) {
+                runtimeVariables[capture.varName] = value;
               } else {
-                parsed.body = String(varValue);
+                errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
               }
             }
-          }
-        }
-        const { retryCount, backoffMs } = extractRetryOptions(step.content);
-        validatePreparedRequest(
-          parsed,
-          buildRequestValidationContext(stepIdx + 1, parsed.method, parsed.url)
-        );
-        const retryOpts = retryCount ?? parsed.retryCount ? {
-          retryCount: retryCount ?? parsed.retryCount ?? 0,
-          backoffMs: backoffMs ?? parsed.backoffMs ?? 1e3,
-          onRetry: (attempt, total, error, waitMs) => {
-            reportProgress(stepIdx, "request", `[Retry ${attempt}/${total}] ${requestDescription} - waiting ${waitMs}ms`, void 0);
-          }
-        } : void 0;
-        const response = cookieJar ? await sendRequestWithJar(parsed, cookieJar, retryOpts) : await sendRequest(parsed, retryOpts);
-        addResponse(response);
-        const stepResult = {
-          type: "request",
-          stepIndex: stepIdx,
-          response,
-          requestMethod: parsed.method,
-          requestUrl: parsed.url
-        };
-        orderedSteps.push(stepResult);
-        reportProgress(stepIdx, "request", requestDescription, stepResult);
-        const relevantCaptures = captures.filter((c) => c.afterRequest === requestIndex);
-        for (const capture of relevantCaptures) {
-          const value = getValueByPath(response, capture.path);
-          if (value !== void 0) {
-            runtimeVariables[capture.varName] = value;
-          } else {
-            errors.push(`Warning: Could not capture ${capture.varName} from $${requestIndex}.${capture.path}`);
-          }
-        }
-      } catch (error) {
-        const userMessage = formatUserFacingError(
-          error,
-          buildRequestValidationContext(stepIdx + 1)
-        );
-        let errorDetails = `Request ${requestIndex} failed:
+          } catch (error) {
+            const userMessage = formatUserFacingError(
+              error,
+              buildRequestValidationContext(stepIdx + 1)
+            );
+            let errorDetails = `Request ${requestIndex} failed:
 ${indentMultiline(userMessage)}`;
-        if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
-          errorDetails += `
+            if (requestDescription && !/\nRequest:\s/.test(userMessage)) {
+              errorDetails += `
   Request: ${requestDescription}`;
+            }
+            errors.push(errorDetails);
+            await emitFailure(errorDetails, step, stepIdx);
+            return {
+              name: "",
+              success: false,
+              responses,
+              scriptResults,
+              assertionResults,
+              steps: orderedSteps,
+              errors,
+              duration: Date.now() - startTime
+            };
+          }
         }
-        errors.push(errorDetails);
-        return {
-          name: "",
-          success: false,
-          responses,
-          scriptResults,
-          assertionResults,
-          steps: orderedSteps,
-          errors,
-          duration: Date.now() - startTime
-        };
+      } finally {
+        await emitAfterStep(step, stepIdx);
       }
     }
+    return {
+      name: "",
+      success: errors.filter((e) => !e.startsWith("Warning")).length === 0,
+      responses,
+      scriptResults,
+      assertionResults,
+      steps: orderedSteps,
+      errors,
+      duration: Date.now() - startTime,
+      variables: runtimeVariables
+    };
+  } finally {
+    if (debugHooks?.onSequenceExit) {
+      await debugHooks.onSequenceExit({
+        sequenceName: executionContext?.sequenceName,
+        filePath: executionContext?.filePath,
+        declarationLine: executionContext?.sequenceStartLine,
+        nestingDepth,
+        runtimeVariables,
+        responses
+      });
+    }
   }
-  return {
-    name: "",
-    success: errors.filter((e) => !e.startsWith("Warning")).length === 0,
-    responses,
-    scriptResults,
-    assertionResults,
-    steps: orderedSteps,
-    errors,
-    duration: Date.now() - startTime,
-    variables: runtimeVariables
-  };
 }
 
 // src/cli/colors.ts
@@ -32270,34 +32376,98 @@ ${fileContent}` : fileContent;
           }
         }
       }
-      const seqResult = await runSequenceWithJar(
-        targetSeq.content,
-        variables,
-        cookieJar,
-        workingDir,
-        fileContentWithImports,
-        void 0,
-        void 0,
-        defaultArgs,
-        apiDefinitions,
-        tagFilterOptions,
-        importResult.sequenceSources,
-        { filePath, sequenceName: targetSeq.name, environment: envValidationContext }
-      );
-      seqResult.name = targetSeq.name;
+      let theoryData = targetSeq.theoryData;
+      if (theoryData?.source && theoryData.cases.length === 0) {
+        try {
+          const cases = await loadTheoryFile(theoryData.source, workingDir);
+          theoryData = { ...theoryData, cases };
+        } catch (error) {
+          const message = `Failed to load theory file '${theoryData.source}': ${error instanceof Error ? error.message : String(error)}`;
+          const failedResult = {
+            name: targetSeq.name,
+            success: false,
+            responses: [],
+            scriptResults: [],
+            assertionResults: [],
+            steps: [],
+            errors: [message],
+            duration: 0
+          };
+          if (options.output === "json") {
+            console.log(JSON.stringify({ success: false, results: [failedResult] }, null, 2));
+          } else {
+            const lines = formatSequenceResult(failedResult, { colors, verbose: options.verbose, redaction: redaction2 });
+            for (const line2 of lines) {
+              console.log(line2);
+            }
+            const summaryLines = formatRunSummary([failedResult], Date.now() - startTime, colors);
+            for (const line2 of summaryLines) {
+              console.log(line2);
+            }
+          }
+          process.exit(1);
+        }
+      }
+      const sequenceResults = [];
+      if (theoryData && theoryData.cases.length > 0) {
+        for (let caseIdx = 0; caseIdx < theoryData.cases.length; caseIdx++) {
+          const caseParams = theoryData.cases[caseIdx];
+          const caseLabel = formatCaseLabel(caseParams);
+          const caseArgs = { ...defaultArgs };
+          for (const [key, value] of Object.entries(caseParams)) {
+            caseArgs[key] = String(value);
+          }
+          const caseResult = await runSequenceWithJar(
+            targetSeq.content,
+            variables,
+            cookieJar,
+            workingDir,
+            fileContentWithImports,
+            void 0,
+            void 0,
+            caseArgs,
+            apiDefinitions,
+            tagFilterOptions,
+            importResult.sequenceSources,
+            { filePath, sequenceName: targetSeq.name, environment: envValidationContext }
+          );
+          caseResult.name = `${targetSeq.name}${caseLabel}`;
+          sequenceResults.push(caseResult);
+        }
+      } else {
+        const seqResult = await runSequenceWithJar(
+          targetSeq.content,
+          variables,
+          cookieJar,
+          workingDir,
+          fileContentWithImports,
+          void 0,
+          void 0,
+          defaultArgs,
+          apiDefinitions,
+          tagFilterOptions,
+          importResult.sequenceSources,
+          { filePath, sequenceName: targetSeq.name, environment: envValidationContext }
+        );
+        seqResult.name = targetSeq.name;
+        sequenceResults.push(seqResult);
+      }
       if (options.output === "json") {
-        console.log(JSON.stringify({ success: seqResult.success, results: [seqResult] }, null, 2));
+        const success = sequenceResults.every((result2) => result2.success);
+        console.log(JSON.stringify({ success, results: sequenceResults }, null, 2));
       } else {
-        const lines = formatSequenceResult(seqResult, { colors, verbose: options.verbose, redaction: redaction2 });
-        for (const line2 of lines) {
-          console.log(line2);
+        for (const result2 of sequenceResults) {
+          const lines = formatSequenceResult(result2, { colors, verbose: options.verbose, redaction: redaction2 });
+          for (const line2 of lines) {
+            console.log(line2);
+          }
         }
-        const summaryLines = formatRunSummary([seqResult], Date.now() - startTime, colors);
+        const summaryLines = formatRunSummary(sequenceResults, Date.now() - startTime, colors);
         for (const line2 of summaryLines) {
           console.log(line2);
         }
       }
-      process.exit(seqResult.success ? 0 : 1);
+      process.exit(sequenceResults.every((result2) => result2.success) ? 0 : 1);
     }
   }
   let totalTestCount = 0;