datagrok-tools 6.4.8 → 6.5.0

package/CHANGELOG.md

@@ -1,37 +1,41 @@
 # Datagrok-tools changelog
 
+## 6.5.0 (2026-07-22)
+
+* `grok test` ??? added a Node (browserless) pass: tests annotated `{node: true}` run headless under the js-api Node runtime before the browser launches; the browser pass excludes them and is skipped entirely when nothing browser-only matches. New flags: `--skip-node`, `--node-only`. Packages opt in by exporting `testNode()` from `package-test.ts`; others keep the previous behavior.
+
 ## 6.4.8 (2026-07-22)
 
-* GROK-20452: `grok publish` — always `docker build` the tools-generated worker dirs (`dockerfiles/queue`, `dockerfiles/celery`, `dockerfiles/<app>-celery`) instead of reusing a cached local tag. The "found local image" shortcut froze the worker at whatever stock base the daemon had when the tag was first built (CI ran day-old worker code with a fresh base available); the layer cache keeps an unchanged rebuild near-instant.
+* GROK-20452: `grok publish` ??? always `docker build` the tools-generated worker dirs (`dockerfiles/queue`, `dockerfiles/celery`, `dockerfiles/<app>-celery`) instead of reusing a cached local tag. The "found local image" shortcut froze the worker at whatever stock base the daemon had when the tag was first built (CI ran day-old worker code with a fresh base available); the layer cache keeps an unchanged rebuild near-instant.
+* `grok test` ??? `--no-retry` is now honored for Playwright runs. minimist parsed `--no-retry` as `{retry:false}`, so the flag was silently dropped and failed specs were still retried once; normalized so `--retries=0` reaches Playwright.
 
 ## 6.4.7 (2026-07-22)
 
-* GROK-20452: `grok publish` — generate `dockerfiles/celery` / `dockerfiles/queue` **before** gathering files for the zip. They were generated after, so the generated Dockerfile never reached the server: `meta.queue` functions fell back to a server-side container named `<pkg>-queue-celery` while the client had built `<pkg>-queue` — image validation 404'd and the worker container never started ("Container is not started" on every call).
+* GROK-20452: `grok publish` ??? generate `dockerfiles/celery` / `dockerfiles/queue` **before** gathering files for the zip. They were generated after, so the generated Dockerfile never reached the server: `meta.queue` functions fell back to a server-side container named `<pkg>-queue-celery` while the client had built `<pkg>-queue` ??? image validation 404'd and the worker container never started ("Container is not started" on every call).
 
 ## 6.4.6 (2026-07-22)
 
-* `grok test` — the whole-run Puppeteer cap (60 min) is now overridable via `GROK_TEST_INVOCATION_TIMEOUT_MS`. When the cap fires mid-pass all collected results are discarded (empty `test-report.csv`, "Passed tests: 0"), which CI reports as "no results produced"; loaded CI agents can now raise the cap instead.
-* `grok test` — `--no-retry` is now honored for Playwright runs. minimist parsed `--no-retry` as `{retry:false}`, so the flag was silently dropped and failed specs were still retried once; normalized so `--retries=0` reaches Playwright.
+* `grok test` ??? the whole-run Puppeteer cap (60 min) is now overridable via `GROK_TEST_INVOCATION_TIMEOUT_MS`. When the cap fires mid-pass all collected results are discarded (empty `test-report.csv`, "Passed tests: 0"), which CI reports as "no results produced"; loaded CI agents can now raise the cap instead.
 
 ## 6.4.5 (2026-06-23)
 
-* `grok test` — screen recording (`--record`) is now optional: if `page.screencast()` can't start (e.g. `ffmpeg` is missing on the runner, `spawnSync ffmpeg ENOENT`), the run warns and continues instead of failing the whole Puppeteer pass with 0 tests executed.
+* `grok test` ??? screen recording (`--record`) is now optional: if `page.screencast()` can't start (e.g. `ffmpeg` is missing on the runner, `spawnSync ffmpeg ENOENT`), the run warns and continues instead of failing the whole Puppeteer pass with 0 tests executed.
 
 ## 6.4.4 (2026-06-22)
 
-* `grok publish` — fixed every publish failing with a silent `exit 1` after a successful upload: a stray `fs.unlinkSync('zip')` threw `ENOENT` (the archive is streamed in-memory, no `zip` file is ever written), and the surrounding `catch` only logged under `--verbose`. The errant unlink is removed and publish errors are now always surfaced.
+* `grok publish` ??? fixed every publish failing with a silent `exit 1` after a successful upload: a stray `fs.unlinkSync('zip')` threw `ENOENT` (the archive is streamed in-memory, no `zip` file is ever written), and the surrounding `catch` only logged under `--verbose`. The errant unlink is removed and publish errors are now always surfaced.
 
 ## 6.4.3 (2026-06-22)
 
-* `grok api` — numeric IVP model inputs are now generated with `nullable: false`, so an emptied input field fails form validation instead of running the solver with a null.
+* `grok api` ??? numeric IVP model inputs are now generated with `nullable: false`, so an emptied input field fails form validation instead of running the solver with a null.
 
 ## 6.4.2 (2026-06-18)
 
-* `grok publish` — registry-aware Docker fallback: when a package's image isn't built locally and the target server has no compatible record, `grok publish` now checks the configured registry and Docker Hub (`docker manifest inspect`) for the expected `datagrok/<name>:<version>` (and content-hashed) tag and uses it, instead of reporting "No fallback available" and failing. Fixes dependency publishes (e.g. Bio → @datagrok/chem) on CI runners where the image exists in the registry but not locally.
+* `grok publish` ??? registry-aware Docker fallback: when a package's image isn't built locally and the target server has no compatible record, `grok publish` now checks the configured registry and Docker Hub (`docker manifest inspect`) for the expected `datagrok/<name>:<version>` (and content-hashed) tag and uses it, instead of reporting "No fallback available" and failing. Fixes dependency publishes (e.g. Bio ??? @datagrok/chem) on CI runners where the image exists in the registry but not locally.
 
 ## 6.4.1 (2026-06-18)
 
-* Fixed `grok` failing with `Cannot find module './commands/build'` — the `.npmignore` `build.js` rule was unanchored and excluded the compiled `bin/commands/build.js` from the published package; anchored it to `/build.js`.
+* Fixed `grok` failing with `Cannot find module './commands/build'` ??? the `.npmignore` `build.js` rule was unanchored and excluded the compiled `bin/commands/build.js` from the published package; anchored it to `/build.js`.
 * Pinned `ignore-walk` to ^6.0.5 so the package still supports Node 18 (9.x requires Node 22+).
 
 ## 6.4.0 (2026-06-18)
@@ -43,46 +47,46 @@
 
 ## 6.3.3 (2026-06-16)
 
-* Fixed Celery Docker image generation — the image wasn't built locally on publish.
+* Fixed Celery Docker image generation ??? the image wasn't built locally on publish.
 
 ## 6.3.2 (2026-06-15)
 
-* `func-gen` webpack plugin — generated RichFunctionView model inputs now use the script-form names (argument bounds/step `_t0`/`_t1`/`_h`, loop count `_count`) instead of the deprefixed forms, so the run, fitting, and sensitivity-analysis paths share one set of input names with diff-grok's pipeline. Fixes `Inconsistent inputs: "_t0" is missing` when starting fitting/SA from a Rich Function View.
-* `func-gen` webpack plugin — the generated RichFunctionView model output annotation appends the `DiffStudio Facet` viewer (last), alongside Grid and Line chart.
-* `grok stresstest` — run the ApiTests Node test runner directly via tsx (`src/package-test-node.ts`) instead of a compiled `dist-node` bundle; dropped the obsolete `npm run build-node` step and the `tsconfig-paths-bootstrap.js` / `dist-node` invocation.
+* `func-gen` webpack plugin ??? generated RichFunctionView model inputs now use the script-form names (argument bounds/step `_t0`/`_t1`/`_h`, loop count `_count`) instead of the deprefixed forms, so the run, fitting, and sensitivity-analysis paths share one set of input names with diff-grok's pipeline. Fixes `Inconsistent inputs: "_t0" is missing` when starting fitting/SA from a Rich Function View.
+* `func-gen` webpack plugin ??? the generated RichFunctionView model output annotation appends the `DiffStudio Facet` viewer (last), alongside Grid and Line chart.
+* `grok stresstest` ??? run the ApiTests Node test runner directly via tsx (`src/package-test-node.ts`) instead of a compiled `dist-node` bundle; dropped the obsolete `npm run build-node` step and the `tsconfig-paths-bootstrap.js` / `dist-node` invocation.
 
 ## 6.3.0 (2026-06-12)
 
-* `func-gen` webpack plugin — generates RichFunctionView model wrappers from Diff Studio `#meta.role: model` `.ivp` files. Inputs/output are derived from the parsed IVP, `#meta.icon` becomes the model icon, and `#meta.inputs` lookups are emitted as real `propagateChoice: all` inputs (rendered natively by the Rich Function View, unlike `meta.inputs`). Ships a prebuilt, tree-shaken CJS bundle of diff-grok's IVP parser (`plugins/ivp-parser.bundle.cjs`); regenerate with `npm run update:ivp-parser`.
+* `func-gen` webpack plugin ??? generates RichFunctionView model wrappers from Diff Studio `#meta.role: model` `.ivp` files. Inputs/output are derived from the parsed IVP, `#meta.icon` becomes the model icon, and `#meta.inputs` lookups are emitted as real `propagateChoice: all` inputs (rendered natively by the Rich Function View, unlike `meta.inputs`). Ships a prebuilt, tree-shaken CJS bundle of diff-grok's IVP parser (`plugins/ivp-parser.bundle.cjs`); regenerate with `npm run update:ivp-parser`.
 
 ## 6.2.6 (2026-05-26)
 
-* `grok s tables upload` — accepts `.d42` binary blobs in addition to `.csv`. Content-Type is auto-detected from the file extension (`application/octet-stream` for d42, `text/csv` otherwise); server content-negotiates and persists either form against the same `/public/v1/tables/{name}` endpoint.
+* `grok s tables upload` ??? accepts `.d42` binary blobs in addition to `.csv`. Content-Type is auto-detected from the file extension (`application/octet-stream` for d42, `text/csv` otherwise); server content-negotiates and persists either form against the same `/public/v1/tables/{name}` endpoint.
 
 ## 6.2.5 (2026-05-21)
 
-* `grok report read` — renamed `--extract-actions` to `--extract-client-log`; sidecar is now `<stem>_client_log.json`. The old flag is no longer accepted.
-* `grok report read` — legacy `actions` field in pre-consolidation report zips is folded into `clientLog` at read time (stderr warning emitted), so downstream consumers see one canonical field. Companion to the platform-side merge that drops `reports_data.actions` in favor of `client_log`.
+* `grok report read` ??? renamed `--extract-actions` to `--extract-client-log`; sidecar is now `<stem>_client_log.json`. The old flag is no longer accepted.
+* `grok report read` ??? legacy `actions` field in pre-consolidation report zips is folded into `clientLog` at read time (stderr warning emitted), so downstream consumers see one canonical field. Companion to the platform-side merge that drops `reports_data.actions` in favor of `client_log`.
 
 ## 6.2.4 (2026-05-13)
 
-* GROK-20097: package template — replaced deprecated `"moduleResolution": "node"` in `tsconfig.json` with `"bundler"`, suppressing the TypeScript warning for new packages.
+* GROK-20097: package template ??? replaced deprecated `"moduleResolution": "node"` in `tsconfig.json` with `"bundler"`, suppressing the TypeScript warning for new packages.
 
 ## 6.2.3 (2026-05-06)
 
-* `grok test` — added `--skip-puppeteer` flag (symmetric counterpart of `--skip-playwright`). Bypasses `loadPackages()` and the Puppeteer/`DG.Test` runner so Playwright-only test directories (e.g. `public/playwright-public`) can run end-to-end via `grok test --skip-puppeteer` without tripping the Dart/JS package loader.
+* `grok test` ??? added `--skip-puppeteer` flag (symmetric counterpart of `--skip-playwright`). Bypasses `loadPackages()` and the Puppeteer/`DG.Test` runner so Playwright-only test directories (e.g. `public/playwright-public`) can run end-to-end via `grok test --skip-puppeteer` without tripping the Dart/JS package loader.
 
 ## 6.2.2 (2026-05-05)
 
-* `grok test` — Playwright runner now writes `test-report-playwright.csv` next to the existing merged `test-report.csv`, so CI can ship Playwright rows to a dedicated Datlas reporting bucket without disturbing the legacy `package` flow.
+* `grok test` ??? Playwright runner now writes `test-report-playwright.csv` next to the existing merged `test-report.csv`, so CI can ship Playwright rows to a dedicated Datlas reporting bucket without disturbing the legacy `package` flow.
 
 ## 6.2.1 (2026-05-05)
 
-* Reports: `grok report attach <ticket> <file>` — upload a file as a JIRA issue attachment via REST v2 multipart POST.
+* Reports: `grok report attach <ticket> <file>` ??? upload a file as a JIRA issue attachment via REST v2 multipart POST.
 
 ## 6.2.0 (2026-05-04)
 
-* `grok test` — Playwright support: when a package's `package.json` declares `"playwrightTests": "<path>"`, `grok test` runs `npx playwright test` against that directory in addition to the existing Puppeteer pass and merges results into a single `test-report.csv`. Auth is unified with the Puppeteer pass (dev key from `~/.grok/config.yaml` → session token → cookie + `localStorage` injection — no login form). Optional `DATAGROK_DEV_KEY_2` env var enables a second-user identity for specs that need it (`DATAGROK_AUTH_TOKEN_2` exposed to specs). New `--skip-playwright` flag opts out of the Playwright pass for a single run.
+* `grok test` ??? Playwright support: when a package's `package.json` declares `"playwrightTests": "<path>"`, `grok test` runs `npx playwright test` against that directory in addition to the existing Puppeteer pass and merges results into a single `test-report.csv`. Auth is unified with the Puppeteer pass (dev key from `~/.grok/config.yaml` ??? session token ??? cookie + `localStorage` injection ??? no login form). Optional `DATAGROK_DEV_KEY_2` env var enables a second-user identity for specs that need it (`DATAGROK_AUTH_TOKEN_2` exposed to specs). New `--skip-playwright` flag opts out of the Playwright pass for a single run.
 
 ## 6.1.14 (2026-05-01)
 
@@ -94,17 +98,17 @@
 
 ## 6.1.11 (2026-04-27)
 
-* `grok report read <path | instance number>` — normalize a report zip/json into one JSON object on stdout (envelope unwrap, `_meta.json` merge, optional `--extract-screenshot` / `--extract-d42` / `--extract-actions`)
-* `grok report fetch` — single round-trip via the new `/reports/by-number/<number>/zip` endpoint, with fallback to the legacy search-then-download path on 404
+* `grok report read <path | instance number>` ??? normalize a report zip/json into one JSON object on stdout (envelope unwrap, `_meta.json` merge, optional `--extract-screenshot` / `--extract-d42` / `--extract-actions`)
+* `grok report fetch` ??? single round-trip via the new `/reports/by-number/<number>/zip` endpoint, with fallback to the legacy search-then-download path on 404
 
 ## 6.1.10 (2026-04-17)
 
-* `grok s connections save` — create/update a connection from a JSON file (`--save-credentials` optional)
-* `grok s connections test` — test connectivity by JSON body or by existing id/name
-* `grok s users save` — create/update a user from a JSON file
-* `grok s groups save` — create/update a group from a JSON file (`--save-relations` optional)
-* `grok s shares add` — share an entity with one or more groups (`--access View|Edit`)
-* `grok s shares list` — list who an entity is shared with
+* `grok s connections save` ??? create/update a connection from a JSON file (`--save-credentials` optional)
+* `grok s connections test` ??? test connectivity by JSON body or by existing id/name
+* `grok s users save` ??? create/update a user from a JSON file
+* `grok s groups save` ??? create/update a group from a JSON file (`--save-relations` optional)
+* `grok s shares add` ??? share an entity with one or more groups (`--access View|Edit`)
+* `grok s shares list` ??? list who an entity is shared with
 * Tools: Normalize package name to lowercase in grok create, preserve original as friendlyName
 
 ## 5.1.3 (2026-02-03)

package/README.md

@@ -135,6 +135,8 @@ For more information on configuring connections, refer to the [Connections](http
   | report         | Sends a report on test results                                                                                                        |
   | skip-build     | Skips package build step                                                                                                              |
   | skip-publish   | Skips package publish step                                                                                                            |
+  | skip-node      | Skips the Node (browserless) pass; runs all tests in the browser                                                                      |
+  | node-only      | Runs only tests annotated `{node: true}` headless under Node, without a browser                                                       |
   | verbose        | Prints detailed information about passed and skipped tests in the console                                                             |
   | platform       | Runs only platform tests (applicable for ApiTests package only)                                                                       |
   | core           | Runs package & core tests & autotests                                                                                                 |

package/bin/commands/help.js

@@ -207,6 +207,8 @@ Options:
 --skip-publish      Skip the package publication step
 --skip-puppeteer    Skip the Puppeteer/DG.Test pass; only run Playwright (for playwright-only test directories)
 --skip-playwright   Skip the Playwright pass; only run Puppeteer/DG.Test
+--skip-node         Skip the Node (browserless) pass; run all tests in the browser
+--node-only         Run only tests annotated {node: true} headless under Node, no browser
 --link  	        Link the package to local utils
 --record            Records the test execution process in mp4 format
 --platform          Runs only platform tests (applicable for ApiTests package only)

package/bin/commands/test.js

@@ -20,6 +20,7 @@ var Papa = _interopRequireWildcard(require("papaparse"));
 var _testUtils = _interopRequireWildcard(require("../utils/test-utils"));
 var testUtils = _testUtils;
 var playwrightRunner = _interopRequireWildcard(require("../utils/playwright-runner"));
+var _nodeTestRunner = require("../utils/node-test-runner");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /* eslint-disable max-len */
 
@@ -29,7 +30,7 @@ const execFileAsync = (0, _util.promisify)(_child_process.execFile);
 // are discarded (they live in the page until a pass completes). CI runners on
 // loaded agents can exceed the 1h default — override via env.
 const testInvocationTimeout = parseInt(process.env['GROK_TEST_INVOCATION_TIMEOUT_MS'] ?? '', 10) || 3600000;
-const availableCommandOptions = ['host', 'package', 'csv', 'gui', 'catchUnhandled', 'platform', 'core', 'report', 'skip-build', 'skip-publish', 'path', 'record', 'verbose', 'benchmark', 'category', 'test', 'stress-test', 'link', 'tag', 'ci-cd', 'debug', 'no-retry', 'dartium', 'f', 'params', 'logfailed', 'skip-playwright', 'skip-puppeteer'];
+const availableCommandOptions = ['host', 'package', 'csv', 'gui', 'catchUnhandled', 'platform', 'core', 'report', 'skip-build', 'skip-publish', 'path', 'record', 'verbose', 'benchmark', 'category', 'test', 'stress-test', 'link', 'tag', 'ci-cd', 'debug', 'no-retry', 'dartium', 'f', 'params', 'logfailed', 'skip-playwright', 'skip-puppeteer', 'skip-node', 'node-only'];
 const curDir = process.cwd();
 
 /** Expands camelCase to space-separated lowercase: "dataManipulation" → "data manipulation" */
@@ -228,12 +229,34 @@ async function test(args) {
     }
   }
   process.env.TARGET_PACKAGE = packageName;
+
+  // Node (browserless) pass: runs tests annotated {node: true} headless under the
+  // js-api Node runtime; the browser pass then excludes them. Skipped for --gui/--debug
+  // so every test stays visible in the browser there.
+  let nodeRes = undefined;
+  if (!args['skip-node'] && !args['skip-puppeteer'] && !args.gui && !args.debug && !args.package) {
+    nodeRes = await (0, _nodeTestRunner.runNodeTests)({
+      packageDir: curDir,
+      packageName: packageName,
+      host: args.host ?? '',
+      category: args.category,
+      test: args.test,
+      stressTest: args['stress-test'],
+      benchmark: args.benchmark,
+      verbose: args.verbose
+    });
+  }
+  if (args['node-only'] && nodeRes == null) {
+    color.error('--node-only: the Node test pass is not available for this package.');
+    process.exit(1);
+  }
   let res;
-  if (args['skip-puppeteer']) {
+  if (args['skip-puppeteer'] || args['node-only'] || nodeRes != null && nodeRes.browserTestsRemaining === 0) {
     // Playwright-only mode: skip the Puppeteer browser launch + DG.Test runner.
     // Used by Playwright-only test directories (e.g. public/playwright-public)
     // that have a `playwrightTests` field in package.json but no Dart/JS package
-    // tests on the server.
+    // tests on the server. Also taken when the Node pass covered every matched test.
+    if (nodeRes != null && nodeRes.browserTestsRemaining === 0 && !args['node-only'] && !args['skip-puppeteer']) color.info('All matched tests ran in the Node pass; skipping the browser run.');
     res = {
       failed: false,
       verbosePassed: '',
@@ -246,7 +269,7 @@ async function test(args) {
     };
   } else {
     try {
-      res = await runTesting(args);
+      res = await runTesting(args, nodeRes != null);
     } catch (e) {
       // Don't let Puppeteer-side failures (login error, browser crash) skip the
       // Playwright pass — the two suites have independent auth and runtime paths,
@@ -265,7 +288,25 @@ async function test(args) {
       };
     }
   }
-  if (!args['skip-playwright']) {
+  if (nodeRes != null) {
+    // Merge the Node pass into the browser result (same CSV columns/order).
+    if (!res.csv || res.csv.trim().split('\n').length < 2) {
+      res.csv = nodeRes.csv;
+      res.passedAmount += nodeRes.passedAmount;
+      res.failedAmount += nodeRes.failedAmount;
+      res.skippedAmount += nodeRes.skippedAmount;
+      res.failed = res.failed || nodeRes.failed;
+      res.verbosePassed = (res.verbosePassed || '') + nodeRes.verbosePassed;
+      res.verboseFailed = (res.verboseFailed || '') + nodeRes.verboseFailed;
+      res.verboseSkipped = (res.verboseSkipped || '') + nodeRes.verboseSkipped;
+      res.modernOutput = res.modernOutput || nodeRes.modernOutput;
+    } else if (nodeRes.csv && nodeRes.csv.trim().split('\n').length >= 2) {
+      res = await (0, _testUtils.mergeBrowsersResults)([res, nodeRes]);
+    } else {
+      res.failed = res.failed || nodeRes.failed;
+    }
+  }
+  if (!args['skip-playwright'] && !args['node-only']) {
     const ptDir = playwrightRunner.hasPlaywrightTests(curDir);
     if (ptDir) {
       const ptRes = await playwrightRunner.runPlaywrightTests(curDir, ptDir, args, args.host ?? '');
@@ -312,7 +353,7 @@ const retriedTests = new Set();
 let totalRetries = 0;
 const MAX_RETRIES_PER_SESSION = 10;
 let retryEnabled = true;
-async function runTesting(args) {
+async function runTesting(args, excludeNodeTests = false) {
   retryEnabled = args['retry'] ?? true;
   if (args.test || args.category) retryEnabled = false;
   let organized = {
@@ -320,6 +361,7 @@ async function runTesting(args) {
     params: {
       category: args.category ?? '',
       test: args.test ?? '',
+      excludeNodeTests: excludeNodeTests || undefined,
       options: {
         catchUnhandled: args.catchUnhandled,
         report: args.report
@@ -956,6 +998,8 @@ function buildTestArgs(args) {
   if (args['stress-test']) parts.push('--stress-test');
   if (args['ci-cd']) parts.push('--ci-cd');
   if (args['no-retry']) parts.push('--no-retry');
+  if (args['skip-node']) parts.push('--skip-node');
+  if (args['node-only']) parts.push('--node-only');
   return parts;
 }
 function parseTestOutput(stdout) {

package/bin/utils/node-test-runner.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runNodeTests = runNodeTests;
+var _child_process = require("child_process");
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _readline = _interopRequireDefault(require("readline"));
+var color = _interopRequireWildcard(require("./color-utils"));
+var _testUtils = require("./test-utils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/* eslint-disable max-len */
+/**
+ * CLI side of the `grok test` Node (browserless) pass: spawns node-test-worker.js
+ * with cwd = the package directory, streams its progress output through the shared
+ * TestProgressReporter, and returns a ResultObject-compatible report.
+ *
+ * Returns undefined when the package doesn't support the Node pass (no testNode export,
+ * no datagrok-api Node runtime, not published) or the worker fails — the caller then
+ * runs everything in the browser as before.
+ */
+
+const workerTimeout = 3600000;
+async function runNodeTests(opts) {
+  // Cheap opt-in gate: don't pay the worker spawn + runtime init for the vast
+  // majority of packages that don't export testNode() from package-test.ts.
+  try {
+    const testSrc = ['ts', 'js'].map(ext => _path.default.join(opts.packageDir, 'src', `package-test.${ext}`)).find(p => _fs.default.existsSync(p));
+    if (testSrc != null && !_fs.default.readFileSync(testSrc, 'utf8').includes('testNode')) return undefined;
+  } catch {}
+  let url;
+  let key;
+  try {
+    ({
+      url,
+      key
+    } = (0, _testUtils.getDevKey)(opts.host));
+  } catch (e) {
+    color.warn(`Node test pass skipped: ${e?.message ?? e}`);
+    return undefined;
+  }
+  const token = await (0, _testUtils.getToken)(url, key);
+  const workerPath = _path.default.join(__dirname, 'node-test-worker.js');
+  const outPath = _path.default.join(_os.default.tmpdir(), `grok-node-test-${Date.now()}-${process.pid}.json`);
+  const args = [workerPath, `--out=${outPath}`];
+  if (opts.category) args.push(`--category=${opts.category}`);
+  if (opts.test) args.push(`--test=${opts.test}`);
+  if (opts.stressTest) args.push('--stress-test');
+  if (opts.benchmark) args.push('--benchmark');
+  if (opts.verbose) args.push('--verbose');
+  color.info('Running Node (browserless) test pass...');
+  const reporter = new _testUtils.TestProgressReporter(opts.verbose ?? false);
+  const stderrTail = [];
+  const exitCode = await new Promise(resolve => {
+    const child = (0, _child_process.spawn)(process.execPath, args, {
+      cwd: opts.packageDir,
+      env: {
+        ...process.env,
+        DG_API_URL: url,
+        DG_API_TOKEN: token,
+        TARGET_PACKAGE: opts.packageName
+      },
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    const killTimer = setTimeout(() => {
+      color.error(`Node test pass timed out after ${workerTimeout / 1000}s. Killing worker.`);
+      child.kill();
+    }, workerTimeout);
+    const rlOut = _readline.default.createInterface({
+      input: child.stdout
+    });
+    rlOut.on('line', line => {
+      if (line.startsWith('Package testing: ')) reporter.onLine(line);else if (line.startsWith('Node pass unavailable: ')) color.info(line);else if (opts.verbose) console.log(line);
+    });
+    const rlErr = _readline.default.createInterface({
+      input: child.stderr
+    });
+    rlErr.on('line', line => {
+      stderrTail.push(line);
+      if (stderrTail.length > 50) stderrTail.shift();
+      if (opts.verbose) console.error(line);
+    });
+    child.on('close', code => {
+      clearTimeout(killTimer);
+      rlOut.close();
+      rlErr.close();
+      resolve(code ?? 2);
+    });
+    child.on('error', e => {
+      clearTimeout(killTimer);
+      color.warn(`Failed to spawn Node test worker: ${e.message}`);
+      resolve(2);
+    });
+  });
+  reporter.finish();
+  if (exitCode === 3) {
+    color.info('Node test pass is not supported here; running all tests in the browser.');
+    return undefined;
+  }
+  if (exitCode !== 0) {
+    if (!opts.verbose && stderrTail.length > 0) console.error(stderrTail.join('\n'));
+    color.warn(`Node test pass failed (exit code ${exitCode}); running all tests in the browser.`);
+    return undefined;
+  }
+  try {
+    const report = JSON.parse(_fs.default.readFileSync(outPath, 'utf8'));
+    _fs.default.unlinkSync(outPath);
+    color.info(`Node pass: ${report.passedAmount} passed, ${report.failedAmount} failed, ${report.skippedAmount} skipped; ` + `${report.browserTestsRemaining} test(s) left for the browser.`);
+    return {
+      ...report,
+      modernOutput: true
+    };
+  } catch (e) {
+    color.warn(`Could not read Node test report: ${e?.message ?? e}; running all tests in the browser.`);
+    return undefined;
+  }
+}

package/bin/utils/node-test-worker.js

@@ -0,0 +1,210 @@
+"use strict";
+
+var vm = _interopRequireWildcard(require("vm"));
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/* eslint-disable max-len */
+/**
+ * Standalone worker for the `grok test` Node (browserless) pass.
+ *
+ * Spawned by node-test-runner.ts with cwd = the package directory:
+ * 1. loads the js-api Node runtime (`datagrok-api/datagrok`) from the package's own node_modules,
+ * 2. resolves the published package version the platform would serve and evaluates its
+ *    `dist/package-test.js` bundle (webpack var-library `<name>_test`),
+ * 3. runs init-tagged functions of the test bundle, then calls its exported `testNode()`
+ *    which executes only tests marked `{node: true}`,
+ * 4. counts the tests the browser pass still has to run, and writes a JSON report to --out.
+ *
+ * Exit codes: 0 = pass executed (test failures are conveyed in the report),
+ * 3 = Node pass unsupported for this package (caller falls back to the browser for everything),
+ * anything else = infrastructure error.
+ */
+
+const UNSUPPORTED_EXIT_CODE = 3;
+const RESULT_COLUMNS = ['date', 'category', 'name', 'success', 'result', 'ms', 'skipped', 'logs', 'owner', 'package', 'widgetsDifference', 'flaking'];
+function getArg(name) {
+  const prefix = `--${name}=`;
+  const arg = process.argv.find(a => a.startsWith(prefix));
+  return arg ? arg.slice(prefix.length) : undefined;
+}
+function hasFlag(name) {
+  return process.argv.includes(`--${name}`);
+}
+function unsupported(reason) {
+  console.log(`Node pass unavailable: ${reason}`);
+  process.exit(UNSUPPORTED_EXIT_CODE);
+}
+
+// A crashing async callback (e.g. a socket handler inside the Dart runtime) must not
+// kill the whole pass — log it and let the per-test timeout fail the affected test.
+process.on('uncaughtException', err => {
+  console.error('Uncaught exception:', err?.stack ?? err);
+});
+process.on('unhandledRejection', reason => {
+  console.error('Unhandled rejection:', reason);
+});
+async function main() {
+  const apiUrl = process.env.DG_API_URL;
+  const token = process.env.DG_API_TOKEN;
+  const packageName = process.env.TARGET_PACKAGE;
+  const outPath = getArg('out');
+  const categoryArg = getArg('category');
+  const testArg = getArg('test');
+  const stressTest = hasFlag('stress-test');
+  const benchmark = hasFlag('benchmark');
+  const verbose = hasFlag('verbose');
+  let dgEntry;
+  try {
+    dgEntry = require.resolve('datagrok-api/datagrok', {
+      paths: [process.cwd()]
+    });
+  } catch {
+    unsupported('the installed datagrok-api has no Node runtime (datagrok-api/datagrok)');
+  }
+  const dgApi = require(dgEntry);
+  if (typeof dgApi.startDatagrok !== 'function') unsupported('the installed datagrok-api has no startDatagrok()');
+  await dgApi.startDatagrok({
+    apiUrl,
+    apiToken: token
+  });
+  const g = globalThis;
+  const grok = g.grok;
+  const DG = g.DG;
+
+  // Package bundles map webpack externals to browser globals (rxjs, rxjs.operators,
+  // dayjs, utc, wu, $). The Node runtime guarantees DG/grok/ui; provide the rest
+  // from datagrok-api's own dependencies so bundle evaluation doesn't throw.
+  const req = id => require(require.resolve(id, {
+    paths: [path.dirname(dgEntry), process.cwd()]
+  }));
+  const ensureGlobal = (name, resolve) => {
+    if (g[name] == null) try {
+      g[name] = resolve();
+    } catch {}
+  };
+  ensureGlobal('rxjs', () => req('rxjs'));
+  if (g.rxjs != null && g.rxjs.operators == null) try {
+    g.rxjs = Object.assign({}, g.rxjs, {
+      operators: req('rxjs/operators')
+    });
+  } catch {}
+  ensureGlobal('dayjs', () => req('dayjs'));
+  ensureGlobal('utc', () => req('dayjs/plugin/utc'));
+  ensureGlobal('wu', () => req('wu'));
+  ensureGlobal('$', () => req('cash-dom'));
+
+  // Resolve the published version the platform would serve: the caller's debug version
+  // if one exists, else the current one (mirrors js-api's Node loadPackage()).
+  const headers = {
+    Authorization: token
+  };
+  const listResp = await fetch(`${apiUrl}/packages?text=${encodeURIComponent(packageName)}`, {
+    headers
+  });
+  if (!listResp.ok) throw new Error(`Failed to list packages: HTTP ${listResp.status}`);
+  const packages = await listResp.json();
+  const pkgInfo = packages.find(p => p.name?.toLowerCase() === packageName.toLowerCase());
+  if (!pkgInfo) unsupported(`package "${packageName}" is not published on ${apiUrl}`);
+  const versions = pkgInfo.publishedVersions ?? [];
+  const login = (await grok.dapi.users.current()).login;
+  const cur = versions.find(v => v.debug && v.version === login) ?? versions.find(v => v.isCurrent) ?? versions.find(v => v.isLatest) ?? versions[0];
+  if (!cur) unsupported(`package "${packageName}" has no published versions`);
+  const webRoot = `${apiUrl}/packages/published/files/${pkgInfo.name}/${cur.version}/${cur.buildHash}/${cur.buildNumber}/`;
+  const jsUrl = `${webRoot}dist/package-test.js`;
+  const codeResp = await fetch(jsUrl, {
+    headers
+  });
+  if (!codeResp.ok) unsupported(`no test bundle at ${jsUrl} (HTTP ${codeResp.status})`);
+  vm.runInThisContext(await codeResp.text(), {
+    filename: jsUrl
+  });
+  const moduleName = `${packageName.toLowerCase()}_test`;
+  const testModule = g[moduleName] ?? g[Object.keys(g).find(k => k.endsWith('_test') && g[k]?.tests) ?? ''];
+  if (!testModule?.tests) unsupported(`test bundle did not define a "${moduleName}" module`);
+  if (typeof testModule.testNode !== 'function') unsupported('package-test.ts does not export testNode()');
+  if (testModule._package != null) {
+    testModule._package.webRoot = webRoot;
+    testModule._package.name = pkgInfo.name;
+    testModule._package.version = cur.version;
+  }
+
+  // The package must carry the resolved published-version id: functions are attached to
+  // package versions, and runTests' initAutoTests filters `package.id = <id>` to register
+  // the annotation-driven auto tests. The family-level entity id matches nothing.
+  const pkg = (await grok.dapi.packages.find(cur.id)) ?? (await grok.dapi.packages.filter(`shortName = "${pkgInfo.name}"`).first());
+  if (!pkg) unsupported(`package entity "${pkgInfo.name}" not found`);
+  try {
+    if (pkg.name !== pkgInfo.name) pkg.name = pkgInfo.name;
+  } catch {}
+  if (benchmark) DG.Test.isInBenchmark = true;
+  const results = await testModule.testNode(pkg, {
+    category: categoryArg,
+    test: testArg,
+    stressTest,
+    verbose
+  });
+
+  // Count what the browser pass still has to run. testNode() ran initAutoTests(), so the
+  // registry now also holds the annotation-driven auto/demo/detector tests.
+  let browserTestsRemaining = 0;
+  for (const [catName, cat] of Object.entries(testModule.tests)) {
+    if (categoryArg != null && !catName.toLowerCase().startsWith(categoryArg.toLowerCase().trim())) continue;
+    for (const t of cat.tests ?? []) {
+      if (testArg != null && t.name.toLowerCase() !== testArg.toLowerCase()) continue;
+      if (benchmark && !t.options?.benchmark) continue;
+      if (stressTest && !t.options?.stressTest) continue;
+      if (!(t.options?.node ?? cat.node ?? false)) browserTestsRemaining++;
+    }
+  }
+
+  // Shape the report like the browser pass does — same CSV columns in the same order,
+  // so the two passes merge row-wise.
+  const Papa = require('papaparse');
+  const rows = results.map(r => {
+    const row = {};
+    for (const c of RESULT_COLUMNS) row[c] = r[c] ?? (c === 'widgetsDifference' ? 0 : '');
+    return row;
+  });
+  let failed = false;
+  let passedAmount = 0;
+  let skippedAmount = 0;
+  let failedAmount = 0;
+  let verbosePassed = '';
+  let verboseSkipped = '';
+  let verboseFailed = '';
+  for (const r of results) {
+    const line = `${r.category}: ${r.name} (${r.ms} ms) :  ${r.result}\n`;
+    if (r.skipped) {
+      skippedAmount++;
+      verboseSkipped += line;
+    } else if (r.success) {
+      passedAmount++;
+      verbosePassed += line;
+    } else {
+      failedAmount++;
+      verboseFailed += line;
+      failed = true;
+    }
+  }
+  const report = {
+    failed,
+    verbosePassed,
+    verboseSkipped,
+    verboseFailed,
+    passedAmount,
+    skippedAmount,
+    failedAmount,
+    csv: rows.length ? Papa.unparse(rows, {
+      columns: RESULT_COLUMNS
+    }) : '',
+    browserTestsRemaining,
+    nodeTestsRun: results.length
+  };
+  fs.writeFileSync(outPath, JSON.stringify(report), 'utf8');
+  process.exit(0);
+}
+main().catch(e => {
+  console.error(e?.stack ?? e?.message ?? String(e));
+  process.exit(2);
+});

package/bin/utils/test-utils.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.TestContext = void 0;
+exports.TestProgressReporter = exports.TestContext = void 0;
 exports.addColumnToCsv = addColumnToCsv;
 exports.addLogsToFile = addLogsToFile;
 exports.defaultLaunchParameters = void 0;
@@ -363,6 +363,132 @@ async function loadTestsList(packages, core = false, record = false) {
 function addLogsToFile(filePath, stringToSave) {
   _fs.default.appendFileSync(filePath, `${stringToSave}`);
 }
+
+/**
+ * Parses the `Package testing: ...` progress lines emitted by the
+ * @datagrok-libraries/test runner and prints live per-category summaries.
+ * Used for both the Puppeteer console stream and the Node-pass worker stdout.
+ */
+class TestProgressReporter {
+  modernOutput = false;
+  categoryResults = new Map();
+  currentCategory = null;
+  pendingFailures = [];
+  pendingSkipped = [];
+  pendingBeforeFailure = null;
+  pendingAfterFailure = null;
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  printCategorySummary(category) {
+    const results = this.categoryResults.get(category);
+    if (!results) return;
+    const passedCount = results.passed;
+    const skippedSuffix = results.skipped > 0 ? `, \x1b[33m${results.skipped} skipped\x1b[0m` : '';
+    if (results.failed > 0 || this.pendingBeforeFailure || this.pendingAfterFailure) {
+      console.log(`\x1b[31m❌ ${category}\x1b[31m (\x1b[32m${passedCount} passed${skippedSuffix}\x1b[31m)\x1b[0m`);
+      if (this.pendingBeforeFailure) {
+        console.log(`  \x1b[31m❌ before\x1b[0m`);
+        if (this.pendingBeforeFailure.error) console.log(`    \x1b[31m${this.pendingBeforeFailure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
+      }
+      if (this.pendingAfterFailure) {
+        console.log(`  \x1b[31m❌ after\x1b[0m`);
+        if (this.pendingAfterFailure.error) console.log(`    \x1b[31m${this.pendingAfterFailure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
+      }
+      for (const skippedName of this.pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
+      for (const failure of this.pendingFailures) {
+        console.log(`  \x1b[31m❌ ${failure.testName}\x1b[0m`);
+        if (failure.error) console.log(`    \x1b[31m${failure.error}\x1b[0m`);
+        console.log(`    \x1b[33mTo run this test separately use --category "${category}" --test "${failure.testName}"\x1b[0m`);
+      }
+    } else {
+      console.log(`\x1b[32m✅ ${category} (${passedCount} passed${skippedSuffix}\x1b[32m)\x1b[0m`);
+      for (const skippedName of this.pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
+    }
+    this.pendingFailures = [];
+    this.pendingSkipped = [];
+    this.pendingBeforeFailure = null;
+    this.pendingAfterFailure = null;
+  }
+  onLine(text) {
+    if (!text.startsWith('Package testing: ')) return;
+    this.modernOutput = true;
+    // Extract tokens in {{...}} format
+    const tokens = [];
+    const tokenRegex = /\{\{([^}]+)\}\}/g;
+    let match;
+    while ((match = tokenRegex.exec(text)) !== null) tokens.push(match[1]);
+
+    // Category start: "Package testing: Started {{Category}}" or "Package testing: Started {{Category}} skipped {{N}}"
+    if (text.includes('Started') && (tokens.length === 1 || tokens.length === 2 && text.includes('skipped'))) {
+      if (this.currentCategory && this.categoryResults.has(this.currentCategory)) this.printCategorySummary(this.currentCategory);
+      this.currentCategory = tokens[0];
+      const skippedCount = tokens.length === 2 ? parseInt(tokens[1]) || 0 : 0;
+      this.categoryResults.set(this.currentCategory, {
+        passed: 0,
+        failed: 0,
+        skipped: skippedCount
+      });
+      this.pendingFailures = [];
+      this.pendingSkipped = [];
+      this.pendingBeforeFailure = null;
+      this.pendingAfterFailure = null;
+    } else if (text.includes('Skipped') && tokens.length === 2 && !text.includes('benchmark')) {
+      // Individual skipped test: "Package testing: Skipped {{Category}} {{TestName}}"
+      if (tokens[0] === this.currentCategory) this.pendingSkipped.push(tokens[1]);
+    } else if (text.includes('Started') && tokens.length === 2) {
+      // Test start: "Package testing: Started {{Category}} {{TestName}}"
+      process.stdout.write(`${tokens[0]}: ${tokens[1]}...`);
+    } else if (text.includes('Finished') && tokens.length === 3) {
+      // Test finish: "Package testing: Finished {{Category}} {{TestName}} with {{success/error}} for X ms"
+      const results = this.categoryResults.get(tokens[0]);
+      if (!this.verbose) process.stdout.write('\r\x1b[K');
+      if (tokens[2] === 'success') {
+        if (results) results.passed++;
+      } else {
+        if (results) results.failed++;
+        this.pendingFailures.push({
+          testName: tokens[1],
+          error: null
+        });
+      }
+    } else if (text.includes('Result for') && tokens.length === 2) {
+      // Error result: "Package testing: Result for {{Category}} {{TestName}}: error message"
+      const errorMsg = text.split(': ').slice(-1)[0];
+      if (this.pendingFailures.length > 0) this.pendingFailures[this.pendingFailures.length - 1].error = errorMsg;
+    } else if (text.includes('Category before()') && text.includes('failed') && tokens.length >= 1) {
+      // Category before() failed: "Package testing: Category before() {{Category}} failed"
+      process.stdout.write('\r\x1b[K');
+      this.pendingBeforeFailure = {
+        error: null
+      };
+    } else if (text.includes('Result for') && text.includes('before:') && tokens.length >= 1) {
+      // Before error result: "Package testing: Result for {{Category}} before: error message"
+      const errorMsg = text.split('before: ').slice(-1)[0];
+      if (this.pendingBeforeFailure) this.pendingBeforeFailure.error = errorMsg;
+    } else if (text.includes('Category after()') && text.includes('failed') && tokens.length >= 1) {
+      // Category after() failed: "Package testing: Category after() {{Category}} failed"
+      process.stdout.write('\r\x1b[K');
+      this.pendingAfterFailure = {
+        error: null
+      };
+    } else if (text.includes('Result for') && text.includes('after:') && tokens.length >= 1) {
+      // After error result: "Package testing: Result for {{Category}} after: error message"
+      const errorMsg = text.split('after: ').slice(-1)[0];
+      if (this.pendingAfterFailure) this.pendingAfterFailure.error = errorMsg;
+    } else if (text.includes('Unhandled Exception')) {
+      process.stdout.write('\r\x1b[K\n');
+      const errorMsg = text.replace('Package testing: Unhandled Exception: ', '');
+      if (errorMsg && errorMsg !== 'null') console.log(`\x1b[31m❌ Unhandled Exception: ${errorMsg}\x1b[0m`);
+    }
+  }
+  finish() {
+    if (this.currentCategory && this.categoryResults.has(this.currentCategory)) this.printCategorySummary(this.currentCategory);
+  }
+}
+exports.TestProgressReporter = TestProgressReporter;
 function printBrowsersResult(browserResult, verbose = false) {
   // Skip detailed summary if modernOutput was used (already printed per-category)
   if (!browserResult.modernOutput) {
@@ -414,8 +540,9 @@ async function runTests(testParams) {
   let countSkipped = 0;
   let countFailed = 0;
   try {
-    // Check if retry is supported by looking for skipToCategory parameter
+    // Check feature support by looking at the test function's declared inputs
     let retrySupported = false;
+    let excludeNodeSupported = false;
     try {
       const funcs = window.DG.Func.find({
         package: testParams.package,
@@ -424,6 +551,7 @@ async function runTests(testParams) {
       if (funcs && funcs.length > 0) {
         const testFunc = funcs[0];
         retrySupported = testFunc.inputs?.some(input => input.name === 'skipToCategory') === true;
+        excludeNodeSupported = testFunc.inputs?.some(input => input.name === 'excludeNodeTests') === true;
       }
     } catch (e) {
       retrySupported = false;
@@ -431,6 +559,8 @@ async function runTests(testParams) {
     const testCallParams = {};
     if (testParams.params?.category) testCallParams.category = testParams.params.category;
     if (testParams.params?.test) testCallParams.test = testParams.params.test;
+    // Skip node-marked tests in the browser only when the Node pass already ran them
+    if (testParams.params?.excludeNodeTests && excludeNodeSupported) testCallParams.excludeNodeTests = true;
     // Only pass retry-related params if supported
     if (retrySupported) {
       if (testParams.params?.skipToCategory) testCallParams.skipToCategory = testParams.params.skipToCategory;
@@ -692,54 +822,8 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
       });
     }
 
-    // State tracking for test output formatting
-    const categoryResults = new Map();
-    let currentCategory = null;
-    let currentTestName = null;
-    // Store failed tests with their errors to print after category header
-    let pendingFailures = [];
-    let pendingSkipped = [];
-    let pendingBeforeFailure = null;
-    let pendingAfterFailure = null;
-    let modernOutput = false;
-    const printCategorySummary = category => {
-      const results = categoryResults.get(category);
-      if (!results) return;
-      const formattedCategory = category;
-      const passedCount = results.passed;
-      const skippedSuffix = results.skipped > 0 ? `, \x1b[33m${results.skipped} skipped\x1b[0m` : '';
-      if (results.failed > 0 || pendingBeforeFailure || pendingAfterFailure) {
-        console.log(`\x1b[31m❌ ${formattedCategory}\x1b[31m (\x1b[32m${passedCount} passed${skippedSuffix}\x1b[31m)\x1b[0m`);
-        // Print before() failure first
-        if (pendingBeforeFailure) {
-          console.log(`  \x1b[31m❌ before\x1b[0m`);
-          if (pendingBeforeFailure.error) console.log(`    \x1b[31m${pendingBeforeFailure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
-        }
-        // Print after() failure
-        if (pendingAfterFailure) {
-          console.log(`  \x1b[31m❌ after\x1b[0m`);
-          if (pendingAfterFailure.error) console.log(`    \x1b[31m${pendingAfterFailure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
-        }
-        // Print skipped tests
-        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
-        // Print test failures
-        for (const failure of pendingFailures) {
-          console.log(`  \x1b[31m❌ ${failure.testName}\x1b[0m`);
-          if (failure.error) console.log(`    \x1b[31m${failure.error}\x1b[0m`);
-          console.log(`    \x1b[33mTo run this test separately use --category "${category}" --test "${failure.testName}"\x1b[0m`);
-        }
-      } else {
-        console.log(`\x1b[32m✅ ${formattedCategory} (${passedCount} passed${skippedSuffix}\x1b[32m)\x1b[0m`);
-        // Print skipped tests
-        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
-      }
-      pendingFailures = [];
-      pendingSkipped = [];
-      pendingBeforeFailure = null;
-      pendingAfterFailure = null;
-    };
+    // Live test-output formatting (shared with the Node pass)
+    const reporter = new TestProgressReporter(browserOptions.verbose ?? false);
 
     // Print all console messages when verbose mode is enabled
     if (browserOptions.verbose) {
@@ -756,95 +840,7 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
 
     // Subscribe to page console events for modern output formatting
     // On retry, old listeners were removed so we need to re-attach
-    page.on('console', msg => {
-      const text = msg.text();
-      if (!text.startsWith('Package testing: ')) return;
-      modernOutput = true;
-      // Extract tokens in {{...}} format
-      const tokens = [];
-      const tokenRegex = /\{\{([^}]+)\}\}/g;
-      let match;
-      while ((match = tokenRegex.exec(text)) !== null) tokens.push(match[1]);
-
-      // Category start: "Package testing: Started {{Category}}" or "Package testing: Started {{Category}} skipped {{N}}"
-      if (text.includes('Started') && (tokens.length === 1 || tokens.length === 2 && text.includes('skipped'))) {
-        // Print summary of previous category if exists
-        if (currentCategory && categoryResults.has(currentCategory)) printCategorySummary(currentCategory);
-        currentCategory = tokens[0];
-        const skippedCount = tokens.length === 2 ? parseInt(tokens[1]) || 0 : 0;
-        categoryResults.set(currentCategory, {
-          passed: 0,
-          failed: 0,
-          skipped: skippedCount
-        });
-        pendingFailures = [];
-        pendingSkipped = [];
-        pendingBeforeFailure = null;
-        pendingAfterFailure = null;
-      } else if (text.includes('Skipped') && tokens.length === 2 && !text.includes('benchmark')) {
-        // Individual skipped test: "Package testing: Skipped {{Category}} {{TestName}}"
-        // Only collect if the test belongs to the current active category
-        if (tokens[0] === currentCategory) pendingSkipped.push(tokens[1]);
-      } else if (text.includes('Started') && tokens.length === 2) {
-        // Test start: "Package testing: Started {{Category}} {{TestName}}"
-        const category = tokens[0];
-        currentTestName = tokens[1];
-        process.stdout.write(`${category}: ${currentTestName}...`);
-      } else if (text.includes('Finished') && tokens.length === 3) {
-        // Test finish: "Package testing: Finished {{Category}} {{TestName}} with {{success/error}} for X ms"
-        const category = tokens[0];
-        const testName = tokens[1];
-        const status = tokens[2];
-        const results = categoryResults.get(category);
-
-        // Clear the current test line
-        if (!browserOptions.verbose) process.stdout.write('\r\x1b[K');
-        if (status === 'success') {
-          if (results) results.passed++;
-        } else {
-          if (results) results.failed++;
-          pendingFailures.push({
-            testName,
-            error: null
-          });
-        }
-        currentTestName = null;
-      } else if (text.includes('Result for') && tokens.length === 2) {
-        // Error result: "Package testing: Result for {{Category}} {{TestName}}: error message"
-        const errorMsg = text.split(': ').slice(-1)[0];
-        // Attach error to the last pending failure
-        if (pendingFailures.length > 0) pendingFailures[pendingFailures.length - 1].error = errorMsg;
-      } else if (text.includes('Category before()') && text.includes('failed') && tokens.length >= 1) {
-        // Category before() failed: "Package testing: Category before() {{Category}} failed"
-        process.stdout.write('\r\x1b[K');
-        pendingBeforeFailure = {
-          error: null
-        };
-      } else if (text.includes('Result for') && text.includes('before:') && tokens.length >= 1) {
-        // Before error result: "Package testing: Result for {{Category}} before: error message"
-        const errorMsg = text.split('before: ').slice(-1)[0];
-        if (pendingBeforeFailure) pendingBeforeFailure.error = errorMsg;
-      } else if (text.includes('Category after()') && text.includes('failed') && tokens.length >= 1) {
-        // Category after() failed: "Package testing: Category after() {{Category}} failed"
-        process.stdout.write('\r\x1b[K');
-        pendingAfterFailure = {
-          error: null
-        };
-      } else if (text.includes('Result for') && text.includes('after:') && tokens.length >= 1) {
-        // After error result: "Package testing: Result for {{Category}} after: error message"
-        const errorMsg = text.split('after: ').slice(-1)[0];
-        if (pendingAfterFailure) pendingAfterFailure.error = errorMsg;
-      } else if (text.includes('Unhandled Exception')) {
-        // Unhandled exception: "Package testing: Unhandled Exception: ..."
-        // Clear any pending test line and move to new line
-        process.stdout.write('\r\x1b[K\n');
-        const errorMsg = text.replace('Package testing: Unhandled Exception: ', '');
-        if (errorMsg && errorMsg !== 'null') console.log(`\x1b[31m❌ Unhandled Exception: ${errorMsg}\x1b[0m`);
-      }
-    });
-    const printFinalCategorySummary = () => {
-      if (currentCategory && categoryResults.has(currentCategory)) printCategorySummary(currentCategory);
-    };
+    page.on('console', msg => reporter.onLine(msg.text()));
     const testingResults = await page.evaluate((testData, options) => {
       if (options.benchmark) window.DG.Test.isInBenchmark = true;
       if (options.reproduce) window.DG.Test.isReproducing = true;
@@ -889,9 +885,9 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
     }, testsToRun, browserOptions);
 
     // Print the final category summary
-    printFinalCategorySummary();
+    reporter.finish();
     if (browserOptions.record && !existingBrowserSession) await recorder?.stop();
-    if (modernOutput) {
+    if (reporter.modernOutput) {
       testingResults.verbosePassed = '';
       testingResults.verboseSkipped = '';
       testingResults.verboseFailed = '';
@@ -908,7 +904,7 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
         page,
         webUrl
       } : undefined,
-      modernOutput
+      modernOutput: reporter.modernOutput
     };
   }, testInvocationTimeout);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "6.4.8",
+  "version": "6.5.0",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {