@tantawowa/hosanna-tools 3.9.0 → 3.10.1

package/README.md

@@ -2,7 +2,7 @@
 
 ## Documentation
 
-- **[MCP debugger & UI tests](src/support-tools/mcp-server/README.md)** — `hst mcp:start`, all MCP tools, commands by use case, examples, `hst test:ui` / `hst test:record`.
+- **[MCP debugger](src/support-tools/mcp-server/README.md)** — `hst mcp:start`, debugger tools, commands by use case, examples, and RASP certification capture.
 - **[docs/README.md](docs/README.md)** — index of docs in this repo (MCP + source-map note).
 - **hosanna-ui** (separate repo): `docs/README.md` for agentic debugging and links back to this README.
 
@@ -94,7 +94,7 @@ Common build-script replacements:
 | `npx hst secrets:check` | `await secrets.check({ cwd: process.cwd() })` |
 | `npx hst env check` | `await env.check({ cwd: process.cwd() })` |
 
-Long-running APIs such as `dev.run`, `debugger.start`, `mcp.start`, `test.record`, and RASP capture-style workflows keep the same operational behavior as the corresponding CLI commands: they start services, attach to debuggers, or wait for user/session activity. `mcp.start`, `dev.run`, and `test.ui` are wired for programmatic no-exit behavior through the top-level API.
+Long-running APIs such as `dev.run`, `debugger.start`, `mcp.start`, and RASP-owned certification capture workflows keep the same operational behavior as the corresponding CLI commands: they start services, attach to debuggers, or wait for user/session activity. `mcp.start` and `dev.run` are wired for programmatic no-exit behavior through the top-level API.
 
 # Getting started
 
@@ -386,9 +386,95 @@ silently break an install.
 
 **Cursor and MCP:** Cursor does not magically attach to a terminal `hst mcp:start`. Add Hosanna as a Command MCP server (project **`.cursor/mcp.json`** or **Cursor Settings → MCP → Add Custom MCP**) so Cursor spawns **`hosanna-mcp`** over stdio. Start the command debugger/app explicitly with `hst run --platform web --target web`, `hst run --platform ios --target web`, `hst run --platform android-tv --target web`, or `hst run --platform roku --target device`.
 
-### UI Test Commands (`test:*`) - UI Test Automation
-- `test:ui` - Replay UI test recordings against a running Hosanna app
-- `test:record` - Interactively record a UI test by navigating the app
+### Deterministic UI testing
+
+Applications own regular Vitest suites. Global setup comes from `@tantawowa/hosanna-tools/testing/vitest`; worker fixtures and matchers come from `@tantawowa/hosanna-tools/testing/vitest/fixture`; shared lifecycle, types, and helpers come from `@tantawowa/hosanna-tools/testing`. There is no HST test CLI or recording/replay format.
+
+Add `createHosannaReporter(config)` from `@tantawowa/hosanna-tools/testing/vitest/reporter` to the application's Vitest reporters. Every run then writes a self-contained JSON and HTML report under `test-results/<testRunId>/`, updates `test-results/latest.json` and `test-results/latest.html`, and includes every Vitest result plus any named visual proofs captured by the tests.
+
+Browser targets can also record the complete owned browser session as WebM:
+
+```ts
+defineHosannaTestConfig({
+  // ...
+  video: true,
+  // Or: video: { size: { width: 1280, height: 720 } },
+});
+```
+
+The finalized recording is written to
+`test-results/<testRunId>/<platform>-web/run.webm` and embedded in the HTML
+report. Recording is opt-in in the shared tools and ignored for device and
+simulator targets. It records browser video only, without audio. This is a
+review artifact, not a replay format or executable test source.
+
+```ts
+import { defineConfig } from 'vitest/config';
+import { createHosannaReporter } from '@tantawowa/hosanna-tools/testing/vitest/reporter';
+import hosannaTestConfig from './integration/hosanna-test.config';
+
+export default defineConfig({
+  reporters: ['default', createHosannaReporter(hosannaTestConfig)],
+});
+```
+
+Use `hs.proof.capture(...)` at meaningful acceptance moments. A proof contains the target screenshot and the inspected screen/focus/control state used to understand it; hierarchy and scoped logs are optional. Proofs are evidence in the report, not an assertion by themselves:
+
+```ts
+const poster = hs.image.inCollectionCell({
+  collectionId: 'collectionView',
+  rowSettingsKey: 'rows.regular',
+  cellIndex: 0,
+  imageId: 'poster',
+});
+await poster.waitForLoaded({ requireBitmapSize: true });
+await expect(poster).toBeLoadedImage({ requireBitmapSize: true });
+
+await hs.proof.capture('programme-focused', {
+  controls: {
+    programmeCard: hs.control.byId('programmeCard'),
+  },
+  images: { poster },
+  includeLogs: true,
+});
+```
+
+Image readiness requires a non-empty URI, `loadStatus: "ready"`, positive rendered dimensions, and positive decoded bitmap dimensions by default. Explicit `loadWidth`/`loadHeight` assertions remain available for controls that request a fixed decode size; zero is valid when the runtime decodes at the source size. `hs.image.byId(...)`, `hs.image.within(...)`, and semantic `hs.image.inCollectionCell(...)` locators work across browser, Roku, and later native drivers.
+
+Screenshots and proofs wait for the command-plane hierarchy and focus to remain stable for 300ms by default, then allow a short platform render-settle window. Consecutive screenshots are also spaced automatically. Override this only for known platform behaviour through the test config's `screenshot` settings or per-capture options; failure diagnostics bypass the stable-frame wait so they can still capture broken states.
+
+Custom test ports must be unique. Keep the Vite and browser CDP ports outside the debugger's dynamic app allocation range; the launcher validates this before starting any processes and reports the conflicting range.
+
+Keep structural and state assertions as the default correctness checks. Use `hs.screenshot.match(...)` only for an explicit visual regression whose target-specific baseline and tolerance are intentionally maintained. Failure diagnostics and proof artifacts are separated below `test-results/<testRunId>/<platform>-<target>/`.
+
+`buildConfig` supplies a non-secret overlay that is merged last for the owned test launch. It may be a target-aware factory, so browser emulation can enable deterministic mocks while a physical Roku keeps its real platform services. The launcher and resolver both reject test overlays for `prod`:
+
+```ts
+defineHosannaTestConfig({
+  // ...
+  environment: 'test',
+  buildConfig: ({ platform, target }) => ({
+    remoteDebug: { isEnabled: true },
+    ...(target === 'web'
+      ? { channelStore: { testMode: { enabled: true } } }
+      : {}),
+  }),
+});
+```
+
+Use `createHosannaTestTarget(config)` with Vitest's standard conditional APIs. Selectors accept one platform or a set, and distinguish browser, simulator, and physical-device targets:
+
+```ts
+const target = createHosannaTestTarget(config);
+
+test.runIf(target.matches({ platform: 'roku', target: 'device' }))('Roku only', async ({ hs }) => {});
+test.runIf(target.matches({ platform: ['ios', 'android'], target: 'sim' }))('mobile simulators', async ({ hs }) => {});
+test.runIf(target.matches({ target: 'web' }))('all browser flavours', async ({ hs }) => {});
+```
+
+Browser Channel Store emulation supports per-test `success`, `cancelled`, and `failed` outcomes when `channelStore.testMode.enabled` is present in the test overlay. Set it from a named precondition with `hs.mocks.channelStore.setPurchaseOutcome(...)`. This API refuses physical-device targets. Roku purchase tests use Roku Pay [billing testing](https://developer.roku.com/dev/docs/billing-testing), a linked [Roku test user](https://developer.roku.com/dev/docs/test-users), and real Channel Store/OS purchase screens; keep them opt-in and serial.
+
+For Roku device suites, the launcher builds and deploys before the test launch, then relaunches through ECP with the exact test run ID and a debugger address reachable from the device. Configure the device IP and developer password in the application test config/environment. `HS_TEST_DEBUG_HOST` overrides automatic LAN address selection when needed. Physical Roku input, held keys, deep links, screenshots, and logs use their device transports; the committed Vitest source remains the same API used by browser tests.
 
 ## Usage Examples
 
@@ -445,16 +531,15 @@ hst env prepare-gitignore      # Update .gitignore
 hst debugger:start               # Start debug proxy (required)
 hst mcp:start                    # Start MCP server for Cursor/Claude
 
-# UI test automation
-hst test:record --name "My test"  # Record UI test interactively
-hst test:ui                       # Replay all recordings
-hst test:ui --suite regression.json  # Run test suite
-hst test:ui --json --report-dir ./reports  # CI mode with reports
+# Application-owned UI tests
+npm run test:ui
+npm run test:ui -- auth/login.test.ts
+HS_TEST_PLATFORM=roku HS_TEST_TARGET=device npm run test:ui
 ```
 
-## MCP Debugging & UI Test Automation
+## MCP Debugging & Deterministic UI Tests
 
-Hosanna Tools includes a powerful MCP (Model Context Protocol) server for AI-assisted debugging and a UI test automation framework.
+Hosanna Tools includes an MCP server for interactive AI-assisted debugging. Deterministic UI tests run in an application's Vitest process and use the separate `@tantawowa/hosanna-tools/testing` export; MCP is only an authoring aid.
 
 ### Cursor Settings → MCP (Hosanna debugger)
 
@@ -507,7 +592,7 @@ After saving, enable the server in the MCP list. **`hst mcp:start`** is still us
 ### Quick Start
 
 ```bash
-# 1. Start the debug proxy (required for both MCP and test automation)
+# 1. Start the debug proxy for an interactive MCP debugging session
 hst debugger:start
 
 # 2. Start your Hosanna app with remote debugging enabled
@@ -515,11 +600,8 @@ hst debugger:start
 # 3. For AI debugging (Cursor, Claude Code):
 #    Add MCP server (see "Cursor Settings → MCP" above) or hst mcp:start in a terminal
 
-# 4. For UI test recording:
-hst test:record --name "My test flow"
-
-# 5. For UI test replay:
-hst test:ui
+# 4. Run committed deterministic tests from the application repository:
+npm run test:ui
 ```
 
 ### See also

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "buildDate": "2026-07-15T18:20:21+00:00",
-  "buildDateISO": "2026-07-15T18:20:21.607Z",
+  "buildDate": "2026-07-17T08:33:15+00:00",
+  "buildDateISO": "2026-07-17T08:33:15.255Z",
   "timeZone": "UTC",
-  "gitHash": "0a46a09"
+  "gitHash": "cb39ebb"
 }

package/dist/cli.js

@@ -300,7 +300,7 @@ catch (err) {
 // Let yargs handle all commands including env
 (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
     .version(`${buildVersion}\n  git: ${buildGitHash}\n  built: ${buildDate}`)
-    .usage('$0 [command] [options]', `Hosanna Tools CLI\nVersion: ${buildVersion}\nBuild Date: ${buildDate}\n\nCommand Groups:\n  compiler:*    Compiler lifecycle (install, status, list)\n  config        hosanna.json management (wizard, show, set)\n  env           Environment checks and repair (check, fix, prepare-gitignore)\n  dev:*         Local development execution\n  debugger:*    Command debugger control\n  mcp:*         Hosanna MCP server control\n  build         Cross-platform build orchestration\n  run           Cross-platform launch orchestration\n  native:*      Native platform bootstrap and validation\n  target:*      Run target discovery and inventory\n  roku:*        Roku deployment, commands & packaging (run, command, package, map-stack)\n  device:*      Device discovery and run workflows\n  generate:*    Code and asset generation\n  sdk:*         Hosanna SDK/framework installation\n  build-config:* Build/runtime configuration resolution\n  ci:*          Continuous integration helpers\n  framework:*   Framework distribution helpers\n  license:*     Hosanna framework licensing\n  secrets:*     Portable .secrets files\n  test:*        UI testing\n  rasp:*        RASP cert scripts`)
+    .usage('$0 [command] [options]', `Hosanna Tools CLI\nVersion: ${buildVersion}\nBuild Date: ${buildDate}\n\nCommand Groups:\n  compiler:*    Compiler lifecycle (install, status, list)\n  config        hosanna.json management (wizard, show, set)\n  env           Environment checks and repair (check, fix, prepare-gitignore)\n  dev:*         Local development execution\n  debugger:*    Command debugger control\n  mcp:*         Hosanna MCP server control\n  build         Cross-platform build orchestration\n  run           Cross-platform launch orchestration\n  native:*      Native platform bootstrap and validation\n  target:*      Run target discovery and inventory\n  roku:*        Roku deployment, commands & packaging (run, command, package, map-stack)\n  device:*      Device discovery and run workflows\n  generate:*    Code and asset generation\n  sdk:*         Hosanna SDK/framework installation\n  build-config:* Build/runtime configuration resolution\n  ci:*          Continuous integration helpers\n  framework:*   Framework distribution helpers\n  license:*     Hosanna framework licensing\n  secrets:*     Portable .secrets files\n  rasp:*        RASP cert scripts`)
     .option('verbose', {
     type: 'boolean',
     default: false,
@@ -2056,121 +2056,13 @@ catch (err) {
         appName: args.appName,
     });
 })
-    .command('test:ui [recordings..]', 'Replay UI test recordings against a running Hosanna app and exit with pass/fail. ' +
-    'Requires a running debug proxy (hst debugger:start) and a connected app.', yargs => yargs
-    .positional('recordings', {
-    describe: 'Recording IDs to replay (omit to run all)',
-    type: 'string',
-    array: true,
-})
-    .option('suite', {
-    type: 'string',
-    describe: 'Path to a test-suite.json file (relative to recordings dir or absolute)',
-})
-    .option('appId', {
-    type: 'string',
-    describe: 'Target app ID (defaults to the one stored in each recording)',
-})
-    .option('managementPort', { type: 'number', default: 59150, describe: 'Debug proxy management port' })
-    .option('managementHost', { type: 'string', default: 'localhost', describe: 'Debug proxy host' })
-    .option('extensionPort', { type: 'number', default: 59153, describe: 'Debug proxy extension WebSocket port' })
-    .option('stop-on-failure', { type: 'boolean', default: true, describe: 'Stop each recording on first step failure' })
-    .option('step-delay-ms', { type: 'number', default: 500, describe: 'Delay after each action (ms)' })
-    .option('focus-assert-retry-ms', {
-    type: 'number',
-    default: 300,
-    describe: 'Delay (ms) between focus polls after a mismatch (0 = no polling)',
-})
-    .option('focus-assert-max-retries', {
-    type: 'number',
-    default: 12,
-    describe: 'Max extra GetFocusedView polls per step (skeleton/load); 0 = single read only',
-})
-    .option('screenshot-settle-ms', { type: 'number', default: 400, describe: 'Extra delay before screenshot capture (ms)' })
-    .option('compare-screenshots', { type: 'boolean', default: true, describe: 'Enable visual regression comparison' })
-    .option('screenshot-threshold', { type: 'number', default: 0.15, describe: 'Pixel diff tolerance (0-1)' })
-    .option('screenshot-fail-percent', { type: 'number', default: 2.0, describe: 'Max allowed diff % before failure' })
-    .option('roku-ip', { type: 'string', describe: 'Roku device IP (env: HOSANNA_ROKU_DEVICE_IP)' })
-    .option('roku-password', { type: 'string', describe: 'Roku dev password (env: HOSANNA_ROKU_DEV_PASSWORD)' })
-    .option('json', { type: 'boolean', default: false, describe: 'Output results as JSON only' })
-    .option('report-dir', { type: 'string', describe: 'Directory for HTML + JUnit XML reports' })
-    .option('update-baselines', { type: 'boolean', default: false, describe: 'Re-capture baseline screenshots without asserting (replays actions only)' })
-    .option('coverage', { type: 'boolean', default: false, describe: 'Analyze recordings and print navigation coverage (no running app needed)' }), async (args) => {
-    if (args.verbose) {
-        process.env.HOSANNA_VERBOSE = '1';
-    }
-    const { runTestUI } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-runner.js')));
-    await runTestUI({
-        recordings: args.recordings,
-        suite: args.suite,
-        appId: args.appId,
-        managementPort: args.managementPort,
-        managementHost: args.managementHost,
-        extensionPort: args.extensionPort,
-        stopOnFailure: args.stopOnFailure,
-        stepDelayMs: args.stepDelayMs,
-        focusAssertRetryMs: args.focusAssertRetryMs,
-        focusAssertMaxRetries: args.focusAssertMaxRetries,
-        screenshotSettleMs: args.screenshotSettleMs,
-        compareScreenshots: args.compareScreenshots,
-        screenshotThreshold: args.screenshotThreshold,
-        screenshotFailPercent: args.screenshotFailPercent,
-        rokuIp: args.rokuIp,
-        rokuPassword: args.rokuPassword,
-        json: args.json,
-        verbose: args.verbose,
-        reportDir: args.reportDir,
-        updateBaselines: args.updateBaselines,
-        coverage: args.coverage,
-    });
-})
-    .command('test:record', 'Interactively record a UI test by navigating the app. ' +
-    'Key events from the running app are captured via the debug proxy.', yargs => yargs
-    .option('name', {
-    type: 'string',
-    demandOption: true,
-    describe: 'Name for this test recording',
-})
-    .option('description', {
-    type: 'string',
-    describe: 'Optional description of what this test covers',
-})
-    .option('appId', {
-    type: 'string',
-    describe: 'Target app ID (defaults to first connected app)',
-})
-    .option('managementPort', { type: 'number', default: 59150, describe: 'Debug proxy management port' })
-    .option('managementHost', { type: 'string', default: 'localhost', describe: 'Debug proxy host' })
-    .option('extensionPort', { type: 'number', default: 59153, describe: 'Debug proxy extension WebSocket port' })
-    .option('roku-ip', { type: 'string', describe: 'Roku device IP for screenshots (env: HOSANNA_ROKU_DEVICE_IP)' })
-    .option('roku-password', { type: 'string', describe: 'Roku dev password for screenshots (env: HOSANNA_ROKU_DEV_PASSWORD)' })
-    .option('screenshot-on-select', { type: 'boolean', default: true, describe: 'Auto-capture screenshot on Select key press' })
-    .example('$0 test:record --name "Home screen navigation"', 'Record key presses while navigating')
-    .example('$0 test:record --name "Details test" --roku-ip 192.168.1.10', 'Record with Roku screenshot support'), async (args) => {
-    if (args.verbose) {
-        process.env.HOSANNA_VERBOSE = '1';
-    }
-    const { runTestRecord } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-recorder.js')));
-    await runTestRecord({
-        name: args.name,
-        description: args.description,
-        appId: args.appId,
-        managementPort: args.managementPort,
-        managementHost: args.managementHost,
-        extensionPort: args.extensionPort,
-        rokuIp: args.rokuIp,
-        rokuPassword: args.rokuPassword,
-        screenshotOnSelect: args.screenshotOnSelect,
-        verbose: args.verbose,
-    });
-})
-    .command('rasp:export <recordingId> <name>', 'Convert a saved test recording into a Roku Automation Scripting Platform (RASP) ' +
+    .command('rasp:export <captureId> <name>', 'Convert a saved RASP input capture into a Roku Automation Scripting Platform (RASP) ' +
     'YAML script suitable for Roku certification testing. Output goes to ' +
     'rasp-scripts/<name>.rasp in the current project by default.', yargs => yargs
-    .positional('recordingId', {
+    .positional('captureId', {
     type: 'string',
     demandOption: true,
-    describe: 'ID of the saved recording (filename without .json), e.g. "signin_1736888000000"',
+    describe: 'ID of the saved capture (filename without .json), e.g. "signin_1736888000000"',
 })
     .positional('name', {
     type: 'string',
@@ -2180,11 +2072,11 @@ catch (err) {
     .option('out', {
     type: 'string',
     alias: 'o',
-    describe: 'Override the output path. Default: rasp-scripts/<name>.rasp next to recordings dir.',
+    describe: 'Override the output path. Default: rasp-scripts/<name>.rasp next to the capture directory.',
 })
     .option('channel-name', {
     type: 'string',
-    describe: 'Channel name for the launch step (overrides recording.debugContext.channel.name).',
+    describe: 'Channel name for the launch step (overrides capture.debugContext.channel.name).',
 })
     .option('channel-mode', {
     type: 'string',
@@ -2242,7 +2134,7 @@ catch (err) {
     describe: 'Master gate for credential auto-injection. When true (default), the exporter ' +
         'watches for OK presses landing on a TextInputView classified as email or password ' +
         '(via inputType / secureMode or field id) and injects the matching half of the RFI credential flow. ' +
-        'Use --no-useWithRfi to disable injection entirely (recording flows through verbatim).',
+        'Use --no-useWithRfi to disable injection entirely (capture flows through verbatim).',
 })
     .option('login-text', {
     type: 'string',
@@ -2277,8 +2169,8 @@ catch (err) {
     }
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { getRecordingsDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/test-runner.js')));
-    const { exportRaspFromRecording, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
+    const { getRaspCapturesDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-input-capture.js')));
+    const { exportRaspFromCapture, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
     // Parses a minimal RASP YAML fragment containing only `- press: <key>` and
     // `- text: <value>` ops (with `LOGIN` / `PASSWORD` reserved tokens). Comments
     // (#…) and blank lines are allowed. Anything else throws.
@@ -2305,16 +2197,16 @@ catch (err) {
         }
         return ops;
     };
-    const recordingId = args.recordingId;
+    const captureId = args.captureId;
     const scriptName = args.name.replace(/[^a-zA-Z0-9_-]/g, '_');
-    const recordingsDir = getRecordingsDir();
-    const recordingPath = path.join(recordingsDir, `${recordingId}.json`);
-    let recording;
+    const capturesDir = getRaspCapturesDir();
+    const capturePath = path.join(capturesDir, `${captureId}.json`);
+    let capture;
     try {
-        recording = JSON.parse(fs.readFileSync(recordingPath, 'utf-8'));
+        capture = JSON.parse(fs.readFileSync(capturePath, 'utf-8'));
     }
     catch (_c) {
-        console.error(`Recording "${recordingId}" not found in ${recordingsDir}.`);
+        console.error(`RASP capture "${captureId}" not found in ${capturesDir}.`);
         process.exit(1);
     }
     // Parse repeatable --text-field flags into a map.
@@ -2332,7 +2224,7 @@ catch (err) {
     const credentialFlow = credentialFlowPath
         ? parseCredentialFlowFile(credentialFlowPath)
         : undefined;
-    const result = exportRaspFromRecording(recording, {
+    const result = exportRaspFromCapture(capture, {
         channelName: args.channelName,
         channelMode: args.channelMode,
         contentId: args.contentId,
@@ -2357,7 +2249,7 @@ catch (err) {
         process.stdout.write(result.yaml);
     }
     console.error(`✅ Wrote ${outPath}`);
-    console.error(`   ${result.stats.recordedSteps} recorded steps → ${result.stats.raspOps} RASP ops` +
+    console.error(`   ${result.stats.capturedSteps} captured steps → ${result.stats.raspOps} RASP ops` +
         ` (auto-pauses: ${result.stats.autoPausesInserted}, text injections: ${result.stats.textInjections}` +
         `, keyboard steps dropped: ${result.stats.keyboardStepsDropped}, verify ops: ${result.stats.verifyOpsEmitted})`);
     for (const d of result.rfiDetections) {
@@ -2380,7 +2272,7 @@ catch (err) {
     }
 })
     .command('rasp:capture <name>', 'Record a UI session and export it directly to a RASP script in one step. ' +
-    'Navigate the app, press Ctrl+C to stop — the recording is saved and the RASP script is written automatically.', yargs => yargs
+    'Navigate the app, press Ctrl+C to stop — the capture is saved and the RASP script is written automatically.', yargs => yargs
     .positional('name', {
     type: 'string',
     demandOption: true,
@@ -2465,10 +2357,10 @@ catch (err) {
     default: false,
     describe: 'Print the YAML to stdout after writing.',
 })
-    .option('keep-recording', {
+    .option('keep-capture', {
     type: 'boolean',
     default: false,
-    describe: 'Keep the temporary test-recordings JSON/screenshots after the RASP script is written.',
+    describe: 'Keep the temporary RASP capture JSON/screenshots after the script is written.',
 })
     .example('$0 rasp:capture login --channel-name "Criterion"', 'Record and export to rasp-scripts/login.rasp')
     .example('$0 rasp:capture login --channel-name "Criterion" --login-text "user@example.com" --password-text "MyPass1!"', 'Default credential flow with custom text')
@@ -2476,13 +2368,13 @@ catch (err) {
     var _a, _b;
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
-    const { cleanupSavedRecordingArtifacts, runTestRecord } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/cli-test-recorder.js')));
-    const { getRecordingsDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/test-runner.js')));
-    const { exportRaspFromRecording, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
+    const { cleanupRaspCaptureArtifacts, runRaspCapture } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-capture.js')));
+    const { getRaspCapturesDir } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-input-capture.js')));
+    const { exportRaspFromCapture, validateRaspYaml } = await Promise.resolve().then(() => __importStar(require('./support-tools/mcp-server/rasp-exporter.js')));
     const scriptName = args.name.replace(/[^a-zA-Z0-9_-]/g, '_');
     const raspScriptsDir = path.join(process.cwd(), 'rasp-scripts');
     const outPath = (_a = args.out) !== null && _a !== void 0 ? _a : path.join(raspScriptsDir, `${scriptName}.rasp`);
-    const recordingsDir = getRecordingsDir();
+    const capturesDir = getRaspCapturesDir();
     const textFields = {};
     const tfArgs = (_b = args['text-field']) !== null && _b !== void 0 ? _b : [];
     for (const tf of tfArgs) {
@@ -2520,7 +2412,7 @@ catch (err) {
     const credentialFlow = credentialFlowPath
         ? parseCredentialFlowFile(credentialFlowPath)
         : undefined;
-    await runTestRecord({
+    await runRaspCapture({
         name: args.name,
         appId: args.appId,
         managementPort: args.managementPort,
@@ -2528,8 +2420,8 @@ catch (err) {
         extensionPort: args.extensionPort,
         rokuIp: args.rokuIp,
         rokuPassword: args.rokuPassword,
-        onSaved: async (recordingId, recording) => {
-            const result = exportRaspFromRecording(recording, {
+        onSaved: async (captureId, capture) => {
+            const result = exportRaspFromCapture(capture, {
                 channelName: args.channelName,
                 channelMode: args.channelMode,
                 contentId: args.contentId,
@@ -2548,7 +2440,7 @@ catch (err) {
             if (args.print)
                 process.stdout.write(result.yaml);
             console.log(`✅ RASP script written: ${outPath}`);
-            console.log(`   ${result.stats.recordedSteps} steps → ${result.stats.raspOps} RASP ops` +
+            console.log(`   ${result.stats.capturedSteps} steps → ${result.stats.raspOps} RASP ops` +
                 ` (pauses: ${result.stats.autoPausesInserted}, text injections: ${result.stats.textInjections})`);
             for (const d of result.rfiDetections) {
                 const icon = d.type === 'login' ? '📧' : '🔑';
@@ -2567,15 +2459,15 @@ catch (err) {
                 console.error(`   Script has validation errors — review before submitting to Roku cert.`);
                 process.exitCode = 1;
             }
-            if (!args.keepRecording) {
+            if (!args.keepCapture) {
                 try {
-                    const cleanup = cleanupSavedRecordingArtifacts(recordingsDir, recordingId);
+                    const cleanup = cleanupRaspCaptureArtifacts(capturesDir, captureId);
                     if (cleanup.jsonDeleted || cleanup.artifactDirDeleted) {
-                        console.log(`🧹 Cleaned up temporary recording: ${recordingId}`);
+                        console.log(`🧹 Cleaned up temporary capture: ${captureId}`);
                     }
                 }
                 catch (err) {
-                    console.warn(`⚠  RASP script was written, but temporary recording cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+                    console.warn(`⚠  RASP script was written, but temporary capture cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
         },