rooibos-roku 5.16.4 → 5.16.6

package/.mocharc.cjs

@@ -0,0 +1,15 @@
+const nodeVersion = +process.versions.node.split('.')[0];
+const config = {
+    spec: 'src/**/*.spec.ts',
+    require: [
+        'source-map-support/register',
+        'ts-node/register'
+    ],
+    fullTrace: true,
+    timeout: 2000,
+    watchExtensions: ['ts']
+};
+if (nodeVersion >= 22) {
+    config['node-option'] = ['no-experimental-strip-types'];
+}
+module.exports = config;

package/CHANGELOG.md

@@ -6,6 +6,48 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 
 
+## [5.16.6](https://github.com/rokucommunity/rooibos/compare/5.16.5...v5.16.6) - 2026-10-01
+### Changed
+ - Process every test suite in a file, not just the first ([#441](https://github.com/rokucommunity/rooibos/pull/441))
+ - Support enums and constants in @params annotations ([#438](https://github.com/rokucommunity/rooibos/pull/438))
+ - Security enhancements ([#426](https://github.com/rokucommunity/rooibos/pull/426), [#429](https://github.com/rokucommunity/rooibos/pull/429), [#439](https://github.com/rokucommunity/rooibos/pull/439))
+ - upgrade to [brighterscript@0.73.5](https://github.com/rokucommunity/brighterscript/blob/v0.73.5/CHANGELOG.md#0735---2026-09-15). Notable changes since 0.73.3:
+     - Fix crash stripping sourceMappingURL comment from non-transpiled files ([#1821](https://github.com/rokucommunity/brighterscript/pull/1821))
+     - Tolerate older BrsTranspileState in continue back-transpile ([#1812](https://github.com/rokucommunity/brighterscript/pull/1812))
+     - Security enhancements ([#1804](https://github.com/rokucommunity/brighterscript/pull/1804), [#1805](https://github.com/rokucommunity/brighterscript/pull/1805))
+     - Locate the super() call when injecting field initializers ([#1803](https://github.com/rokucommunity/brighterscript/pull/1803))
+ - upgrade to [roku-debug@0.24.6](https://github.com/rokucommunity/roku-debug/blob/v0.24.6/CHANGELOG.md#0246---2026-10-01). Notable changes since 0.24.3:
+     - Security enhancements ([#419](https://github.com/rokucommunity/roku-debug/pull/419), [#427](https://github.com/rokucommunity/roku-debug/pull/427))
+ - upgrade to [roku-deploy@4.0.0-alpha.9](https://github.com/rokucommunity/roku-deploy/blob/v4.0.0-alpha.9/CHANGELOG.md#400-alpha9---2026-09-28). Notable changes since 4.0.0-alpha.5:
+     - Security enhancements ([#422](https://github.com/rokucommunity/roku-deploy/pull/422))
+     - upgrade to [@rokucommunity/logger@0.4.2](https://github.com/rokucommunity/logger/blob/master/CHANGELOG.md#042---2026-09-02). Notable changes since 0.4.1:
+         - Security enhancements ([#38](https://github.com/rokucommunity/logger/pull/38), [#39](https://github.com/rokucommunity/logger/pull/39))
+### Fixed
+ - Fixed ignored tests count reporting in the summary output ([#435](https://github.com/rokucommunity/rooibos/pull/435))
+
+
+
+## [5.16.5](https://github.com/rokucommunity/rooibos/compare/5.16.4...v5.16.5) - 2026-09-09
+### Changed
+ - Security enhancements ([#405](https://github.com/rokucommunity/rooibos/pull/405), [#406](https://github.com/rokucommunity/rooibos/pull/406), [#407](https://github.com/rokucommunity/rooibos/pull/407), [#409](https://github.com/rokucommunity/rooibos/pull/409), [#410](https://github.com/rokucommunity/rooibos/pull/410), [#411](https://github.com/rokucommunity/rooibos/pull/411), [#412](https://github.com/rokucommunity/rooibos/pull/412), [#414](https://github.com/rokucommunity/rooibos/pull/414), [#421](https://github.com/rokucommunity/rooibos/pull/421))
+ - Make before-exit sleep duration configurable ([#418](https://github.com/rokucommunity/rooibos/pull/418))
+ - Run stubCall/expectCalled/expectNotCalled rewrites in setUp/tearDown/beforeEach/afterEach hooks ([#403](https://github.com/rokucommunity/rooibos/pull/403))
+ - upgrade to [brighterscript@0.73.3](https://github.com/rokucommunity/brighterscript/blob/master/CHANGELOG.md#0733---2026-09-09). Notable changes since 0.72.5:
+     - Security enhancements ([#1733](https://github.com/rokucommunity/brighterscript/pull/1733), [#1763](https://github.com/rokucommunity/brighterscript/pull/1763), [#1764](https://github.com/rokucommunity/brighterscript/pull/1764), [#1766](https://github.com/rokucommunity/brighterscript/pull/1766), [#1773](https://github.com/rokucommunity/brighterscript/pull/1773), [#1774](https://github.com/rokucommunity/brighterscript/pull/1774), [#1775](https://github.com/rokucommunity/brighterscript/pull/1775), [#1782](https://github.com/rokucommunity/brighterscript/pull/1782), [#1796](https://github.com/rokucommunity/brighterscript/pull/1796))
+ - upgrade to [roku-debug@0.24.3](https://github.com/rokucommunity/roku-debug/blob/master/CHANGELOG.md#0243---2026-09-09). Notable changes since 0.23.11:
+     - Security enhancements ([#369](https://github.com/rokucommunity/roku-debug/pull/369), [#372](https://github.com/rokucommunity/roku-debug/pull/372), [#387](https://github.com/rokucommunity/roku-debug/pull/387), [#402](https://github.com/rokucommunity/roku-debug/pull/402), [#403](https://github.com/rokucommunity/roku-debug/pull/403), [#407](https://github.com/rokucommunity/roku-debug/pull/407), [#412](https://github.com/rokucommunity/roku-debug/pull/412), [#414](https://github.com/rokucommunity/roku-debug/pull/414), [#417](https://github.com/rokucommunity/roku-debug/pull/417))
+ - upgrade to [roku-deploy@3.18.4](https://github.com/rokucommunity/roku-deploy/blob/master/CHANGELOG.md#3184---2026-09-02). Notable changes since 3.17.6:
+     - Security enhancements ([#293](https://github.com/rokucommunity/roku-deploy/pull/293), [#345](https://github.com/rokucommunity/roku-deploy/pull/345))
+ - upgrade to [@rokucommunity/bslint@0.8.46](https://github.com/rokucommunity/bslint/blob/master/CHANGELOG.md#0846---2026-09-09). Notable changes since 0.8.43:
+     - Security enhancements ([#186](https://github.com/rokucommunity/bslint/pull/186), [#196](https://github.com/rokucommunity/bslint/pull/196), [#198](https://github.com/rokucommunity/bslint/pull/198), [#203](https://github.com/rokucommunity/bslint/pull/203))
+ - upgrade to [ropm@0.11.11](https://github.com/rokucommunity/ropm/blob/master/CHANGELOG.md#01111---2026-09-09). Notable changes since 0.11.8:
+     - Security enhancements ([#147](https://github.com/rokucommunity/ropm/pull/147), [#152](https://github.com/rokucommunity/ropm/pull/152), [#154](https://github.com/rokucommunity/ropm/pull/154), [#156](https://github.com/rokucommunity/ropm/pull/156), [#159](https://github.com/rokucommunity/ropm/pull/159))
+### Fixed
+ - Fix coverage instrumentation changing constructor execution order ([#355](https://github.com/rokucommunity/rooibos/pull/355))
+ - fix: skip assertion tracking injection for namespace function calls ([#385](https://github.com/rokucommunity/rooibos/pull/385))
+
+
+
 ## [5.16.4](https://github.com/rokucommunity/rooibos/compare/5.16.3...v5.16.4) - 2026-06-10
 ### Changed
  - Make tests less brittle - removes full transpile string checks ([#396](https://github.com/rokucommunity/rooibos/pull/396))

package/README.md

@@ -30,6 +30,16 @@ Rooibos is an independent open-source project maintained exclusively by voluntee
 
 You might want to help! Get in touch via the [slack group](https://join.slack.com/t/rokudevelopers/shared_invite/zt-4vw7rg6v-NH46oY7hTktpRIBM_zGvwA) or [raise issues](https://github.com/rokucommunity/rooibos/issues/new).
 
+To work on Rooibos locally:
+
+```bash
+npm install
+npx ropm copy   # copies the framework's ropm dependencies into framework/src
+npm test
+```
+
+`npx ropm copy` is required because `npm install` alone doesn't copy the ropm modules the framework depends on. `npm run build` also runs it for you, and the test/device scripts will tell you if you've forgotten it.
+
 ## Sample project
 
 https://github.com/rokucommunity/rooibos-roku-sample

package/audit-ci.jsonc

@@ -3,13 +3,5 @@
     // why each allowlisted entry is safe to defer.
     "$schema": "https://github.com/IBM/audit-ci/raw/main/docs/schema.json",
     "high": true,
-    "allowlist": [
-        {
-            "GHSA-w5hq-g745-h8pq": {
-                // Added: 2026-05-22
-                "active": true,
-                "notes": "`uuid` <11.1.1 (via `postman-request` and dev-only `nyc>istanbul-lib-processinfo`): vulnerable code path is `v3()`/`v5()`/`v6()` when a caller-provided buffer is passed. All consumers in this dep graph call only `v4()` (no buffer arg), so the vulnerable path is unreachable."
-            }
-        }
-    ]
+    "allowlist": []
 }

package/dist/cli.js

@@ -6,6 +6,33 @@ const brighterscript_1 = require("brighterscript");
 const yargs = require("yargs");
 const roku_deploy_1 = require("roku-deploy");
 const fs = require("fs");
+const path = require("path");
+/**
+ * Load simple `KEY=value` pairs from a .env file into process.env, without
+ * overwriting variables that are already set in the real environment.
+ */
+function loadDotEnv(envPath = '.env') {
+    var _a;
+    var _b, _c;
+    if (!fs.existsSync(envPath)) {
+        return;
+    }
+    const contents = fs.readFileSync(envPath, 'utf8');
+    for (const line of contents.split(/\r?\n/)) {
+        const match = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+        if (!match) {
+            //skip blanks and comments
+            continue;
+        }
+        let value = match[2].trim();
+        //strip matching surrounding quotes
+        if (/^"(.*)"$/.test(value) || /^'(.*)'$/.test(value)) {
+            value = value.slice(1, -1);
+        }
+        (_a = (_b = process.env)[_c = match[1]]) !== null && _a !== void 0 ? _a : (_b[_c] = value);
+    }
+}
+loadDotEnv();
 let options = yargs
     .usage('$0', 'Rooibos: a simple, flexible, fun Brightscript test framework for Roku Scenegraph apps')
     .help('help', 'View help information about this tool.')
@@ -15,11 +42,11 @@ let options = yargs
     .option('log-level', { type: 'string', defaultDescription: '"log"', description: 'The log level. Value can be "error", "warn", "log", "info", "debug".' })
     .check((argv) => {
     var _a;
-    if (!argv.host) {
-        return new Error('You must provide a host. (--host)');
+    if (!argv.host && !process.env.ROKU_HOST) {
+        return new Error('You must provide a host. (--host, or ROKU_HOST in .env)');
     }
-    if (!argv.password) {
-        return new Error('You must provide a password. (--password)');
+    if (!argv.password && !process.env.ROKU_PASSWORD) {
+        return new Error('You must provide a password. (--password, or ROKU_PASSWORD in .env)');
     }
     if (!argv.project) {
         console.log('No project file specified. Using "./bsconfig.json"');
@@ -32,22 +59,23 @@ let options = yargs
 })
     .argv;
 async function main() {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     let currentErrorCode = 0;
     let bsconfigPath = (_a = options.project) !== null && _a !== void 0 ? _a : 'bsconfig.json';
     console.log(`Using bsconfig: ${bsconfigPath}`);
     const rawConfig = brighterscript_1.util.loadConfigFile(bsconfigPath);
     const bsConfig = brighterscript_1.util.normalizeConfig(rawConfig);
-    const host = (_b = options.host) !== null && _b !== void 0 ? _b : bsConfig.host;
-    const password = (_c = options.password) !== null && _c !== void 0 ? _c : bsConfig.password;
-    const logLevel = (_d = brighterscript_1.LogLevel[options['log-level']]) !== null && _d !== void 0 ? _d : bsConfig.logLevel;
+    const host = (_c = (_b = options.host) !== null && _b !== void 0 ? _b : bsConfig.host) !== null && _c !== void 0 ? _c : process.env.ROKU_HOST;
+    const password = (_e = (_d = options.password) !== null && _d !== void 0 ? _d : bsConfig.password) !== null && _e !== void 0 ? _e : process.env.ROKU_PASSWORD;
+    const logLevel = (_f = brighterscript_1.LogLevel[options['log-level']]) !== null && _f !== void 0 ? _f : bsConfig.logLevel;
     const builder = new brighterscript_1.ProgramBuilder();
     builder.logger.logLevel = logLevel;
     await builder.run(Object.assign(Object.assign({}, options), { retainStagingDir: true, createPackage: true }));
+    const device = { host: host };
     const rokuDeploy = new roku_deploy_1.RokuDeploy();
-    const deviceInfo = await rokuDeploy.getDeviceInfo({ host: host });
-    const rendezvousTracker = new roku_debug_1.RendezvousTracker({ softwareVersion: deviceInfo['software-version'] }, { host: host, remotePort: 8085 });
-    const telnet = new roku_debug_1.TelnetAdapter({ host: options.host }, rendezvousTracker);
+    const deviceInfo = await rokuDeploy.getDeviceInfo({ device: device });
+    const rendezvousTracker = new roku_debug_1.RendezvousTracker({ softwareVersion: deviceInfo['software-version'] }, { device: device, remotePort: 8085 });
+    const telnet = new roku_debug_1.TelnetAdapter({ device: device }, rendezvousTracker);
     telnet.logger.logLevel = logLevel;
     await telnet.activate();
     await telnet.connect();
@@ -57,7 +85,7 @@ async function main() {
         if (emitAppExit) {
             telnet.beginAppExit();
         }
-        await rokuDeploy.pressHomeButton(host); // roku-deploy v4: keyPress({ host: options.host, key: 'home' });
+        await rokuDeploy.keyPress({ device: device, key: 'Home' });
         process.exit(currentErrorCode);
     }
     telnet.on('console-output', (output) => {
@@ -96,11 +124,10 @@ async function main() {
     async function deployBuiltFiles() {
         const outFile = bsConfig.outFile;
         console.log(`Deploying ${outFile} to ${host}`);
-        await rokuDeploy.publish({
+        await rokuDeploy.sideload({
             password: password,
-            host: host,
-            outFile: outFile,
-            outDir: process.cwd()
+            device: device,
+            zip: path.resolve(process.cwd(), outFile)
         });
     }
     await deployBuiltFiles();

package/dist/lib/framework/source/roku_modules/rooibos_promises/promises.brs

@@ -685,7 +685,7 @@ sub rooibos_promises_internal_delay(callback as Function, context as dynamic, du
 end sub
 
 ' Observes a node field using observeFieldScoped
-' @param {roSGNode} node - The node to apply the observer
+' @param {rooibos.promises.roSGNode} node - The node to apply the observer
 ' @param {String} field - The name of the field to be monitored.
 ' @param {Dynamic} callback - The name or message port to be executed when the value of the field changes.
 ' @return true if field could be observed, false if not
@@ -704,7 +704,7 @@ function rooibos_promises_internal_observeFieldScoped(node as object, field as s
 end function
 
 ' Unobserve a node field using unobserveFieldScoped
-' @param {roSGNode} node - The node to remove the observer from
+' @param {rooibos.promises.roSGNode} node - The node to remove the observer from
 ' @param {String} field - The name of the field to no longer be monitored.
 ' @return true if field could be unobserved, false if not
 function rooibos_promises_internal_unobserveFieldScoped(node as object, field as string)

package/dist/lib/framework/source/roku_modules/rooibos_promises/promises.d.bs

@@ -1,49 +1,49 @@
+namespace rooibos.promises
 ' @rokucommunity/promises v0.5.0
     ' Create a new promise
-    namespace rooibos.promises
-function create() as dynamic
+    function create() as dynamic
     end function
 end namespace
-    ' TODO rename this to `then` once BrighterScript supports using keywords as namespaced function names
     namespace rooibos.promises
-function onThen(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
+' TODO rename this to `then` once BrighterScript supports using keywords as namespaced function names
+    function onThen(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
     end function
 end namespace
-    ' TODO rename this to `catch` once BrighterScript supports using keywords as namespaced function names
     namespace rooibos.promises
-function onCatch(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
+' TODO rename this to `catch` once BrighterScript supports using keywords as namespaced function names
+    function onCatch(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
     end function
 end namespace
-    ' TODO rename this to `finally` once BrighterScript supports using keywords as namespaced function names
     namespace rooibos.promises
-function onFinally(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
+' TODO rename this to `finally` once BrighterScript supports using keywords as namespaced function names
+    function onFinally(promise as dynamic, callback as function, context = "__INVALID__" as object) as dynamic
     end function
 end namespace
-    ' Takes an array of promises as input and returns a single Promise.
+    namespace rooibos.promises
+' Takes an array of promises as input and returns a single Promise.
     ' This returned promise fulfills when all of the input's promises fulfill (including when an empty array is passed), with an array of the fulfillment values.
     ' It rejects when any of the input's promises rejects, with this first rejection reason.
-    namespace rooibos.promises
-function all(promiseArray as dynamic) as dynamic
+    function all(promiseArray as dynamic) as dynamic
     end function
 end namespace
-    ' Takes an array of promises as input and returns a single Promise.
+    namespace rooibos.promises
+' Takes an array of promises as input and returns a single Promise.
     ' This returned promise fulfills when all of the input's promises settle (including when an empty array is passed),
     ' with an array of objects that describe the outcome of each promise.
-    namespace rooibos.promises
-function allSettled(promiseArray as dynamic) as dynamic
+    function allSettled(promiseArray as dynamic) as dynamic
     end function
 end namespace
-    ' Takes an array of promises as input and returns a single Promise.
+    namespace rooibos.promises
+' Takes an array of promises as input and returns a single Promise.
     ' This returned promise fulfills when any of the input's promises fulfills, with this first fulfillment value.
     ' It rejects when all of the input's promises reject (including when an empty array is passed), with an AggregateError containing an array of rejection reasons.
-    namespace rooibos.promises
-function any(promiseArray as dynamic) as dynamic
+    function any(promiseArray as dynamic) as dynamic
     end function
 end namespace
-    ' Takes an array of promises as input and returns a single Promise.
-    ' This returned promise settles with the eventual state of the first promise that settles.
     namespace rooibos.promises
-function race(promiseArray as dynamic) as dynamic
+' Takes an array of promises as input and returns a single Promise.
+    ' This returned promise settles with the eventual state of the first promise that settles.
+    function race(promiseArray as dynamic) as dynamic
     end function
 end namespace
     namespace rooibos.promises
@@ -58,29 +58,29 @@ end namespace
 function isComplete(promise as object) as boolean
     end function
 end namespace
-    ' Determines if the given item is a promise.
+    namespace rooibos.promises
+' Determines if the given item is a promise.
     '
     ' Will return true if at least one of the following conditions are true:
     ' - the SubType exactly equals "Promise"
     ' - the subtype ends with "_promise" case insensitive
     ' - the node has a field called "promiseState"
-    namespace rooibos.promises
-function isPromise(promise as dynamic) as boolean
+    function isPromise(promise as dynamic) as boolean
     end function
 end namespace
-    ' Remove all promise storage from the current m
     namespace rooibos.promises
-sub clean()
+' Remove all promise storage from the current m
+    sub clean()
     end sub
 end namespace
-    'Allows chaining multiple promise operations in a row in a clean syntax
     namespace rooibos.promises
-function chain(initialPromise as object, context = "__INVALID__" as object) as object
+'Allows chaining multiple promise operations in a row in a clean syntax
+    function chain(initialPromise as object, context = "__INVALID__" as object) as object
     end function
 end namespace
-    ' Makes sure the value supplied is a promise
     namespace rooibos.promises
-function ensurePromise(value as object) as object
+' Makes sure the value supplied is a promise
+    function ensurePromise(value as object) as object
     end function
 end namespace
     namespace rooibos.promises
@@ -151,14 +151,14 @@ namespace rooibos.promises.internal
     sub delay(callback as function, context as dynamic, duration = 0.0001 as float)
     end sub
     ' Observes a node field using observeFieldScoped
-    ' @param {roSGNode} node - The node to apply the observer
+    ' @parrooibos.promises.internal.roSGNodeNode} node - The node to apply the observer
     ' @param {String} field - The name of the field to be monitored.
     ' @param {Dynamic} callback - The name or message port to be executed when the value of the field changes.
     ' @return true if field could be observed, false if not
     function observeFieldScoped(node as object, field as string, callback as dynamic, infoFields = [] as object)
     end function
     ' Unobserve a node field using unobserveFieldScoped
-    ' @param {roSGNode} node - The node to remove the observer from
+    ' @parrooibos.promises.internal.roSGNodeNode} node - The node to remove the observer from
     ' @param {String} field - The name of the field to no longer be monitored.
     ' @return true if field could be unobserved, false if not
     function unobserveFieldScoped(node as object, field as string)

package/dist/lib/framework/source/rooibos/ConsoleTestReporter.bs

@@ -72,12 +72,12 @@ namespace rooibos
             m.printLine(0, "  Passed: " + rooibos.common.AsString(m.allStats.passedCount))
             m.printLine(0, "  Crashed: " + rooibos.common.AsString(m.allStats.crashedCount))
             m.printLine(0, "  Failed: " + rooibos.common.AsString(m.allStats.failedCount))
-            m.printLine(0, "  Ignored: " + rooibos.common.AsString(ignoredInfo.count))
+            m.printLine(0, "  Ignored: " + rooibos.common.AsString(m.allStats.ignoredCount))
             m.printLine(0, "  Time: " + rooibos.common.AsString(m.allStats.time) + "ms")
             m.printLine()
             m.printLine()
 
-            if ignoredInfo.count > 0 then
+            if m.allStats.ignoredCount > 0 then
                 m.printLine(0, "IGNORED TESTS:")
                 for each ignoredItemName in ignoredInfo.items
                     m.printLine(1, ignoredItemName)

package/dist/lib/framework/source/rooibos/Rooibos.bs

@@ -40,7 +40,7 @@ namespace rooibos
                 ' leading to an instant exit of the application
 
                 ' Give the io port time to finish sending all the logs
-                sleep(400)
+                sleep(runner.config.shutdownDelay)
                 end
             end if
         end if

package/dist/lib/rooibos/Annotation.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAnnotationType = exports.RooibosAnnotation = exports.AnnotationParams = exports.AnnotationType = void 0;
 const Diagnostics_1 = require("../utils/Diagnostics");
+const Utils_1 = require("./Utils");
 var AnnotationType;
 (function (AnnotationType) {
     AnnotationType["None"] = "none";
@@ -46,9 +47,12 @@ let annotationLookup = {
 };
 const defaultSlowDuration = 75;
 class AnnotationParams {
-    constructor(annotation, text, lineNumber, params, isIgnore = false, isSolo = false, noCatch = false, noEarlyexit = false) {
+    constructor(annotation, lineNumber, 
+    /**
+     * The argument expressions of the annotation. These are cloned into the generated test suite data so they get transpiled like any other code
+     */
+    params, isIgnore = false, isSolo = false, noCatch = false, noEarlyexit = false) {
         this.annotation = annotation;
-        this.text = text;
         this.lineNumber = lineNumber;
         this.params = params;
         this.isIgnore = isIgnore;
@@ -167,6 +171,7 @@ class RooibosAnnotation {
                     asyncTimeout = -1;
                 }
                 for (const annotation of getAnnotationsOfType(AnnotationType.Params, AnnotationType.SoloParams, AnnotationType.IgnoreParams)) {
+                    (0, Utils_1.linkAnnotationToStatement)(annotation, statement);
                     if (testAnnotation) {
                         testAnnotation.parseParams(file, annotation, getAnnotationType(annotation.name), noCatch);
                     }
@@ -194,23 +199,13 @@ class RooibosAnnotation {
         return { blockAnnotation: blockAnnotation, testAnnotation: testAnnotation };
     }
     parseParams(file, annotation, annotationType, noCatch) {
-        let rawParams = JSON.stringify(annotation.getArguments());
+        var _a, _b;
         let isSolo = annotationType === AnnotationType.SoloParams;
         let isIgnore = annotationType === AnnotationType.IgnoreParams;
         if (isSolo) {
             this.hasSoloParams = true;
         }
-        try {
-            if (rawParams) {
-                this.params.push(new AnnotationParams(annotation, rawParams, annotation.range.start.line, annotation.getArguments(), isIgnore, isSolo, noCatch));
-            }
-            else {
-                (0, Diagnostics_1.diagnosticIllegalParams)(file, annotation);
-            }
-        }
-        catch (e) {
-            (0, Diagnostics_1.diagnosticIllegalParams)(file, annotation);
-        }
+        this.params.push(new AnnotationParams(annotation, annotation.range.start.line, (_b = (_a = annotation.call) === null || _a === void 0 ? void 0 : _a.args) !== null && _b !== void 0 ? _b : [], isIgnore, isSolo, noCatch));
     }
 }
 exports.RooibosAnnotation = RooibosAnnotation;

package/dist/lib/rooibos/CodeCoverageProcessor.js

@@ -121,7 +121,11 @@ class CodeCoverageProcessor {
             },
             ExpressionStatement: (ds, parent, owner, key) => {
                 this.addStatement(ds);
-                this.convertStatementToCoverageStatement(ds, CodeCoverageLineType.code, owner, key);
+                //bsc's class transpiler assumes a `super()` call sits at index 0 of the constructor body, and
+                //injects field initializers immediately after it. Inserting our coverage statement *before*
+                //`super()` would shift it off index 0, causing field initializers to be emitted before the
+                //`super()` call. So for `super()` we insert coverage *after* the call instead.
+                this.convertStatementToCoverageStatement(ds, CodeCoverageLineType.code, owner, key, this.isSuperCall(ds));
             }
         }), { walkMode: brighterscript_1.WalkMode.visitAllRecursive });
         const coverageMapObject = {};
@@ -132,14 +136,27 @@ class CodeCoverageProcessor {
         this.filePathMap[this.fileId] = file.pkgPath;
         this.addBrsAPIText(file, astEditor);
     }
-    convertStatementToCoverageStatement(statement, coverageType, owner, key) {
+    /**
+     * Is this statement a call to `super()`? (i.e. the parent-constructor call in a derived class constructor)
+     */
+    isSuperCall(statement) {
+        var _a, _b, _c;
+        return (0, brighterscript_1.isExpressionStatement)(statement) &&
+            (0, brighterscript_1.isCallExpression)(statement.expression) &&
+            ((_c = (_b = (_a = brighterscript_1.util.findBeginningVariableExpression(statement.expression.callee)) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.text) === null || _c === void 0 ? void 0 : _c.toLowerCase()) === 'super';
+    }
+    /**
+     * Insert a coverage-tracking statement adjacent to the given statement.
+     * When `insertAfter` is true, the coverage statement is inserted *after* the given statement rather than before it.
+     */
+    convertStatementToCoverageStatement(statement, coverageType, owner, key, insertAfter = false) {
         if (this.processedStatements.has(statement) || this.addedStatements.has(statement)) {
             return;
         }
         const lineNumber = statement.range.start.line;
         this.coverageMap.set(lineNumber, coverageType);
         const parsed = brighterscript_1.Parser.parse(this.getFuncCallText(lineNumber, coverageType)).ast.statements[0];
-        this.astEditor.arraySplice(owner, key, 0, parsed);
+        this.astEditor.arraySplice(owner, insertAfter ? key + 1 : key, 0, parsed);
         this.addedStatements.add(parsed);
         // store the statement in a set to avoid handling again after inserting statement above
         this.processedStatements.add(statement);

package/dist/lib/rooibos/MockUtil.js

@@ -101,15 +101,35 @@ class MockUtil {
     }
     gatherGlobalMethodMocks(testSuite) {
         // console.log('gathering global method mocks for testSuite', testSuite.name);
+        const processedFuncs = new Set();
         for (let group of [...testSuite.testGroups.values()].filter((tg) => tg.isIncluded)) {
+            for (const hookName of [group.setupFunctionName, group.tearDownFunctionName, group.beforeEachFunctionName, group.afterEachFunctionName]) {
+                if (hookName) {
+                    const key = hookName.toLowerCase();
+                    if (!processedFuncs.has(key)) {
+                        this.gatherMockedFunctionByName(testSuite, hookName);
+                        processedFuncs.add(key);
+                    }
+                }
+            }
             for (let testCase of [...group.testCases].filter((tc) => tc.isIncluded)) {
-                this.gatherMockedGlobalMethods(testSuite, testCase);
+                const key = testCase.funcName.toLowerCase();
+                if (!processedFuncs.has(key)) {
+                    this.gatherMockedGlobalMethods(testSuite, testCase);
+                    processedFuncs.add(key);
+                }
             }
         }
     }
     gatherMockedGlobalMethods(testSuite, testCase) {
+        this.gatherMockedFunctionByName(testSuite, testCase.funcName);
+    }
+    gatherMockedFunctionByName(testSuite, funcName) {
         try {
-            let func = testSuite.classStatement.methods.find((m) => m.name.text.toLowerCase() === testCase.funcName.toLowerCase());
+            let func = testSuite.classStatement.methods.find((m) => m.name.text.toLowerCase() === funcName.toLowerCase());
+            if (!func) {
+                return;
+            }
             func.walk((0, brighterscript_1.createVisitor)({
                 ExpressionStatement: (expressionStatement, parent, owner) => {
                     let callExpression = expressionStatement.expression;

package/dist/lib/rooibos/RooibosSession.js

@@ -112,7 +112,7 @@ class RooibosSession {
         }
     }
     updateRunTimeConfigFunction(classStatement, editor) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         let method = classStatement.methods.find((m) => m.name.text === 'getRuntimeConfig');
         if (method) {
             editor.addToArray(method.func.body.statements, method.func.body.statements.length, brighterscript_1.Parser.parse((0, undent_1.default) `
@@ -130,6 +130,7 @@ class RooibosSession {
                         "colorizeOutput": ${this.config.colorizeOutput ? 'true' : 'false'}
                         "throwOnFailedAssertion": ${this.config.throwOnFailedAssertion ? 'true' : 'false'}
                         "keepAppOpen": ${this.config.keepAppOpen === undefined || this.config.keepAppOpen ? 'true' : 'false'}
+                        "shutdownDelay": ${(_d = this.config.shutdownDelay) !== null && _d !== void 0 ? _d : 400}
                         "isRecordingCodeCoverage": ${this.config.isRecordingCodeCoverage ? 'true' : 'false'}
                     }
                 `).ast.statements[0]);

package/dist/lib/rooibos/TestCase.js

@@ -21,7 +21,6 @@ class TestCase {
         this.isParamTest = this.expectedNumberOfParams > 0;
     }
     asText() {
-        let rawParamsText = this.fixBadJson(this.rawParams).replace(/null/g, 'invalid');
         return `
         {
           isSolo: ${this.isSolo}
@@ -36,28 +35,12 @@ class TestCase {
           lineNumber: ${this.lineNumber + 1}
           paramLineNumber: ${this.isParamTest ? this.paramLineNumber + 1 : 0}
           assertIndex: ${this.assertIndex}
-          rawParams: ${rawParamsText}
+          rawParams: ${this.rawParams ? '[]' /* filled with the actual param expressions by `addParamsToTestSuiteData` */ : 'invalid'}
           paramTestIndex: ${this.paramTestIndex}
           expectedNumberOfParams: ${this.expectedNumberOfParams}
           isParamsValid: ${(this.rawParams || []).length === this.expectedNumberOfParams}
         }`;
     }
-    fixBadJson(o) {
-        // In case of an array we'll stringify all objects.
-        if (Array.isArray(o)) {
-            return `[${o.map(obj => `${this.fixBadJson(obj)}`).join(',')}]`;
-        }
-        // not an object, stringify using native function
-        if (typeof o !== 'object' || o === null) {
-            return JSON.stringify(o);
-        }
-        return `{${Object
-            .keys(o)
-            .map(key => {
-            return `"${key.replace(/"/g, '')}":${this.fixBadJson(o[key])}`;
-        })
-            .join(',')}}`;
-    }
 }
 exports.TestCase = TestCase;
 //# sourceMappingURL=TestCase.js.map

package/dist/lib/rooibos/TestGroup.js

@@ -23,15 +23,28 @@ class TestGroup extends TestSuite_1.TestBlock {
         this.hasAsyncTests || (this.hasAsyncTests = testCase.isAsync);
     }
     modifyAssertions(testCase, noEarlyExit, editor, namespaceLookup, scope) {
+        let func = this.testSuite.classStatement.methods.find((m) => m.name.text.toLowerCase() === testCase.funcName.toLowerCase());
+        this.modifyAssertionsInFunction(func, noEarlyExit, editor, namespaceLookup, scope);
+    }
+    modifyAssertionsForHook(hookFuncName, noEarlyExit, editor, namespaceLookup, scope) {
+        if (!hookFuncName) {
+            return;
+        }
+        let func = this.testSuite.classStatement.methods.find((m) => m.name.text.toLowerCase() === hookFuncName.toLowerCase());
+        if (!func) {
+            return;
+        }
+        this.modifyAssertionsInFunction(func, noEarlyExit, editor, namespaceLookup, scope);
+    }
+    modifyAssertionsInFunction(func, noEarlyExit, editor, namespaceLookup, scope) {
         //for each method
         //if assertion
         //wrap with if is not fail
         //add line number as last param
         try {
-            let func = this.testSuite.classStatement.methods.find((m) => m.name.text.toLowerCase() === testCase.funcName.toLowerCase());
             func.walk((0, brighterscript_1.createVisitor)({
                 ExpressionStatement: (expressionStatement, parent, owner, key) => {
-                    var _a, _b;
+                    var _a, _b, _c;
                     let callExpression = expressionStatement.expression;
                     if ((0, brighterscript_1.isCallExpression)(callExpression) && (0, brighterscript_1.isDottedGetExpression)(callExpression.callee)) {
                         let dge = callExpression.callee;
@@ -44,6 +57,14 @@ class TestGroup extends TestSuite_1.TestBlock {
                             // `someMagicVar`.assert*(...)
                             const callPath = (_b = brighterscript_1.util.getAllDottedGetParts(callExpression.callee.obj)) === null || _b === void 0 ? void 0 : _b.map((part) => part.text).join('.');
                             if (callPath) {
+                                // Skip if callPath starts with a namespace name — this is a namespace
+                                // function call (e.g. some.space.assertEqual()), not a method call on
+                                // an object like m. Injecting assertion tracking on a namespace prefix
+                                // produces invalid output (e.g. some_space.currentAssertLineNumber).
+                                const callPathFirstPart = callPath.split('.')[0].toLowerCase();
+                                if (namespaceLookup.has(callPathFirstPart) || ((_c = scope === null || scope === void 0 ? void 0 : scope.namespaceLookup) === null || _c === void 0 ? void 0 : _c.has(callPathFirstPart))) {
+                                    return;
+                                }
                                 if (dge.name.text === 'stubCall') {
                                     this.modifyModernRooibosExpectCallExpression(callExpression, editor, namespaceLookup, scope);
                                     return expressionStatement;

package/dist/lib/rooibos/TestSuite.js

@@ -78,7 +78,17 @@ class TestSuite extends TestBlock {
     }
     addDataFunctions(editor) {
         if (this.isIncluded) {
-            (0, Utils_1.addOverriddenMethod)(this.file, this.annotation.annotation, this.classStatement, 'getTestSuiteData', `return ${this.asText()}`, editor);
+            const method = (0, Utils_1.addOverriddenMethod)(this.file, this.annotation.annotation, this.classStatement, 'getTestSuiteData', `return ${this.asText()}`, editor);
+            if (method) {
+                //same order as the `rawParams` placeholders in `asText()`
+                const paramExpressionsList = [];
+                for (const testGroup of [...this.testGroups.values()].filter((tg) => tg.isIncluded)) {
+                    for (const testCase of [...testGroup.testCases].filter((tc) => tc.isIncluded && tc.rawParams)) {
+                        paramExpressionsList.push(testCase.rawParams);
+                    }
+                }
+                (0, Utils_1.addParamsToTestSuiteData)(this.file, method, paramExpressionsList, editor);
+            }
         }
     }
     getTestGroups() {

package/dist/lib/rooibos/Utils.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScopeForSuite = exports.getPathValuePartAsString = exports.getStringPathFromDottedGet = exports.getRootObjectFromDottedGet = exports.getAllDottedGetParts = exports.functionRequiresReturnValue = exports.sanitizeBsJsonString = exports.addOverriddenMethod = void 0;
+exports.getScopeForSuite = exports.addParamsToTestSuiteData = exports.linkAnnotationToStatement = exports.getPathValuePartAsString = exports.getStringPathFromDottedGet = exports.getRootObjectFromDottedGet = exports.getAllDottedGetParts = exports.functionRequiresReturnValue = exports.sanitizeBsJsonString = exports.addOverriddenMethod = void 0;
 const brighterscript_1 = require("brighterscript");
 const Diagnostics_1 = require("../utils/Diagnostics");
+/**
+ * Add a generated method to the class.
+ * @returns the added method, or undefined if the source could not be parsed
+ */
 function addOverriddenMethod(file, annotation, target, name, source, editor) {
     var _a, _b;
     let { method, diagnostics, text } = createMethod(file, name, source);
@@ -11,11 +15,12 @@ function addOverriddenMethod(file, annotation, target, name, source, editor) {
         //trigger that functionality BEFORE performing AstEditor operations. TODO remove this whenever bsc stops doing this.
         (_b = (_a = target).ensureConstructorFunctionExists) === null || _b === void 0 ? void 0 : _b.call(_a);
         editor.addToArray(target.body, target.body.length, method);
-        return true;
+        method.parent = target;
+        return method;
     }
     const error = (diagnostics === null || diagnostics === void 0 ? void 0 : diagnostics.length) > 0 ? diagnostics[0].message : 'unknown error';
     (0, Diagnostics_1.diagnosticCorruptTestProduced)(file, annotation, error, text);
-    return false;
+    return undefined;
 }
 exports.addOverriddenMethod = addOverriddenMethod;
 /**
@@ -130,6 +135,73 @@ function getPathValuePartAsString(expr) {
     }
 }
 exports.getPathValuePartAsString = getPathValuePartAsString;
+/**
+ * bsc does not link annotations into the AST, so the expressions in their arguments have no parent (and therefore no symbol table or namespace).
+ * That makes the bsc validator flag references like `@params(SomeEnum.value)` as unknown names. Link the annotation (and its arguments) to
+ * the statement it decorates so those references are validated and resolved like any other expression in that statement's scope.
+ */
+function linkAnnotationToStatement(annotation, statement) {
+    if (!(annotation === null || annotation === void 0 ? void 0 : annotation.call)) {
+        return;
+    }
+    (0, brighterscript_1.walkArray)(annotation.call.args, () => { }, { walkMode: brighterscript_1.WalkMode.visitAllRecursive }, annotation.call);
+    annotation.call.parent = annotation;
+    annotation.parent = statement;
+}
+exports.linkAnnotationToStatement = linkAnnotationToStatement;
+/**
+ * Fill the `rawParams: []` placeholders in a generated `getTestSuiteData` method with clones of each test case's actual `@params` argument expressions.
+ * The clones are registered in the file's references, so bsc's own pre-transpile processing (i.e. inlining enums and constants) applies to them
+ * exactly like it does for handwritten code. This must run before bsc's `beforeFileTranspile` (i.e. during `beforeProgramTranspile`).
+ * @param file the file containing the test suite
+ * @param method the generated `getTestSuiteData` method
+ * @param paramExpressionsList the `@params` argument expressions for each placeholder, in the order they appear in the method
+ * @param editor the editor used to make (and later undo) the changes
+ */
+function addParamsToTestSuiteData(file, method, paramExpressionsList, editor) {
+    const placeholders = [];
+    method.walk((node) => {
+        if ((0, brighterscript_1.isAAMemberExpression)(node) && node.keyToken.text === 'rawParams' && (0, brighterscript_1.isArrayLiteralExpression)(node.value)) {
+            placeholders.push(node.value);
+        }
+    }, { walkMode: brighterscript_1.WalkMode.visitExpressionsRecursive });
+    const references = new Set();
+    const addReferences = (expression) => {
+        references.add(expression);
+        if ((0, brighterscript_1.isArrayLiteralExpression)(expression)) {
+            for (const element of expression.elements) {
+                if (!(0, brighterscript_1.isCommentStatement)(element)) {
+                    addReferences(element);
+                }
+            }
+        }
+        else if ((0, brighterscript_1.isAALiteralExpression)(expression)) {
+            for (const member of expression.elements) {
+                if ((0, brighterscript_1.isAAMemberExpression)(member)) {
+                    addReferences(member.value);
+                }
+            }
+        }
+    };
+    for (let i = 0; i < placeholders.length && i < paramExpressionsList.length; i++) {
+        const clones = paramExpressionsList[i].map(x => x.clone());
+        editor.arrayPush(placeholders[i].elements, ...clones);
+        //link the clones into the AST
+        (0, brighterscript_1.walkArray)(placeholders[i].elements, () => { }, { walkMode: brighterscript_1.WalkMode.visitAllRecursive }, placeholders[i]);
+        clones.forEach(addReferences);
+    }
+    const fileReferences = file.parser.references.expressions;
+    editor.edit(() => {
+        for (const expression of references) {
+            fileReferences.add(expression);
+        }
+    }, () => {
+        for (const expression of references) {
+            fileReferences.delete(expression);
+        }
+    });
+}
+exports.addParamsToTestSuiteData = addParamsToTestSuiteData;
 function getScopeForSuite(testSuite) {
     if (testSuite.isNodeTest) {
         return testSuite.file.program.getScopesForFile(testSuite.file).find((scope) => {

package/dist/plugin.js

@@ -130,22 +130,35 @@ class RooibosPlugin {
     }
     beforeProgramTranspile(program, entries, editor) {
         this.session.prepareForTranspile(editor, program, this.mockUtil);
+        //this must happen before bsc's `beforeFileTranspile` (which runs before ours), so bsc will inline any enums/constants used in the `@params`
+        for (const testSuite of this.session.sessionInfo.testSuitesToRun) {
+            testSuite.addDataFunctions(editor);
+        }
     }
     afterProgramTranspile(program, entries, editor) {
         this.session.addLaunchHookFileIfNotPresent();
         this.codeCoverageProcessor.generateMetadata(this.config.isRecordingCodeCoverage, program);
     }
     beforeFileTranspile(event) {
-        let testSuite = this.session.sessionInfo.testSuitesToRun.find((ts) => ts.file.pkgPath === event.file.pkgPath);
-        if (testSuite) {
+        const testSuites = this.session.sessionInfo.testSuitesToRun.filter((ts) => ts.file.pkgPath === event.file.pkgPath);
+        for (const testSuite of testSuites) {
             const scope = (0, Utils_1.getScopeForSuite)(testSuite);
             let noEarlyExit = testSuite.annotation.noEarlyExit;
             if (noEarlyExit) {
                 console.warn(`WARNING: testSuite "${testSuite.name}" is marked as noEarlyExit`);
             }
             const modifiedTestCases = new Set();
-            testSuite.addDataFunctions(event.editor);
+            const modifiedHookFunctions = new Set();
             for (let group of [...testSuite.testGroups.values()].filter((tg) => tg.isIncluded)) {
+                for (const hookName of [group.setupFunctionName, group.tearDownFunctionName, group.beforeEachFunctionName, group.afterEachFunctionName]) {
+                    if (hookName) {
+                        const hookKey = group.testSuite.generatedNodeName + group.file.pkgPath + hookName.toLowerCase();
+                        if (!modifiedHookFunctions.has(hookKey)) {
+                            group.modifyAssertionsForHook(hookName, noEarlyExit, event.editor, this.session.namespaceLookup, scope);
+                            modifiedHookFunctions.add(hookKey);
+                        }
+                    }
+                }
                 for (let testCase of [...group.testCases].filter((tc) => tc.isIncluded)) {
                     let caseName = group.testSuite.generatedNodeName + group.file.pkgPath + testCase.funcName;
                     if (!modifiedTestCases.has(caseName)) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rooibos-roku",
-    "version": "5.16.4",
+    "version": "5.16.6",
     "description": "simple, flexible, fun brightscript test framework for roku scenegraph apps - roku brighterscript plugin",
     "scripts": {
         "preversion": "npm run build && npm run lint && npm run test",
@@ -16,15 +16,16 @@
         "test:nocover": "mocha",
         "audit": "npm audit || audit-ci --config ./audit-ci.jsonc",
         "cli": "ts-node src/cli.ts",
+        "cli:device": "ts-node src/cli.ts --project test-project/bsconfig.device.json",
         "package": "npm run build && npm pack"
     },
     "dependencies": {
-        "brighterscript": "^0.72.5",
+        "brighterscript": "^0.73.5",
         "fast-glob": "^3.2.12",
         "fs-extra": "^10.1.0",
         "minimatch": "^3.0.4",
-        "roku-debug": "^0.23.11",
-        "roku-deploy": "^3.17.6",
+        "roku-debug": "^0.24.6",
+        "roku-deploy": "^4.0.0-alpha.9",
         "rooibos_promises": "npm:@rokucommunity/promises@^0.5.0",
         "source-map": "^0.7.3",
         "undent": "^1.0.1",
@@ -33,7 +34,7 @@
         "yargs": "^16.2.0"
     },
     "devDependencies": {
-        "@rokucommunity/bslint": "^0.8.43",
+        "@rokucommunity/bslint": "^0.8.46",
         "@types/chai": "^4.1.2",
         "@types/events": "^3.0.0",
         "@types/fs-extra": "^5.0.1",
@@ -55,13 +56,19 @@
         "jsdoc": "^4.0.5",
         "mocha": "^10.8.2",
         "nyc": "^15.1.0",
-        "ropm": "^0.11.8",
+        "ropm": "^0.11.11",
         "source-map-support": "^0.5.13",
         "ts-node": "^10.7.0",
         "typescript": "^4.7.2"
     },
     "overrides": {
-        "serialize-javascript": "^7.0.5"
+        "serialize-javascript": "^7",
+        "js-yaml@^3": "^3.15.2",
+        "js-yaml@^4": "^4",
+        "browserslist": "^4.28.8",
+        "istanbul-lib-processinfo": "^3.0.1",
+        "uuid": "^11.1.1",
+        "@babel/core": "^7.29.7"
     },
     "main": "dist/plugin.js",
     "bin": {
@@ -109,17 +116,6 @@
         "functions": 5,
         "branches": 5
     },
-    "mocha": {
-        "spec": "src/**/*.spec.ts",
-        "fullTrace": true,
-        "require": [
-            "source-map-support/register",
-            "ts-node/register"
-        ],
-        "watchExtensions": [
-            "ts"
-        ]
-    },
     "ropm": {
         "rootDir": "./framework/src"
     }