roku-debug 0.21.16 → 0.21.18

package/dist/debugSession/BrightScriptDebugSession.js

@@ -22,11 +22,13 @@ const BreakpointManager_1 = require("../managers/BreakpointManager");
 const logging_1 = require("../logging");
 const VariablesResponse_1 = require("../debugProtocol/events/responses/VariablesResponse");
 const brighterscript_1 = require("brighterscript");
+const debounce_1 = require("debounce");
 const diagnosticSource = 'roku-debug';
 class BrightScriptDebugSession extends debugadapter_1.DebugSession {
     constructor() {
         super();
         this.logger = logging_1.logger.createLogger(`[session]`);
+        this.isWindowsPlatform = process.platform.startsWith('win');
         /**
          * A sequence used to help identify log statements for requests
          */
@@ -49,6 +51,10 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
          */
         this.COMPILE_ERROR_THREAD_ID = 7777;
         this.exceptionBreakpoints = [];
+        this.pendingSendLogPromise = Promise.resolve();
+        this.debounceSendInvalidatedEvent = (0, debounce_1.debounce)((threadId, frameId) => {
+            this.sendInvalidatedEvent(threadId, frameId);
+        }, 50);
         this.evaluateRequestPromise = Promise.resolve();
         this.evaluateVarIndexByFrameId = new Map();
         /**
@@ -239,7 +245,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
      * @returns
      */
     normalizeLaunchConfig(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         (_a = config.cwd) !== null && _a !== void 0 ? _a : (config.cwd = process.cwd());
         (_b = config.outDir) !== null && _b !== void 0 ? _b : (config.outDir = (0, FileUtils_1.standardizePath) `${config.cwd}/out`);
         (_c = config.stagingDir) !== null && _c !== void 0 ? _c : (config.stagingDir = (0, FileUtils_1.standardizePath) `${config.outDir}/.roku-deploy-staging`);
@@ -251,6 +257,8 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         (_j = config.brightScriptConsolePort) !== null && _j !== void 0 ? _j : (config.brightScriptConsolePort = 8085);
         (_k = config.stagingDir) !== null && _k !== void 0 ? _k : (config.stagingDir = config.stagingFolderPath);
         (_l = config.emitChannelPublishedEvent) !== null && _l !== void 0 ? _l : (config.emitChannelPublishedEvent = true);
+        (_m = config.rewriteDevicePathsInLogs) !== null && _m !== void 0 ? _m : (config.rewriteDevicePathsInLogs = true);
+        (_o = config.autoResolveVirtualVariables) !== null && _o !== void 0 ? _o : (config.autoResolveVirtualVariables = false);
         return config;
     }
     async launchRequest(response, config) {
@@ -301,7 +309,13 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
             else {
                 util_1.util.log(`Connecting to Roku via telnet at ${this.launchConfiguration.host}:${this.launchConfiguration.brightScriptConsolePort}`);
             }
-            await this.initRendezvousTracking();
+            //activate rendezvous tracking (if enabled). Log the error and move on if it crashes, this shouldn't bring down the session.
+            try {
+                await this.initRendezvousTracking();
+            }
+            catch (e) {
+                this.logger.error('Failed to initialize rendezvous tracking', e);
+            }
             this.createRokuAdapter(this.rendezvousTracker);
             await this.connectRokuAdapter();
             await this.runAutomaticSceneGraphCommands(this.launchConfiguration.autoRunSgDebugCommands);
@@ -312,12 +326,12 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
             //pass along the console output
             if (this.launchConfiguration.consoleOutput === 'full') {
                 this.rokuAdapter.on('console-output', (data) => {
-                    this.sendLogOutput(data);
+                    void this.sendLogOutput(data);
                 });
             }
             else {
                 this.rokuAdapter.on('unhandled-console-output', (data) => {
-                    this.sendLogOutput(data);
+                    void this.sendLogOutput(data);
                 });
             }
             // Send chanperf events to the extension
@@ -543,15 +557,125 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
      */
     sendLogOutput(logOutput) {
         this.fileLoggingManager.writeRokuDeviceLog(logOutput);
-        const lines = logOutput.split(/\r?\n/g);
-        for (let i = 0; i < lines.length; i++) {
-            let line = lines[i];
-            if (i < lines.length - 1) {
-                line += '\n';
+        this.pendingSendLogPromise = this.pendingSendLogPromise.then(async () => {
+            logOutput = await this.convertBacktracePaths(logOutput);
+            const lines = logOutput.split(/\r?\n/g);
+            for (let i = 0; i < lines.length; i++) {
+                let line = lines[i];
+                if (i < lines.length - 1) {
+                    line += '\n';
+                }
+                if (this.launchConfiguration.rewriteDevicePathsInLogs) {
+                    let potentialPaths = this.getPotentialPkgPaths(line);
+                    for (let potentialPath of potentialPaths) {
+                        let originalLocation = await this.projectManager.getSourceLocation(potentialPath.path, potentialPath.lineNumber, potentialPath.columnNumber);
+                        if (originalLocation) {
+                            let replacement;
+                            replacement = originalLocation.filePath.replaceAll(' ', '%20');
+                            if (replacement !== originalLocation.filePath) {
+                                if (this.isWindowsPlatform) {
+                                    replacement = `vscode://file/${replacement}`;
+                                }
+                                else {
+                                    replacement = `file://${replacement}`;
+                                }
+                            }
+                            replacement += `:${originalLocation.lineNumber}`;
+                            if (potentialPath.columnNumber !== undefined) {
+                                replacement += `:${originalLocation.columnIndex + 1}`;
+                            }
+                            line = line.replaceAll(potentialPath.fullMatch, replacement);
+                        }
+                    }
+                }
+                this.sendEvent(new debugadapter_1.OutputEvent(line, 'stdout'));
+                this.sendEvent(new Events_1.LogOutputEvent(line));
+            }
+        });
+        return this.pendingSendLogPromise;
+    }
+    /**
+     * Extracts potential package paths from a given line of text.
+     *
+     * This method uses a regular expression to find matches in the provided line
+     * and returns an array of objects containing details about each match.
+     *
+     * @param input - The line of text to search for potential package paths.
+     * @returns An array of objects, each containing:
+     *   - `fullMatch`: The full matched string.
+     *   - `path`: The extracted path from the match.
+     *   - `lineNumber`: The line number extracted from the match.
+     *   - `columnNumber`: The column number extracted from the match, or `undefined` if not found.
+     */
+    getPotentialPkgPaths(input) {
+        var _a, _b;
+        // https://regex101.com/r/ixpQiq/1
+        let matches = input.matchAll(/((?:\.\.\.|[A-Za-z_0-9]*pkg\:\/)[A-Za-z_0-9 \/\.]+\.[A-Za-z_0-9 \/]+)(?:(?:\:)(\d+)(?:\:(\d+))?|\((\d+)(?:\:(\d+))?\))/ig);
+        let paths = [];
+        if (matches) {
+            for (let match of matches) {
+                let fullMatch = match[0];
+                let path = match[1];
+                let lineNumber = parseInt((_a = match[2]) !== null && _a !== void 0 ? _a : match[4]);
+                let columnNumber = parseInt((_b = match[3]) !== null && _b !== void 0 ? _b : match[5]);
+                if (isNaN(columnNumber)) {
+                    columnNumber = undefined;
+                }
+                paths.push({
+                    fullMatch: fullMatch,
+                    path: path,
+                    lineNumber: lineNumber,
+                    columnNumber: columnNumber
+                });
+            }
+        }
+        return paths;
+    }
+    /**
+     * Converts the filename property in backtrace objects in the given input string to source paths if found
+     */
+    async convertBacktracePaths(input) {
+        if (!this.launchConfiguration.rewriteDevicePathsInLogs) {
+            return input;
+        }
+        // Why does this not work? It should work, but it doesn't. I'm not sure why.
+        // let matches = input.matchAll(this.deviceBacktraceObjectRegex);
+        // https://regex101.com/r/y1koaV/2
+        let deviceBacktraceObjectRegex = /{\s+filename:\s+"([A-Za-z0-9_\.\/\: ]+)"\s+function\:\s+".+"\s+(line_number\:\s+(\d+))\s+}/gi;
+        let matches = [];
+        let match = deviceBacktraceObjectRegex.exec(input);
+        while (match) {
+            matches.push(match);
+            match = deviceBacktraceObjectRegex.exec(input);
+        }
+        if (matches) {
+            for (let match of matches) {
+                let fullMatch = match[0];
+                let filePath = match[1];
+                let fullLineNumber = match[2];
+                let lineNumber = parseInt(match[3]);
+                let originalLocation = await this.projectManager.getSourceLocation(filePath, lineNumber);
+                if (originalLocation) {
+                    let fileReplacement;
+                    fileReplacement = originalLocation.filePath.replaceAll(' ', '%20');
+                    if (fileReplacement !== originalLocation.filePath) {
+                        if (this.isWindowsPlatform) {
+                            fileReplacement = `vscode://file/${fileReplacement}`;
+                        }
+                        else {
+                            fileReplacement = `file://${fileReplacement}`;
+                        }
+                    }
+                    fileReplacement += `:${originalLocation.lineNumber}`;
+                    let lineNumberReplacement = fullLineNumber.replace(lineNumber.toString(), originalLocation.lineNumber.toString());
+                    // replace the full backtrace object with the an updated version so we don't modify other parts of the log output that might contain the same file path
+                    let completeReplacement = fullMatch.replace(filePath, fileReplacement);
+                    completeReplacement = completeReplacement.replace(fullLineNumber, lineNumberReplacement);
+                    input = input.replaceAll(fullMatch, completeReplacement);
+                }
             }
-            this.sendEvent(new debugadapter_1.OutputEvent(line, 'stdout'));
-            this.sendEvent(new Events_1.LogOutputEvent(line));
         }
+        return input;
     }
     async runAutomaticSceneGraphCommands(commands) {
         if (commands) {
@@ -855,7 +979,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                     if (!result) {
                         throw new Error(`Could not get scopes`);
                     }
-                    v = this.getVariableFromResult(result, args.frameId);
+                    v = await this.getVariableFromResult(result, args.frameId);
                     //TODO - testing something, remove later
                     // eslint-disable-next-line camelcase
                     v.request_seq = response.request_seq;
@@ -969,13 +1093,15 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         this.logger.info('[stepBackRequest] end');
     }
     async variablesRequest(response, args) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const logger = this.logger.createLogger('[variablesRequest]');
+        let sendInvalidatedEvent = false;
+        let frameId = null;
         try {
             logger.log('begin', { args });
             //ensure the rokuAdapter is loaded
             await this.getRokuAdapter();
-            let childVariables = [];
+            let updatedVariables = [];
             //wait for any `evaluate` commands to finish so we have a higher likely hood of being at a debugger prompt
             await this.evaluateRequestPromise;
             if (((_a = this.rokuAdapter) === null || _a === void 0 ? void 0 : _a.isAtDebuggerPrompt) !== true) {
@@ -993,13 +1119,15 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                     for (const varName of vars) {
                         let { evalArgs } = await this.evaluateExpressionToTempVar({ expression: varName, frameId: -1 }, util_1.util.getVariablePath(varName));
                         let result = await this.rokuAdapter.getVariable(evalArgs.expression, -1);
-                        let tempVar = this.getVariableFromResult(result, -1);
-                        childVariables.push(tempVar);
+                        let tempVar = await this.getVariableFromResult(result, -1);
+                        updatedVariables.push(tempVar);
                     }
                 }
                 else {
-                    childVariables.push(new debugadapter_1.Variable('variables disabled by launch.json setting', 'enableVariablesPanel: false'));
+                    updatedVariables.push(new debugadapter_1.Variable('variables disabled by launch.json setting', 'enableVariablesPanel: false'));
                 }
+                this.variables[args.variablesReference] = new debugadapter_1.Variable('', '', args.variablesReference, 0, updatedVariables.length);
+                this.variables[args.variablesReference].childVariables = updatedVariables;
             }
             else {
                 //find the variable with this reference
@@ -1010,49 +1138,120 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                     return this.sendResponse(response);
                 }
                 logger.log('variable', v);
-                //query for child vars if we haven't done it yet.
-                if (v.childVariables.length === 0) {
-                    let { evalArgs } = await this.evaluateExpressionToTempVar({ expression: v.evaluateName, frameId: v.frameId }, util_1.util.getVariablePath(v.evaluateName));
-                    let result = await this.rokuAdapter.getVariable(evalArgs.expression, v.frameId);
-                    let tempVar = this.getVariableFromResult(result, v.frameId);
-                    tempVar.frameId = v.frameId;
-                    v.childVariables = tempVar.childVariables;
-                }
-                childVariables = v.childVariables;
-            }
-            //if the variable is an array, send only the requested range
-            if (Array.isArray(childVariables) && args.filter === 'indexed') {
-                //only send the variable range requested by the debugger
-                childVariables = childVariables.slice(args.start, args.start + args.count);
-            }
-            let filteredChildVariables = this.launchConfiguration.showHiddenVariables !== true ? childVariables.filter((child) => !child.name.startsWith(this.tempVarPrefix)) : childVariables;
-            if (this.launchConfiguration.showHiddenVariables !== true) {
-                filteredChildVariables = filteredChildVariables.filter((child) => {
-                    //A transient variable that we show when there is a value
-                    if (child.name === '__brs_err__' && child.type !== VariablesResponse_1.VariableType.Uninitialized) {
-                        return true;
+                //query for child vars if we haven't done it yet or DAP is asking to resolve a lazy variable
+                if (v.childVariables.length === 0 || v.isResolved) {
+                    let tempVar;
+                    if (!v.isResolved) {
+                        // Evaluate the variable
+                        try {
+                            let { evalArgs } = await this.evaluateExpressionToTempVar({ expression: v.evaluateName, frameId: v.frameId }, util_1.util.getVariablePath(v.evaluateName));
+                            let result = await this.rokuAdapter.getVariable(evalArgs.expression, v.frameId);
+                            tempVar = await this.getVariableFromResult(result, v.frameId);
+                            tempVar.frameId = v.frameId;
+                            // Determine if the variable has changed
+                            sendInvalidatedEvent = v.type !== tempVar.type || v.indexedVariables !== tempVar.indexedVariables;
+                        }
+                        catch (error) {
+                            logger.error('Error getting variables', error);
+                            tempVar = new debugadapter_1.Variable('Error', `❌ Error: ${error.message}`);
+                            tempVar.type = '';
+                            tempVar.childVariables = [];
+                            sendInvalidatedEvent = true;
+                            response.success = false;
+                            response.message = error.message;
+                        }
+                        // Merge the resulting updates together
+                        v.childVariables = tempVar.childVariables;
+                        v.value = tempVar.value;
+                        v.type = tempVar.type;
+                        v.indexedVariables = tempVar.indexedVariables;
+                        v.namedVariables = tempVar.namedVariables;
                     }
-                    else if (util_1.util.isTransientVariable(child.name)) {
-                        return false;
+                    frameId = v.frameId;
+                    if (((_b = v === null || v === void 0 ? void 0 : v.presentationHint) === null || _b === void 0 ? void 0 : _b.lazy) || v.isResolved) {
+                        // If this was a lazy variable we need to respond with the updated variable and not the children
+                        if (v.isResolved && v.childVariables.length > 0) {
+                            updatedVariables = v.childVariables;
+                        }
+                        else {
+                            updatedVariables = [v];
+                        }
+                        v.isResolved = true;
                     }
                     else {
-                        return true;
+                        updatedVariables = v.childVariables;
                     }
-                });
+                    // If the variable has no children, set the reference to 0
+                    // so it does not look expandable in the Ui
+                    if (v.childVariables.length === 0) {
+                        v.variablesReference = 0;
+                    }
+                    // If the variable was resolve in the past we may not have fetched a new temp var
+                    tempVar !== null && tempVar !== void 0 ? tempVar : (tempVar = v);
+                    if (v === null || v === void 0 ? void 0 : v.presentationHint) {
+                        v.presentationHint.lazy = (_c = tempVar.presentationHint) === null || _c === void 0 ? void 0 : _c.lazy;
+                    }
+                    else {
+                        v.presentationHint = tempVar.presentationHint;
+                    }
+                }
+                else {
+                    updatedVariables = v.childVariables;
+                }
             }
             response.body = {
-                variables: filteredChildVariables
+                variables: this.filterVariablesUpdates(updatedVariables, args, this.variables[args.variablesReference])
             };
         }
         catch (error) {
             logger.error('Error during variablesRequest', error, { args });
             response.success = false;
-            response.message = (_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : 'Error during variablesRequest';
+            response.message = (_d = error === null || error === void 0 ? void 0 : error.message) !== null && _d !== void 0 ? _d : 'Error during variablesRequest';
         }
         finally {
             logger.info('end', { response });
         }
         this.sendResponse(response);
+        if (sendInvalidatedEvent) {
+            this.debounceSendInvalidatedEvent(null, frameId);
+        }
+    }
+    filterVariablesUpdates(updatedVariables, args, v) {
+        var _a;
+        if (!updatedVariables || !v) {
+            return [];
+        }
+        let start = (_a = args.start) !== null && _a !== void 0 ? _a : 0;
+        //if the variable is an array, send only the requested range
+        if (Array.isArray(updatedVariables) && args.filter === 'indexed') {
+            //only send the variable range requested by the debugger
+            if (!args.count) {
+                updatedVariables = updatedVariables.slice(0, v.indexedVariables);
+            }
+            else {
+                updatedVariables = updatedVariables.slice(start, start + args.count);
+            }
+        }
+        if (Array.isArray(updatedVariables) && args.filter === 'named') {
+            // We currently do not support named variable paging so we always send all named variables
+            updatedVariables = updatedVariables.slice(v.indexedVariables);
+        }
+        let filteredUpdatedVariables = this.launchConfiguration.showHiddenVariables !== true ? updatedVariables.filter((child) => !child.name.startsWith(this.tempVarPrefix)) : updatedVariables;
+        if (this.launchConfiguration.showHiddenVariables !== true) {
+            filteredUpdatedVariables = filteredUpdatedVariables.filter((child) => {
+                //A transient variable that we show when there is a value
+                if (child.name === '__brs_err__' && child.type !== VariablesResponse_1.VariableType.Uninitialized) {
+                    return true;
+                }
+                else if (util_1.util.isTransientVariable(child.name)) {
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            });
+        }
+        return filteredUpdatedVariables;
     }
     getNextVarIndex(frameId) {
         if (!this.evaluateVarIndexByFrameId.has(frameId)) {
@@ -1098,7 +1297,9 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 }
                 //is at debugger prompt
             }
-            else {
+            else if (args.expression.trim()) {
+                // We trim and check that the expression is not an empty string so that we do not send empty expressions to the Roku
+                // This happens mostly when hovering over leading whitespace in the editor
                 let { evalArgs, variablePath } = await this.evaluateExpressionToTempVar(args, util_1.util.getVariablePath(args.expression));
                 //if we found a variable path (e.g. ['a', 'b', 'c']) then do a variable lookup because it's faster and more widely supported than `evaluate`
                 if (variablePath) {
@@ -1113,7 +1314,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                         if (!result) {
                             throw new Error('Error: unable to evaluate expression');
                         }
-                        v = this.getVariableFromResult(result, evalArgs.frameId);
+                        v = await this.getVariableFromResult(result, evalArgs.frameId);
                         //TODO - testing something, remove later
                         // eslint-disable-next-line camelcase
                         v.request_seq = response.request_seq;
@@ -1131,14 +1332,20 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 else {
                     let commandResults = await this.rokuAdapter.evaluate(evalArgs.expression, evalArgs.frameId);
                     commandResults.message = util_1.util.trimDebugPrompt(commandResults.message);
-                    if (args.context !== 'watch') {
-                        //clear variable cache since this action could have side-effects
+                    if (args.context === 'repl') {
+                        // Clear variable cache since this action could have side-effects
+                        // Only do this for REPL requests as hovers and watches should not clear the cache
                         this.clearState();
                         this.sendInvalidatedEvent(null, evalArgs.frameId);
                     }
-                    //if the adapter captured output (probably only telnet), print it to the vscode debug console
+                    // If the adapter captured output (probably only telnet), log the results
                     if (typeof commandResults.message === 'string') {
-                        this.sendEvent(new debugadapter_1.OutputEvent(commandResults.message, commandResults.type === 'error' ? 'stderr' : 'stdio'));
+                        this.logger.debug('evaluateRequest', { commandResults });
+                        if (args.context === 'repl') {
+                            // If the command was a repl command, send the output to the debug console for the developer as well
+                            // We limit this to repl only so you don't get extra logs when hovering over variables ro running watches
+                            this.sendEvent(new debugadapter_1.OutputEvent(commandResults.message, commandResults.type === 'error' ? 'stderr' : 'stdio'));
+                        }
                     }
                     if (this.enableDebugProtocol || (typeof commandResults.message !== 'string')) {
                         response.body = {
@@ -1171,13 +1378,14 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         if (!variablePath && util_1.util.isAssignableExpression(args.expression)) {
             let varIndex = this.getNextVarIndex(args.frameId);
             let arrayVarName = this.tempVarPrefix + 'eval';
+            let command = '';
             if (varIndex === 0) {
-                const response = await this.rokuAdapter.evaluate(`${arrayVarName} = []`, args.frameId);
-                console.log(response);
+                command += `if type(${arrayVarName}) = "<uninitialized>" then ${arrayVarName} = []\n`;
             }
             let statement = `${arrayVarName}[${varIndex}] = ${args.expression}`;
             returnVal.evalArgs.expression = `${arrayVarName}[${varIndex}]`;
-            let commandResults = await this.rokuAdapter.evaluate(statement, args.frameId);
+            command += statement;
+            let commandResults = await this.rokuAdapter.evaluate(command, args.frameId);
             if (commandResults.type === 'error') {
                 throw new Error(commandResults.message);
             }
@@ -1185,6 +1393,49 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         }
         return returnVal;
     }
+    async bulkEvaluateExpressionToTempVar(frameId, argsArray, variablePathArray) {
+        let results = {
+            evaluations: [],
+            bulkVarName: ''
+        };
+        let storedVariables = [];
+        let command = '';
+        for (let i = 0; i < argsArray.length; i++) {
+            let args = argsArray[i];
+            let variablePath = variablePathArray[i];
+            let returnVal = { evalArgs: args, variablePath };
+            if (!variablePath && util_1.util.isAssignableExpression(args.expression)) {
+                let varIndex = this.getNextVarIndex(frameId);
+                let arrayVarName = this.tempVarPrefix + 'eval';
+                if (varIndex === 0) {
+                    command += `if type(${arrayVarName}) = "<uninitialized>" then ${arrayVarName} = []\n`;
+                }
+                let statement = `${arrayVarName}[${varIndex}] = ${args.expression}\n`;
+                returnVal.evalArgs.expression = `${arrayVarName}[${varIndex}]`;
+                command += statement;
+                storedVariables.push(`${arrayVarName}[${varIndex}]`);
+                returnVal.variablePath = [arrayVarName, varIndex.toString()];
+            }
+            results.evaluations[i] = returnVal;
+        }
+        if (command) {
+            // create a bulk container for the command results
+            let varIndex = this.getNextVarIndex(frameId);
+            let arrayVarName = this.tempVarPrefix + 'eval';
+            let bulkContainerStatement = `${arrayVarName}[${varIndex}] = [\n`;
+            for (let storedVariable of storedVariables) {
+                bulkContainerStatement += `${storedVariable},\n`;
+            }
+            bulkContainerStatement += `]`;
+            command += bulkContainerStatement;
+            results.bulkVarName = `${arrayVarName}[${varIndex}]`;
+            let commandResults = await this.rokuAdapter.evaluate(command, frameId);
+            if (commandResults.type === 'error') {
+                throw new Error(commandResults.message);
+            }
+        }
+        return results;
+    }
     /**
      * Called when the host stops debugging
      * @param response
@@ -1304,28 +1555,57 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         this.clearState();
         return threads;
     }
-    getVariableFromResult(result, frameId) {
-        var _a, _b, _c, _d, _e;
+    async getVariableFromResult(result, frameId, maxDepth = 1) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         let v;
         if (result) {
             if (this.enableDebugProtocol) {
                 let refId = this.getEvaluateRefId(result.evaluateName, frameId);
+                if (result.isCustom && !((_a = result.presentationHint) === null || _a === void 0 ? void 0 : _a.lazy) && result.evaluateNow) {
+                    try {
+                        // We should not wait to resolve this variable later. Fetch, store, and merge the results right away.
+                        let { evalArgs } = await this.evaluateExpressionToTempVar({ expression: result.evaluateName, frameId: frameId }, util_1.util.getVariablePath(result.evaluateName));
+                        let newResult = await this.rokuAdapter.getVariable(evalArgs.expression, frameId);
+                        this.mergeEvaluateContainers(result, newResult);
+                    }
+                    catch (error) {
+                        logging_1.logger.error('Error getting variables', error);
+                        this.mergeEvaluateContainers(result, {
+                            name: result.name,
+                            evaluateName: result.evaluateName,
+                            children: [],
+                            value: `❌ Error: ${error.message}`,
+                            type: '',
+                            highLevelType: undefined,
+                            keyType: undefined
+                        });
+                    }
+                }
                 if (result.keyType) {
+                    let value = `${(_b = result.value) !== null && _b !== void 0 ? _b : result.type}`;
+                    let indexedVariables = result.indexedVariables;
+                    let namedVariables = result.namedVariables;
+                    if (indexedVariables === undefined || namedVariables === undefined) {
+                        // If either indexed or named variables are undefined, we should tell the debugger to ask for everything
+                        // by supplying undefined values for both
+                        indexedVariables = undefined;
+                        namedVariables = undefined;
+                    }
                     // check to see if this is an dictionary or a list
                     if (result.keyType === 'Integer') {
                         // list type
-                        v = new debugadapter_1.Variable(result.name, result.type, refId, result.elementCount, 0);
-                        this.variables[refId] = v;
+                        v = new debugadapter_1.Variable(result.name, value, refId, indexedVariables, namedVariables);
                     }
                     else if (result.keyType === 'String') {
                         // dictionary type
-                        v = new debugadapter_1.Variable(result.name, result.type, refId, 0, result.elementCount);
+                        v = new debugadapter_1.Variable(result.name, value, refId, indexedVariables, namedVariables);
                     }
+                    v.type = result.type;
                 }
                 else {
                     let value;
                     if (result.type === VariablesResponse_1.VariableType.Invalid) {
-                        value = (_a = result.value) !== null && _a !== void 0 ? _a : 'Invalid';
+                        value = (_c = result.value) !== null && _c !== void 0 ? _c : 'Invalid';
                     }
                     else if (result.type === VariablesResponse_1.VariableType.Uninitialized) {
                         value = 'Uninitialized';
@@ -1333,7 +1613,9 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                     else {
                         value = `${result.value}`;
                     }
-                    v = new debugadapter_1.Variable(result.name, value);
+                    // If the variable is lazy we must assign a refId to inform the system
+                    // to request this variable again in the future for value resolution
+                    v = new debugadapter_1.Variable(result.name, value, ((_d = result === null || result === void 0 ? void 0 : result.presentationHint) === null || _d === void 0 ? void 0 : _d.lazy) ? refId : 0);
                 }
                 this.variables[refId] = v;
             }
@@ -1343,45 +1625,101 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 }
                 else if (result.highLevelType === 'array') {
                     let refId = this.getEvaluateRefId(result.evaluateName, frameId);
-                    v = new debugadapter_1.Variable(result.name, result.type, refId, (_c = (_b = result.children) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0, 0);
+                    v = new debugadapter_1.Variable(result.name, result.type, refId, (_f = (_e = result.children) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0, 0);
                     this.variables[refId] = v;
                 }
                 else if (result.highLevelType === 'object') {
-                    let refId = this.getEvaluateRefId(result.evaluateName, frameId);
-                    v = new debugadapter_1.Variable(result.name, result.type, refId, 0, (_e = (_d = result.children) === null || _d === void 0 ? void 0 : _d.length) !== null && _e !== void 0 ? _e : 0);
+                    let refId;
+                    //handle collections
+                    if (this.rokuAdapter.isScrapableContainObject(result.type)) {
+                        refId = this.getEvaluateRefId(result.evaluateName, frameId);
+                    }
+                    v = new debugadapter_1.Variable(result.name, result.type, refId, 0, (_h = (_g = result.children) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : 0);
                     this.variables[refId] = v;
                 }
                 else if (result.highLevelType === 'function') {
-                    v = new debugadapter_1.Variable(result.name, result.value);
+                    v = new debugadapter_1.Variable(result.name, `${result.value}`);
                 }
                 else {
                     //all other cases, but mostly for HighLevelType.unknown
-                    v = new debugadapter_1.Variable(result.name, result.value);
+                    v = new debugadapter_1.Variable(result.name, `${result.value}`);
                 }
             }
             v.type = result.type;
             v.evaluateName = result.evaluateName;
             v.frameId = frameId;
             v.type = result.type;
-            v.presentationHint = result.presentationHint ? { kind: result.presentationHint } : undefined;
+            v.presentationHint = result.presentationHint ? { kind: (_j = result.presentationHint) === null || _j === void 0 ? void 0 : _j.kind, lazy: (_k = result.presentationHint) === null || _k === void 0 ? void 0 : _k.lazy } : undefined;
             if (util_1.util.isTransientVariable(v.name)) {
                 v.presentationHint = { kind: 'virtual' };
             }
-            if (result.children) {
-                let childVariables = [];
-                for (let childContainer of result.children) {
-                    let childVar = this.getVariableFromResult(childContainer, frameId);
-                    childVariables.push(childVar);
+            if (result.children && maxDepth > 0) {
+                if (!v.childVariables) {
+                    v.childVariables = [];
                 }
-                v.childVariables = childVariables;
+                // Create a mapping of the children to their index so we can evaluate them in bulk
+                let indexMappedChildren = result.children.map((child, index) => {
+                    var _a;
+                    let remapped = { child: child, index: index, evaluate: !!(child.isCustom && !((_a = child.presentationHint) === null || _a === void 0 ? void 0 : _a.lazy) && child.evaluateNow) };
+                    return remapped;
+                });
+                if (this.enableDebugProtocol) {
+                    let childrenToEvaluate = indexMappedChildren.filter(x => x.evaluate);
+                    let evaluateArgsArray = childrenToEvaluate.map(x => {
+                        return { expression: x.child.evaluateName, frameId: frameId };
+                    });
+                    let variablePathArray = childrenToEvaluate.map(x => {
+                        return util_1.util.getVariablePath(x.child.evaluateName);
+                    });
+                    try {
+                        let bulkEvaluations = await this.bulkEvaluateExpressionToTempVar(frameId, evaluateArgsArray, variablePathArray);
+                        if (bulkEvaluations.bulkVarName) {
+                            let newResults = await this.rokuAdapter.getVariable(bulkEvaluations.bulkVarName, frameId);
+                            childrenToEvaluate.map((mappedChild, index) => {
+                                let newResult = newResults.children[index];
+                                this.mergeEvaluateContainers(mappedChild.child, newResult);
+                                mappedChild.child.evaluateNow = false;
+                                return mappedChild;
+                            });
+                        }
+                    }
+                    catch (error) {
+                        this.logger.error('Error getting bulk variables, will fall back to var by var lookups', error);
+                    }
+                }
+                // If bulk evaluations failed, there is fall back logic in `getVariableFromResult` to do individual evaluations
+                v.childVariables = await Promise.all(indexMappedChildren.map(async (mappedChild) => {
+                    return this.getVariableFromResult(mappedChild.child, frameId, maxDepth - 1);
+                }));
+            }
+            else {
+                v.childVariables = [];
             }
             // if the var is an array and debugProtocol is enabled, include the array size
             if (this.enableDebugProtocol && v.type === VariablesResponse_1.VariableType.Array) {
-                v.value = `${v.type}(${result.elementCount})`;
+                if (isNaN(result.indexedVariables)) {
+                    v.value = v.type;
+                }
+                else {
+                    v.value = `${v.type}(${result.indexedVariables})`;
+                }
             }
         }
         return v;
     }
+    /**
+     * Helper function to merge the results of an evaluate call into an existing EvaluateContainer
+     * Used primarily for custom variables
+     */
+    mergeEvaluateContainers(original, updated) {
+        original.children = updated.children;
+        original.value = updated.value;
+        original.type = updated.type;
+        original.highLevelType = updated.highLevelType;
+        original.keyType = updated.keyType;
+        original.indexedVariables = updated.indexedVariables;
+        original.namedVariables = updated.namedVariables;
+    }
     getEvaluateRefId(expression, frameId) {
         let evaluateRefId = `${expression}-${frameId}`;
         if (!this.evaluateRefIdLookup[evaluateRefId]) {
@@ -1430,13 +1768,19 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
         return this.shutdownPromise;
     }
     async _shutdown(errorMessage, modal = false) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         try {
             (_a = this.componentLibraryServer) === null || _a === void 0 ? void 0 : _a.stop();
             void ((_c = (_b = this.rendezvousTracker) === null || _b === void 0 ? void 0 : _b.destroy) === null || _c === void 0 ? void 0 : _c.call(_b));
+            try {
+                (_e = (_d = this.sourceMapManager) === null || _d === void 0 ? void 0 : _d.destroy) === null || _e === void 0 ? void 0 : _e.call(_d);
+            }
+            catch (e) {
+                this.logger.error(e);
+            }
             //if configured, delete the staging directory
             if (!this.launchConfiguration.retainStagingFolder) {
-                const stagingDirs = (_e = (_d = this.projectManager) === null || _d === void 0 ? void 0 : _d.getStagingDirs()) !== null && _e !== void 0 ? _e : [];
+                const stagingDirs = (_g = (_f = this.projectManager) === null || _f === void 0 ? void 0 : _f.getStagingDirs()) !== null && _g !== void 0 ? _g : [];
                 this.logger.info('deleting staging folders', stagingDirs);
                 for (let stagingDir of stagingDirs) {
                     try {
@@ -1454,7 +1798,7 @@ class BrightScriptDebugSession extends debugadapter_1.DebugSession {
                 this.showPopupMessage(errorMessage, 'error', modal);
             }
             this.logger.log('Destroy rokuAdapter');
-            await ((_g = (_f = this.rokuAdapter) === null || _f === void 0 ? void 0 : _f.destroy) === null || _g === void 0 ? void 0 : _g.call(_f));
+            await ((_j = (_h = this.rokuAdapter) === null || _h === void 0 ? void 0 : _h.destroy) === null || _j === void 0 ? void 0 : _j.call(_h));
             //press the home button to return to the home screen
             try {
                 this.logger.log('Press home button');