@churivibhav/reqex 0.1.2 → 0.1.3

package/dist/cli.js

@@ -1,14 +1,93 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path4 from "path";
-import process2 from "process";
+import path7 from "path";
+import process3 from "process";
+import { ZR_MOD_CTRL, ZR_MOD_SHIFT } from "@rezi-ui/core/keybindings";
 import { createNodeApp } from "@rezi-ui/node";
 
-// src/config/keybindings.ts
+// src/config/config.ts
 import fs from "fs";
+import path2 from "path";
+
+// src/config/paths.ts
 import os from "os";
 import path from "path";
+function getConfigDir() {
+  if (process.env.REQEX_CONFIG_DIR) {
+    return process.env.REQEX_CONFIG_DIR;
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "reqex");
+  }
+  if (process.platform === "darwin") {
+    return path.join(os.homedir(), "Library", "Application Support", "reqex");
+  }
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(xdg, "reqex");
+}
+function getProjectConfigDir(workspaceRoot) {
+  return path.join(workspaceRoot, ".reqex");
+}
+
+// src/config/config.ts
+var DEFAULT_THEME = "auto";
+function readJsonIfExists(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function parseThemePreference(value) {
+  if (value === "auto" || value === "light" || value === "dark") {
+    return value;
+  }
+  return null;
+}
+function loadConfig(workspaceRoot) {
+  const userConfig = readJsonIfExists(path2.join(getConfigDir(), "config.json"));
+  const projectConfig = readJsonIfExists(
+    path2.join(getProjectConfigDir(workspaceRoot), "config.json")
+  );
+  const envTheme = parseThemePreference(process.env.REQEX_THEME);
+  const fileTheme = projectConfig?.theme ?? userConfig?.theme ?? DEFAULT_THEME;
+  return {
+    theme: envTheme ?? fileTheme
+  };
+}
+function watchConfig(workspaceRoot, onChange) {
+  const files = [
+    path2.join(getConfigDir(), "config.json"),
+    path2.join(getProjectConfigDir(workspaceRoot), "config.json")
+  ];
+  const watchers = files.map((filePath) => {
+    const dir = path2.dirname(filePath);
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+    } catch {
+    }
+    return fs.watch(dir, { persistent: false }, (_event, filename) => {
+      if (filename === "config.json") {
+        onChange();
+      }
+    });
+  });
+  return () => {
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+  };
+}
+
+// src/config/keybindings.ts
+import fs2 from "fs";
+import path3 from "path";
 var VSCODE_DEFAULTS = {
   F5: "request.send",
   "ctrl+enter": "request.send",
@@ -30,13 +109,14 @@ var VSCODE_DEFAULTS = {
   F11: "pane.zoom",
   z: "pane.zoom",
   F1: "help.show",
-  "?": "help.show",
   "ctrl+/": "keybindings.show",
   escape: "overlay.close",
   "ctrl+q": "app.quit",
   "ctrl+x": "request.cancel",
   "ctrl+shift+c": "response.copy",
   "ctrl+f": "response.search",
+  "ctrl+[": "response.jsonFoldToggle",
+  "ctrl+]": "response.jsonUnfoldAll",
   "ctrl+tab": "response.tab.next",
   "ctrl+shift+tab": "response.tab.prev"
 };
@@ -71,6 +151,8 @@ var COMMAND_LABELS = {
   "response.tab.prev": "Previous response tab",
   "response.copy": "Copy response",
   "response.search": "Search response",
+  "response.jsonFoldToggle": "Fold/unfold JSON node",
+  "response.jsonUnfoldAll": "Unfold all JSON",
   "editor.searchNext": "Find next in editor"
 };
 var CHORD_PART_LABELS = {
@@ -116,38 +198,21 @@ function buildKeybindingsViewLines(bindings, maxLines) {
   }
   return rows;
 }
-function getConfigDir() {
-  if (process.env.REQEX_CONFIG_DIR) {
-    return process.env.REQEX_CONFIG_DIR;
-  }
-  if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
-    return path.join(appData, "reqex");
-  }
-  if (process.platform === "darwin") {
-    return path.join(os.homedir(), "Library", "Application Support", "reqex");
-  }
-  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-  return path.join(xdg, "reqex");
-}
-function getProjectConfigDir(workspaceRoot) {
-  return path.join(workspaceRoot, ".reqex");
-}
-function readJsonIfExists(filePath) {
+function readJsonIfExists2(filePath) {
   try {
-    if (!fs.existsSync(filePath)) {
+    if (!fs2.existsSync(filePath)) {
       return null;
     }
-    const raw = fs.readFileSync(filePath, "utf8");
+    const raw = fs2.readFileSync(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function loadKeybindings(workspaceRoot) {
-  const userConfig = readJsonIfExists(path.join(getConfigDir(), "keybindings.json"));
-  const projectConfig = readJsonIfExists(
-    path.join(getProjectConfigDir(workspaceRoot), "keybindings.json")
+  const userConfig = readJsonIfExists2(path3.join(getConfigDir(), "keybindings.json"));
+  const projectConfig = readJsonIfExists2(
+    path3.join(getProjectConfigDir(workspaceRoot), "keybindings.json")
   );
   const preset = projectConfig?.preset ?? userConfig?.preset ?? "vscode";
   const defaults = preset === "vim" ? VIM_DEFAULTS : VSCODE_DEFAULTS;
@@ -164,10 +229,10 @@ function watchKeybindings(workspaceRoot, onChange) {
   const dirs = [getConfigDir(), getProjectConfigDir(workspaceRoot)];
   const watchers = dirs.map((dir) => {
     try {
-      fs.mkdirSync(dir, { recursive: true });
+      fs2.mkdirSync(dir, { recursive: true });
     } catch {
     }
-    return fs.watch(dir, { persistent: false }, () => onChange());
+    return fs2.watch(dir, { persistent: false }, () => onChange());
   });
   return () => {
     for (const watcher of watchers) {
@@ -175,34 +240,166 @@ function watchKeybindings(workspaceRoot, onChange) {
     }
   };
 }
-var FOOTER_HINTS = {
-  editor: ["F5 Send", "Ctrl+S Save", "Tab Panes", "F2 Palette"],
-  response: ["Tab Panes", "Ctrl+Shift+C Copy", "F5 Send", "F2 Palette"],
-  files: ["Enter Open", "Tab Panes", "Ctrl+P Files", "F2 Palette"],
-  overlay: ["\u2191\u2193 Navigate", "Enter Select", "Esc Close"],
-  sending: ["Ctrl+X Cancel", "Tab Panes", "Ctrl+Q Quit"]
+var FOOTER_COMMANDS = {
+  editor: ["file.save", "palette.commands"],
+  response: ["response.copy", "response.jsonFoldToggle", "response.jsonUnfoldAll"],
+  files: ["palette.files", "pane.focusNext", "palette.commands"],
+  overlay: ["overlay.close"],
+  sending: ["pane.focusNext", "app.quit"]
+};
+var FOOTER_LABELS = {
+  "request.send": "Send",
+  "request.cancel": "Cancel",
+  "pane.focusNext": "Panes",
+  "pane.focusPrev": "Prev pane",
+  "pane.focusFiles": "Files pane",
+  "pane.focusEditor": "Editor pane",
+  "pane.focusResponse": "Response pane",
+  "sidebar.toggle": "Sidebar",
+  "file.save": "Save",
+  "env.switcher": "Env",
+  "env.selectNext": "Next env",
+  "env.selectPrev": "Prev env",
+  "env.apply": "Select",
+  "overlay.close": "Close",
+  "app.quit": "Quit",
+  "palette.commands": "Palette",
+  "palette.files": "Files",
+  "help.show": "Help",
+  "keybindings.show": "Keys",
+  "pane.zoom": "Zoom",
+  "response.tab.next": "Next tab",
+  "response.tab.prev": "Prev tab",
+  "response.copy": "Copy",
+  "response.search": "Search",
+  "response.jsonFoldToggle": "Fold",
+  "response.jsonUnfoldAll": "Unfold",
+  "editor.searchNext": "Find next"
 };
-function footerHints(context) {
-  let hints;
+var PREFERRED_FOOTER_KEYS = {
+  "request.send": ["F5", "ctrl+enter", "alt+enter"],
+  "request.cancel": ["ctrl+x"],
+  "pane.focusNext": ["tab"],
+  "pane.focusPrev": ["shift+tab"],
+  "pane.focusFiles": ["ctrl+1", "alt+1"],
+  "pane.focusEditor": ["ctrl+2", "alt+2"],
+  "pane.focusResponse": ["ctrl+3", "alt+3"],
+  "sidebar.toggle": ["ctrl+b"],
+  "file.save": ["ctrl+s"],
+  "env.switcher": ["ctrl+e"],
+  "env.selectNext": ["down"],
+  "env.selectPrev": ["up"],
+  "env.apply": ["enter"],
+  "overlay.close": ["escape"],
+  "app.quit": ["ctrl+q"],
+  "palette.commands": ["F2", "ctrl+shift+p"],
+  "palette.files": ["ctrl+p"],
+  "help.show": ["F1"],
+  "keybindings.show": ["ctrl+/"],
+  "pane.zoom": ["F11", "z"],
+  "response.tab.next": ["ctrl+tab"],
+  "response.tab.prev": ["ctrl+shift+tab"],
+  "response.copy": ["ctrl+shift+c"],
+  "response.search": ["ctrl+f"],
+  "response.jsonFoldToggle": ["ctrl+["],
+  "response.jsonUnfoldAll": ["ctrl+]"],
+  "editor.searchNext": []
+};
+function commandKey(bindings, command) {
+  const keys = Object.entries(bindings).filter(([, boundCommand]) => boundCommand === command).map(([key]) => key);
+  if (command === "help.show" && keys.length === 0) {
+    return "F1";
+  }
+  if (keys.length === 0) {
+    return null;
+  }
+  const preferred = PREFERRED_FOOTER_KEYS[command] ?? [];
+  keys.sort((a, b) => {
+    const aPreferred = preferred.indexOf(a);
+    const bPreferred = preferred.indexOf(b);
+    if (aPreferred !== -1 || bPreferred !== -1) {
+      return (aPreferred === -1 ? Number.MAX_SAFE_INTEGER : aPreferred) - (bPreferred === -1 ? Number.MAX_SAFE_INTEGER : bPreferred);
+    }
+    return formatKeyChord(a).length - formatKeyChord(b).length || a.localeCompare(b);
+  });
+  return keys[0] ?? null;
+}
+function footerCommandList(context) {
+  const action = context.sending ? "request.cancel" : "request.send";
+  let contextual;
   if (context.overlay !== "none") {
-    hints = FOOTER_HINTS.overlay;
+    contextual = FOOTER_COMMANDS.overlay;
   } else if (context.sending) {
-    hints = FOOTER_HINTS.sending;
+    contextual = FOOTER_COMMANDS.sending;
   } else {
-    hints = FOOTER_HINTS[context.focusPane] ?? FOOTER_HINTS.editor;
+    contextual = FOOTER_COMMANDS[context.focusPane] ?? FOOTER_COMMANDS.editor;
+  }
+  const commands = [action, ...contextual];
+  if (!context.hasResponse) {
+    return commands.filter(
+      (command) => command !== "response.copy" && command !== "response.jsonFoldToggle" && command !== "response.jsonUnfoldAll"
+    );
+  }
+  if (context.responseTab !== "pretty") {
+    return commands.filter(
+      (command) => command !== "response.jsonFoldToggle" && command !== "response.jsonUnfoldAll"
+    );
+  }
+  if (!context.hasFoldedJson) {
+    return commands.filter((command) => command !== "response.jsonUnfoldAll");
   }
+  return commands;
+}
+function footerHintItems(context) {
+  const bindings = context.bindings ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [...footerCommandList(context), "help.show"].filter((command) => {
+    if (command === "help.show") {
+      seen.delete(command);
+    }
+    if (seen.has(command)) {
+      return false;
+    }
+    seen.add(command);
+    return true;
+  });
+  const items = commands.flatMap((command) => {
+    const key = commandKey(bindings, command);
+    if (!key) {
+      return [];
+    }
+    const formattedKey = command === "help.show" ? "F1" : formatKeyChord(key);
+    return [{ command, key: formattedKey, label: `${formattedKey} ${FOOTER_LABELS[command]}` }];
+  });
   const leftBudget = 48;
   const maxWidth = Math.max(20, context.viewportWidth - leftBudget);
-  let text = hints.join(" \xB7 ");
-  if (text.length > maxWidth) {
-    text = `${text.slice(0, maxWidth - 1)}\u2026`;
+  const pinned = items.filter(
+    (item) => item.command === "request.send" || item.command === "request.cancel" || item.command === "help.show"
+  );
+  const middle = items.filter((item) => !pinned.includes(item));
+  const selected = [];
+  const append = (item) => {
+    selected.push(item);
+  };
+  append(pinned[0] ?? items[0]);
+  for (const item of middle) {
+    const candidate = [...selected, item, pinned[pinned.length - 1]].filter(Boolean);
+    if (candidate.map((entry) => entry.label).join(" \xB7 ").length <= maxWidth) {
+      append(item);
+    }
   }
-  return text;
+  const help = pinned.find((item) => item.command === "help.show");
+  if (help && selected[selected.length - 1]?.command !== "help.show") {
+    append(help);
+  }
+  return selected.filter(Boolean);
 }
 var HELP_HINT_LINES = [
   "F5 Send request under cursor",
   "Tab / Shift+Tab Cycle panes",
   "Ctrl+S Save file",
+  "Mouse click Place editor cursor \xB7 Shift+click Select",
+  "Ctrl+A/C/X/V Select all, copy, cut, paste in editor",
   "Ctrl+E Environment switcher",
   "F2 / Ctrl+Shift+P Command palette",
   "Ctrl+Shift+C Copy response tab",
@@ -270,33 +467,91 @@ function resolveRegionAtLine(regions, line) {
     return best;
   });
 }
+function resolveActiveRegion(parsedFile, cursorLine) {
+  if (!parsedFile) {
+    return null;
+  }
+  return resolveRegionAtLine(parsedFile.regions, cursorLine);
+}
 var HTTP_METHOD_PREFIX = /^\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|GRAPHQL)\b/u;
-function markerColumnAfterMethod(line) {
-  const match = HTTP_METHOD_PREFIX.exec(line);
-  return match ? match[0].length : 0;
-}
-function buildRegionDiagnostics(regions, activeRegionId, fileLines) {
-  const markers = [];
-  for (const region of regions) {
-    if (!region.hasRequest || region.isGlobal) {
-      continue;
+function firstRequestLine(regions, fileLines) {
+  const firstRegion = regions.find((region) => region.hasRequest && !region.isGlobal);
+  if (!firstRegion) {
+    return null;
+  }
+  for (let line = firstRegion.startLine; line <= firstRegion.endLine; line++) {
+    if (HTTP_METHOD_PREFIX.test(fileLines[line] ?? "")) {
+      return line;
     }
-    const isActive = region.id === activeRegionId;
-    const line = fileLines[region.startLine] ?? "";
-    const markerCol = markerColumnAfterMethod(line);
-    markers.push({
-      line: region.startLine,
-      startColumn: markerCol,
-      endColumn: markerCol + 1,
-      severity: isActive ? "hint" : "info",
-      message: `${region.method ?? "REQ"} ${region.name}`
-    });
   }
-  return markers;
+  return firstRegion.startLine;
 }
 
 // src/engine/store.ts
 import { store as httpyacStoreModule } from "httpyac";
+
+// src/engine/env-config.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+var ENV_FILE_NAMES = [
+  ".env.json",
+  "http-client.env.json",
+  "http-client.private.env.json"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeVariables(target, source) {
+  for (const [envName, variables] of Object.entries(source)) {
+    if (!isRecord(variables)) {
+      continue;
+    }
+    target[envName] = {
+      ...target[envName] ?? {},
+      ...variables
+    };
+  }
+}
+function directoriesToSearch(filePath, workingDir) {
+  const root = path4.resolve(workingDir);
+  const dirs = [];
+  let current = path4.dirname(path4.resolve(filePath));
+  while (current.startsWith(root)) {
+    dirs.unshift(current);
+    const parent = path4.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs.length > 0 ? dirs : [path4.dirname(path4.resolve(filePath))];
+}
+async function readEnvFile(filePath) {
+  try {
+    const raw = await fs3.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : null;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+}
+async function loadEnvironmentConfig(filePath, workingDir) {
+  const environments = {};
+  for (const dir of directoriesToSearch(filePath, workingDir)) {
+    for (const fileName of ENV_FILE_NAMES) {
+      const parsed = await readEnvFile(path4.join(dir, fileName));
+      if (parsed) {
+        mergeVariables(environments, parsed);
+      }
+    }
+  }
+  return Object.keys(environments).length > 0 ? { environments } : {};
+}
+
+// src/engine/store.ts
 var store = new httpyacStoreModule.HttpFileStore();
 var versions = /* @__PURE__ */ new Map();
 function toRegion(region) {
@@ -321,7 +576,9 @@ function getParseVersion(filePath) {
 }
 async function parseFile(filePath, getText, workingDir, version) {
   const parseVersion = version ?? getParseVersion(filePath);
+  const config = await loadEnvironmentConfig(filePath, workingDir);
   const httpFile = await store.getOrCreate(filePath, getText, parseVersion, {
+    config,
     workingDir
   });
   const regions = httpFile.httpRegions.map(toRegion);
@@ -403,11 +660,13 @@ async function sendRegion(options) {
   const logResponse = async (response) => {
     capturedResponse = response;
   };
+  const config = await loadEnvironmentConfig(options.filePath, options.workingDir);
   try {
     await send({
       httpFile,
       httpRegion,
       activeEnvironment: options.activeEnvironment,
+      config,
       variables: options.variables,
       logResponse
     });
@@ -432,26 +691,28 @@ async function sendRegion(options) {
     };
   }
 }
-async function listEnvironments(filePath) {
+async function listEnvironments(filePath, workingDir) {
   const httpFile = getHttpFile(filePath);
   if (!httpFile) {
     return [];
   }
-  return getEnvironments({ httpFile });
+  const config = await loadEnvironmentConfig(filePath, workingDir);
+  return getEnvironments({ httpFile, config });
 }
-async function listVariables(filePath, activeEnvironment) {
+async function listVariables(filePath, workingDir, activeEnvironment) {
   const httpFile = getHttpFile(filePath);
   if (!httpFile) {
     return {};
   }
-  return getVariables({ httpFile, activeEnvironment });
+  const config = await loadEnvironmentConfig(filePath, workingDir);
+  return getVariables({ httpFile, activeEnvironment, config });
 }
 
 // src/keymap/dispatcher.ts
 function buildBindingMap(bindings, execute) {
   const map = {};
   for (const [key, command] of Object.entries(bindings)) {
-    map[key] = () => execute(command);
+    map[key] = (ctx) => execute(command, ctx);
   }
   return map;
 }
@@ -464,6 +725,8 @@ function commandFromPaletteId(id) {
     "palette.commands": "palette.commands",
     "help.show": "help.show",
     "keybindings.show": "keybindings.show",
+    "response.jsonFoldToggle": "response.jsonFoldToggle",
+    "response.jsonUnfoldAll": "response.jsonUnfoldAll",
     "pane.zoom": "pane.zoom",
     "sidebar.toggle": "sidebar.toggle"
   };
@@ -475,6 +738,8 @@ var COMMAND_ITEMS = [
   { id: "file.save", label: "Save File", description: "Write editor to disk", shortcut: "Ctrl+S" },
   { id: "env.switcher", label: "Switch Environment", description: "Choose active environment", shortcut: "Ctrl+E" },
   { id: "sidebar.toggle", label: "Toggle Sidebar", description: "Show/hide file tree", shortcut: "Ctrl+B" },
+  { id: "response.jsonFoldToggle", label: "Fold/Unfold JSON", description: "Toggle JSON node in pretty response", shortcut: "Ctrl+[" },
+  { id: "response.jsonUnfoldAll", label: "Unfold All JSON", description: "Expand folded pretty response JSON", shortcut: "Ctrl+]" },
   { id: "pane.zoom", label: "Zoom Pane", description: "Zoom focused pane", shortcut: "F11" },
   { id: "help.show", label: "Help", description: "Show quick help", shortcut: "F1" },
   { id: "keybindings.show", label: "Keybindings", description: "Show all keybindings", shortcut: "Ctrl+/" }
@@ -487,7 +752,7 @@ import { EventEmitter } from "events";
 
 // src/workspace/discovery.ts
 import { readdir, stat } from "fs/promises";
-import path2 from "path";
+import path5 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".git",
   "node_modules",
@@ -502,7 +767,7 @@ var FILE_KINDS = [
   { ext: ".env.json", kind: "env-json" }
 ];
 function classifyFile(filePath) {
-  const base = path2.basename(filePath);
+  const base = path5.basename(filePath);
   for (const { ext, kind } of FILE_KINDS) {
     if (base === ext || base.endsWith(ext)) {
       return kind;
@@ -531,7 +796,7 @@ async function discoverDirectory(rootDir, currentDir) {
         continue;
       }
     }
-    const fullPath = path2.join(currentDir, entry);
+    const fullPath = path5.join(currentDir, entry);
     let entryStat;
     try {
       entryStat = await stat(fullPath);
@@ -622,17 +887,17 @@ var Workspace = class extends EventEmitter {
       ],
       awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
     });
-    const handle = async (type, path5) => {
+    const handle = async (type, path8) => {
       try {
         this.tree = await discoverFileTree(this.rootDir);
-        this.emitChange({ type, path: path5 });
+        this.emitChange({ type, path: path8 });
       } catch (error) {
         this.emit("error", error instanceof Error ? error : new Error(String(error)));
       }
     };
-    this.watcher.on("add", (path5) => void handle("add", path5));
-    this.watcher.on("change", (path5) => void handle("change", path5));
-    this.watcher.on("unlink", (path5) => void handle("unlink", path5));
+    this.watcher.on("add", (path8) => void handle("add", path8));
+    this.watcher.on("change", (path8) => void handle("change", path8));
+    this.watcher.on("unlink", (path8) => void handle("unlink", path8));
     this.watcher.on("error", (error) => {
       this.emit("error", error instanceof Error ? error : new Error(String(error)));
     });
@@ -662,12 +927,12 @@ function createInitialState(workspaceRoot) {
     dirty: false,
     parseVersion: 0,
     parsedFile: null,
-    activeRegion: null,
     responseEditor: {
       scrollTop: 0,
       scrollLeft: 0,
       cursor: { line: 0, column: 0 },
-      selection: null
+      selection: null,
+      foldedJsonPaths: []
     },
     resultGeneration: 0,
     editor: {
@@ -703,7 +968,9 @@ function createInitialState(workspaceRoot) {
     },
     settings: {
       keymapPreset: "vscode",
-      keybindings: {}
+      keybindings: {},
+      theme: "auto",
+      themeMode: "dark"
     }
   };
 }
@@ -760,7 +1027,196 @@ function createSendController() {
   };
 }
 
+// src/utils/http-syntax.ts
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE",
+  "GRAPHQL"
+]);
+function tokenizeHttpLine(line, _context) {
+  const tokens = [];
+  const methodMatch = /^\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|GRAPHQL)\b/u.exec(
+    line
+  );
+  if (methodMatch) {
+    const method = methodMatch[1] ?? "";
+    tokens.push({ text: method, kind: "keyword" });
+    const rest = line.slice(methodMatch[0].length);
+    if (rest.length > 0) {
+      tokens.push({ text: rest, kind: "string" });
+    }
+    return tokens;
+  }
+  if (/^\s*#/u.test(line)) {
+    return [{ text: line, kind: "comment" }];
+  }
+  if (/^\s*\/\//u.test(line)) {
+    return [{ text: line, kind: "comment" }];
+  }
+  if (/^\s*@/u.test(line)) {
+    return [{ text: line, kind: "type" }];
+  }
+  const headerMatch = /^\s*([!#$%&'*+\-.^_`|~0-9A-Za-z]+)(\s*:\s*)(.*)$/u.exec(line);
+  if (headerMatch) {
+    tokens.push({ text: headerMatch[1] ?? "", kind: "function" });
+    tokens.push({ text: headerMatch[2] ?? "", kind: "operator" });
+    tokens.push({ text: headerMatch[3] ?? "", kind: "string" });
+    return tokens;
+  }
+  const words = line.split(/(\s+)/u);
+  for (const word of words) {
+    if (KEYWORDS.has(word)) {
+      tokens.push({ text: word, kind: "keyword" });
+    } else if (word.length > 0) {
+      tokens.push({ text: word, kind: "plain" });
+    }
+  }
+  return tokens.length > 0 ? tokens : [{ text: line, kind: "plain" }];
+}
+function prettyJsonIfPossible(text) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return text;
+  }
+  try {
+    return JSON.stringify(JSON.parse(trimmed), null, 2);
+  } catch {
+    return text;
+  }
+}
+function statusTone(statusCode) {
+  if (!statusCode) {
+    return "cyan";
+  }
+  if (statusCode >= 200 && statusCode < 300) {
+    return "green";
+  }
+  if (statusCode >= 400 && statusCode < 500) {
+    return "yellow";
+  }
+  if (statusCode >= 500) {
+    return "red";
+  }
+  return "cyan";
+}
+
+// src/utils/json-folding.ts
+var INDENT = 2;
+function escapeJsonPointerSegment(segment) {
+  return segment.replace(/~/gu, "~0").replace(/\//gu, "~1");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function primitiveToJson(value) {
+  return JSON.stringify(value);
+}
+function summarizeFolded(value) {
+  if (Array.isArray(value)) {
+    return `${value.length} ${value.length === 1 ? "item" : "items"}`;
+  }
+  if (isRecord2(value)) {
+    const count = Object.keys(value).length;
+    return `${count} ${count === 1 ? "property" : "properties"}`;
+  }
+  return "";
+}
+function renderValue(args) {
+  const { value, path: path8, parentPath, key, indent, isLast, foldedPaths, lines, lineToFoldPath } = args;
+  const leading = " ".repeat(indent);
+  const keyPrefix = key === void 0 ? "" : `${JSON.stringify(key)}: `;
+  const comma = isLast ? "" : ",";
+  if (Array.isArray(value) || isRecord2(value)) {
+    const isArray = Array.isArray(value);
+    const open = isArray ? "[" : "{";
+    const close = isArray ? "]" : "}";
+    const entries = isArray ? value.map((item, index) => [String(index), item]) : Object.entries(value);
+    if (entries.length === 0) {
+      lines.push(`${leading}${keyPrefix}${open}${close}${comma}`);
+      lineToFoldPath.push(parentPath);
+      return;
+    }
+    if (foldedPaths.has(path8)) {
+      lines.push(`${leading}${keyPrefix}${open} ... ${summarizeFolded(value)} ${close}${comma}`);
+      lineToFoldPath.push(path8);
+      return;
+    }
+    lines.push(`${leading}${keyPrefix}${open}`);
+    lineToFoldPath.push(path8);
+    entries.forEach(([entryKey, entryValue], index) => {
+      const childPath = `${path8}/${escapeJsonPointerSegment(entryKey)}`;
+      renderValue({
+        value: entryValue,
+        path: childPath,
+        parentPath: path8,
+        key: isArray ? void 0 : entryKey,
+        indent: indent + INDENT,
+        isLast: index === entries.length - 1,
+        foldedPaths,
+        lines,
+        lineToFoldPath
+      });
+    });
+    lines.push(`${leading}${close}${comma}`);
+    lineToFoldPath.push(path8);
+    return;
+  }
+  lines.push(`${leading}${keyPrefix}${primitiveToJson(value)}${comma}`);
+  lineToFoldPath.push(parentPath);
+}
+function buildFoldableJsonView(text, foldedPaths) {
+  try {
+    const value = JSON.parse(text.trim());
+    const lines = [];
+    const lineToFoldPath = [];
+    renderValue({
+      value,
+      path: "",
+      parentPath: null,
+      indent: 0,
+      isLast: true,
+      foldedPaths: new Set(foldedPaths),
+      lines,
+      lineToFoldPath
+    });
+    return { lines, lineToFoldPath };
+  } catch {
+    return { lines: text.split("\n"), lineToFoldPath: text.split("\n").map(() => null) };
+  }
+}
+function toggleJsonFoldAtLine(text, foldedPaths, line) {
+  const view = buildFoldableJsonView(text, foldedPaths);
+  const path8 = view.lineToFoldPath[line] ?? null;
+  if (path8 === null) {
+    return foldedPaths;
+  }
+  const next = new Set(foldedPaths);
+  if (next.has(path8)) {
+    next.delete(path8);
+  } else {
+    next.add(path8);
+  }
+  return [...next].sort();
+}
+
 // src/state/commands.ts
+function envNameFromSelectedIndex(environments, selectedIndex) {
+  return selectedIndex === 0 ? void 0 : environments[selectedIndex - 1];
+}
+function envSelectedIndexFromActive(environments, activeEnvironment) {
+  if (activeEnvironment.length === 0) {
+    return 0;
+  }
+  const idx = environments.indexOf(activeEnvironment[0]);
+  return idx === -1 ? 0 : idx + 1;
+}
 function createCommandContext(deps) {
   setPromptHandler(async (request) => {
     return new Promise((resolve) => {
@@ -791,27 +1247,28 @@ function createCommandContext(deps) {
       ui: { ...state.ui, pendingPrompt: null }
     }));
   };
-  const openFile = async (path5) => {
-    const content = await deps.workspace.readFile(path5);
+  const openFile = async (path8) => {
+    const content = await deps.workspace.readFile(path8);
     const lines = linesFromContent(content);
-    const parsed = await parseFile(path5, async () => content, deps.workspace.rootDir);
-    const environments = await listEnvironments(path5);
-    const variables = await listVariables(path5, [...deps.getState().request.activeEnvironment]);
-    const activeRegion = resolveRegionAtLine(parsed.regions, 0);
+    const parsed = await parseFile(path8, async () => content, deps.workspace.rootDir);
+    const environments = await listEnvironments(path8, deps.workspace.rootDir);
+    const variables = await listVariables(path8, deps.workspace.rootDir, [
+      ...deps.getState().request.activeEnvironment
+    ]);
+    const initialLine = firstRequestLine(parsed.regions, lines) ?? 0;
     deps.update((state) => ({
       ...state,
-      selectedFilePath: path5,
+      selectedFilePath: path8,
       fileContent: content,
       fileLines: lines,
       dirty: false,
       parseVersion: parsed.version,
       parsedFile: parsed,
-      activeRegion,
       editor: {
         ...state.editor,
-        cursor: { line: activeRegion?.startLine ?? 0, column: 0 },
+        cursor: { line: initialLine, column: 0 },
         selection: null,
-        scrollTop: activeRegion?.startLine ?? 0
+        scrollTop: initialLine
       },
       request: {
         ...state.request,
@@ -845,22 +1302,37 @@ function createCommandContext(deps) {
       deps.workspace.rootDir,
       version
     );
-    const activeRegion = state.activeRegion ? parsed.regions.find((region) => region.id === state.activeRegion?.id) ?? resolveRegionAtLine(parsed.regions, state.editor.cursor.line) : resolveRegionAtLine(parsed.regions, state.editor.cursor.line);
     deps.update((s) => ({
       ...s,
       fileContent: content,
       dirty: false,
       parsedFile: parsed,
-      activeRegion: activeRegion ?? null,
       ui: { ...s.ui, statusMessage: "Saved" }
     }));
   };
   const runSend = async () => {
     const state = deps.getState();
-    if (!state.selectedFilePath || !state.parsedFile) {
+    if (!state.selectedFilePath) {
       return;
     }
-    const region = resolveRegionAtLine(state.parsedFile.regions, state.editor.cursor.line);
+    const cursorLine = state.editor.cursor.line;
+    const content = contentFromLines(state.fileLines);
+    let parsedFile = state.parsedFile;
+    if (!parsedFile || state.dirty) {
+      const version = bumpParseVersion(state.selectedFilePath);
+      parsedFile = await parseFile(
+        state.selectedFilePath,
+        async () => content,
+        deps.workspace.rootDir,
+        version
+      );
+      deps.update((s) => ({
+        ...s,
+        parsedFile,
+        parseVersion: parsedFile.version
+      }));
+    }
+    const region = resolveActiveRegion(parsedFile, cursorLine);
     if (!region) {
       deps.update((s) => ({
         ...s,
@@ -872,13 +1344,13 @@ function createCommandContext(deps) {
     const gen = sendController.beginSend();
     deps.update((s) => ({
       ...s,
-      activeRegion: region,
       request: { ...s.request, sending: true, error: null, result: null },
       responseEditor: {
         scrollTop: 0,
         scrollLeft: 0,
         cursor: { line: 0, column: 0 },
-        selection: null
+        selection: null,
+        foldedJsonPaths: []
       },
       resultGeneration: s.resultGeneration + 1,
       ui: { ...s.ui, focusPane: "response", responseTab: "pretty" }
@@ -894,10 +1366,12 @@ function createCommandContext(deps) {
     if (!sendController.isCurrent(gen)) {
       return;
     }
-    const variables = await listVariables(state.selectedFilePath, [
-      ...deps.getState().request.activeEnvironment
-    ]);
-    if (!sendController.isCurrent(gen)) {
+    const variables = await listVariables(
+      state.selectedFilePath,
+      deps.workspace.rootDir,
+      [...deps.getState().request.activeEnvironment]
+    );
+    if (!sendController.isCurrent(gen)) {
       return;
     }
     deps.update((s) => ({
@@ -969,9 +1443,9 @@ function createCommandContext(deps) {
           ui: {
             ...s.ui,
             overlay: s.ui.overlay === "env" ? "none" : "env",
-            envSelectedIndex: Math.max(
-              0,
-              s.request.environments.indexOf(s.request.activeEnvironment.join(",")) || 0
+            envSelectedIndex: envSelectedIndexFromActive(
+              s.request.environments,
+              s.request.activeEnvironment
             )
           }
         }));
@@ -1002,10 +1476,13 @@ function createCommandContext(deps) {
         }
         break;
       case "env.apply": {
-        const envName = state.request.environments[state.ui.envSelectedIndex];
+        const envName = envNameFromSelectedIndex(
+          state.request.environments,
+          state.ui.envSelectedIndex
+        );
         void (async () => {
           const activeEnvironment = envName ? [envName] : [];
-          const variables = state.selectedFilePath ? await listVariables(state.selectedFilePath, activeEnvironment) : {};
+          const variables = state.selectedFilePath ? await listVariables(state.selectedFilePath, deps.workspace.rootDir, activeEnvironment) : {};
           deps.update((s) => ({
             ...s,
             request: { ...s.request, activeEnvironment, variables },
@@ -1095,6 +1572,46 @@ function createCommandContext(deps) {
           ui: { ...s.ui, focusPane: "response", responseTab: "pretty" }
         }));
         break;
+      case "response.jsonFoldToggle": {
+        const result = state.request.result;
+        if (!result || state.ui.responseTab !== "pretty") {
+          break;
+        }
+        const text = prettyJsonIfPossible(result.prettyBody || result.body);
+        const foldedJsonPaths = toggleJsonFoldAtLine(
+          text,
+          state.responseEditor.foldedJsonPaths,
+          state.responseEditor.cursor.line
+        );
+        if (foldedJsonPaths === state.responseEditor.foldedJsonPaths) {
+          deps.update((s) => ({
+            ...s,
+            ui: { ...s.ui, statusMessage: "No foldable JSON node" }
+          }));
+          break;
+        }
+        const visibleLineCount = buildFoldableJsonView(text, foldedJsonPaths).lines.length;
+        deps.update((s) => ({
+          ...s,
+          responseEditor: {
+            ...s.responseEditor,
+            foldedJsonPaths,
+            cursor: {
+              ...s.responseEditor.cursor,
+              line: Math.min(s.responseEditor.cursor.line, Math.max(0, visibleLineCount - 1))
+            }
+          },
+          ui: { ...s.ui, focusPane: "response", statusMessage: "JSON fold toggled" }
+        }));
+        break;
+      }
+      case "response.jsonUnfoldAll":
+        deps.update((s) => ({
+          ...s,
+          responseEditor: { ...s.responseEditor, foldedJsonPaths: [] },
+          ui: { ...s.ui, focusPane: "response", statusMessage: "JSON unfolded" }
+        }));
+        break;
       case "editor.searchNext":
         break;
       default:
@@ -1117,103 +1634,240 @@ function createCommandContext(deps) {
   return context;
 }
 
+// src/state/editor-edit.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function clampCursor(lines, cursor) {
+  const lineCount = Math.max(1, lines.length);
+  const line = clamp(cursor.line, 0, lineCount - 1);
+  const text = lines[line] ?? "";
+  return { line, column: clamp(cursor.column, 0, text.length) };
+}
+function normalizeSelection(selection) {
+  const { anchor, active } = selection;
+  if (anchor.line < active.line || anchor.line === active.line && anchor.column <= active.column) {
+    return [anchor, active];
+  }
+  return [active, anchor];
+}
+function deleteSelection(lines, selection) {
+  const nextLines = [...lines];
+  if (nextLines.length === 0) {
+    nextLines.push("");
+  }
+  const [rawStart, rawEnd] = normalizeSelection(selection);
+  const start = clampCursor(nextLines, rawStart);
+  const end = clampCursor(nextLines, rawEnd);
+  const startLine = nextLines[start.line] ?? "";
+  const endLine = nextLines[end.line] ?? "";
+  if (start.line === end.line) {
+    nextLines[start.line] = startLine.slice(0, start.column) + startLine.slice(end.column);
+    return { lines: nextLines, cursor: start };
+  }
+  nextLines.splice(
+    start.line,
+    end.line - start.line + 1,
+    startLine.slice(0, start.column) + endLine.slice(end.column)
+  );
+  return { lines: nextLines, cursor: start };
+}
+function insertText(lines, cursor, text) {
+  const nextLines = [...lines];
+  if (nextLines.length === 0) {
+    nextLines.push("");
+  }
+  const safeCursor = clampCursor(nextLines, cursor);
+  const currentLine = nextLines[safeCursor.line] ?? "";
+  const before = currentLine.slice(0, safeCursor.column);
+  const after = currentLine.slice(safeCursor.column);
+  const insertLines = text.replace(/\r\n?/gu, "\n").split("\n");
+  if (insertLines.length === 1) {
+    const inserted = insertLines[0] ?? "";
+    nextLines[safeCursor.line] = before + inserted + after;
+    return {
+      lines: nextLines,
+      cursor: { line: safeCursor.line, column: safeCursor.column + inserted.length }
+    };
+  }
+  const first = before + (insertLines[0] ?? "");
+  const lastInsert = insertLines[insertLines.length - 1] ?? "";
+  const last = lastInsert + after;
+  nextLines.splice(safeCursor.line, 1, first, ...insertLines.slice(1, -1), last);
+  return {
+    lines: nextLines,
+    cursor: {
+      line: safeCursor.line + insertLines.length - 1,
+      column: lastInsert.length
+    }
+  };
+}
+function pasteIntoEditor(args) {
+  const base = args.selection ? deleteSelection(args.lines, args.selection) : { lines: args.lines, cursor: args.cursor };
+  const next = insertText(base.lines, base.cursor, args.text);
+  return { ...next, selection: null };
+}
+
+// src/ui/theme-colors.ts
+import {
+  darkTheme,
+  lightTheme,
+  resolveColorToken
+} from "@rezi-ui/core";
+function token(theme, path8) {
+  return resolveColorToken(theme, path8) ?? 0;
+}
+function themeForMode(mode) {
+  return mode === "light" ? lightTheme : darkTheme;
+}
+function colorsFor(theme) {
+  return {
+    bgBase: token(theme, "bg.base"),
+    bgElevated: token(theme, "bg.elevated"),
+    bgSubtle: token(theme, "bg.subtle"),
+    fgPrimary: token(theme, "fg.primary"),
+    paneFocused: token(theme, "accent.secondary"),
+    paneMuted: token(theme, "fg.muted"),
+    selected: token(theme, "accent.primary"),
+    dirty: token(theme, "warning"),
+    success: token(theme, "success"),
+    warning: token(theme, "warning"),
+    error: token(theme, "error"),
+    info: token(theme, "info")
+  };
+}
+function colorsForMode(mode) {
+  return colorsFor(themeForMode(mode));
+}
+function statusColorForTone(colors, tone) {
+  switch (tone) {
+    case "green":
+      return colors.success;
+    case "yellow":
+      return colors.warning;
+    case "red":
+      return colors.error;
+    default:
+      return colors.info;
+  }
+}
+
 // src/ui/app-view.ts
-import path3 from "path";
+import path6 from "path";
 import {
-  rgb,
   ui
 } from "@rezi-ui/core";
 
-// src/utils/http-syntax.ts
-var KEYWORDS = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "HEAD",
-  "OPTIONS",
-  "CONNECT",
-  "TRACE",
-  "GRAPHQL"
-]);
-function tokenizeHttpLine(line, _context) {
-  const tokens = [];
-  const methodMatch = /^\s*(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|GRAPHQL)\b/u.exec(
-    line
-  );
-  if (methodMatch) {
-    const method = methodMatch[1] ?? "";
-    tokens.push({ text: method, kind: "keyword" });
-    const rest = line.slice(methodMatch[0].length);
-    if (rest.length > 0) {
-      tokens.push({ text: rest, kind: "string" });
-    }
-    return tokens;
-  }
-  if (/^\s*#/u.test(line)) {
-    return [{ text: line, kind: "comment" }];
-  }
-  if (/^\s*\/\//u.test(line)) {
-    return [{ text: line, kind: "comment" }];
-  }
-  if (/^\s*@/u.test(line)) {
-    return [{ text: line, kind: "type" }];
-  }
-  const headerMatch = /^\s*([!#$%&'*+\-.^_`|~0-9A-Za-z]+)(\s*:\s*)(.*)$/u.exec(line);
-  if (headerMatch) {
-    tokens.push({ text: headerMatch[1] ?? "", kind: "function" });
-    tokens.push({ text: headerMatch[2] ?? "", kind: "operator" });
-    tokens.push({ text: headerMatch[3] ?? "", kind: "string" });
-    return tokens;
-  }
-  const words = line.split(/(\s+)/u);
-  for (const word of words) {
-    if (KEYWORDS.has(word)) {
-      tokens.push({ text: word, kind: "keyword" });
-    } else if (word.length > 0) {
-      tokens.push({ text: word, kind: "plain" });
-    }
+// src/ui/editor-gutter.ts
+var EDITOR_GUTTER_WIDTH = 1;
+var ACTIVE_GUTTER = "\u258E";
+var INACTIVE_GUTTER = " ";
+function clamp2(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function gutterTokenKind(method, highlighted) {
+  if (!highlighted) {
+    return "plain";
+  }
+  switch ((method ?? "GET").toUpperCase()) {
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+      return "string";
+    case "POST":
+    case "PUT":
+    case "PATCH":
+      return "type";
+    case "DELETE":
+      return "operator";
+    default:
+      return "keyword";
   }
-  return tokens.length > 0 ? tokens : [{ text: line, kind: "plain" }];
 }
-function prettyJsonIfPossible(text) {
-  const trimmed = text.trim();
-  if (!trimmed) {
-    return text;
-  }
-  try {
-    return JSON.stringify(JSON.parse(trimmed), null, 2);
-  } catch {
-    return text;
-  }
+function prefixEditorLines(lines, activeRegion) {
+  return lines.map((line, index) => {
+    const highlighted = activeRegion !== null && index >= activeRegion.startLine && index <= activeRegion.endLine;
+    return `${highlighted ? ACTIVE_GUTTER : INACTIVE_GUTTER}${line}`;
+  });
 }
-function statusTone(statusCode) {
-  if (!statusCode) {
-    return "cyan";
-  }
-  if (statusCode >= 200 && statusCode < 300) {
-    return "green";
+function stripEditorLines(lines) {
+  return lines.map((line) => line.slice(EDITOR_GUTTER_WIDTH));
+}
+function editorCursorFromSource(cursor) {
+  return {
+    line: cursor.line,
+    column: cursor.column + EDITOR_GUTTER_WIDTH
+  };
+}
+function sourceCursorFromEditor(cursor) {
+  return {
+    line: cursor.line,
+    column: Math.max(0, cursor.column - EDITOR_GUTTER_WIDTH)
+  };
+}
+function sourceCursorFromEditorPoint(args) {
+  const { x, y, rect, lines, scrollTop, scrollLeft } = args;
+  if (rect.w <= 0 || rect.h <= 0 || x < rect.x || x >= rect.x + rect.w || y < rect.y || y >= rect.y + rect.h) {
+    return null;
   }
-  if (statusCode >= 400 && statusCode < 500) {
-    return "yellow";
+  const lineCount = Math.max(1, lines.length);
+  const lineNumberWidth2 = args.lineNumbers === false ? 0 : String(lineCount).length + 1;
+  const line = clamp2(scrollTop + (y - rect.y), 0, lineCount - 1);
+  const lineText = lines[line] ?? "";
+  const localTextColumn = x - rect.x - lineNumberWidth2;
+  const editorColumn = Math.max(0, scrollLeft + localTextColumn);
+  const sourceColumn = clamp2(editorColumn - EDITOR_GUTTER_WIDTH, 0, lineText.length);
+  return { line, column: sourceColumn };
+}
+function editorSelectionFromSource(selection) {
+  if (!selection) {
+    return null;
   }
-  if (statusCode >= 500) {
-    return "red";
+  return {
+    anchor: editorCursorFromSource(selection.anchor),
+    active: editorCursorFromSource(selection.active)
+  };
+}
+function sourceSelectionFromEditor(selection) {
+  if (!selection) {
+    return null;
   }
-  return "cyan";
+  return {
+    anchor: sourceCursorFromEditor(selection.anchor),
+    active: sourceCursorFromEditor(selection.active)
+  };
+}
+function createRegionAwareTokenizer(activeRegion) {
+  return (line, context) => {
+    const gutter = line[0] ?? INACTIVE_GUTTER;
+    const body = line.slice(EDITOR_GUTTER_WIDTH);
+    const highlighted = activeRegion !== null && context.lineNumber >= activeRegion.startLine && context.lineNumber <= activeRegion.endLine;
+    const tokens = [
+      {
+        text: gutter,
+        kind: gutterTokenKind(activeRegion?.method, highlighted && gutter !== INACTIVE_GUTTER)
+      }
+    ];
+    if (body.length > 0) {
+      tokens.push(...tokenizeHttpLine(body, context));
+    }
+    return tokens;
+  };
 }
 
 // src/ui/app-view.ts
-function paneStyle(focused) {
-  return focused ? { fg: rgb(180, 220, 255), bold: true } : { fg: rgb(120, 120, 120) };
+function paneStyle(colors, focused) {
+  return {
+    bg: colors.bgElevated,
+    ...focused ? { fg: colors.paneFocused, bold: true } : { fg: colors.paneMuted }
+  };
 }
-function renderFileTree(state, deps) {
+function renderFileTree(state, deps, colors) {
   return ui.panel(
     {
       id: "pane-files",
       title: state.ui.focusPane === "files" ? "\u25CF Files" : "Files",
-      style: paneStyle(state.ui.focusPane === "files")
+      style: paneStyle(colors, state.ui.focusPane === "files")
     },
     [
       ui.tree({
@@ -1228,7 +1882,7 @@ function renderFileTree(state, deps) {
         onPress: (node) => deps.onTreePress(node),
         renderNode: (node, _depth, nodeState) => ui.row({ gap: 1 }, [
           ui.text(nodeState.selected ? `\u25B8 ${node.name}` : node.name, {
-            style: nodeState.selected ? { fg: rgb(255, 220, 120), bold: true } : state.dirty && node.path === state.selectedFilePath ? { fg: rgb(255, 180, 80) } : void 0
+            style: nodeState.selected ? { fg: colors.selected, bold: true } : state.dirty && node.path === state.selectedFilePath ? { fg: colors.dirty } : void 0
           })
         ]),
         flex: 1,
@@ -1237,38 +1891,32 @@ function renderFileTree(state, deps) {
     ]
   );
 }
-function renderEditor(state, deps, readOnly) {
-  const activeRegion = state.activeRegion ?? (state.parsedFile ? resolveRegionAtLine(state.parsedFile.regions, state.editor.cursor.line) : null);
+function renderEditor(state, deps, readOnly, colors) {
+  const activeRegion = resolveActiveRegion(state.parsedFile, state.editor.cursor.line);
   const titleParts = [
     state.ui.focusPane === "editor" ? "\u25CF Editor" : "Editor",
     state.selectedFilePath ? state.selectedFilePath.split("/").pop() : "No file",
     state.dirty ? " \u25CF" : "",
     activeRegion ? ` | ${activeRegion.method ?? "?"} ${activeRegion.name}` : ""
   ];
-  const diagnostics = state.parsedFile ? buildRegionDiagnostics(
-    state.parsedFile.regions,
-    activeRegion?.id ?? null,
-    state.fileLines
-  ) : [];
   return ui.panel(
     {
       id: "pane-editor",
       title: titleParts.join(""),
-      style: paneStyle(state.ui.focusPane === "editor")
+      style: paneStyle(colors, state.ui.focusPane === "editor")
     },
     [
       ui.codeEditor({
         id: "editor",
-        lines: state.fileLines,
-        cursor: state.editor.cursor,
-        selection: state.editor.selection,
+        lines: prefixEditorLines(state.fileLines, activeRegion),
+        cursor: editorCursorFromSource(state.editor.cursor),
+        selection: editorSelectionFromSource(state.editor.selection),
         scrollTop: state.editor.scrollTop,
         scrollLeft: state.editor.scrollLeft,
         readOnly,
         lineNumbers: true,
         syntaxLanguage: "plain",
-        tokenizeLine: tokenizeHttpLine,
-        diagnostics,
+        tokenizeLine: createRegionAwareTokenizer(activeRegion),
         onChange: (lines, cursor) => deps.onEditorChange(lines, cursor),
         onSelectionChange: deps.onEditorSelection,
         onScroll: deps.onEditorScroll,
@@ -1295,7 +1943,7 @@ function responseCursorProps(state, deps) {
     onSelectionChange: deps.onResponseSelection
   };
 }
-function renderResponseBody(state, deps) {
+function renderResponseBody(state, deps, colors) {
   const result = state.request.result;
   const scroll = responseScrollProps(state, deps);
   const cursor = responseCursorProps(state, deps);
@@ -1338,7 +1986,7 @@ function renderResponseBody(state, deps) {
     case "variables":
       return ui.codeEditor({
         id: `response-vars-${gen}`,
-        lines: [JSON.stringify(state.request.variables, null, 2)],
+        lines: JSON.stringify(state.request.variables, null, 2).split("\n"),
         readOnly: true,
         syntaxLanguage: "json",
         ...cursor,
@@ -1350,16 +1998,20 @@ function renderResponseBody(state, deps) {
         ...result.testResults.map(
           (test) => ui.text(`${test.status === "SUCCESS" ? "\u2713" : "\u2717"} ${test.message}`, {
             style: {
-              fg: test.status === "SUCCESS" ? rgb(120, 220, 120) : test.status === "SKIPPED" ? rgb(220, 220, 120) : rgb(220, 120, 120)
+              fg: test.status === "SUCCESS" ? colors.success : test.status === "SKIPPED" ? colors.warning : colors.error
             }
           })
         )
       ]);
     case "pretty":
-    default:
+    default: {
+      const prettyView = buildFoldableJsonView(
+        prettyJsonIfPossible(result.prettyBody || result.body),
+        state.responseEditor.foldedJsonPaths
+      );
       return ui.codeEditor({
         id: `response-pretty-${gen}`,
-        lines: prettyJsonIfPossible(result.prettyBody || result.body).split("\n"),
+        lines: prettyView.lines,
         readOnly: true,
         lineNumbers: true,
         syntaxLanguage: "json",
@@ -1368,9 +2020,10 @@ function renderResponseBody(state, deps) {
         ...scroll,
         flex: 1
       });
+    }
   }
 }
-function renderResponse(state, deps) {
+function renderResponse(state, deps, colors) {
   const result = state.request.result;
   const statusLine = state.request.sending || !result ? null : `${result.protocol ?? "HTTP"} ${result.statusCode ?? "?"} ${result.statusMessage ?? ""} \xB7 ${result.durationMs ?? "?"} ms`;
   const tabItems = [
@@ -1384,12 +2037,15 @@ function renderResponse(state, deps) {
     {
       id: "pane-response",
       title: state.ui.focusPane === "response" ? "\u25CF Response" : "Response",
-      style: paneStyle(state.ui.focusPane === "response")
+      style: paneStyle(colors, state.ui.focusPane === "response")
     },
     [
       ui.row({ gap: 2 }, [
         state.request.sending ? ui.spinner({ label: "Sending request\u2026" }) : ui.text(statusLine ?? "Ready", {
-          style: { fg: rgb(...statusColor(result?.statusCode)), bold: true }
+          style: {
+            fg: statusColorForTone(colors, statusTone(result?.statusCode)),
+            bold: true
+          }
         }),
         result?.error && !state.request.sending ? ui.badge(result.error, { variant: "error" }) : null
       ]),
@@ -1401,43 +2057,42 @@ function renderResponse(state, deps) {
             disabled: state.request.sending,
             onPress: () => deps.onResponseTab(tab.key)
           })
-        )
+        ),
+        state.ui.responseTab === "pretty" && result ? ui.button({
+          id: "response-json-fold",
+          label: "Fold/Unfold",
+          disabled: state.request.sending,
+          onPress: deps.onResponseJsonFoldToggle
+        }) : null,
+        state.ui.responseTab === "pretty" && state.responseEditor.foldedJsonPaths.length > 0 ? ui.button({
+          id: "response-json-unfold-all",
+          label: "Unfold all",
+          disabled: state.request.sending,
+          onPress: deps.onResponseJsonUnfoldAll
+        }) : null
       ]),
-      renderResponseBody(state, deps)
+      renderResponseBody(state, deps, colors)
     ]
   );
 }
-function statusColor(code) {
-  const tone = statusTone(code);
-  switch (tone) {
-    case "green":
-      return [120, 220, 140];
-    case "yellow":
-      return [240, 200, 100];
-    case "red":
-      return [240, 120, 120];
-    default:
-      return [140, 200, 240];
-  }
-}
-function renderMainLayout(state, deps) {
+function renderMainLayout(state, deps, colors) {
   const layoutMode = resolveLayoutMode(state.ui.viewportWidth);
   const zoom = state.ui.zoomPane;
   if (zoom) {
-    if (zoom === "files") return renderFileTree(state, deps);
-    if (zoom === "editor") return renderEditor(state, deps, false);
-    return renderResponse(state, deps);
+    if (zoom === "files") return renderFileTree(state, deps, colors);
+    if (zoom === "editor") return renderEditor(state, deps, false, colors);
+    return renderResponse(state, deps, colors);
   }
   if (layoutMode === "stacked") {
-    const pane = state.ui.focusPane === "files" ? renderFileTree(state, deps) : state.ui.focusPane === "response" ? renderResponse(state, deps) : renderEditor(state, deps, false);
+    const pane = state.ui.focusPane === "files" ? renderFileTree(state, deps, colors) : state.ui.focusPane === "response" ? renderResponse(state, deps, colors) : renderEditor(state, deps, false, colors);
     return pane;
   }
   if (layoutMode === "sidebar-overlay") {
     return ui.row({ gap: 1, flex: 1 }, [
-      state.ui.sidebarVisible ? ui.box({ width: 28, flex: 0 }, [renderFileTree(state, deps)]) : null,
+      state.ui.sidebarVisible ? ui.box({ width: 28, flex: 0 }, [renderFileTree(state, deps, colors)]) : null,
       ui.column({ gap: 1, flex: 1 }, [
-        renderEditor(state, deps, false),
-        renderResponse(state, deps)
+        renderEditor(state, deps, false, colors),
+        renderResponse(state, deps, colors)
       ])
     ]);
   }
@@ -1451,38 +2106,53 @@ function renderMainLayout(state, deps) {
         onChange: deps.onSplitChange
       },
       [
-        renderFileTree(state, deps),
-        renderEditor(state, deps, false),
-        renderResponse(state, deps)
+        renderFileTree(state, deps, colors),
+        renderEditor(state, deps, false, colors),
+        renderResponse(state, deps, colors)
       ]
     )
   ]);
 }
-function renderFooter(state) {
+function renderFooter(state, deps, colors) {
   const env = state.request.activeEnvironment.length > 0 ? state.request.activeEnvironment.join(",") : "none";
-  const dirName = path3.basename(state.workspaceRoot);
+  const dirName = path6.basename(state.workspaceRoot);
   const branch = state.ui.gitBranch ?? "\u2014";
-  const fileName = state.selectedFilePath ? path3.basename(state.selectedFilePath) : null;
-  const hints = footerHints({
+  const fileName = state.selectedFilePath ? path6.basename(state.selectedFilePath) : null;
+  const hints = footerHintItems({
     focusPane: state.ui.focusPane,
     overlay: state.ui.overlay,
     viewportWidth: state.ui.viewportWidth,
-    sending: state.request.sending
+    sending: state.request.sending,
+    bindings: state.settings.keybindings,
+    responseTab: state.ui.responseTab,
+    hasResponse: Boolean(state.request.result),
+    hasFoldedJson: state.responseEditor.foldedJsonPaths.length > 0
   });
   return ui.statusBar({
     id: "status-bar",
+    style: { bg: colors.bgSubtle, fg: colors.fgPrimary },
     left: [
-      ui.text(dirName, { style: { fg: rgb(180, 220, 255), bold: true } }),
-      ui.text(` \u2387 ${branch}`, { style: { fg: rgb(160, 220, 160) } }),
+      ui.text(dirName, { style: { fg: colors.paneFocused, bold: true } }),
+      ui.text(` \u2387 ${branch}`, { style: { fg: colors.success } }),
       fileName ? ui.text(` | ${fileName}`) : null,
-      state.dirty ? ui.text(" \u25CF", { style: { fg: rgb(255, 180, 80) } }) : null,
-      ui.text(` | env: ${env}`, { style: { fg: rgb(160, 200, 255) } }),
+      state.dirty ? ui.text(" \u25CF", { style: { fg: colors.dirty } }) : null,
+      ui.button({
+        id: "status-env.switcher",
+        label: ` ^E env: ${env}`,
+        onPress: () => deps.onCommand("env.switcher")
+      }),
       state.ui.statusMessage ? ui.text(` | ${state.ui.statusMessage}`) : null
     ].filter(Boolean),
-    right: [ui.text(hints)]
+    right: hints.map(
+      (hint) => ui.button({
+        id: `status-${hint.command}`,
+        label: hint.label,
+        onPress: () => deps.onCommand(hint.command)
+      })
+    )
   });
 }
-function renderOverlayContent(state, deps) {
+function renderOverlayContent(state, deps, colors) {
   switch (state.ui.overlay) {
     case "env":
       return ui.modal({
@@ -1490,12 +2160,18 @@ function renderOverlayContent(state, deps) {
         title: "Environment",
         content: ui.column({ gap: 1 }, [
           ui.text("Select environment (Enter to apply, Esc to close)"),
-          ui.text("(none)", {
-            style: state.ui.envSelectedIndex === 0 ? { fg: rgb(255, 220, 120), bold: true } : void 0
+          ui.button({
+            id: "env-option-none",
+            label: "(none)",
+            onPress: () => deps.onEnvSelect(0),
+            style: state.ui.envSelectedIndex === 0 ? { fg: colors.selected, bold: true } : void 0
           }),
           ...state.request.environments.map(
-            (env, index) => ui.text(env, {
-              style: index + 1 === state.ui.envSelectedIndex ? { fg: rgb(255, 220, 120), bold: true } : void 0
+            (env, index) => ui.button({
+              id: `env-option-${index}`,
+              label: env,
+              onPress: () => deps.onEnvSelect(index + 1),
+              style: index + 1 === state.ui.envSelectedIndex ? { fg: colors.selected, bold: true } : void 0
             })
           )
         ]),
@@ -1561,9 +2237,10 @@ function renderOverlayContent(state, deps) {
   }
 }
 function renderApp(state, deps) {
-  const base = ui.column({ gap: 1, flex: 1 }, [
-    renderMainLayout(state, deps),
-    renderFooter(state)
+  const colors = colorsForMode(state.settings.themeMode);
+  const base = ui.column({ gap: 1, flex: 1, style: { bg: colors.bgBase } }, [
+    renderMainLayout(state, deps, colors),
+    renderFooter(state, deps, colors)
   ]);
   if (state.ui.overlay === "none") {
     return base;
@@ -1576,7 +2253,7 @@ function renderApp(state, deps) {
       backdrop: "dim",
       closeOnEscape: true,
       onClose: deps.onOverlayClose,
-      content: renderOverlayContent(state, deps)
+      content: renderOverlayContent(state, deps, colors)
     })
   ]);
 }
@@ -1591,6 +2268,35 @@ function focusPaneId(pane) {
   }
 }
 
+// src/ui/scroll.ts
+import { routeWheel } from "@rezi-ui/core";
+function lineNumberWidth(lines, lineNumbers) {
+  if (!lineNumbers) {
+    return 0;
+  }
+  return String(Math.max(1, lines.length)).length + 1;
+}
+function maxLineWidth(lines) {
+  return lines.reduce((max, line) => Math.max(max, line.length), 0);
+}
+function resolveWheelScroll(event, state, lines, viewport) {
+  const routed = routeWheel(event, {
+    scrollX: state.scrollLeft,
+    scrollY: state.scrollTop,
+    contentWidth: maxLineWidth(lines),
+    contentHeight: Math.max(1, lines.length),
+    viewportWidth: Math.max(0, viewport.width - lineNumberWidth(lines, viewport.lineNumbers ?? true)),
+    viewportHeight: Math.max(0, viewport.height)
+  });
+  if (routed.nextScrollX === void 0 && routed.nextScrollY === void 0) {
+    return null;
+  }
+  return {
+    scrollTop: routed.nextScrollY ?? state.scrollTop,
+    scrollLeft: routed.nextScrollX ?? state.scrollLeft
+  };
+}
+
 // src/utils/clipboard.ts
 import clipboard from "clipboardy";
 async function copyToClipboard(text) {
@@ -1604,12 +2310,11 @@ async function copyToClipboard(text) {
     return false;
   }
 }
-function disableFlowControl() {
-  if (process.stdin.isTTY) {
-    try {
-      process.stdin.setRawMode?.(true);
-    } catch {
-    }
+async function readFromClipboard() {
+  try {
+    return await clipboard.read();
+  } catch {
+    return null;
   }
 }
 
@@ -1631,17 +2336,229 @@ async function getGitBranch(root) {
   }
 }
 
+// src/utils/terminal-theme.ts
+import process2 from "process";
+import { Readable } from "stream";
+var OSC_11_BACKGROUND_QUERY = "\x1B]11;?\x07";
+function parseHexComponent(value) {
+  const parsed = Number.parseInt(value, 16);
+  if (Number.isNaN(parsed)) {
+    return null;
+  }
+  if (value.length <= 2) {
+    return parsed;
+  }
+  return Math.round(parsed * 255 / 65535);
+}
+function parseOsc11BackgroundColor(sequence) {
+  const rgbMatch = /\x1b\]11;rgb:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})(?:\x07|\x1b\\)/iu.exec(
+    sequence
+  );
+  if (rgbMatch) {
+    const red = parseHexComponent(rgbMatch[1] ?? "");
+    const green = parseHexComponent(rgbMatch[2] ?? "");
+    const blue = parseHexComponent(rgbMatch[3] ?? "");
+    if (red === null || green === null || blue === null) {
+      return null;
+    }
+    return { red, green, blue };
+  }
+  const hexMatch = /\x1b\]11;#([0-9a-f]{6})(?:\x07|\x1b\\)/iu.exec(sequence);
+  if (hexMatch) {
+    const hex = hexMatch[1] ?? "";
+    const red = parseHexComponent(hex.slice(0, 2));
+    const green = parseHexComponent(hex.slice(2, 4));
+    const blue = parseHexComponent(hex.slice(4, 6));
+    if (red === null || green === null || blue === null) {
+      return null;
+    }
+    return { red, green, blue };
+  }
+  return null;
+}
+function themeModeForBackgroundColor({ red, green, blue }) {
+  const linear = [red, green, blue].map((component) => {
+    const normalized = component / 255;
+    return normalized <= 0.03928 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+  });
+  const luminance = 0.2126 * linear[0] + 0.7152 * linear[1] + 0.0722 * linear[2];
+  return luminance > 0.5 ? "light" : "dark";
+}
+function themeModeFromColorFgbg() {
+  const colorFgbg = process2.env.COLORFGBG;
+  if (!colorFgbg) {
+    return null;
+  }
+  const parts = colorFgbg.split(";");
+  const background = Number.parseInt(parts[parts.length - 1] ?? "", 10);
+  if (Number.isNaN(background)) {
+    return null;
+  }
+  return background > 7 ? "light" : "dark";
+}
+async function detectTerminalThemeMode(options = {}) {
+  const input = options.input ?? process2.stdin;
+  const output = options.output ?? process2.stdout;
+  const timeoutMs = options.timeoutMs ?? 150;
+  if (!("isTTY" in input && input.isTTY) || !("isTTY" in output && output.isTTY)) {
+    return null;
+  }
+  const wasRaw = "isRaw" in input ? input.isRaw : void 0;
+  let settled = false;
+  let buffer = "";
+  return await new Promise((resolve) => {
+    const drainInput = () => {
+      if (!(input instanceof Readable)) {
+        return;
+      }
+      while (input.readableLength > 0) {
+        input.read();
+      }
+      input.pause();
+    };
+    const cleanup = () => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      input.removeListener("data", onData);
+      if (wasRaw !== void 0 && "setRawMode" in input) {
+        input.setRawMode?.(wasRaw);
+      }
+      drainInput();
+    };
+    const finish = (mode) => {
+      cleanup();
+      resolve(mode);
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    const onData = (chunk) => {
+      buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+      const color = parseOsc11BackgroundColor(buffer);
+      if (color) {
+        finish(themeModeForBackgroundColor(color));
+      }
+    };
+    input.setRawMode?.(true);
+    if (input instanceof Readable) {
+      input.resume();
+    }
+    input.on("data", onData);
+    output.write(OSC_11_BACKGROUND_QUERY);
+  });
+}
+async function resolveThemeMode(preference, options = {}) {
+  const { allowProbe = true, fallbackMode = "dark" } = options;
+  if (preference === "light") {
+    return "light";
+  }
+  if (preference === "dark") {
+    return "dark";
+  }
+  if (allowProbe) {
+    const detected = await detectTerminalThemeMode();
+    if (detected) {
+      return detected;
+    }
+  }
+  return themeModeFromColorFgbg() ?? fallbackMode;
+}
+
 // src/cli.ts
+function isPointInRect(x, y, rect) {
+  return x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h;
+}
+function responseEditorId(state) {
+  switch (state.ui.responseTab) {
+    case "pretty":
+      return `response-pretty-${state.resultGeneration}`;
+    case "raw":
+      return `response-raw-${state.resultGeneration}`;
+    case "variables":
+      return `response-vars-${state.resultGeneration}`;
+    case "headers":
+    case "tests":
+      return null;
+  }
+}
+function responseEditorLines(state) {
+  const result = state.request.result;
+  if (!result) {
+    return null;
+  }
+  switch (state.ui.responseTab) {
+    case "pretty":
+      return buildFoldableJsonView(
+        prettyJsonIfPossible(result.prettyBody || result.body),
+        state.responseEditor.foldedJsonPaths
+      ).lines;
+    case "raw":
+      return result.body ? result.body.split("\n") : [""];
+    case "variables":
+      return JSON.stringify(state.request.variables, null, 2).split("\n");
+    case "headers":
+    case "tests":
+      return null;
+  }
+}
+function handleWheelEvent(event, app) {
+  if (event.kind !== "mouse" || event.mouseKind !== 5) {
+    return false;
+  }
+  let handled = false;
+  app.update((prev) => {
+    const editorRect = app.measureElement("editor");
+    if (editorRect && isPointInRect(event.x, event.y, editorRect)) {
+      handled = true;
+      const next = resolveWheelScroll(
+        event,
+        prev.editor,
+        prefixEditorLines(prev.fileLines, null),
+        { width: editorRect.w, height: editorRect.h }
+      );
+      return {
+        ...prev,
+        ui: { ...prev.ui, focusPane: "editor" },
+        editor: next ? { ...prev.editor, scrollTop: next.scrollTop, scrollLeft: next.scrollLeft } : prev.editor
+      };
+    }
+    const id = responseEditorId(prev);
+    const responseRect = id ? app.measureElement(id) : null;
+    if (responseRect && isPointInRect(event.x, event.y, responseRect)) {
+      handled = true;
+      const lines = responseEditorLines(prev);
+      const next = lines ? resolveWheelScroll(event, prev.responseEditor, lines, {
+        width: responseRect.w,
+        height: responseRect.h
+      }) : null;
+      return {
+        ...prev,
+        ui: { ...prev.ui, focusPane: "response" },
+        responseEditor: next ? { ...prev.responseEditor, scrollTop: next.scrollTop, scrollLeft: next.scrollLeft } : prev.responseEditor
+      };
+    }
+    return prev;
+  });
+  return handled;
+}
 async function main() {
   initEngineProviders();
-  const workspaceRoot = path4.resolve(process2.argv[2] ?? process2.cwd());
+  const workspaceRoot = path7.resolve(process3.argv[2] ?? process3.cwd());
   const workspace = new Workspace(workspaceRoot);
   const tree = await workspace.open();
+  const config = loadConfig(workspaceRoot);
+  const initialThemeMode = await resolveThemeMode(config.theme);
   let currentState = createInitialState(workspaceRoot);
   currentState = {
     ...currentState,
     fileTree: tree,
     expandedPaths: tree.filter((n) => n.kind === "directory").map((n) => n.path),
+    settings: {
+      ...currentState.settings,
+      theme: config.theme,
+      themeMode: initialThemeMode
+    },
     ui: {
       ...currentState.ui,
       gitBranch: await getGitBranch(workspaceRoot)
@@ -1662,19 +2579,24 @@ async function main() {
     }
     const loaded = loadKeybindings(workspaceRoot);
     app.keys({
-      ...buildBindingMap(loaded.bindings, (command) => {
+      ...buildBindingMap(loaded.bindings, (command, ctx) => {
+        currentState = ctx.state;
         if (command === "response.copy") {
           void handleCopy(app, currentState);
         }
         bus.execute(command);
       }),
       enter: {
-        handler: () => bus.execute("env.apply"),
+        handler: (ctx) => {
+          currentState = ctx.state;
+          bus.execute("env.apply");
+        },
         when: (ctx) => ctx.state.ui.overlay === "env",
         description: "Apply selected environment"
       },
       up: {
-        handler: () => {
+        handler: (ctx) => {
+          currentState = ctx.state;
           if (currentState.ui.overlay === "env") {
             bus.execute("env.selectPrev");
           }
@@ -1682,7 +2604,8 @@ async function main() {
         when: (ctx) => ctx.state.ui.overlay === "env" || ctx.state.ui.overlay === "commandPalette"
       },
       down: {
-        handler: () => {
+        handler: (ctx) => {
+          currentState = ctx.state;
           if (currentState.ui.overlay === "env") {
             bus.execute("env.selectNext");
           }
@@ -1693,11 +2616,33 @@ async function main() {
     app.update((state) => ({
       ...state,
       settings: {
+        ...state.settings,
         keymapPreset: loaded.preset,
         keybindings: loaded.bindings
       }
     }));
   };
+  const applyTheme = async (preference) => {
+    if (!app) {
+      return;
+    }
+    const themeMode = await resolveThemeMode(preference, {
+      allowProbe: false,
+      fallbackMode: currentState.settings.themeMode
+    });
+    app.setTheme(themeForMode(themeMode));
+    app.update((state) => ({
+      ...state,
+      settings: {
+        ...state.settings,
+        theme: preference,
+        themeMode
+      }
+    }));
+  };
+  const reloadConfig = () => {
+    void applyTheme(loadConfig(workspaceRoot).theme);
+  };
   bus = createCommandContext({
     workspace,
     getState: () => currentState,
@@ -1708,16 +2653,27 @@ async function main() {
       });
     },
     quit: () => {
-      void workspace.close().finally(() => {
-        app?.stop().finally(() => process2.exit(0));
+      void workspace.close().finally(async () => {
+        await app?.stop();
+        await app?.dispose();
+        process3.exit(0);
       });
     },
     reloadKeybindings
   });
-  app = createNodeApp({ initialState: currentState });
+  app = createNodeApp({ initialState: currentState, theme: themeForMode(initialThemeMode) });
   reloadKeybindings();
-  disableFlowControl();
-  const stopWatch = watchKeybindings(workspaceRoot, reloadKeybindings);
+  const executeCommand = (command) => {
+    if (!bus || !app) {
+      return;
+    }
+    if (command === "response.copy") {
+      void handleCopy(app, currentState);
+    }
+    bus.execute(command);
+  };
+  const stopKeybindingWatch = watchKeybindings(workspaceRoot, reloadKeybindings);
+  const stopConfigWatch = watchConfig(workspaceRoot, reloadConfig);
   workspace.on("change", () => {
     void bus.refreshWorkspace();
     void refreshGitBranch();
@@ -1726,29 +2682,27 @@ async function main() {
     (state) => renderApp(state, {
       onEditorChange: (lines, cursor) => {
         app?.update((prev) => {
-          const activeRegion = prev.parsedFile ? resolveRegionAtLine(prev.parsedFile.regions, cursor.line) : null;
+          const fileLines = stripEditorLines(lines);
+          const sourceCursor = sourceCursorFromEditor(cursor);
           return {
             ...prev,
-            fileLines: [...lines],
-            dirty: contentFromLines(lines) !== prev.fileContent,
-            activeRegion,
+            fileLines,
+            dirty: contentFromLines(fileLines) !== prev.fileContent,
             ui: { ...prev.ui, focusPane: "editor" },
-            editor: { ...prev.editor, cursor }
+            editor: { ...prev.editor, cursor: sourceCursor }
           };
         });
       },
       onEditorSelection: (selection) => {
         app?.update((prev) => {
-          const cursorLine = selection?.active.line ?? prev.editor.cursor.line;
-          const activeRegion = prev.parsedFile ? resolveRegionAtLine(prev.parsedFile.regions, cursorLine) : null;
+          const sourceSelection = sourceSelectionFromEditor(selection);
           return {
             ...prev,
-            activeRegion,
             ui: { ...prev.ui, focusPane: "editor" },
             editor: {
               ...prev.editor,
-              selection,
-              cursor: selection?.active ?? prev.editor.cursor
+              selection: sourceSelection,
+              cursor: sourceSelection?.active ?? prev.editor.cursor
             }
           };
         });
@@ -1812,6 +2766,12 @@ async function main() {
           responseEditor: { ...prev.responseEditor, cursor }
         }));
       },
+      onResponseJsonFoldToggle: () => {
+        bus?.execute("response.jsonFoldToggle");
+      },
+      onResponseJsonUnfoldAll: () => {
+        bus?.execute("response.jsonUnfoldAll");
+      },
       onSplitChange: (sizes) => {
         if (sizes.length === 3) {
           app?.update((prev) => ({
@@ -1849,26 +2809,34 @@ async function main() {
         bus?.execute("overlay.close");
       },
       onEnvSelect: (index) => {
-        app?.update((prev) => ({
-          ...prev,
-          ui: { ...prev.ui, envSelectedIndex: index }
-        }));
+        app?.update((prev) => {
+          currentState = {
+            ...prev,
+            ui: { ...prev.ui, envSelectedIndex: index }
+          };
+          return currentState;
+        });
+        bus?.execute("env.apply");
       },
       onResponseSearch: (query) => {
         app?.update((prev) => ({
           ...prev,
           editor: { ...prev.editor, searchQuery: query }
         }));
-      }
+      },
+      onCommand: executeCommand
     })
   );
-  app.onEvent((event) => handleUiEvent(event, app));
+  app.onEvent((event) => {
+    void handleUiEvent(event, app);
+  });
   const files = flattenFiles(tree).filter((node) => node.kind === "file");
   if (files[0]) {
     await bus.openFile(files[0].path);
   }
   await app.run();
-  stopWatch();
+  stopKeybindingWatch();
+  stopConfigWatch();
 }
 async function handleCopy(app, state) {
   const result = state.request.result;
@@ -1887,7 +2855,38 @@ async function handleCopy(app, state) {
     ui: { ...prev.ui, statusMessage: ok ? "Copied" : "Copy failed" }
   }));
 }
-function handleUiEvent(event, app) {
+async function handlePaste(app) {
+  const text = await readFromClipboard();
+  app.update((prev) => {
+    if (prev.ui.overlay !== "none" || prev.ui.focusPane !== "editor") {
+      return prev;
+    }
+    if (!text) {
+      return {
+        ...prev,
+        ui: { ...prev.ui, statusMessage: text === "" ? "Clipboard empty" : "Paste failed" }
+      };
+    }
+    const next = pasteIntoEditor({
+      lines: prev.fileLines,
+      cursor: prev.editor.cursor,
+      selection: prev.editor.selection,
+      text
+    });
+    return {
+      ...prev,
+      fileLines: next.lines,
+      dirty: contentFromLines(next.lines) !== prev.fileContent,
+      editor: {
+        ...prev.editor,
+        cursor: next.cursor,
+        selection: next.selection
+      },
+      ui: { ...prev.ui, focusPane: "editor", statusMessage: "Pasted" }
+    };
+  });
+}
+async function handleUiEvent(event, app) {
   if (event.kind === "engine" && event.event.kind === "resize") {
     const resize = event.event;
     app.update((prev) => ({
@@ -1902,10 +2901,46 @@ function handleUiEvent(event, app) {
     }));
     return;
   }
+  if (event.kind === "engine" && event.event.kind === "key" && event.event.action === "down" && (event.event.mods & ZR_MOD_CTRL) !== 0 && event.event.key === 86) {
+    await handlePaste(app);
+    return;
+  }
   if (event.kind !== "engine" || event.event.kind !== "mouse") {
     return;
   }
-  const { x, y } = event.event;
+  if (handleWheelEvent(event.event, app)) {
+    return;
+  }
+  const { x, y, mouseKind, mods } = event.event;
+  if (mouseKind === 3) {
+    const editorRect = app.measureElement("editor");
+    if (editorRect && isPointInRect(x, y, editorRect)) {
+      app.update((prev) => {
+        const cursor = sourceCursorFromEditorPoint({
+          x,
+          y,
+          rect: editorRect,
+          lines: prev.fileLines,
+          scrollTop: prev.editor.scrollTop,
+          scrollLeft: prev.editor.scrollLeft
+        });
+        if (!cursor) {
+          return prev;
+        }
+        const extendSelection = (mods & ZR_MOD_SHIFT) !== 0;
+        return {
+          ...prev,
+          ui: { ...prev.ui, focusPane: "editor" },
+          editor: {
+            ...prev.editor,
+            cursor,
+            selection: extendSelection ? { anchor: prev.editor.cursor, active: cursor } : null
+          }
+        };
+      });
+      return;
+    }
+  }
   const panes = [
     { id: "pane-files", pane: "files" },
     { id: "pane-editor", pane: "editor" },
@@ -1916,7 +2951,7 @@ function handleUiEvent(event, app) {
     if (!rect) {
       continue;
     }
-    if (x >= rect.x && x < rect.x + rect.w && y >= rect.y && y < rect.y + rect.h) {
+    if (isPointInRect(x, y, rect)) {
       app.update((prev) => ({
         ...prev,
         ui: { ...prev.ui, focusPane: entry.pane }
@@ -1927,7 +2962,7 @@ function handleUiEvent(event, app) {
 }
 void main().catch((error) => {
   console.error(error);
-  process2.exit(1);
+  process3.exit(1);
 });
 export {
   focusPaneId