@testsmith/api-spector 0.2.0 → 0.2.1

package/out/main/index.js

@@ -25,7 +25,7 @@ const electron = require("electron");
 const path = require("path");
 const fs = require("fs");
 const promises = require("fs/promises");
-const requestHandler = require("./chunks/request-handler-AFBOd__c.js");
+const requestCollection = require("./chunks/request-collection-Dx0ZqB54.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
@@ -64,14 +64,14 @@ function registerFileHandlers(ipc) {
   ipc.handle("file:openWorkspace", async () => {
     const result = await electron.dialog.showOpenDialog({
       title: "Open Workspace",
-      filters: [{ name: "api Spector Workspace", extensions: ["spector", "json"] }],
+      filters: [{ name: "API Spector Workspace", extensions: ["spector", "json"] }],
       properties: ["openFile"]
     });
     if (result.canceled || !result.filePaths[0]) return null;
     const wsPath = result.filePaths[0];
     workspaceDir = path.dirname(wsPath);
     workspaceFile = wsPath;
-    await requestHandler.loadGlobals(workspaceDir);
+    await requestCollection.loadGlobals(workspaceDir);
     await saveLastWorkspacePath(wsPath);
     const raw = await promises.readFile(wsPath, "utf8");
     return { workspace: JSON.parse(raw), workspacePath: wsPath };
@@ -80,15 +80,15 @@ function registerFileHandlers(ipc) {
     const result = await electron.dialog.showSaveDialog({
       title: "Create Workspace",
       defaultPath: "my-workspace.spector",
-      filters: [{ name: "api Spector Workspace", extensions: ["spector", "json"] }]
+      filters: [{ name: "API Spector Workspace", extensions: ["spector", "json"] }]
     });
     if (result.canceled || !result.filePath) return null;
     workspaceDir = path.dirname(result.filePath);
     workspaceFile = result.filePath;
-    await requestHandler.loadGlobals(workspaceDir);
+    await requestCollection.loadGlobals(workspaceDir);
     await promises.mkdir(path.join(workspaceDir, "collections"), { recursive: true });
     await promises.mkdir(path.join(workspaceDir, "environments"), { recursive: true });
-    const gitignore = "# api Spector — never commit secrets\n*.secrets\n.env.local\n\n# Dependencies\nnode_modules/\n";
+    const gitignore = "# API Spector — never commit secrets\n*.secrets\n.env.local\n\n# Dependencies\nnode_modules/\n";
     await atomicWrite(path.join(workspaceDir, ".gitignore"), gitignore);
     const ws = {
       version: "1.0",
@@ -149,10 +149,10 @@ function registerFileHandlers(ipc) {
     await promises.writeFile(result.filePath, content, "utf8");
     return true;
   });
-  ipc.handle("globals:get", () => requestHandler.getGlobals());
+  ipc.handle("globals:get", () => requestCollection.getGlobals());
   ipc.handle("globals:set", async (_e, patch) => {
-    requestHandler.setGlobals(patch);
-    await requestHandler.persistGlobals();
+    requestCollection.setGlobals(patch);
+    await requestCollection.persistGlobals();
   });
   ipc.handle("file:closeWorkspace", async () => {
     workspaceDir = null;
@@ -166,7 +166,7 @@ function registerFileHandlers(ipc) {
     try {
       workspaceDir = path.dirname(wsPath);
       workspaceFile = wsPath;
-      await requestHandler.loadGlobals(workspaceDir);
+      await requestCollection.loadGlobals(workspaceDir);
       const raw = await promises.readFile(wsPath, "utf8");
       return { workspace: JSON.parse(raw), workspacePath: wsPath };
     } catch {
@@ -983,6 +983,60 @@ function registerImportHandlers(ipc) {
     return extractSchemasFromUrl(url);
   });
 }
+function parsePostScript(script) {
+  const assertions = [];
+  const extractions = [];
+  if (!script?.trim()) return { assertions, extractions };
+  const testBlockRegex = /sp\.test\(\s*(['"])((?:(?!\1).|\\.)*)\1\s*,\s*(?:function\s*\(\)|\(\)\s*=>)\s*\{([\s\S]*?)\}\s*\)/g;
+  let match;
+  while (match = testBlockRegex.exec(script)) {
+    const name = match[2];
+    const body = match[3];
+    const equalMatch = body.match(/sp\.expect\(([^)]+)\)\.to(?:\.be)?\.equal\(([^)]+)\)/);
+    if (equalMatch) {
+      assertions.push({ name, accessor: equalMatch[1].trim(), kind: "equals", expected: equalMatch[2].trim() });
+      continue;
+    }
+    const includeMatch = body.match(/sp\.expect\(([^)]+)\)\.to\.(?:include|contain)\(([^)]+)\)/);
+    if (includeMatch) {
+      assertions.push({ name, accessor: includeMatch[1].trim(), kind: "contains", expected: includeMatch[2].trim() });
+      continue;
+    }
+    const existsMatch = body.match(/sp\.expect\(([^)]+)\)\.to\.not\.be\.oneOf\(\[null,\s*undefined\]\)/);
+    if (existsMatch) {
+      assertions.push({ name, accessor: existsMatch[1].trim(), kind: "exists" });
+      continue;
+    }
+    const typeMatch = body.match(/sp\.expect\(([^)]+)\)\.to\.be\.a\(\s*"([^"]+)"\s*\)/);
+    if (typeMatch) {
+      assertions.push({ name, accessor: typeMatch[1].trim(), kind: "type", expected: `"${typeMatch[2]}"` });
+      continue;
+    }
+    const aboveMatch = body.match(/sp\.expect\(([^)]+)\)\.to\.be\.above\((\d+)\)/);
+    if (aboveMatch) {
+      assertions.push({ name, accessor: aboveMatch[1].trim(), kind: "above", expected: aboveMatch[2] });
+      continue;
+    }
+    assertions.push({ name, accessor: "", kind: "status" });
+  }
+  const statusMatch = script.match(/sp\.response\.to\.have\.status\((\d+)\)/);
+  if (statusMatch) {
+    assertions.push({ name: `status is ${statusMatch[1]}`, accessor: "", kind: "status", expected: statusMatch[1] });
+  }
+  const extractRegex = /sp\.(variables|environment|globals)\.set\(\s*"([^"]+)"\s*,\s*(.+)\s*\)\s*;/g;
+  while (match = extractRegex.exec(script)) {
+    const target = match[1];
+    const varName = match[2];
+    let accessor = match[3].trim();
+    const stringWrap = accessor.match(/^String\((.+)\)$/);
+    if (stringWrap) accessor = stringWrap[1];
+    extractions.push({ varName, accessor, target });
+  }
+  return { assertions, extractions };
+}
+function accessorToJsonPath(accessor) {
+  return accessor.replace(/^json\.?/, "").replace(/\["([^"]+)"\]/g, "['$1']");
+}
 function safeName(name) {
   return name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
 }
@@ -1004,7 +1058,7 @@ function buildNameMap$2(root, requests) {
   function visit(folder) {
     for (const id of folder.requestIds) {
       const req = requests[id];
-      if (!req) continue;
+      if (!req || req.disabled) continue;
       const base = safeName(req.name);
       let name = base;
       if (used.has(name)) {
@@ -1048,38 +1102,90 @@ function jsonToRfDictPairs(json, vars) {
     return null;
   }
 }
-function buildKeywordsFile(collection, varMap, nameMap) {
+function buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) {
   const lines = [
     "*** Settings ***",
     "Library    RequestsLibrary",
+    "Library    Collections",
     "Resource    variables.resource",
     "",
     "*** Keywords ***"
   ];
+  function processHooks(folder) {
+    for (const reqId of folder.requestIds) {
+      const req = collection.requests[reqId];
+      if (!req || req.disabled || !req.hookType) continue;
+      const kwName = nameMap.get(reqId);
+      if (!kwName) continue;
+      const url = interpolate(req.url, varMap);
+      const method = req.method.charAt(0) + req.method.slice(1).toLowerCase();
+      lines.push(kwName);
+      lines.push(`    [Documentation]    Hook: ${req.hookType} — ${req.name}`);
+      const { body } = req;
+      const hasBody = body.mode !== "none" && !["GET", "HEAD"].includes(req.method);
+      if (hasBody && body.mode === "json" && body.json) {
+        const bodyPairs = jsonToRfDictPairs(body.json, varMap);
+        if (bodyPairs !== null) {
+          lines.push(`    VAR    &{body}    ${bodyPairs}`);
+        } else {
+          lines.push(`    VAR    \${body}    ${interpolate(body.json, varMap)}`);
+        }
+      }
+      const callArgs = [];
+      if (hasBody && body.mode === "json") callArgs.push("json=${body}");
+      lines.push(`    \${response}=    ${method}    ${url}`);
+      if (callArgs.length) lines.push(`    ...    ${callArgs.join("    ")}`);
+      const parsed = parsePostScript(req.postRequestScript);
+      for (const e of parsed.extractions) {
+        const jp = accessorToJsonPath(e.accessor);
+        const rfVar = e.varName.replace(/\W+/g, "_").toUpperCase();
+        hookExtractedVars.add(rfVar);
+        lines.push(`    \${${rfVar}}=    Evaluate    str($response.json().get('${jp}', ''))`);
+        lines.push(`    Set Suite Variable    \${${rfVar}}`);
+      }
+      lines.push(`    RETURN    \${response}`);
+      lines.push("");
+    }
+    for (const sub of folder.folders) processHooks(sub);
+  }
+  processHooks(collection.rootFolder);
   function processFolder(folder) {
     for (const reqId of folder.requestIds) {
       const req = collection.requests[reqId];
-      if (!req) continue;
+      if (!req || req.disabled || req.hookType) continue;
       const kwName = nameMap.get(reqId);
       const url = interpolate(req.url, varMap);
       lines.push(kwName);
       lines.push(`    [Documentation]    ${req.description || req.name}`);
+      const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+      const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+      const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
       const headerPairs = [];
-      const { auth } = req;
-      if (auth.type === "bearer") {
-        const ref = auth.tokenSecretRef ?? "API_TOKEN";
-        headerPairs.push(`Authorization=Bearer ${envVar(ref)}`);
-      } else if (auth.type === "basic") {
-        const passRef = auth.passwordSecretRef ?? "API_PASSWORD";
-        const user = auth.username ?? "";
+      if (effectiveAuth.type === "bearer") {
+        const token = effectiveAuth.token ?? "";
+        if (token.includes("{{")) {
+          const varRef = token.match(/\{\{([^}]+)\}\}/)?.[1]?.trim();
+          const rfVar = varRef ? varRef.replace(/\W+/g, "_").toUpperCase() : "";
+          if (rfVar && hookExtractedVars.has(rfVar)) {
+            headerPairs.push(`Authorization=Bearer \${${rfVar}}`);
+          } else {
+            headerPairs.push(`Authorization=Bearer ${interpolate(token, varMap)}`);
+          }
+        } else {
+          const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
+          headerPairs.push(`Authorization=Bearer ${envVar(ref)}`);
+        }
+      } else if (effectiveAuth.type === "basic") {
+        const passRef = effectiveAuth.passwordSecretRef ?? "API_PASSWORD";
+        const user = effectiveAuth.username ?? "";
         lines.push(`    \${credentials}=    Evaluate    base64.b64encode(f"${user}:${envVar(passRef)}".encode()).decode()    base64`);
         headerPairs.push(`Authorization=Basic \${credentials}`);
-      } else if (auth.type === "apikey" && auth.apiKeyIn === "header") {
-        const keyRef = auth.apiKeySecretRef ?? "API_KEY";
-        const keyName = auth.apiKeyName ?? "X-API-Key";
+      } else if (effectiveAuth.type === "apikey" && effectiveAuth.apiKeyIn === "header") {
+        const keyRef = effectiveAuth.apiKeySecretRef ?? "API_KEY";
+        const keyName = effectiveAuth.apiKeyName ?? "X-API-Key";
         headerPairs.push(`${keyName}=${envVar(keyRef)}`);
       }
-      for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
+      for (const h of allHeaders) {
         headerPairs.push(`${h.key}=${interpolate(h.value, varMap)}`);
       }
       if (headerPairs.length) {
@@ -1120,23 +1226,72 @@ function buildKeywordsFile(collection, varMap, nameMap) {
 function buildTestSuite(collection, environment, nameMap) {
   const colName = safeName(collection.name);
   const envName = environment?.name ?? "default";
+  const beforeAllHooks = [];
+  const afterAllHooks = [];
+  function collectAll(folder) {
+    for (const id of folder.requestIds) {
+      const r = collection.requests[id];
+      if (!r || r.disabled) continue;
+      if (r.hookType === "beforeAll") beforeAllHooks.push(r);
+      else if (r.hookType === "afterAll") afterAllHooks.push(r);
+    }
+    for (const sub of folder.folders) collectAll(sub);
+  }
+  collectAll(collection.rootFolder);
+  const suiteSetup = beforeAllHooks.length ? `Suite Setup    Run Keywords    ${beforeAllHooks.map((h) => nameMap.get(h.id) ?? safeName(h.name)).join("    AND    ")}` : `Suite Setup    Log    Running ${colName} against ${envName} environment`;
+  const suiteTeardown = afterAllHooks.length ? `Suite Teardown    Run Keywords    ${afterAllHooks.map((h) => nameMap.get(h.id) ?? safeName(h.name)).join("    AND    ")}` : "";
   const lines = [
     "*** Settings ***",
     "Resource    ../resources/api_keywords.resource",
     "",
-    `Suite Setup    Log    Running ${colName} against ${envName} environment`,
+    suiteSetup,
+    ...suiteTeardown ? [suiteTeardown] : [],
     "",
     "*** Test Cases ***"
   ];
   function processFolder(folder) {
     for (const reqId of folder.requestIds) {
       const req = collection.requests[reqId];
-      if (!req) continue;
+      if (!req || req.disabled || req.hookType) continue;
       const kwName = nameMap.get(reqId);
       lines.push(kwName);
       lines.push(`    [Documentation]    ${req.description || req.name}`);
       lines.push(`    \${response}=    ${kwName}`);
-      lines.push(`    Status Should Be    200    \${response}`);
+      const parsed = parsePostScript(req.postRequestScript);
+      if (parsed.assertions.length > 0) {
+        for (const a of parsed.assertions) {
+          const jp = accessorToJsonPath(a.accessor);
+          switch (a.kind) {
+            case "status":
+              lines.push(`    Status Should Be    ${a.expected ?? 200}    \${response}`);
+              break;
+            case "equals": {
+              const expected = a.expected?.replace(/^"|"$/g, "") ?? "";
+              lines.push(`    \${value}=    Get From Dictionary    \${response.json()}    ${jp}`);
+              lines.push(`    Should Be Equal As Strings    \${value}    ${expected}`);
+              break;
+            }
+            case "contains": {
+              const expected = a.expected?.replace(/^"|"$/g, "") ?? "";
+              lines.push(`    \${value}=    Get From Dictionary    \${response.json()}    ${jp}`);
+              lines.push(`    Should Contain    \${value}    ${expected}`);
+              break;
+            }
+            case "exists":
+              lines.push(`    Dictionary Should Contain Key    \${response.json()}    ${jp}`);
+              break;
+            default:
+              lines.push(`    Status Should Be    200    \${response}`);
+          }
+        }
+      } else {
+        lines.push(`    Status Should Be    200    \${response}`);
+      }
+      for (const e of parsed.extractions) {
+        const jp = accessorToJsonPath(e.accessor);
+        lines.push(`    \${${e.varName}}=    Get From Dictionary    \${response.json()}    ${jp}`);
+        lines.push(`    Set Suite Variable    \${${e.varName}}`);
+      }
       lines.push("");
     }
     for (const sub of folder.folders) processFolder(sub);
@@ -1195,9 +1350,10 @@ function generateRobotFramework(collection, environment) {
   );
   const nameMap = buildNameMap$2(collection.rootFolder, collection.requests);
   const slug2 = collection.name.replace(/\W+/g, "_").toLowerCase();
+  const hookExtractedVars = /* @__PURE__ */ new Set();
   const contentFiles = [
     { path: "resources/variables.resource", content: buildVariablesFile(environment) },
-    { path: "resources/api_keywords.resource", content: buildKeywordsFile(collection, varMap, nameMap) },
+    { path: "resources/api_keywords.resource", content: buildKeywordsFile(collection, varMap, nameMap, hookExtractedVars) },
     { path: `tests/test_${slug2}.robot`, content: buildTestSuite(collection, environment, nameMap) }
   ];
   const allPaths = ["requirements.txt", ...contentFiles.map((f) => f.path)];
@@ -1213,8 +1369,11 @@ function slug$3(name) {
 function toEnvVar$3(key) {
   return key.replace(/\W+/g, "_").toUpperCase();
 }
-function interpolatePath$1(value) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => `\${process.env.${toEnvVar$3(key.trim())} ?? ''}`);
+function interpolatePath$1(value, sharedVars = /* @__PURE__ */ new Set()) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const envKey = toEnvVar$3(key.trim());
+    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
+  });
 }
 function buildNameMap$1(folder, requests) {
   const map = /* @__PURE__ */ new Map();
@@ -1234,28 +1393,27 @@ function buildNameMap$1(folder, requests) {
   }
   return map;
 }
-function renderJsValue$1(value, indent) {
+function renderJsValue$1(value, indent, sharedVars = /* @__PURE__ */ new Set()) {
   const next = indent + "  ";
   if (value === null) return "null";
   if (typeof value === "boolean" || typeof value === "number") return String(value);
   if (typeof value === "string") {
     if (value.includes("{{")) {
-      const s = value.replace(/\{\{([^}]+)\}\}/g, (_, k) => `\${process.env.${toEnvVar$3(k.trim())} ?? ''}`);
-      return "`" + s + "`";
+      return "`" + interpolatePath$1(value, sharedVars) + "`";
     }
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
     if (!value.length) return "[]";
     return `[
-${value.map((v) => next + renderJsValue$1(v, next)).join(",\n")},
+${value.map((v) => next + renderJsValue$1(v, next, sharedVars)).join(",\n")},
 ${indent}]`;
   }
   if (typeof value === "object") {
     const entries = Object.entries(value);
     if (!entries.length) return "{}";
     return `{
-${entries.map(([k, v]) => `${next}${k}: ${renderJsValue$1(v, next)}`).join(",\n")},
+${entries.map(([k, v]) => `${next}${k}: ${renderJsValue$1(v, next, sharedVars)}`).join(",\n")},
 ${indent}}`;
   }
   return JSON.stringify(value);
@@ -1280,28 +1438,127 @@ export default defineConfig({
 })
 `;
 }
-function buildSpec$1(folderName, folder, requests, nameMap) {
+function buildHookLines$1(req, sharedVars) {
+  const method = req.method.toLowerCase();
+  const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
+  const pathExpr = path2.includes("{{") ? "`" + interpolatePath$1(path2) + "`" : `'${path2}'`;
+  const headerEntries = [];
+  if (req.auth.type === "bearer") {
+    const token = req.auth.token ?? "";
+    if (token.includes("{{")) {
+      headerEntries.push(`Authorization: \`Bearer ${interpolatePath$1(token)}\``);
+    } else {
+      const ref = req.auth.tokenSecretRef ?? "API_TOKEN";
+      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+    }
+  }
+  for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
+    headerEntries.push(`'${h.key}': \`${interpolatePath$1(h.value)}\``);
+  }
+  const optionParts = [];
+  if (headerEntries.length) {
+    optionParts.push(`headers: { ${headerEntries.join(", ")} }`);
+  }
+  if (req.body.mode === "json" && req.body.json && !["get", "head"].includes(method)) {
+    try {
+      optionParts.push(`data: ${renderJsValue$1(JSON.parse(req.body.json), "        ")}`);
+    } catch {
+    }
+  }
+  const opts = optionParts.length ? `, { ${optionParts.join(", ")} }` : "";
+  const lines = [];
+  lines.push(`    // ${req.name}`);
+  const parsed = parsePostScript(req.postRequestScript);
+  if (parsed.extractions.length > 0) {
+    lines.push(`    const hookResponse = await request.${method}(${pathExpr}${opts});`);
+    lines.push(`    const hookJson = await hookResponse.json();`);
+    for (const e of parsed.extractions) {
+      const jsonPath = e.accessor.replace(/^json\.?/, "");
+      const expr = jsonPath ? `hookJson.${jsonPath}` : "hookJson";
+      const varName = toEnvVar$3(e.varName);
+      sharedVars.add(varName);
+      lines.push(`    ${varName} = String(${expr});`);
+    }
+  } else {
+    lines.push(`    await request.${method}(${pathExpr}${opts});`);
+  }
+  return lines;
+}
+function buildSpec$1(folderName, folder, collection, nameMap) {
+  const requests = collection.requests;
   const tests = [];
+  const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
+  const beforeAllHooks = hooks.beforeAll;
+  const beforeHooks = hooks.before;
+  const afterHooks = hooks.after;
+  const afterAllHooks = hooks.afterAll;
+  const sharedVars = /* @__PURE__ */ new Set();
+  const hookBlocks = [];
+  if (beforeAllHooks.length) {
+    const lines = beforeAllHooks.flatMap((h) => buildHookLines$1(h, sharedVars));
+    hookBlocks.push(`  test.beforeAll(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (beforeHooks.length) {
+    const lines = beforeHooks.flatMap((h) => buildHookLines$1(h, sharedVars));
+    hookBlocks.push(`  test.beforeEach(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterHooks.length) {
+    const lines = afterHooks.flatMap((h) => buildHookLines$1(h, sharedVars));
+    hookBlocks.push(`  test.afterEach(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterAllHooks.length) {
+    const lines = afterAllHooks.flatMap((h) => buildHookLines$1(h, sharedVars));
+    hookBlocks.push(`  test.afterAll(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  for (const v of sharedVars) {
+    tests.push(`  let ${v} = '';`);
+  }
+  if (sharedVars.size) tests.push("");
+  tests.push(...hookBlocks);
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const testName = nameMap.get(reqId) ?? req.name;
     const method = req.method.toLowerCase();
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-    const pathExpr = path2.includes("{{") ? "`" + interpolatePath$1(path2) + "`" : `'${path2}'`;
+    const pathExpr = path2.includes("{{") ? "`" + interpolatePath$1(path2, sharedVars) + "`" : `'${path2}'`;
     const optionParts = [];
+    const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
     const headerEntries = [];
-    const { auth } = req;
-    if (auth.type === "bearer") {
-      const ref = auth.tokenSecretRef ?? "API_TOKEN";
-      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$3(ref)} ?? ''}\``);
-    } else if (auth.type === "apikey" && auth.apiKeyIn === "header") {
-      const ref = auth.apiKeySecretRef ?? "API_KEY";
-      const name = auth.apiKeyName ?? "X-API-Key";
-      headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+    if (effectiveAuth.type === "bearer") {
+      const token = effectiveAuth.token ?? "";
+      if (token.includes("{{")) {
+        headerEntries.push(`Authorization: \`Bearer ${interpolatePath$1(token, sharedVars)}\``);
+      } else {
+        const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
+        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+      }
+    } else if (effectiveAuth.type === "apikey" && effectiveAuth.apiKeyIn === "header") {
+      const val = effectiveAuth.apiKeyValue ?? "";
+      const name = effectiveAuth.apiKeyName ?? "X-API-Key";
+      if (val.includes("{{")) {
+        headerEntries.push(`'${name}': \`${interpolatePath$1(val, sharedVars)}\``);
+      } else {
+        const ref = effectiveAuth.apiKeySecretRef ?? "API_KEY";
+        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$3(ref)} ?? ''}\``);
+      }
     }
-    for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
-      headerEntries.push(`'${h.key}': \`${interpolatePath$1(h.value)}\``);
+    for (const h of allHeaders) {
+      headerEntries.push(`'${h.key}': \`${interpolatePath$1(h.value, sharedVars)}\``);
     }
     if (headerEntries.length) {
       optionParts.push(`      headers: {
@@ -1310,27 +1567,76 @@ function buildSpec$1(folderName, folder, requests, nameMap) {
     }
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `'${p.key}': '${interpolatePath$1(p.value)}'`).join(", ");
+      const pairs = enabledParams.map(
+        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolatePath$1(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
+      ).join(", ");
       optionParts.push(`      params: { ${pairs} }`);
     }
     const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     if (hasBody && req.body.mode === "json" && req.body.json) {
       try {
-        const rendered = renderJsValue$1(JSON.parse(req.body.json), "      ");
+        const rendered = renderJsValue$1(JSON.parse(req.body.json), "      ", sharedVars);
         optionParts.push(`      data: ${rendered}`);
       } catch {
-        optionParts.push(`      data: \`${interpolatePath$1(req.body.json)}\``);
+        optionParts.push(`      data: \`${interpolatePath$1(req.body.json, sharedVars)}\``);
       }
     }
     const optionsStr = optionParts.length ? `, {
 ${optionParts.join(",\n")},
     }` : "";
-    tests.push([
+    const parsed = parsePostScript(req.postRequestScript);
+    const lines = [
       `  test('${testName}', async ({ request }) => {`,
-      `    const response = await request.${method}(${pathExpr}${optionsStr});`,
-      `    expect(response.ok()).toBeTruthy();`,
-      `  });`
-    ].join("\n"));
+      `    const response = await request.${method}(${pathExpr}${optionsStr});`
+    ];
+    const needsJson = parsed.assertions.some((a) => a.accessor.startsWith("json")) || parsed.extractions.length > 0;
+    if (needsJson) {
+      lines.push(`    const json = await response.json();`);
+    }
+    if (req.schema?.trim()) {
+      lines.push(`    // JSON Schema validation`);
+      lines.push(`    // Schema: ${req.schema.replace(/\n/g, " ").slice(0, 80)}...`);
+    }
+    if (parsed.assertions.length > 0) {
+      for (const a of parsed.assertions) {
+        const path22 = a.accessor.replace(/^json\.?/, "");
+        const jsonExpr = path22 ? `json.${path22}` : "json";
+        switch (a.kind) {
+          case "status":
+            if (a.expected) {
+              lines.push(`    expect(response.status()).toBe(${a.expected});`);
+            } else {
+              lines.push(`    expect(response.ok()).toBeTruthy();`);
+            }
+            break;
+          case "equals":
+            lines.push(`    expect(${jsonExpr}).toBe(${a.expected});`);
+            break;
+          case "contains":
+            lines.push(`    expect(${jsonExpr}).toContain(${a.expected});`);
+            break;
+          case "exists":
+            lines.push(`    expect(${jsonExpr}).toBeDefined();`);
+            break;
+          case "type":
+            lines.push(`    expect(typeof ${jsonExpr}).toBe(${a.expected});`);
+            break;
+          case "above":
+            lines.push(`    expect(${jsonExpr}).toBeGreaterThan(${a.expected});`);
+            break;
+        }
+      }
+    } else {
+      lines.push(`    expect(response.ok()).toBeTruthy();`);
+    }
+    for (const e of parsed.extractions) {
+      const path22 = e.accessor.replace(/^json\.?/, "");
+      const expr = path22 ? `json.${path22}` : "json";
+      lines.push(`    // Extract: ${e.varName} = ${expr}`);
+      lines.push(`    process.env.${toEnvVar$3(e.varName)} = String(${expr});`);
+    }
+    lines.push(`  });`);
+    tests.push(lines.join("\n"));
   }
   return `import { test, expect } from '@playwright/test'
 
@@ -1403,7 +1709,7 @@ function generatePlaywright(collection, environment) {
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
       const nameMap = buildNameMap$1(folder, collection.requests);
-      files.push({ path: `tests/${slug$3(name)}.spec.ts`, content: buildSpec$1(name, folder, collection.requests, nameMap) });
+      files.push({ path: `tests/${slug$3(name)}.spec.ts`, content: buildSpec$1(name, folder, collection, nameMap) });
     }
     for (const sub of folder.folders) processFolder(sub, sub.name);
   }
@@ -1423,8 +1729,11 @@ function slug$2(name) {
 function toEnvVar$2(key) {
   return key.replace(/\W+/g, "_").toUpperCase();
 }
-function interpolatePath(value) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => `\${process.env.${toEnvVar$2(key.trim())} ?? ''}`);
+function interpolatePath(value, sharedVars = /* @__PURE__ */ new Set()) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const envKey = toEnvVar$2(key.trim());
+    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
+  });
 }
 function buildNameMap(folder, requests) {
   const map = /* @__PURE__ */ new Map();
@@ -1444,28 +1753,27 @@ function buildNameMap(folder, requests) {
   }
   return map;
 }
-function renderJsValue(value, indent) {
+function renderJsValue(value, indent, sharedVars = /* @__PURE__ */ new Set()) {
   const next = indent + "  ";
   if (value === null) return "null";
   if (typeof value === "boolean" || typeof value === "number") return String(value);
   if (typeof value === "string") {
     if (value.includes("{{")) {
-      const s = value.replace(/\{\{([^}]+)\}\}/g, (_, k) => `\${process.env.${toEnvVar$2(k.trim())} ?? ''}`);
-      return "`" + s + "`";
+      return "`" + interpolatePath(value, sharedVars) + "`";
     }
     return JSON.stringify(value);
   }
   if (Array.isArray(value)) {
     if (!value.length) return "[]";
     return `[
-${value.map((v) => next + renderJsValue(v, next)).join(",\n")},
+${value.map((v) => next + renderJsValue(v, next, sharedVars)).join(",\n")},
 ${indent}]`;
   }
   if (typeof value === "object") {
     const entries = Object.entries(value);
     if (!entries.length) return "{}";
     return `{
-${entries.map(([k, v]) => `${next}${k}: ${renderJsValue(v, next)}`).join(",\n")},
+${entries.map(([k, v]) => `${next}${k}: ${renderJsValue(v, next, sharedVars)}`).join(",\n")},
 ${indent}}`;
   }
   return JSON.stringify(value);
@@ -1489,28 +1797,122 @@ module.exports = defineConfig({
 });
 `;
 }
-function buildSpec(folderName, folder, requests, nameMap) {
+function buildHookLines(req, sharedVars) {
+  const method = req.method.toLowerCase();
+  const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
+  const pathExpr = path2.includes("{{") ? "`" + interpolatePath(path2) + "`" : `'${path2}'`;
+  const headerEntries = [];
+  if (req.auth.type === "bearer") {
+    const token = req.auth.token ?? "";
+    if (token.includes("{{")) {
+      headerEntries.push(`Authorization: \`Bearer ${interpolatePath(token)}\``);
+    } else {
+      const ref = req.auth.tokenSecretRef ?? "API_TOKEN";
+      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+    }
+  }
+  for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
+    headerEntries.push(`'${h.key}': \`${interpolatePath(h.value)}\``);
+  }
+  const optParts = [];
+  if (headerEntries.length) optParts.push(`headers: { ${headerEntries.join(", ")} }`);
+  if (req.body.mode === "json" && req.body.json && !["get", "head"].includes(method)) {
+    try {
+      optParts.push(`data: ${renderJsValue(JSON.parse(req.body.json), "        ")}`);
+    } catch {
+    }
+  }
+  const opts = optParts.length ? `, { ${optParts.join(", ")} }` : "";
+  const lines = [`    // ${req.name}`];
+  const parsed = parsePostScript(req.postRequestScript);
+  if (parsed.extractions.length > 0) {
+    lines.push(`    const hookResponse = await request.${method}(${pathExpr}${opts});`);
+    lines.push(`    const hookJson = await hookResponse.json();`);
+    for (const e of parsed.extractions) {
+      const jp = e.accessor.replace(/^json\.?/, "");
+      const expr = jp ? `hookJson.${jp}` : "hookJson";
+      const varName = toEnvVar$2(e.varName);
+      sharedVars.add(varName);
+      lines.push(`    ${varName} = String(${expr});`);
+    }
+  } else {
+    lines.push(`    await request.${method}(${pathExpr}${opts});`);
+  }
+  return lines;
+}
+function buildSpec(folderName, folder, collection, nameMap) {
+  const requests = collection.requests;
   const tests = [];
+  const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
+  const beforeAllHooks = hooks.beforeAll;
+  const beforeHooks = hooks.before;
+  const afterHooks = hooks.after;
+  const afterAllHooks = hooks.afterAll;
+  const sharedVars = /* @__PURE__ */ new Set();
+  const hookBlocks = [];
+  if (beforeAllHooks.length) {
+    const lines = beforeAllHooks.flatMap((h) => buildHookLines(h, sharedVars));
+    hookBlocks.push(`  test.beforeAll(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (beforeHooks.length) {
+    const lines = beforeHooks.flatMap((h) => buildHookLines(h, sharedVars));
+    hookBlocks.push(`  test.beforeEach(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterHooks.length) {
+    const lines = afterHooks.flatMap((h) => buildHookLines(h, sharedVars));
+    hookBlocks.push(`  test.afterEach(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterAllHooks.length) {
+    const lines = afterAllHooks.flatMap((h) => buildHookLines(h, sharedVars));
+    hookBlocks.push(`  test.afterAll(async ({ request }) => {
+${lines.join("\n")}
+  });
+`);
+  }
+  for (const v of sharedVars) tests.push(`  let ${v} = '';`);
+  if (sharedVars.size) tests.push("");
+  tests.push(...hookBlocks);
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const testName = nameMap.get(reqId) ?? req.name;
     const method = req.method.toLowerCase();
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-    const pathExpr = path2.includes("{{") ? "`" + interpolatePath(path2) + "`" : `'${path2}'`;
+    const pathExpr = path2.includes("{{") ? "`" + interpolatePath(path2, sharedVars) + "`" : `'${path2}'`;
     const optionParts = [];
+    const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
     const headerEntries = [];
-    const { auth } = req;
-    if (auth.type === "bearer") {
-      const ref = auth.tokenSecretRef ?? "API_TOKEN";
-      headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$2(ref)} ?? ''}\``);
-    } else if (auth.type === "apikey" && auth.apiKeyIn === "header") {
-      const ref = auth.apiKeySecretRef ?? "API_KEY";
-      const name = auth.apiKeyName ?? "X-API-Key";
-      headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+    if (effectiveAuth.type === "bearer") {
+      const token = effectiveAuth.token ?? "";
+      if (token.includes("{{")) {
+        headerEntries.push(`Authorization: \`Bearer ${interpolatePath(token, sharedVars)}\``);
+      } else {
+        const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
+        headerEntries.push(`Authorization: \`Bearer \${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+      }
+    } else if (effectiveAuth.type === "apikey" && effectiveAuth.apiKeyIn === "header") {
+      const val = effectiveAuth.apiKeyValue ?? "";
+      const name = effectiveAuth.apiKeyName ?? "X-API-Key";
+      if (val.includes("{{")) {
+        headerEntries.push(`'${name}': \`${interpolatePath(val, sharedVars)}\``);
+      } else {
+        const ref = effectiveAuth.apiKeySecretRef ?? "API_KEY";
+        headerEntries.push(`'${name}': \`\${process.env.${toEnvVar$2(ref)} ?? ''}\``);
+      }
     }
-    for (const h of req.headers.filter((h2) => h2.enabled && h2.key)) {
-      headerEntries.push(`'${h.key}': \`${interpolatePath(h.value)}\``);
+    for (const h of allHeaders) {
+      headerEntries.push(`'${h.key}': \`${interpolatePath(h.value, sharedVars)}\``);
     }
     if (headerEntries.length) {
       optionParts.push(`      headers: {
@@ -1519,27 +1921,67 @@ function buildSpec(folderName, folder, requests, nameMap) {
     }
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `'${p.key}': '${interpolatePath(p.value)}'`).join(", ");
+      const pairs = enabledParams.map(
+        (p) => p.value.includes("{{") ? `'${p.key}': \`${interpolatePath(p.value, sharedVars)}\`` : `'${p.key}': '${p.value}'`
+      ).join(", ");
       optionParts.push(`      params: { ${pairs} }`);
     }
     const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     if (hasBody && req.body.mode === "json" && req.body.json) {
       try {
-        const rendered = renderJsValue(JSON.parse(req.body.json), "      ");
+        const rendered = renderJsValue(JSON.parse(req.body.json), "      ", sharedVars);
         optionParts.push(`      data: ${rendered}`);
       } catch {
-        optionParts.push(`      data: \`${interpolatePath(req.body.json)}\``);
+        optionParts.push(`      data: \`${interpolatePath(req.body.json, sharedVars)}\``);
       }
     }
     const optionsStr = optionParts.length ? `, {
 ${optionParts.join(",\n")},
     }` : "";
-    tests.push([
+    const parsed = parsePostScript(req.postRequestScript);
+    const lines = [
       `  test('${testName}', async ({ request }) => {`,
-      `    const response = await request.${method}(${pathExpr}${optionsStr});`,
-      `    expect(response.ok()).toBeTruthy();`,
-      `  });`
-    ].join("\n"));
+      `    const response = await request.${method}(${pathExpr}${optionsStr});`
+    ];
+    const needsJson = parsed.assertions.some((a) => a.accessor.startsWith("json")) || parsed.extractions.length > 0;
+    if (needsJson) {
+      lines.push(`    const json = await response.json();`);
+    }
+    if (parsed.assertions.length > 0) {
+      for (const a of parsed.assertions) {
+        const path22 = a.accessor.replace(/^json\.?/, "");
+        const jsonExpr = path22 ? `json.${path22}` : "json";
+        switch (a.kind) {
+          case "status":
+            lines.push(a.expected ? `    expect(response.status()).toBe(${a.expected});` : `    expect(response.ok()).toBeTruthy();`);
+            break;
+          case "equals":
+            lines.push(`    expect(${jsonExpr}).toBe(${a.expected});`);
+            break;
+          case "contains":
+            lines.push(`    expect(${jsonExpr}).toContain(${a.expected});`);
+            break;
+          case "exists":
+            lines.push(`    expect(${jsonExpr}).toBeDefined();`);
+            break;
+          case "type":
+            lines.push(`    expect(typeof ${jsonExpr}).toBe(${a.expected});`);
+            break;
+          case "above":
+            lines.push(`    expect(${jsonExpr}).toBeGreaterThan(${a.expected});`);
+            break;
+        }
+      }
+    } else {
+      lines.push(`    expect(response.ok()).toBeTruthy();`);
+    }
+    for (const e of parsed.extractions) {
+      const path22 = e.accessor.replace(/^json\.?/, "");
+      const expr = path22 ? `json.${path22}` : "json";
+      lines.push(`    process.env.${toEnvVar$2(e.varName)} = String(${expr});`);
+    }
+    lines.push(`  });`);
+    tests.push(lines.join("\n"));
   }
   return `const { test, expect } = require('@playwright/test');
 
@@ -1611,7 +2053,7 @@ function generatePlaywrightJs(collection, environment) {
   function processFolder(folder, name) {
     if (folder.requestIds.length > 0) {
       const nameMap = buildNameMap(folder, collection.requests);
-      files.push({ path: `tests/${slug$2(name)}.spec.js`, content: buildSpec(name, folder, collection.requests, nameMap) });
+      files.push({ path: `tests/${slug$2(name)}.spec.js`, content: buildSpec(name, folder, collection, nameMap) });
     }
     for (const sub of folder.folders) processFolder(sub, sub.name);
   }
@@ -1631,8 +2073,11 @@ function slug$1(name) {
 function toEnvVar$1(key) {
   return key.replace(/\W+/g, "_").toUpperCase();
 }
-function interpolateValue$1(value) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => `\${process.env.${toEnvVar$1(key.trim())} ?? ''}`);
+function interpolateValue$1(value, sharedVars = /* @__PURE__ */ new Set()) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const envKey = toEnvVar$1(key.trim());
+    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
+  });
 }
 function buildJestConfig$1() {
   return `import type { Config } from 'jest'
@@ -1665,13 +2110,14 @@ ${envComments ? `// ${envComments.replace(/\n/g, "\n// ")}
 export const api = supertest(BASE_URL);
 `;
 }
-function buildTestFile$1(folderName, folder, requests) {
+function buildTestFile$1(folderName, folder, collection) {
+  const requests = collection.requests;
   const tests = [];
   const used = /* @__PURE__ */ new Set();
   const nameMap = /* @__PURE__ */ new Map();
   for (const id of folder.requestIds) {
     const req = requests[id];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const base = req.name;
     let name = base;
     if (used.has(name)) {
@@ -1682,38 +2128,127 @@ function buildTestFile$1(folderName, folder, requests) {
     used.add(name);
     nameMap.set(id, name);
   }
+  const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
+  const beforeAllH = hooks.beforeAll;
+  const afterAllH = hooks.afterAll;
+  const sharedVars = /* @__PURE__ */ new Set();
+  function buildSupertestHookLines(h) {
+    const lines = [`    // ${h.name}`];
+    const method = h.method.toLowerCase();
+    const path2 = h.url.replace(/^https?:\/\/[^/]+/, "") || "/";
+    const parsed = parsePostScript(h.postRequestScript);
+    if (parsed.extractions.length > 0) {
+      lines.push(`    const hookRes = await api.${method}('${path2}');`);
+      for (const e of parsed.extractions) {
+        const jp = e.accessor.replace(/^json\.?/, "");
+        const expr = jp ? `hookRes.body.${jp}` : "hookRes.body";
+        const varName = toEnvVar$1(e.varName);
+        sharedVars.add(varName);
+        lines.push(`    ${varName} = String(${expr});`);
+      }
+    } else {
+      lines.push(`    await api.${method}('${path2}');`);
+    }
+    return lines;
+  }
+  const hookBlocks = [];
+  if (beforeAllH.length) {
+    const lines = beforeAllH.flatMap(buildSupertestHookLines);
+    hookBlocks.push(`  beforeAll(async () => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterAllH.length) {
+    const lines = afterAllH.flatMap(buildSupertestHookLines);
+    hookBlocks.push(`  afterAll(async () => {
+${lines.join("\n")}
+  });
+`);
+  }
+  for (const v of sharedVars) tests.push(`  let ${v}: string = '';`);
+  if (sharedVars.size) tests.push("");
+  tests.push(...hookBlocks);
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const method = req.method.toLowerCase();
-    const path2 = interpolateValue$1(req.url.replace(/^https?:\/\/[^/]+/, "") || "/");
-    const enabledHeaders = req.headers.filter((h) => h.enabled && h.key);
+    const path2 = interpolateValue$1(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
+    const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`  it('${nameMap.get(reqId)}', async () => {`);
     lines.push(`    const res = await api`);
     lines.push(`      .${method}(\`${path2}\`)`);
-    for (const h of enabledHeaders) {
-      lines.push(`      .set('${h.key}', \`${interpolateValue$1(h.value)}\`)`);
+    if (effectiveAuth.type === "bearer") {
+      const token = effectiveAuth.token ?? "";
+      if (token.includes("{{")) {
+        lines.push(`      .set('Authorization', \`Bearer ${interpolateValue$1(token, sharedVars)}\`)`);
+      } else {
+        const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
+        lines.push(`      .set('Authorization', \`Bearer \${process.env.${toEnvVar$1(ref)} ?? ''}\`)`);
+      }
+    }
+    for (const h of allHeaders) {
+      lines.push(`      .set('${h.key}', \`${interpolateValue$1(h.value, sharedVars)}\`)`);
     }
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue$1(p.value)}\``).join(", ");
+      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue$1(p.value, sharedVars)}\``).join(", ");
       lines.push(`      .query({ ${pairs} })`);
     }
     if (hasBody) {
       if (req.body.mode === "json") {
-        lines.push(`      .send(${req.body.json ?? "{}"})`);
+        const jsonBody = req.body.json ?? "{}";
+        if (jsonBody.includes("{{")) {
+          lines.push(`      .send(JSON.parse(\`${interpolateValue$1(jsonBody, sharedVars)}\`))`);
+        } else {
+          lines.push(`      .send(${jsonBody})`);
+        }
       } else if (req.body.mode === "form" && req.body.form) {
-        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue$1(p.value)}\``).join(", ");
+        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue$1(p.value, sharedVars)}\``).join(", ");
         lines.push(`      .type('form')`);
         lines.push(`      .send({ ${pairs} })`);
       }
     }
     lines[lines.length - 1] += ";";
     lines.push(``);
-    lines.push(`    expect(res.status).toBe(200);`);
-    lines.push(`    // expect(res.body).toMatchObject({});`);
+    const parsed = parsePostScript(req.postRequestScript);
+    if (parsed.assertions.length > 0) {
+      for (const a of parsed.assertions) {
+        const path22 = a.accessor.replace(/^json\.?/, "");
+        const bodyExpr = path22 ? `res.body.${path22}` : "res.body";
+        switch (a.kind) {
+          case "status":
+            lines.push(`    expect(res.status).toBe(${a.expected ?? 200});`);
+            break;
+          case "equals":
+            lines.push(`    expect(${bodyExpr}).toBe(${a.expected});`);
+            break;
+          case "contains":
+            lines.push(`    expect(${bodyExpr}).toContain(${a.expected});`);
+            break;
+          case "exists":
+            lines.push(`    expect(${bodyExpr}).toBeDefined();`);
+            break;
+          case "type":
+            lines.push(`    expect(typeof ${bodyExpr}).toBe(${a.expected});`);
+            break;
+          case "above":
+            lines.push(`    expect(${bodyExpr}).toBeGreaterThan(${a.expected});`);
+            break;
+        }
+      }
+    } else {
+      lines.push(`    expect(res.status).toBe(200);`);
+    }
+    for (const e of parsed.extractions) {
+      const path22 = e.accessor.replace(/^json\.?/, "");
+      const expr = path22 ? `res.body.${path22}` : "res.body";
+      lines.push(`    process.env.${toEnvVar$1(e.varName)} = String(${expr});`);
+    }
     lines.push(`  })`);
     tests.push(lines.join("\n"));
   }
@@ -1804,7 +2339,7 @@ function generateSupertestTs(collection, environment) {
     if (folder.requestIds.length > 0) {
       files.push({
         path: `tests/${slug$1(name)}.test.ts`,
-        content: buildTestFile$1(name, folder, collection.requests)
+        content: buildTestFile$1(name, folder, collection)
       });
     }
     for (const sub of folder.folders) {
@@ -1831,8 +2366,11 @@ function slug(name) {
 function toEnvVar(key) {
   return key.replace(/\W+/g, "_").toUpperCase();
 }
-function interpolateValue(value) {
-  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => `\${process.env.${toEnvVar(key.trim())} ?? ''}`);
+function interpolateValue(value, sharedVars = /* @__PURE__ */ new Set()) {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const envKey = toEnvVar(key.trim());
+    return sharedVars.has(envKey) ? `\${${envKey}}` : `\${process.env.${envKey} ?? ''}`;
+  });
 }
 function buildJestConfig() {
   return `/** @type {import('jest').Config} */
@@ -1859,13 +2397,14 @@ ${envComments ? `// ${envComments.replace(/\n/g, "\n// ")}
 module.exports.api = supertest(BASE_URL);
 `;
 }
-function buildTestFile(folderName, folder, requests) {
+function buildTestFile(folderName, folder, collection) {
+  const requests = collection.requests;
   const tests = [];
   const used = /* @__PURE__ */ new Set();
   const nameMap = /* @__PURE__ */ new Map();
   for (const id of folder.requestIds) {
     const req = requests[id];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const base = req.name;
     let name = base;
     if (used.has(name)) {
@@ -1876,38 +2415,127 @@ function buildTestFile(folderName, folder, requests) {
     used.add(name);
     nameMap.set(id, name);
   }
+  const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
+  const beforeAllH = hooks.beforeAll;
+  const afterAllH = hooks.afterAll;
+  const sharedVars = /* @__PURE__ */ new Set();
+  function buildJsHookLines(h) {
+    const lines = [`    // ${h.name}`];
+    const method = h.method.toLowerCase();
+    const path2 = h.url.replace(/^https?:\/\/[^/]+/, "") || "/";
+    const parsed = parsePostScript(h.postRequestScript);
+    if (parsed.extractions.length > 0) {
+      lines.push(`    const hookRes = await api.${method}('${path2}');`);
+      for (const e of parsed.extractions) {
+        const jp = e.accessor.replace(/^json\.?/, "");
+        const expr = jp ? `hookRes.body.${jp}` : "hookRes.body";
+        const varName = toEnvVar(e.varName);
+        sharedVars.add(varName);
+        lines.push(`    ${varName} = String(${expr});`);
+      }
+    } else {
+      lines.push(`    await api.${method}('${path2}');`);
+    }
+    return lines;
+  }
+  const hookBlocks = [];
+  if (beforeAllH.length) {
+    const lines = beforeAllH.flatMap(buildJsHookLines);
+    hookBlocks.push(`  beforeAll(async () => {
+${lines.join("\n")}
+  });
+`);
+  }
+  if (afterAllH.length) {
+    const lines = afterAllH.flatMap(buildJsHookLines);
+    hookBlocks.push(`  afterAll(async () => {
+${lines.join("\n")}
+  });
+`);
+  }
+  for (const v of sharedVars) tests.push(`  let ${v} = '';`);
+  if (sharedVars.size) tests.push("");
+  tests.push(...hookBlocks);
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const method = req.method.toLowerCase();
-    const path2 = interpolateValue(req.url.replace(/^https?:\/\/[^/]+/, "") || "/");
-    const enabledHeaders = req.headers.filter((h) => h.enabled && h.key);
+    const path2 = interpolateValue(req.url.replace(/^https?:\/\/[^/]+/, "") || "/", sharedVars);
+    const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
     lines.push(`  it('${nameMap.get(reqId)}', async () => {`);
     lines.push(`    const res = await api`);
     lines.push(`      .${method}(\`${path2}\`)`);
-    for (const h of enabledHeaders) {
-      lines.push(`      .set('${h.key}', \`${interpolateValue(h.value)}\`)`);
+    if (effectiveAuth.type === "bearer") {
+      const token = effectiveAuth.token ?? "";
+      if (token.includes("{{")) {
+        lines.push(`      .set('Authorization', \`Bearer ${interpolateValue(token, sharedVars)}\`)`);
+      } else {
+        const ref = effectiveAuth.tokenSecretRef ?? "API_TOKEN";
+        lines.push(`      .set('Authorization', \`Bearer \${process.env.${toEnvVar(ref)} ?? ''}\`)`);
+      }
+    }
+    for (const h of allHeaders) {
+      lines.push(`      .set('${h.key}', \`${interpolateValue(h.value, sharedVars)}\`)`);
     }
     if (enabledParams.length) {
-      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue(p.value)}\``).join(", ");
+      const pairs = enabledParams.map((p) => `${p.key}: \`${interpolateValue(p.value, sharedVars)}\``).join(", ");
       lines.push(`      .query({ ${pairs} })`);
     }
     if (hasBody) {
       if (req.body.mode === "json") {
-        lines.push(`      .send(${req.body.json ?? "{}"})`);
+        const jsonBody = req.body.json ?? "{}";
+        if (jsonBody.includes("{{")) {
+          lines.push(`      .send(JSON.parse(\`${interpolateValue(jsonBody, sharedVars)}\`))`);
+        } else {
+          lines.push(`      .send(${jsonBody})`);
+        }
       } else if (req.body.mode === "form" && req.body.form) {
-        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue(p.value)}\``).join(", ");
+        const pairs = req.body.form.filter((p) => p.enabled && p.key).map((p) => `${p.key}: \`${interpolateValue(p.value, sharedVars)}\``).join(", ");
         lines.push(`      .type('form')`);
         lines.push(`      .send({ ${pairs} })`);
       }
     }
     lines[lines.length - 1] += ";";
     lines.push(``);
-    lines.push(`    expect(res.status).toBe(200);`);
-    lines.push(`    // expect(res.body).toMatchObject({});`);
+    const parsed = parsePostScript(req.postRequestScript);
+    if (parsed.assertions.length > 0) {
+      for (const a of parsed.assertions) {
+        const path22 = a.accessor.replace(/^json\.?/, "");
+        const bodyExpr = path22 ? `res.body.${path22}` : "res.body";
+        switch (a.kind) {
+          case "status":
+            lines.push(`    expect(res.status).toBe(${a.expected ?? 200});`);
+            break;
+          case "equals":
+            lines.push(`    expect(${bodyExpr}).toBe(${a.expected});`);
+            break;
+          case "contains":
+            lines.push(`    expect(${bodyExpr}).toContain(${a.expected});`);
+            break;
+          case "exists":
+            lines.push(`    expect(${bodyExpr}).toBeDefined();`);
+            break;
+          case "type":
+            lines.push(`    expect(typeof ${bodyExpr}).toBe(${a.expected});`);
+            break;
+          case "above":
+            lines.push(`    expect(${bodyExpr}).toBeGreaterThan(${a.expected});`);
+            break;
+        }
+      }
+    } else {
+      lines.push(`    expect(res.status).toBe(200);`);
+    }
+    for (const e of parsed.extractions) {
+      const path22 = e.accessor.replace(/^json\.?/, "");
+      const expr = path22 ? `res.body.${path22}` : "res.body";
+      lines.push(`    process.env.${toEnvVar(e.varName)} = String(${expr});`);
+    }
     lines.push(`  })`);
     tests.push(lines.join("\n"));
   }
@@ -1980,7 +2608,7 @@ function generateSupertestJs(collection, environment) {
     if (folder.requestIds.length > 0) {
       files.push({
         path: `tests/${slug(name)}.test.js`,
-        content: buildTestFile(name, folder, collection.requests)
+        content: buildTestFile(name, folder, collection)
       });
     }
     for (const sub of folder.folders) {
@@ -2007,12 +2635,27 @@ function javaMethod(name) {
   const parts = name.replace(/[^\w\s]/g, " ").split(/\s+/).filter(Boolean);
   return parts[0].toLowerCase() + parts.slice(1).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 }
+function javaTypeFor(expected) {
+  switch (expected?.replace(/"/g, "")) {
+    case "string":
+      return "String.class";
+    case "number":
+      return "Number.class";
+    case "boolean":
+      return "Boolean.class";
+    default:
+      return "Object.class";
+  }
+}
 function toEnvConst(key) {
   return key.replace(/\W+/g, "_").toUpperCase();
 }
-function interpolateJava(value) {
+function interpolateJava(value, sharedVars = /* @__PURE__ */ new Set()) {
   return '"' + value.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
     const envKey = toEnvConst(key.trim());
+    if (sharedVars.has(envKey)) {
+      return `" + ${envKey} + "`;
+    }
     return `" + System.getenv("${envKey}") + "`;
   }) + '"';
 }
@@ -2126,14 +2769,56 @@ public class BaseTest {
 }
 `;
 }
-function buildTestClass(folderName, folder, requests) {
+function buildTestClass(folderName, folder, collection) {
+  const requests = collection.requests;
   const className = javaClass(folderName) + "Test";
   const methods = [];
+  const hooks = requestCollection.getAllApplicableHooks(folder.id, collection);
+  const beforeAllH = hooks.beforeAll;
+  const afterAllH = hooks.afterAll;
+  const sharedVars = /* @__PURE__ */ new Set();
+  function buildJavaHookLines(h) {
+    const lines = [`        // ${h.name}`];
+    const method = h.method.toLowerCase();
+    const path2 = h.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
+    const parsed = parsePostScript(h.postRequestScript);
+    if (parsed.extractions.length > 0) {
+      lines.push(`        var hookResponse = given().spec(requestSpec)`);
+      if (h.body.mode === "json" && h.body.json) {
+        const escaped = h.body.json.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        lines.push(`            .body("${escaped}")`);
+      }
+      lines.push(`            .when().${method}("${path2}");`);
+      for (const e of parsed.extractions) {
+        const jp = accessorToJsonPath(e.accessor);
+        const varName = toEnvConst(e.varName);
+        sharedVars.add(varName);
+        lines.push(`        ${varName} = hookResponse.jsonPath().getString("${jp}");`);
+      }
+    } else {
+      lines.push(`        given().spec(requestSpec).when().${method}("${path2}");`);
+    }
+    return lines;
+  }
+  if (beforeAllH.length) {
+    const lines = beforeAllH.flatMap(buildJavaHookLines);
+    methods.push(`    @BeforeAll
+    static void beforeAll() {
+${lines.join("\n")}
+    }`);
+  }
+  if (afterAllH.length) {
+    const lines = afterAllH.flatMap(buildJavaHookLines);
+    methods.push(`    @AfterAll
+    static void afterAll() {
+${lines.join("\n")}
+    }`);
+  }
   const usedNames = /* @__PURE__ */ new Set();
   const nameMap = /* @__PURE__ */ new Map();
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const base = javaMethod(req.name);
     let name = base;
     if (usedNames.has(name)) {
@@ -2146,12 +2831,14 @@ function buildTestClass(folderName, folder, requests) {
   }
   for (const reqId of folder.requestIds) {
     const req = requests[reqId];
-    if (!req) continue;
+    if (!req || req.disabled || req.hookType) continue;
     const methodName = nameMap.get(reqId);
     const method = req.method.toLowerCase();
     const path2 = req.url.replace(/^https?:\/\/[^/]+/, "").replace(/^\{\{[^}]+\}\}/, "") || "/";
-    const javaPath = interpolateJava(path2);
-    const enabledHeaders = req.headers.filter((h) => h.enabled && h.key);
+    const javaPath = interpolateJava(path2, sharedVars);
+    const inherited = requestCollection.resolveInheritedAuthAndHeaders(reqId, collection);
+    const effectiveAuth = req.auth.type !== "none" ? req.auth : inherited.auth ?? req.auth;
+    const allHeaders = [...inherited.headers.filter((h) => h.enabled && h.key), ...req.headers.filter((h) => h.enabled && h.key)];
     const enabledParams = req.params.filter((p) => p.enabled && p.key);
     const hasBody = req.body.mode !== "none" && !["get", "head"].includes(method);
     const lines = [];
@@ -2159,34 +2846,82 @@ function buildTestClass(folderName, folder, requests) {
     lines.push(`    public void ${methodName}() {`);
     lines.push(`        given()`);
     lines.push(`            .spec(requestSpec)`);
-    for (const h of enabledHeaders) {
-      lines.push(`            .header("${h.key}", ${interpolateJava(h.value)})`);
+    if (effectiveAuth.type === "bearer") {
+      const token = effectiveAuth.token ?? "";
+      if (token.includes("{{")) {
+        const varRef = token.match(/\{\{([^}]+)\}\}/)?.[1]?.trim();
+        const envKey = varRef ? toEnvConst(varRef) : "";
+        if (envKey && sharedVars.has(envKey)) {
+          lines.push(`            .header("Authorization", "Bearer " + ${envKey})`);
+        } else {
+          lines.push(`            .header("Authorization", "Bearer " + ${interpolateJava(token, sharedVars)})`);
+        }
+      } else {
+        lines.push(`            .header("Authorization", "Bearer " + System.getenv("${toEnvConst(effectiveAuth.tokenSecretRef ?? "API_TOKEN")}"))`);
+      }
+    }
+    for (const h of allHeaders) {
+      lines.push(`            .header("${h.key}", ${interpolateJava(h.value, sharedVars)})`);
     }
     for (const p of enabledParams) {
-      lines.push(`            .queryParam("${p.key}", ${interpolateJava(p.value)})`);
+      lines.push(`            .queryParam("${p.key}", ${interpolateJava(p.value, sharedVars)})`);
     }
     if (hasBody) {
       if (req.body.mode === "json" && req.body.json) {
-        const escaped = req.body.json.replace(/"/g, '\\"').replace(/\n/g, "\\n");
-        lines.push(`            .body("${escaped}")`);
+        const escaped = req.body.json.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        lines.push(`            .body(${interpolateJava(escaped, sharedVars)})`);
       }
     }
     lines.push(`        .when()`);
     lines.push(`            .${method}(${javaPath})`);
     lines.push(`        .then()`);
-    lines.push(`            .statusCode(200);`);
-    lines.push(`            // .body("field", equalTo("value"));`);
+    const parsed = parsePostScript(req.postRequestScript);
+    if (parsed.assertions.length > 0) {
+      for (const a of parsed.assertions) {
+        const jp = accessorToJsonPath(a.accessor);
+        switch (a.kind) {
+          case "status":
+            lines.push(`            .statusCode(${a.expected ?? 200})`);
+            break;
+          case "equals":
+            if (a.expected?.startsWith('"')) {
+              lines.push(`            .body("${jp}", equalTo(${a.expected}))`);
+            } else {
+              lines.push(`            .body("${jp}", equalTo(${a.expected}))`);
+            }
+            break;
+          case "contains":
+            lines.push(`            .body("${jp}", containsString(${a.expected}))`);
+            break;
+          case "exists":
+            lines.push(`            .body("${jp}", notNullValue())`);
+            break;
+          case "type":
+            lines.push(`            .body("${jp}", instanceOf(${javaTypeFor(a.expected)}))`);
+            break;
+          case "above":
+            lines.push(`            .body("${jp}", greaterThan(${a.expected}))`);
+            break;
+        }
+      }
+      lines[lines.length - 1] += ";";
+    } else {
+      lines.push(`            .statusCode(200);`);
+    }
     lines.push(`    }`);
     methods.push(lines.join("\n"));
   }
+  const hasHooks = beforeAllH.length > 0 || afterAllH.length > 0;
+  const fieldDecls = Array.from(sharedVars).map((v) => `    private static String ${v} = "";`).join("\n");
   return `package com.example.api;
 
 import org.junit.jupiter.api.Test;
-
+${hasHooks ? "import org.junit.jupiter.api.BeforeAll;\nimport org.junit.jupiter.api.AfterAll;\n" : ""}
 import static io.restassured.RestAssured.given;
 import static org.hamcrest.Matchers.*;
 
 public class ${className} extends BaseTest {
+${fieldDecls ? "\n" + fieldDecls + "\n" : ""}
 
 ${methods.join("\n\n")}
 }
@@ -2244,7 +2979,7 @@ function generateRestAssured(collection, environment) {
       const className = javaClass(name) + "Test";
       files.push({
         path: `src/test/java/com/example/api/${className}.java`,
-        content: buildTestClass(name, folder, collection.requests)
+        content: buildTestClass(name, folder, collection)
       });
     }
     for (const sub of folder.folders) {
@@ -2340,6 +3075,10 @@ async function buildDispatcher(proxy, tls) {
   return void 0;
 }
 async function executeOne(req, collectionVars, envVars, globals, localVars, dispatcher, piiMaskPatterns) {
+  if (!req.headers) req.headers = [];
+  if (!req.params) req.params = [];
+  if (!req.body) req.body = { mode: "none" };
+  if (!req.auth) req.auth = { type: "none" };
   const base = {
     requestId: req.id,
     name: req.name,
@@ -2347,13 +3086,14 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     resolvedUrl: "",
     status: "running"
   };
-  let vars = requestHandler.mergeVars(envVars, collectionVars, globals, localVars);
+  const dynamicVars = await requestCollection.buildDynamicVars();
+  let vars = requestCollection.mergeVars(envVars, collectionVars, globals, localVars, dynamicVars);
   let updatedEnvVars = { ...envVars };
   let updatedCollectionVars = { ...collectionVars };
   let updatedGlobals = { ...globals };
   let preScriptError;
   if (req.preRequestScript?.trim()) {
-    const r = await requestHandler.runScript(requestHandler.interpolate(req.preRequestScript, vars), {
+    const r = await requestCollection.runScript(requestCollection.interpolate(req.preRequestScript, vars), {
       envVars: { ...envVars },
       collectionVars: { ...collectionVars },
       globals: { ...globals },
@@ -2364,11 +3104,11 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     updatedEnvVars = r.updatedEnvVars;
     updatedCollectionVars = r.updatedCollectionVars;
     updatedGlobals = r.updatedGlobals;
-    requestHandler.patchGlobals(r.updatedGlobals);
-    await requestHandler.persistGlobals();
-    vars = requestHandler.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars);
+    requestCollection.patchGlobals(r.updatedGlobals);
+    await requestCollection.persistGlobals();
+    vars = requestCollection.mergeVars(updatedEnvVars, updatedCollectionVars, updatedGlobals, localVars, dynamicVars);
   }
-  const resolvedUrl = requestHandler.buildUrl(req.url, req.params, vars);
+  const resolvedUrl = requestCollection.buildUrl(req.url, req.params, vars);
   base.resolvedUrl = resolvedUrl;
   const start = Date.now();
   try {
@@ -2377,23 +3117,23 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       const tokenMissing = !req.auth.oauth2CachedToken;
       const tokenExpired = req.auth.oauth2TokenExpiry ? req.auth.oauth2TokenExpiry <= now + 5e3 : true;
       if (tokenMissing || tokenExpired) {
-        const result = await requestHandler.fetchOAuth2Token(req.auth, vars);
+        const result = await requestCollection.fetchOAuth2Token(req.auth, vars);
         req.auth.oauth2CachedToken = result.accessToken;
         req.auth.oauth2TokenExpiry = result.expiresAt;
       }
     }
-    const authHeaders = await requestHandler.buildAuthHeaders(req.auth, vars);
+    const authHeaders = await requestCollection.buildAuthHeaders(req.auth, vars);
     const headers = new undici.Headers();
     for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(requestHandler.interpolate(h.key, vars), requestHandler.interpolate(h.value, vars));
+      if (h.enabled && h.key) headers.set(requestCollection.interpolate(h.key, vars), requestCollection.interpolate(h.value, vars));
     }
     for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
     let body;
     if (req.body.mode === "json" && req.body.json) {
-      body = requestHandler.interpolate(req.body.json, vars);
+      body = requestCollection.interpolate(req.body.json, vars);
       if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
     } else if (req.body.mode === "raw" && req.body.raw) {
-      body = requestHandler.interpolate(req.body.raw, vars);
+      body = requestCollection.interpolate(req.body.raw, vars);
       if (!headers.has("content-type")) headers.set("Content-Type", req.body.rawContentType ?? "text/plain");
     }
     const methodHasBody = !["GET", "HEAD"].includes(req.method);
@@ -2405,14 +3145,14 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     });
     let fetchResp;
     if (req.auth.type === "ntlm") {
-      await requestHandler.performNtlmRequest(resolvedUrl, req.method, req.auth, vars);
+      await requestCollection.performNtlmRequest(resolvedUrl, req.method, req.auth, vars);
       fetchResp = await doFetch(headers);
     } else if (req.auth.type === "digest") {
       const probeFetch = (url, init) => undici.fetch(url, {
         ...init,
         dispatcher
       });
-      const digestHeader = await requestHandler.performDigestAuth(resolvedUrl, req.method, req.auth, vars, probeFetch);
+      const digestHeader = await requestCollection.performDigestAuth(resolvedUrl, req.method, req.auth, vars, probeFetch);
       if (digestHeader) headers.set("Authorization", digestHeader);
       fetchResp = await doFetch(headers);
     } else {
@@ -2424,8 +3164,8 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
     fetchResp.headers.forEach((v, k) => {
       rawRespHeaders[k] = v;
     });
-    const maskedBody = requestHandler.maskPii(responseBody, piiMaskPatterns);
-    const maskedHeaders = requestHandler.maskHeaders(rawRespHeaders, piiMaskPatterns);
+    const maskedBody = requestCollection.maskPii(responseBody, piiMaskPatterns);
+    const maskedHeaders = requestCollection.maskHeaders(rawRespHeaders, piiMaskPatterns);
     const response = {
       status: fetchResp.status,
       statusText: fetchResp.statusText,
@@ -2434,12 +3174,12 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       bodySize: Buffer.byteLength(responseBody, "utf8"),
       durationMs
     };
-    const schemaTestResults = requestHandler.buildSchemaTestResults(req.schema, responseBody);
+    const schemaTestResults = requestCollection.buildSchemaTestResults(req.schema, responseBody);
     let testResults = [...schemaTestResults];
     let consoleOutput = [];
     let postScriptError;
     if (req.postRequestScript?.trim()) {
-      const r = await requestHandler.runScript(requestHandler.interpolate(req.postRequestScript, vars), {
+      const r = await requestCollection.runScript(requestCollection.interpolate(req.postRequestScript, vars), {
         envVars: updatedEnvVars,
         collectionVars: updatedCollectionVars,
         globals: updatedGlobals,
@@ -2453,14 +3193,14 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       updatedCollectionVars = r.updatedCollectionVars;
       updatedGlobals = r.updatedGlobals;
       localVars = r.updatedLocalVars;
-      requestHandler.patchGlobals(r.updatedGlobals);
-      await requestHandler.persistGlobals();
+      requestCollection.patchGlobals(r.updatedGlobals);
+      await requestCollection.persistGlobals();
     }
     const allPassed = testResults.every((t) => t.passed);
     const httpFailed = fetchResp.status >= 400;
     const hasTests = testResults.length > 0;
-    const status = postScriptError ? "error" : httpFailed ? "failed" : hasTests ? allPassed ? "passed" : "failed" : "skipped";
-    if (httpFailed && !testResults.some((t) => !t.passed)) {
+    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "skipped";
+    if (httpFailed && testResults.length === 0) {
       testResults = [
         ...testResults,
         {
@@ -2517,8 +3257,8 @@ const sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function registerRunnerHandler(ipc) {
   ipc.handle("runner:start", async (event, payload) => {
     const { items, environment, globals: payloadGlobals, proxy, tls, piiMaskPatterns = [], requestDelay = 0 } = payload;
-    const envVars = await requestHandler.buildEnvVars(environment);
-    const liveGlobals = requestHandler.getGlobals();
+    const envVars = await requestCollection.buildEnvVars(environment);
+    const liveGlobals = requestCollection.getGlobals();
     const globals = { ...payloadGlobals, ...liveGlobals };
     const dispatcher = await buildDispatcher(proxy, tls);
     const summary = { total: items.length, passed: 0, failed: 0, errors: 0, skipped: 0, durationMs: 0 };
@@ -2652,14 +3392,14 @@ function registerOAuth2Handlers(ipc) {
   ipc.handle("oauth2:startFlow", async (_e, auth, vars) => {
     const port = auth.oauth2RedirectPort ?? 9876;
     const redirectUri = `http://localhost:${port}/callback`;
-    const authUrl = requestHandler.interpolate(auth.oauth2AuthUrl ?? "", vars);
-    const tokenUrl = requestHandler.interpolate(auth.oauth2TokenUrl ?? "", vars);
-    const clientId = requestHandler.interpolate(auth.oauth2ClientId ?? "", vars);
+    const authUrl = requestCollection.interpolate(auth.oauth2AuthUrl ?? "", vars);
+    const tokenUrl = requestCollection.interpolate(auth.oauth2TokenUrl ?? "", vars);
+    const clientId = requestCollection.interpolate(auth.oauth2ClientId ?? "", vars);
     let clientSecret = auth.oauth2ClientSecret ?? "";
     if (!clientSecret && auth.oauth2ClientSecretRef) {
-      clientSecret = await requestHandler.getSecret(auth.oauth2ClientSecretRef) ?? "";
+      clientSecret = await requestCollection.getSecret(auth.oauth2ClientSecretRef) ?? "";
     }
-    clientSecret = requestHandler.interpolate(clientSecret, vars);
+    clientSecret = requestCollection.interpolate(clientSecret, vars);
     if (!authUrl) throw new Error("OAuth 2.0: authUrl is required for authorization_code flow.");
     if (!tokenUrl) throw new Error("OAuth 2.0: tokenUrl is required for authorization_code flow.");
     if (!clientId) throw new Error("OAuth 2.0: clientId is required.");
@@ -2734,13 +3474,13 @@ function registerOAuth2Handlers(ipc) {
     };
   });
   ipc.handle("oauth2:refreshToken", async (_e, auth, vars, refreshToken) => {
-    const tokenUrl = requestHandler.interpolate(auth.oauth2TokenUrl ?? "", vars);
-    const clientId = requestHandler.interpolate(auth.oauth2ClientId ?? "", vars);
+    const tokenUrl = requestCollection.interpolate(auth.oauth2TokenUrl ?? "", vars);
+    const clientId = requestCollection.interpolate(auth.oauth2ClientId ?? "", vars);
     let clientSecret = auth.oauth2ClientSecret ?? "";
     if (!clientSecret && auth.oauth2ClientSecretRef) {
-      clientSecret = await requestHandler.getSecret(auth.oauth2ClientSecretRef) ?? "";
+      clientSecret = await requestCollection.getSecret(auth.oauth2ClientSecretRef) ?? "";
     }
-    clientSecret = requestHandler.interpolate(clientSecret, vars);
+    clientSecret = requestCollection.interpolate(clientSecret, vars);
     if (!tokenUrl) throw new Error("OAuth 2.0: tokenUrl is required for refresh.");
     const { fetch: nodeFetch } = await import("undici");
     const params = new URLSearchParams();
@@ -3188,21 +3928,21 @@ function validateConsumerResponse(contract, actualStatus, actualHeaders, bodyTex
   return violations;
 }
 async function executeContract(req, vars) {
-  const url = requestHandler.buildUrl(req.url, req.params, vars);
+  const url = requestCollection.buildUrl(req.url, req.params, vars);
   const start = Date.now();
   try {
     const headers = new undici.Headers();
     for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(requestHandler.interpolate(h.key, vars), requestHandler.interpolate(h.value, vars));
+      if (h.enabled && h.key) headers.set(requestCollection.interpolate(h.key, vars), requestCollection.interpolate(h.value, vars));
     }
-    const authHeaders = await requestHandler.buildAuthHeaders(req.auth, vars);
+    const authHeaders = await requestCollection.buildAuthHeaders(req.auth, vars);
     for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
     let body;
     if (req.body.mode === "json" && req.body.json) {
-      body = requestHandler.interpolate(req.body.json, vars);
+      body = requestCollection.interpolate(req.body.json, vars);
       if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
     } else if (req.body.mode === "raw" && req.body.raw) {
-      body = requestHandler.interpolate(req.body.raw, vars);
+      body = requestCollection.interpolate(req.body.raw, vars);
     }
     const resp = await undici.fetch(url, {
       method: req.method,
@@ -3357,7 +4097,7 @@ function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
     const jsonContent = content["application/json"];
     if (jsonContent?.["schema"]) {
       try {
-        const data = JSON.parse(requestHandler.interpolate(req.body.json, vars));
+        const data = JSON.parse(requestCollection.interpolate(req.body.json, vars));
         const schema = resolveSchema(spec, jsonContent["schema"]);
         const validate = ajv.compile(schema);
         if (!validate(data)) {
@@ -3494,18 +4234,18 @@ function getProviderResponseSchema(spec, req, envVars, statusCode, requestBaseUr
   return null;
 }
 async function executeRequest(req, vars) {
-  const url = requestHandler.buildUrl(req.url, req.params, vars);
+  const url = requestCollection.buildUrl(req.url, req.params, vars);
   const start = Date.now();
   try {
     const headers = new undici.Headers();
     for (const h of req.headers) {
-      if (h.enabled && h.key) headers.set(requestHandler.interpolate(h.key, vars), requestHandler.interpolate(h.value, vars));
+      if (h.enabled && h.key) headers.set(requestCollection.interpolate(h.key, vars), requestCollection.interpolate(h.value, vars));
     }
-    const authHeaders = await requestHandler.buildAuthHeaders(req.auth, vars);
+    const authHeaders = await requestCollection.buildAuthHeaders(req.auth, vars);
     for (const [k, v] of Object.entries(authHeaders)) headers.set(k, v);
     let body;
     if (req.body.mode === "json" && req.body.json) {
-      body = requestHandler.interpolate(req.body.json, vars);
+      body = requestCollection.interpolate(req.body.json, vars);
       if (!headers.has("content-type")) headers.set("Content-Type", "application/json");
     }
     const resp = await undici.fetch(url, {
@@ -3531,7 +4271,7 @@ async function runBidirectional(requests, envVars, collectionVars = {}, specUrl,
     (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
   );
   const results = await Promise.all(contractRequests.map(async (req) => {
-    const url = requestHandler.buildUrl(req.url, req.params, vars);
+    const url = requestCollection.buildUrl(req.url, req.params, vars);
     const violations = [];
     const expectedStatus = req.contract.statusCode ?? 200;
     const consumerSchema = req.contract.bodySchema ? (() => {
@@ -3857,7 +4597,7 @@ function createWindow() {
   });
   if (process.platform === "win32") {
     const version = electron.app.getVersion();
-    win.setTitle(`api Spector${version ? ` v${version}` : ""}`);
+    win.setTitle(`API Spector${version ? ` v${version}` : ""}`);
     win.webContents.on("page-title-updated", (e) => e.preventDefault());
   }
   win.webContents.on("before-input-event", (_e, input) => {
@@ -3868,10 +4608,10 @@ function createWindow() {
 }
 electron.app.whenReady().then(async () => {
   if (process.platform !== "darwin") electron.Menu.setApplicationMenu(null);
-  await requestHandler.initSecretStore(electron.app.getPath("userData"));
+  await requestCollection.initSecretStore(electron.app.getPath("userData"));
   registerFileHandlers(electron.ipcMain);
-  requestHandler.registerRequestHandler(electron.ipcMain);
-  requestHandler.registerSecretHandlers(electron.ipcMain);
+  requestCollection.registerRequestHandler(electron.ipcMain);
+  requestCollection.registerSecretHandlers(electron.ipcMain);
   registerImportHandlers(electron.ipcMain);
   registerGenerateHandlers(electron.ipcMain);
   registerRunnerHandler(electron.ipcMain);