@usebruno/js 0.46.1 → 0.47.0

package/src/sandbox/quickjs/utils/property-list-bridge.js

@@ -0,0 +1,165 @@
+const { cleanJson, cleanCircularJson } = require('../../../utils');
+const { marshallToVm } = require('../utils');
+
+/**
+ * Creates an async bridge that resolves with `undefined` (write-only).
+ * Do NOT reuse this for read methods that need to return values —
+ * those require resolving with the callback's result argument instead.
+ */
+const createAsyncBridge = (vm, targetObj, propName, nativeMethod) => {
+  const fn = vm.newFunction(propName, (...vmArgs) => {
+    const promise = vm.newPromise();
+    const args = vmArgs.map((a) => vm.dump(a));
+    nativeMethod(...args, (err) => {
+      if (err) {
+        promise.reject(marshallToVm(cleanJson(err), vm));
+      } else {
+        promise.resolve(vm.undefined);
+      }
+    });
+    promise.settled.then(vm.runtime.executePendingJobs);
+    return promise.handle;
+  });
+  fn.consume((handle) => vm.setProp(targetObj, propName, handle));
+};
+
+/**
+ * Factory that auto-wires PropertyList methods onto a QuickJS VM object.
+ *
+ * Generates:
+ * - Sync read methods: `vm.newFunction` → `marshallToVm(nativeList.method(...args), vm)`
+ * - Sync read object methods: same but wrapped with `cleanCircularJson()`
+ * - Async write methods: `_prefix` bridge pattern (native callback → QuickJS promise)
+ * - Returns `{ evalCode }` string containing `callWithCallback` helper + async wrappers + iterators
+ *
+ * @example
+ * In shims/bru.js, wiring up bru.cookies takes a single call:
+ *
+ * const { evalCode: cookiesEvalCode } = createPropertyListBridge(vm, bru.cookies, bruCookiesObject, {
+ *   globalPath: 'globalThis.bru.cookies',
+ *   syncReadMethods: ['get', 'has', 'count', 'indexOf', 'toObject', 'toString'],
+ *   syncReadObjectMethods: ['one', 'all', 'idx', 'toJSON'],
+ *   asyncWriteMethods: ['add', 'upsert', 'remove', 'clear', 'delete'],
+ *   withIterators: true
+ * });
+ *
+ * Without this factory, each method would require manual boilerplate like the
+ * hand-written jar() bridge in bru.js (~100 lines), where every method needs:
+ *
+ *   const _fn = vm.newFunction('_method', (...vmArgs) => {
+ *     const promise = vm.newPromise();
+ *     nativeObj.method(vm.dump(vmArgs[0]), (err, result) => {
+ *       if (err) {
+ *         promise.reject(marshallToVm(cleanJson(err), vm));
+ *       } else {
+ *         promise.resolve(marshallToVm(cleanCircularJson(result), vm));
+ *       }
+ *     });
+ *     promise.settled.then(vm.runtime.executePendingJobs);
+ *     return promise.handle;
+ *   });
+ *   _fn.consume((handle) => vm.setProp(obj, '_method', handle));
+ *
+ * …repeated for every method, plus separate evalCode for async wrappers.
+ *
+ * To wire up a new PropertyList-backed object, add one createPropertyListBridge
+ * call instead of duplicating all that boilerplate.
+ *
+ * @param {Object} vm - QuickJS VM instance
+ * @param {Object} nativeList - Native PropertyList instance
+ * @param {Object} targetObj - QuickJS object handle to attach methods to
+ * @param {Object} options
+ * @param {string} options.globalPath - Global path in QuickJS (e.g. 'globalThis.bru.cookies')
+ * @param {string[]} [options.syncReadMethods] - Methods that return primitive values
+ * @param {string[]} [options.syncReadObjectMethods] - Methods that return objects (need cleanCircularJson)
+ * @param {string[]} [options.asyncWriteMethods] - Async write methods (use _prefix bridge)
+ * @param {boolean} [options.withIterators] - Whether to add each/find/filter/map/reduce
+ * @returns {{ evalCode: string }} - JavaScript code to eval in the VM for async wrappers and iterators
+ */
+const createPropertyListBridge = (vm, nativeList, targetObj, options) => {
+  const {
+    globalPath,
+    syncReadMethods = [],
+    syncReadObjectMethods = [],
+    asyncWriteMethods = [],
+    withIterators = false
+  } = options;
+
+  // Sync read methods — return primitive values
+  for (const methodName of syncReadMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      return marshallToVm(nativeList[methodName](...args), vm);
+    });
+    fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
+  }
+
+  // Sync read object methods — need cleanCircularJson
+  for (const methodName of syncReadObjectMethods) {
+    const fn = vm.newFunction(methodName, (...vmArgs) => {
+      const args = vmArgs.map((a) => vm.dump(a));
+      return marshallToVm(cleanCircularJson(nativeList[methodName](...args)), vm);
+    });
+    fn.consume((handle) => vm.setProp(targetObj, methodName, handle));
+  }
+
+  // Async write methods — two-phase setup:
+  // Phase 1 (native): Register `_prefixed` bridge functions (e.g. `_add`, `_remove`) via
+  // createAsyncBridge. These are QuickJS promise-based wrappers that call the native method's
+  // callback API and resolve with `undefined` (write-only).
+  // Phase 2 (evalCode): Generates JS code eval'd in the VM that:
+  //   1. Defines a `callWithCallback` helper supporting both `await method(args)` and
+  //      `method(args, callback)` calling styles.
+  //   2. Captures `_prefixed` direct references, then overwrites the public method name with
+  //      a wrapper that auto-detects whether the last argument is a callback.
+  for (const methodName of asyncWriteMethods) {
+    createAsyncBridge(vm, targetObj, `_${methodName}`, (...a) => nativeList[methodName](...a));
+  }
+
+  let evalCode = '';
+
+  if (asyncWriteMethods.length > 0) {
+    evalCode += `const callWithCallback = async (promiseFn, callback) => {
+      if (!callback) return await promiseFn();
+      try {
+        const result = await promiseFn();
+        try { await callback(null, result); } catch(cbErr) { return Promise.reject(cbErr); }
+      } catch(err) {
+        try { await callback(err, null); } catch(cbErr) { return Promise.reject(cbErr); }
+      }
+    };\n`;
+
+    // Capture _prefixed direct references before overwriting
+    for (const methodName of asyncWriteMethods) {
+      evalCode += `const _${methodName}Direct = ${globalPath}._${methodName};\n`;
+    }
+
+    // Generate wrapper functions: method(...args, cb?) => callWithCallback(() => _direct(...args), cb)
+    for (const methodName of asyncWriteMethods) {
+      evalCode += `${globalPath}.${methodName} = (...args) => {
+      const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined;
+      return callWithCallback(() => _${methodName}Direct(...args), cb);
+    };\n`;
+    }
+  }
+
+  // Iterators — these can't be bridged as syncReadObjectMethods because they take a callback
+  // function as an argument, and functions can't cross the native↔VM boundary (vm.dump() can't
+  // serialize them). Instead, we pull the data into the VM via `all()`, then run the array
+  // operation inside the VM where the callback lives. Requires `all` in `syncReadObjectMethods`.
+  if (withIterators) {
+    evalCode += `const _allNative = ${globalPath}.all;
+    ${globalPath}.each = (fn) => { _allNative().forEach(fn); };
+    ${globalPath}.filter = (fn) => _allNative().filter(fn);
+    ${globalPath}.find = (fn) => _allNative().find(fn);
+    ${globalPath}.map = (fn) => _allNative().map(fn);
+    ${globalPath}.reduce = (fn, ...rest) => rest.length ? _allNative().reduce(fn, rest[0]) : _allNative().reduce(fn);\n`;
+  }
+
+  return { evalCode };
+};
+
+module.exports = {
+  createPropertyListBridge,
+  createAsyncBridge
+};

package/src/sandbox/quickjs/utils/test-helpers.js

@@ -0,0 +1,31 @@
+/**
+ * Evaluates code in a QuickJS VM and returns the dumped result.
+ * Handles unwrapping and disposing of handles automatically.
+ *
+ * @param {Object} vm - QuickJS VM context
+ * @param {string} code - JavaScript code to evaluate
+ * @returns {*} The evaluated and dumped result
+ */
+function evalAndDump(vm, code) {
+  const result = vm.evalCode(code);
+  const handle = vm.unwrapResult(result);
+  const value = vm.dump(handle);
+  handle.dispose();
+  return value;
+}
+
+/**
+ * Creates a helper function bound to a specific VM instance.
+ * Useful in beforeEach to create a test-scoped helper.
+ *
+ * @param {Object} vm - QuickJS VM context
+ * @returns {Function} evalAndDump function bound to the VM
+ */
+function createEvalHelper(vm) {
+  return (code) => evalAndDump(vm, code);
+}
+
+module.exports = {
+  evalAndDump,
+  createEvalHelper
+};

package/src/utils/error-formatter.js

@@ -1,9 +1,12 @@
 const fs = require('fs');
+const path = require('path');
 const YAML = require('yaml');
 const { NODEVM_SCRIPT_WRAPPER_OFFSET, QUICKJS_SCRIPT_WRAPPER_OFFSET } = require('./sandbox');
 
+const posixifyPath = (p) => (p ? p.replace(/\\/g, '/') : p);
+
 const DEFAULT_CONTEXT_LINES = 5;
-const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml', '.yaml'];
+const ALLOWED_SOURCE_EXTENSIONS = ['.bru', '.yml'];
 
 const isAllowedSourceFile = (filePath) =>
   typeof filePath === 'string' && ALLOWED_SOURCE_EXTENSIONS.some((ext) => filePath.endsWith(ext));
@@ -64,9 +67,45 @@ const findScriptBlockStartLine = (filePath, scriptType, cache = null) => {
   return result;
 };
 
+/** Find the 1-indexed last content line of a script block in a .bru file (excludes closing }) */
+const findScriptBlockEndLine = (filePath, scriptType, cache = null) => {
+  if (!filePath.endsWith('.bru')) return null;
+
+  const cacheKey = `bru-end:${filePath}:${scriptType}`;
+  if (cache?.has(cacheKey)) return cache.get(cacheKey);
+
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+
+  const pattern = BLOCK_PATTERNS[scriptType];
+  if (!pattern) return null;
+
+  const lines = content.split('\n');
+  let inBlock = false;
+  let hasContent = false;
+  let result = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (!inBlock && pattern.test(lines[i])) {
+      inBlock = true;
+      continue;
+    }
+    if (inBlock) {
+      if (/^\}/.test(lines[i])) {
+        // Closing brace at 0-indexed position i; last content line is at 0-indexed (i-1) = 1-indexed i
+        result = hasContent ? i : null;
+        break;
+      }
+      hasContent = true;
+    }
+  }
+
+  if (cache) cache.set(cacheKey, result);
+  return result;
+};
+
 /** Find the 1-indexed line where a script block's content starts in a .yml file */
 const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
-  if (!filePath.endsWith('.yml') && !filePath.endsWith('.yaml')) return null;
+  if (!filePath.endsWith('.yml')) return null;
 
   const cacheKey = `yml:${filePath}:${scriptType}`;
   if (cache?.has(cacheKey)) return cache.get(cacheKey);
@@ -97,7 +136,52 @@ const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
             }
           }
         }
-        if (result) break;
+        if (result != null) break;
+      }
+    }
+  } catch {
+    // invalid YAML
+  }
+
+  if (cache) cache.set(cacheKey, result);
+  return result;
+};
+
+/** Find the 1-indexed last content line of a script block in a .yml file */
+const findYmlScriptBlockEndLine = (filePath, scriptType, cache = null) => {
+  if (!filePath.endsWith('.yml')) return null;
+
+  const cacheKey = `yml-end:${filePath}:${scriptType}`;
+  if (cache?.has(cacheKey)) return cache.get(cacheKey);
+
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+
+  const ymlType = SCRIPT_TYPE_TO_YML[scriptType];
+  if (!ymlType) return null;
+
+  let result = null;
+  try {
+    const lineCounter = new YAML.LineCounter();
+    const doc = YAML.parseDocument(content, { lineCounter });
+
+    const scriptPaths = [['runtime', 'scripts'], ['request', 'scripts']];
+    for (const scriptPath of scriptPaths) {
+      const scripts = doc.getIn(scriptPath, true);
+      if (YAML.isSeq(scripts)) {
+        for (const item of scripts.items) {
+          if (!YAML.isMap(item)) continue;
+          if (item.get('type') === ymlType) {
+            const codeNode = item.get('code', true);
+            if (codeNode && codeNode.range) {
+              // range[1] is the end offset; go back 1 to get the last content character
+              const endOffset = Math.max(codeNode.range[1] - 1, codeNode.range[0]);
+              result = lineCounter.linePos(endOffset).line;
+              break;
+            }
+          }
+        }
+        if (result != null) break;
       }
     }
   } catch {
@@ -111,7 +195,7 @@ const findYmlScriptBlockStartLine = (filePath, scriptType, cache = null) => {
 /** Adjust a runtime-reported line number to the actual line in the .bru/.yml file */
 const adjustLineNumber = (filePath, reportedLine, isQuickJS, scriptType = null, cache = null, scriptMetadata = null) => {
   const isBruFile = filePath.endsWith('.bru');
-  const isYmlFile = filePath.endsWith('.yml') || filePath.endsWith('.yaml');
+  const isYmlFile = filePath.endsWith('.yml');
 
   if (!isBruFile && !isYmlFile) {
     return reportedLine;
@@ -157,6 +241,13 @@ const adjustLineNumber = (filePath, reportedLine, isQuickJS, scriptType = null,
   return scriptRelativeLine;
 };
 
+/** Look up the script block start line for a .bru or .yml file */
+const findBlockStart = (filePath, scriptType, cache) => {
+  if (filePath.endsWith('.bru')) return findScriptBlockStartLine(filePath, scriptType, cache);
+  if (filePath.endsWith('.yml')) return findYmlScriptBlockStartLine(filePath, scriptType, cache);
+  return null;
+};
+
 /**
  * Resolve an error in a collection/folder script segment to its source file and line.
  * Uses the segments array in metadata to find which segment the error falls in,
@@ -171,19 +262,34 @@ const resolveSegmentError = (parsed, metadata, scriptType, cache) => {
 
   for (const segment of metadata.segments) {
     if (scriptRelativeLine >= segment.startLine && scriptRelativeLine <= segment.endLine) {
-      const isBru = segment.filePath.endsWith('.bru');
-      const isYml = segment.filePath.endsWith('.yml') || segment.filePath.endsWith('.yaml');
-      if (!isBru && !isYml) return null;
-
-      const blockStartLine = isBru
-        ? findScriptBlockStartLine(segment.filePath, scriptType, cache)
-        : findYmlScriptBlockStartLine(segment.filePath, scriptType, cache);
-      if (!blockStartLine) return null;
+      if (!isAllowedSourceFile(segment.filePath)) return null;
+
+      const blockStartLine = findBlockStart(segment.filePath, scriptType, cache);
+      if (!blockStartLine) {
+        // No script block on disk — only possible when user added a new script as a draft.
+        // If we have in-memory content, return it so the caller can show the code snippet.
+        if (segment.scriptContent) {
+          return {
+            line: null,
+            filePath: segment.filePath,
+            displayPath: segment.displayPath,
+            scriptContent: segment.scriptContent,
+            // segment.startLine points to the IIFE wrapper line (`await (async () => {`),
+            // so subtracting it yields a 1-based index into the user's script content.
+            lineInScript: scriptRelativeLine - segment.startLine
+          };
+        }
+        return null;
+      }
 
       return {
         line: blockStartLine + (scriptRelativeLine - segment.startLine) - 1,
         filePath: segment.filePath,
-        displayPath: segment.displayPath
+        displayPath: segment.displayPath,
+        scriptContent: segment.scriptContent || null,
+        // segment.startLine points to the IIFE wrapper line (`await (async () => {`),
+        // so subtracting it yields a 1-based index into the user's script content.
+        lineInScript: scriptRelativeLine - segment.startLine
       };
     }
   }
@@ -248,12 +354,10 @@ const parseErrorLocation = (error) => {
   return parsed;
 };
 
-/** Read source file and extract context lines around the error location */
-const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LINES, cache = null) => {
-  const content = readFile(filePath, cache);
-  if (!content) return null;
+/** Build a context-lines object from an array of source lines around an error */
+const buildContextLines = (lines, errorLine, contextLines) => {
+  if (errorLine < 1 || errorLine > lines.length) return null;
 
-  const lines = content.split('\n');
   const startLine = Math.max(1, errorLine - contextLines);
   const endLine = Math.min(lines.length, errorLine + contextLines);
 
@@ -269,6 +373,19 @@ const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LI
   return { lines: contextLinesArray, startLine, errorLine };
 };
 
+/** Read source file and extract context lines around the error location */
+const getSourceContext = (filePath, errorLine, contextLines = DEFAULT_CONTEXT_LINES, cache = null) => {
+  const content = readFile(filePath, cache);
+  if (!content) return null;
+  return buildContextLines(content.split('\n'), errorLine, contextLines);
+};
+
+/** Extract context lines from in-memory script content (e.g. unsaved draft scripts) */
+const getSourceContextFromContent = (content, errorLine, contextLines = DEFAULT_CONTEXT_LINES) => {
+  if (!content) return null;
+  return buildContextLines(content.split('\n'), errorLine, contextLines);
+};
+
 /** Build adjusted stack trace string from structured CallSite data */
 const buildStackFromCallSites = (callSites, scriptType = null, cache = null, scriptMetadata = null) => {
   return callSites.map((site) => {
@@ -280,7 +397,7 @@ const buildStackFromCallSites = (callSites, scriptType = null, cache = null, scr
     if (adjusted === null && scriptMetadata?.segments) {
       const parsed = { line: site.line, isQuickJS: false };
       const resolved = resolveSegmentError(parsed, scriptMetadata, scriptType, cache);
-      if (resolved) {
+      if (resolved && resolved.line !== null) {
         fileToUse = resolved.filePath;
         lineToUse = resolved.line;
       }
@@ -307,7 +424,7 @@ const adjustStackTrace = (stack, scriptType = null, cache = null, scriptMetadata
     if (adjusted === null && scriptMetadata?.segments) {
       const parsed = { line: match.line, isQuickJS };
       const resolved = resolveSegmentError(parsed, scriptMetadata, scriptType, cache);
-      if (resolved) {
+      if (resolved && resolved.line !== null) {
         const suffix = match.isQuickJS ? ')' : '';
         return match.column !== null
           ? line.replace(`${match.filePath}:${match.line}:${match.column}${suffix}`, `${resolved.filePath}:${resolved.line}:${match.column}${suffix}`)
@@ -409,6 +526,210 @@ const formatErrorWithContext = (error, relativeFilePath = null, scriptType = nul
   return lines.join('\n');
 };
 
+/**
+ * Build a structured error context object for the desktop UI's ScriptError component.
+ *
+ * formatErrorWithContext (V1) returns a pre-formatted string for CLI output.
+ * This function returns a structured object so the desktop UI can render it
+ * with its own layout (CodeSnippet component, collapsible stack, etc.).
+ *
+ * Key difference: line numbers in the returned object are block-relative
+ * (i.e. relative to the script block, starting at 1) rather than absolute
+ * file line numbers, because users edit scripts in a CodeMirror editor that
+ * starts numbering at line 1.
+ *
+ * @example
+ * Given a .bru file at /home/user/my-collection/requests/get-user.bru:
+ *
+ *   meta {                          ← file line 1
+ *     name: get-user                ← file line 2
+ *   }                               ← file line 3
+ *                                   ← file line 4
+ *   script:post-response {          ← file line 5
+ *     const data = res.body;        ← file line 6  (script line 1)
+ *     data.missing.prop;            ← file line 7  (script line 2) ← error
+ *     console.log(data);            ← file line 8  (script line 3)
+ *   }                               ← file line 9
+ *
+ * formatErrorWithContextV2(error, 'post-response', null, '/home/user/my-collection')
+ * → {
+ *     errorType: 'TypeError',
+ *     filePath: 'requests/get-user.bru',   ← relative to collectionPath
+ *     errorLine: 2,                        ← block-relative, not file line 7
+ *     lines: [
+ *       { lineNumber: 1, content: '  const data = res.body;', isError: false },
+ *       { lineNumber: 2, content: '  data.missing.prop;',     isError: true  },
+ *       { lineNumber: 3, content: '  console.log(data);',     isError: false }
+ *     ],
+ *     stack: '    at …/requests/get-user.bru:7:3'
+ *   }
+ *
+ * V1 (formatErrorWithContext) returns a flat string for the same error:
+ *   File: requests/get-user.bru
+ *
+ *    5 |  const data = res.body;
+ *  > 6 |  data.missing.prop;
+ *    7 |  console.log(data);
+ *
+ *   TypeError: Cannot read properties of undefined
+ *       at …/requests/get-user.bru:7:3
+ *
+ * @param {Error} error - The error to build context for
+ * @param {string} scriptType - 'pre-request' | 'post-response' | 'test'
+ * @param {object} scriptMetadata - Optional metadata for line mapping in combined scripts
+ * @param {string} collectionPath - Absolute path to the collection root (used to compute relative display paths)
+ * @returns {object|null} Structured error context or null
+ */
+/**
+ * Resolve error context, preferring in-memory draft content over disk.
+ *
+ * Three resolution paths (tried in order):
+ * 1. Request-level error with in-memory draft content
+ * 2. Segment (collection/folder) error with in-memory draft content
+ * 3. Disk-based file read (original behavior)
+ *
+ * @returns {{ context, fromMemory, draftOnlyBlock }|null}
+ */
+const resolveErrorContext = ({ adjustedLine, scriptRelativeLine, metadata, segmentResult, filePath, sourceFile, sourceLine, scriptType, cache }) => {
+  // Request-level error with in-memory draft content
+  if (adjustedLine !== null && metadata?.requestScriptContent) {
+    // Check whether the script block exists on disk. When the user added a brand-new
+    // script that hasn't been saved yet, findBlockStart returns null and adjustLineNumber
+    // returned scriptRelativeLine (not a real .bru file line), so stack frame adjustment
+    // would produce misleading results — flag it as draft-only.
+    const blockStartLine = findBlockStart(filePath, scriptType, cache);
+    const draftOnlyBlock = !blockStartLine && isAllowedSourceFile(filePath);
+    // requestStartLine points to the IIFE wrapper line (`await (async () => {`),
+    // so subtracting it yields a 1-based index into the user's script content.
+    const lineInScript = scriptRelativeLine - metadata.requestStartLine;
+    const context = getSourceContextFromContent(metadata.requestScriptContent, lineInScript, 3);
+    if (context) return { context, fromMemory: true, draftOnlyBlock };
+  }
+
+  // Segment (collection/folder) error with in-memory draft content
+  if (adjustedLine === null && segmentResult?.scriptContent) {
+    const context = getSourceContextFromContent(segmentResult.scriptContent, segmentResult.lineInScript, 3);
+    // segmentResult.line is null when the block doesn't exist on disk
+    if (context) return { context, fromMemory: true, draftOnlyBlock: segmentResult.line === null };
+  }
+
+  // Fall back to reading from disk
+  if (sourceLine !== null) {
+    const context = getSourceContext(sourceFile, sourceLine, 3, cache);
+    if (context) return { context, fromMemory: false, draftOnlyBlock: false };
+  }
+
+  return null;
+};
+
+const formatErrorWithContextV2 = (error, scriptType, scriptMetadata, collectionPath) => {
+  if (!error) return null;
+
+  try {
+    const cache = new Map();
+    const metadata = (error.scriptMetadata && Object.keys(error.scriptMetadata).length > 0)
+      ? error.scriptMetadata
+      : scriptMetadata;
+    const parsed = parseErrorLocation(error);
+    if (!parsed) return null;
+
+    const { filePath } = parsed;
+    const wrapperOffset = parsed.isQuickJS ? QUICKJS_SCRIPT_WRAPPER_OFFSET : NODEVM_SCRIPT_WRAPPER_OFFSET;
+    const scriptRelativeLine = parsed.line - wrapperOffset;
+    const adjustedLine = adjustLineNumber(filePath, parsed.line, parsed.isQuickJS, scriptType, cache, metadata);
+
+    let sourceFile = filePath;
+    let sourceLine = adjustedLine;
+
+    // Handle collection/folder script segments
+    let segmentResult = null;
+    if (adjustedLine === null) {
+      segmentResult = resolveSegmentError(parsed, metadata, scriptType, cache);
+      if (!segmentResult) return null;
+      sourceFile = segmentResult.filePath;
+      sourceLine = segmentResult.line;
+    }
+
+    // Resolve context: prefer in-memory draft content, fall back to disk
+    const resolved = resolveErrorContext({
+      adjustedLine, scriptRelativeLine, metadata, segmentResult,
+      filePath, sourceFile, sourceLine, scriptType, cache
+    });
+    if (!resolved || resolved.context.lines.length === 0) return null;
+
+    const { context, fromMemory, draftOnlyBlock } = resolved;
+
+    const resolvedDisplayPath = posixifyPath(
+      collectionPath ? path.relative(collectionPath, sourceFile) : sourceFile
+    );
+
+    const errorType = getErrorTypeName(error);
+    let stack = null;
+    if (error.stack) {
+      // When the script block only exists as a draft (not on disk), adjustLineNumber
+      // cannot map to real .bru file lines — skip adjustment to preserve original frames.
+      const rawStack = draftOnlyBlock
+        ? error.stack
+        : adjustStackTrace(error.stack, scriptType, cache, metadata, parsed.isQuickJS);
+      const stackLines = rawStack.split('\n').slice(1).filter((l) => l.trim().startsWith('at'));
+      stack = stackLines.length ? stackLines.map((l) => `    ${l.trim()}`).join('\n') : null;
+    }
+
+    // When context came from in-memory content, lines are already block-relative
+    if (fromMemory) {
+      return {
+        errorType,
+        filePath: resolvedDisplayPath,
+        errorLine: context.errorLine,
+        lines: context.lines,
+        stack
+      };
+    }
+
+    // Compute block-relative line numbers for the desktop UI.
+    // Users edit scripts in a CodeMirror editor starting at line 1,
+    // so show lines relative to the script block, not absolute .bru file lines.
+    const blockStartLine = findBlockStart(sourceFile, scriptType, cache);
+
+    const isBru = sourceFile.endsWith('.bru');
+    const isYml = sourceFile.endsWith('.yml');
+    const blockEndLine = isBru
+      ? findScriptBlockEndLine(sourceFile, scriptType, cache)
+      : isYml
+        ? findYmlScriptBlockEndLine(sourceFile, scriptType, cache)
+        : null;
+
+    // If this is a .bru/.yml file but the script block is missing or empty, there's nothing to show
+    if ((isBru || isYml) && !blockEndLine) return null;
+
+    const blockOffset = blockStartLine ? blockStartLine - 1 : 0;
+
+    const filteredLines = context.lines
+      .filter((l) => {
+        const rel = l.lineNumber - blockOffset;
+        return rel >= 1 && (!blockEndLine || l.lineNumber <= blockEndLine);
+      })
+      .map((l) => ({
+        lineNumber: l.lineNumber - blockOffset,
+        content: l.content,
+        isError: l.isError
+      }));
+
+    if (filteredLines.length === 0) return null;
+
+    return {
+      errorType,
+      filePath: resolvedDisplayPath,
+      errorLine: sourceLine - blockOffset,
+      lines: filteredLines,
+      stack
+    };
+  } catch (e) {
+    console.warn('formatErrorWithContextV2 failed:', e);
+    return null;
+  }
+};
+
 module.exports = {
   SCRIPT_TYPES,
   DEFAULT_CONTEXT_LINES,
@@ -416,11 +737,15 @@ module.exports = {
   parseErrorLocation,
   buildStackFromCallSites,
   getSourceContext,
+  getSourceContextFromContent,
   formatErrorWithContext,
+  formatErrorWithContextV2,
   adjustLineNumber,
   resolveSegmentError,
   findScriptBlockStartLine,
+  findScriptBlockEndLine,
   findYmlScriptBlockStartLine,
+  findYmlScriptBlockEndLine,
   adjustStackTrace,
   getErrorTypeName
 };