@testsmith/api-spector 0.1.9 → 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-DAXUMRyd.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 {
@@ -458,6 +458,39 @@ function schemaToExample(schema) {
       return null;
   }
 }
+function buildResponseSchema(operation, spec) {
+  const responses = operation.responses;
+  if (!responses || typeof responses !== "object") return void 0;
+  const codes = Object.keys(responses);
+  const ordered = [];
+  if (codes.includes("200")) ordered.push("200");
+  if (codes.includes("201")) ordered.push("201");
+  for (const code of codes.sort()) {
+    if (/^2\d\d$/.test(code) && !ordered.includes(code)) ordered.push(code);
+  }
+  for (const code of codes) {
+    if (/^2xx$/i.test(code) && !ordered.includes(code)) ordered.push(code);
+  }
+  if (codes.includes("default")) ordered.push("default");
+  for (const code of ordered) {
+    const responseObj = resolve(spec, responses[code]);
+    const content = responseObj?.content;
+    if (!content || typeof content !== "object") continue;
+    const mediaKeys = Object.keys(content);
+    const jsonKey = mediaKeys.find((k) => k.toLowerCase().split(";")[0].trim() === "application/json") ?? mediaKeys.find((k) => /[+/]json(\b|;)/i.test(k)) ?? mediaKeys.find((k) => k.toLowerCase().includes("json"));
+    if (!jsonKey) continue;
+    const rawSchema = content[jsonKey]?.schema;
+    if (!rawSchema) continue;
+    const resolved = resolve(spec, rawSchema);
+    if (!resolved || typeof resolved === "object" && Object.keys(resolved).length === 0) continue;
+    try {
+      return JSON.stringify(resolved, null, 2);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
 function buildBody(operation, spec) {
   const content = resolve(spec, operation.requestBody?.content ?? {});
   if ("application/json" in content) {
@@ -475,6 +508,39 @@ function buildParams(operation) {
     description: p.description ?? ""
   }));
 }
+function buildPathParamRows(operation) {
+  return (operation.parameters ?? []).filter((p) => p.in === "path" && p.name).map((p) => {
+    const schema = p.schema ?? {};
+    let value;
+    if (p.example !== void 0) value = p.example;
+    else if (schema.example !== void 0) value = schema.example;
+    else if (schema.default !== void 0) value = schema.default;
+    else if (Array.isArray(schema.enum) && schema.enum.length) value = schema.enum[0];
+    else {
+      switch (schema.type) {
+        case "integer":
+        case "number":
+          value = 1;
+          break;
+        case "boolean":
+          value = true;
+          break;
+        default:
+          value = "";
+      }
+    }
+    return {
+      key: String(p.name),
+      value: value === null || value === void 0 ? "" : String(value),
+      enabled: true,
+      description: p.description ?? "",
+      paramType: "path"
+    };
+  });
+}
+function rewritePathTemplate(url) {
+  return url.replace(/\{([^/{}]+)\}/g, (_m, name) => `{{${name}}}`);
+}
 function buildHeaders(operation) {
   return (operation.parameters ?? []).filter((p) => p.in === "header").map((p) => ({
     key: p.name,
@@ -524,17 +590,24 @@ function buildCollection(spec) {
       const allParams = [...pathLevelParams, ...operation.parameters ?? []];
       const opWithParams = { ...operation, parameters: allParams };
       const security = operation.security ?? globalSecurity;
+      const params = [
+        ...buildPathParamRows(opWithParams),
+        ...buildParams(opWithParams)
+      ];
+      const rawOperation = pathItem[method];
+      const responseSchema = buildResponseSchema(rawOperation, spec);
       const req = {
         id: uuid.v4(),
         name: operation.summary ?? operation.operationId ?? `${method.toUpperCase()} ${pathStr}`,
         method: method.toUpperCase(),
-        url: `${baseUrl}${pathStr}`,
+        url: rewritePathTemplate(`${baseUrl}${pathStr}`),
         headers: buildHeaders(opWithParams),
-        params: buildParams(opWithParams),
+        params,
         auth: buildAuth(security, securitySchemes),
         body: buildBody(opWithParams, spec),
         description: operation.description ?? "",
-        meta: { tags }
+        meta: { tags },
+        ...responseSchema ? { schema: responseSchema } : {}
       };
       requests[req.id] = req;
       if (!foldersByTag[tag]) {
@@ -558,6 +631,32 @@ async function importOpenApi(filePath) {
 async function importOpenApiFromUrl(url) {
   return buildCollection(await loadSpecFromUrl(url));
 }
+function extractSchemas(spec) {
+  const entries = [];
+  for (const [pathStr, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const method of HTTP_METHODS$1) {
+      const operation = pathItem?.[method];
+      if (!operation) continue;
+      const schema = buildResponseSchema(operation, spec);
+      if (!schema) continue;
+      entries.push({
+        method: method.toUpperCase(),
+        pathTemplate: pathStr,
+        pathRewritten: rewritePathTemplate(pathStr),
+        schema,
+        operationId: operation.operationId,
+        summary: operation.summary
+      });
+    }
+  }
+  return entries;
+}
+async function extractSchemasFromFile(filePath) {
+  return extractSchemas(await loadSpec$1(filePath));
+}
+async function extractSchemasFromUrl(url) {
+  return extractSchemas(await loadSpecFromUrl(url));
+}
 function parseHeaders(headers) {
   return (headers ?? []).map((h) => ({
     key: h.name ?? "",
@@ -871,6 +970,72 @@ function registerImportHandlers(ipc) {
     if (result.canceled || !result.filePaths[0]) return null;
     return importBruno(result.filePaths[0]);
   });
+  ipc.handle("import:openapi-schemas", async () => {
+    const result = await electron.dialog.showOpenDialog({
+      title: "Load OpenAPI spec for schema sync",
+      filters: [{ name: "OpenAPI", extensions: ["json", "yaml", "yml"] }],
+      properties: ["openFile"]
+    });
+    if (result.canceled || !result.filePaths[0]) return null;
+    return extractSchemasFromFile(result.filePaths[0]);
+  });
+  ipc.handle("import:openapi-schemas-url", async (_event, url) => {
+    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(" ");
@@ -893,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)) {
@@ -937,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) {
@@ -1009,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);
@@ -1084,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)];
@@ -1102,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();
@@ -1123,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);
@@ -1169,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: {
@@ -1199,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'
 
@@ -1292,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);
   }
@@ -1312,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();
@@ -1333,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);
@@ -1378,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: {
@@ -1408,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');
 
@@ -1500,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);
   }
@@ -1520,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'
@@ -1554,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)) {
@@ -1571,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"));
   }
@@ -1693,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) {
@@ -1720,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} */
@@ -1748,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)) {
@@ -1765,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"));
   }
@@ -1869,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) {
@@ -1896,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}") + "`;
   }) + '"';
 }
@@ -2015,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)) {
@@ -2035,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 = [];
@@ -2048,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")}
 }
@@ -2133,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) {
@@ -2219,17 +3065,20 @@ async function buildDispatcher(proxy, tls) {
     }
   }
   if (proxy?.url) {
-    const proxyUri = proxy.auth ? proxy.url.replace("://", `://${encodeURIComponent(proxy.auth.username)}:${encodeURIComponent(proxy.auth.password)}@`) : proxy.url;
-    const proxyConnect = { rejectUnauthorized: false, ...connectOpts };
     return new undici.ProxyAgent({
       uri: proxyUri,
-      connect: proxyConnect
+      requestTls: proxyConnect,
+      proxyTls: proxyConnect
     });
   }
   if (hasTls) return new undici.Agent({ connect: connectOpts });
   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,
@@ -2237,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(req.preRequestScript, {
+    const r = await requestCollection.runScript(requestCollection.interpolate(req.preRequestScript, vars), {
       envVars: { ...envVars },
       collectionVars: { ...collectionVars },
       globals: { ...globals },
@@ -2254,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 {
@@ -2267,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);
@@ -2295,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 {
@@ -2314,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,
@@ -2324,29 +3174,42 @@ async function executeOne(req, collectionVars, envVars, globals, localVars, disp
       bodySize: Buffer.byteLength(responseBody, "utf8"),
       durationMs
     };
-    let testResults = [];
+    const schemaTestResults = requestCollection.buildSchemaTestResults(req.schema, responseBody);
+    let testResults = [...schemaTestResults];
     let consoleOutput = [];
     let postScriptError;
     if (req.postRequestScript?.trim()) {
-      const r = await requestHandler.runScript(req.postRequestScript, {
+      const r = await requestCollection.runScript(requestCollection.interpolate(req.postRequestScript, vars), {
         envVars: updatedEnvVars,
         collectionVars: updatedCollectionVars,
         globals: updatedGlobals,
         localVars,
         response
       });
-      testResults = r.testResults;
+      testResults = [...schemaTestResults, ...r.testResults];
       consoleOutput = r.consoleOutput;
       postScriptError = r.error;
       updatedEnvVars = r.updatedEnvVars;
       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 status = postScriptError ? "error" : testResults.length > 0 ? allPassed ? "passed" : "failed" : "passed";
+    const httpFailed = fetchResp.status >= 400;
+    const hasTests = testResults.length > 0;
+    const status = postScriptError ? "error" : hasTests ? allPassed ? "passed" : "failed" : httpFailed ? "failed" : "skipped";
+    if (httpFailed && testResults.length === 0) {
+      testResults = [
+        ...testResults,
+        {
+          name: `HTTP status ${fetchResp.status} ${fetchResp.statusText}`.trim(),
+          passed: false,
+          error: `Request returned ${fetchResp.status} — no assertion was defined to verify the status code.`
+        }
+      ];
+    }
     const sentHeaders = {};
     headers.forEach((v, k) => {
       sentHeaders[k] = v;
@@ -2394,11 +3257,11 @@ 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, durationMs: 0 };
+    const summary = { total: items.length, passed: 0, failed: 0, errors: 0, skipped: 0, durationMs: 0 };
     const totalStart = Date.now();
     let runEnvVars = { ...envVars };
     let runCollectionVars = {};
@@ -2441,6 +3304,7 @@ function registerRunnerHandler(ipc) {
           isHook: item.isHook,
           hookType: item.hookType,
           scopeId: item.scopeId,
+          scopePath: item.scopePath,
           iterationLabel: item.iterationLabel
         };
         summary.failed++;
@@ -2452,7 +3316,8 @@ function registerRunnerHandler(ipc) {
         iterationLabel: item.iterationLabel,
         isHook: item.isHook,
         hookType: item.hookType,
-        scopeId: item.scopeId
+        scopeId: item.scopeId,
+        scopePath: item.scopePath
       };
       event.sender.send("runner:progress", { requestId: item.request.id, ...runningUpdate });
       const { result, updatedEnvVars, updatedCollectionVars, updatedGlobals, updatedLocalVars } = await executeOne(
@@ -2468,7 +3333,8 @@ function registerRunnerHandler(ipc) {
       runCollectionVars = updatedCollectionVars;
       runGlobals = updatedGlobals;
       runLocalVars = updatedLocalVars;
-      if (isHook && result.status !== "passed") {
+      const hookFailed = result.status === "failed" || result.status === "error";
+      if (isHook && hookFailed) {
         if (hookType === "beforeAll" && scopeId) {
           failedScopes.add(scopeId);
         } else if (hookType === "before" && mainRequestId) {
@@ -2477,13 +3343,15 @@ function registerRunnerHandler(ipc) {
       }
       if (result.status === "passed") summary.passed++;
       else if (result.status === "failed") summary.failed++;
+      else if (result.status === "skipped") summary.skipped++;
       else summary.errors++;
       event.sender.send("runner:progress", {
         ...result,
         iterationLabel: item.iterationLabel,
         isHook: item.isHook,
         hookType: item.hookType,
-        scopeId: item.scopeId
+        scopeId: item.scopeId,
+        scopePath: item.scopePath
       });
       if (requestDelay > 0 && item !== items[items.length - 1]) {
         await sleep(requestDelay);
@@ -2524,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.");
@@ -2606,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();
@@ -3060,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,
@@ -3115,7 +3983,7 @@ async function executeContract(req, vars) {
 async function runConsumerContracts(requests, envVars, collectionVars = {}) {
   const vars = { ...envVars, ...collectionVars };
   const contractRequests = requests.filter(
-    (r) => r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+    (r) => !r.disabled && r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
   );
   const start = Date.now();
   const results = await Promise.all(contractRequests.map((r) => executeContract(r, vars)));
@@ -3229,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)) {
@@ -3268,7 +4136,8 @@ function validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl) {
 async function runProviderVerification(requests, envVars, specUrl, specPath, requestBaseUrl) {
   const spec = await loadSpec(specUrl, specPath);
   const start = Date.now();
-  const results = requests.map((req) => {
+  const activeRequests = requests.filter((r) => !r.disabled);
+  const results = activeRequests.map((req) => {
     const violations = validateRequestAgainstSpec(spec, req, envVars, requestBaseUrl);
     const url = req.url.replace(/\{\{([^}]+)\}\}/g, (_, k) => envVars[k] ?? `{{${k}}}`);
     return {
@@ -3365,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, {
@@ -3399,10 +4268,10 @@ async function runBidirectional(requests, envVars, collectionVars = {}, specUrl,
   const vars = { ...envVars, ...collectionVars };
   const start = Date.now();
   const contractRequests = requests.filter(
-    (r) => r.contract && (r.contract.statusCode !== void 0 || r.contract.bodySchema || r.contract.headers?.length)
+    (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 ? (() => {
@@ -3728,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) => {
@@ -3739,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);