@putdotio/rokit 1.6.0 → 2.0.0

package/AGENTS.md

@@ -0,0 +1,90 @@
+# Agent Guide
+
+`rokit` is a small Node CLI that wraps generic Roku device harness primitives.
+Keep it platform-focused, typed, and useful for both humans and agents.
+
+## Generic Tool Boundary
+
+- Keep `rokit` free of put.io product behavior. Do not add put.io app IDs,
+  deep links, content IDs, account data, credentials, journeys, UI node names,
+  or product assertions.
+- `@putdotio/rokit`, `putdotio/rokit`, release-bot wiring, copyright, and
+  security contacts are ownership/publishing metadata only; do not treat them
+  as permission to add product-specific fixtures.
+- Use neutral examples such as `dev`, `Example Channel`, `videoPlayerScreen`,
+  and synthetic SceneGraph/XML data when docs or tests need sample app data.
+- Consumer app repos own product scenario scripts, app-specific selectors,
+  playback/content assertions, and review artifacts.
+
+## Patterns
+
+- Use Effect at the runtime boundary and for reusable effectful operations. Keep
+  errors schema-backed and render them without stack traces in CLI output.
+- Keep CLI wiring thin: parse/dispatch commands, then call named Roku helpers.
+- Keep human output stable; `--json` / `--output json` should wrap every
+  command result and error in a deterministic object for agents.
+- Keep `src/index.ts` as the public library surface for app-specific scenario
+  scripts. Export generic Roku/SceneGraph primitives only.
+- Treat `process.cwd()` as the consumer app root.
+- Keep `.rokit/` consumer-local; it can hold env, generated artifacts, and
+  transient device state.
+- Keep `examples/live-probe-channel` generic. It exists only to prove package,
+  install, launch, input, SceneGraph, screenshot, and proof mechanics.
+- Wrap `roku-deploy` for package publish, screenshots, and device metadata when
+  it already owns the platform mechanics.
+- Use Roku ECP for launch, keypresses, active-app queries, and raw runtime
+  state.
+- Media-player helpers can parse and wait on Roku `/query/media-player` state,
+  but app repos own expectations about specific content, playback URLs, and
+  containers.
+- Keep SceneGraph helpers generic: node state, text, attributes, focus/state
+  waits, and raw tree output are okay; product-specific screen contracts stay in
+  app repos.
+- Keep app journeys, content IDs, account data, and product assertions out of
+  the generic harness.
+
+## Sharp Edges
+
+- Missing config/env and child-command failures should not print stack traces.
+- `ROKIT_PASSWORD` is required only for developer-installer operations such as
+  install and screenshot.
+- `ROKU_DEV_TARGET` and `ROKU_DEV_PASSWORD` are compatibility fallbacks, not the
+  primary public contract.
+- Avoid sleeps in generic commands. App repos can add meaningful wait/assert
+  loops around `rokit` primitives.
+- Release details live in `docs/DISTRIBUTION.md`; readiness details live in
+  `docs/READINESS.md`.
+
+## When Contracts Change
+
+- Command, env, or output changes: update `README.md` and CLI tests.
+- CI/release/publishing changes: update workflow docs or release config in the
+  same change.
+- Keep `CLAUDE.md` as a symlink to this file if Claude-compatible discovery is
+  added.
+
+## Checks
+
+```bash
+vp install
+vp run verify
+```
+
+Fast loops:
+
+```bash
+vp run check
+vp run typecheck
+vp run smoke
+vp run test
+```
+
+Live Roku checks when a developer-enabled device exists:
+
+```bash
+ROKIT_TARGET=<roku-ip> vp run live:smoke
+ROKIT_TARGET=<roku-ip> ROKIT_PASSWORD=<password> vp run live:probe
+ROKIT_TARGET=<roku-ip> vp exec rokit check
+ROKIT_TARGET=<roku-ip> vp exec rokit launch dev
+ROKIT_TARGET=<roku-ip> vp exec rokit press Info Back
+```

package/CONTRIBUTING.md

@@ -0,0 +1,52 @@
+# Contributing
+
+## Setup
+
+```bash
+vp install
+```
+
+## Run Locally
+
+Use the built CLI through the package scripts while developing:
+
+```bash
+vp run smoke
+```
+
+For live Roku checks, set local environment variables in your shell or
+`.rokit/.env`.
+
+## Validation
+
+```bash
+vp run verify
+```
+
+`verify` runs static checks, TypeScript, packaging, tests, and an npm pack dry
+run.
+
+## Live Checks
+
+Live checks require a developer-enabled Roku on the same network:
+
+```bash
+ROKIT_TARGET=<roku-ip> vp run live:smoke
+ROKIT_TARGET=<roku-ip> vp exec rokit press Info Back
+```
+
+Screenshots and installs require `ROKIT_PASSWORD`.
+
+Keep local device details in `.rokit/.env` or your shell. Do not commit device
+IPs, passwords, signing keys, tokens, or account-specific app data.
+
+## Pull Requests
+
+- Keep changes focused.
+- Add or update tests when command behavior, parsing, output, or public exports change.
+- Include the most useful verification evidence for the change.
+- Keep app-specific journeys out of `rokit`; add those to the consuming app repo instead.
+
+## Distribution
+
+Release and publishing details live in [Distribution](./docs/DISTRIBUTION.md).

package/README.md

@@ -1,7 +1,12 @@
 <div align="center">
+  <p>
+    <img src="https://static.put.io/images/putio-boncuk.png" width="72" alt="put.io Boncuk logo">
+  </p>
+
   <h1>rokit</h1>
 
-  <p>A tiny CLI companion for Roku device harness work.</p>
+  <p>Roku device harness primitives for package, launch, input, state, and proof loops.</p>
+  <p>Generic by design: app journeys, credentials, content IDs, and product assertions stay in consumer repos.</p>
 
   <p>
     <a href="https://github.com/putdotio/rokit/actions/workflows/ci.yml?query=branch%3Amain" style="text-decoration:none;"><img src="https://img.shields.io/github/actions/workflow/status/putdotio/rokit/ci.yml?branch=main&style=flat&label=ci&colorA=000000&colorB=000000" alt="CI"></a>
@@ -16,37 +21,86 @@
 pnpm add -D @putdotio/rokit
 ```
 
-`rokit` wraps Roku platform primitives for live-device proof loops. It does not
-own app-specific journeys, content IDs, credentials, or product assertions.
+Node `>=24.14 <25`
 
-## Usage
+## Quick Start
 
-Create `.rokit/.env` or export environment variables in the app repo:
+Set the target Roku in the app repo that consumes `rokit`:
 
 ```bash
-ROKIT_TARGET=<roku-ip>
-ROKIT_PASSWORD=<developer-mode-password>
+export ROKIT_TARGET=<roku-ip>
+export ROKIT_PASSWORD=<developer-mode-password>
 ```
 
-Then run:
+Then run the generic device checks and actions you need:
 
 ```bash
 pnpm exec rokit check
+pnpm exec rokit package --out artifacts/live/channel.zip
+pnpm exec rokit install artifacts/live/channel.zip
 pnpm exec rokit launch dev
 pnpm exec rokit press Down Select
-pnpm exec rokit press --delay-ms 250 Right Select
-pnpm exec rokit query /query/active-app
-pnpm exec rokit wait-node videoPlayerScreen visible
-pnpm exec rokit screenshot artifacts/live/player.png
+pnpm exec rokit proof artifacts/live/proof --screenshot
+```
+
+`ROKIT_PASSWORD` is required for developer-installer operations such as
+`install` and `screenshot`. `ROKU_DEV_TARGET` and `ROKU_DEV_PASSWORD` are
+accepted as compatibility fallbacks for app repos that already use Roku dev
+naming.
+
+## Automation
+
+Prefer JSON when `rokit` feeds another tool:
+
+```bash
+pnpm exec rokit describe
 pnpm exec rokit --json active-app
+pnpm exec rokit --dry-run launch dev
+pnpm exec rokit --fields status,data.state media-player
+pnpm exec rokit --input-json '{"command":"press","keys":["Down","Select"]}'
 ```
 
-App-specific scenario scripts can also import the generic helpers:
+`describe` prints the machine-readable command surface, including command
+names, parameters, JSON payload fields, global options, and automation feature
+flags. When stdout is not a TTY, command output defaults to JSON unless
+`--output text` is explicit.
+
+## Command Surface
+
+Common commands:
+
+| Command                                            | Purpose                                            |
+| -------------------------------------------------- | -------------------------------------------------- |
+| `describe`                                         | Print the machine-readable command surface         |
+| `check`                                            | Confirm ECP and developer-installer reachability   |
+| `discover`                                         | Find Roku ECP devices with SSDP                    |
+| `device-info`                                      | Read Roku device metadata                          |
+| `active-app`                                       | Read the foreground app                            |
+| `media-player`                                     | Read parsed `/query/media-player` state            |
+| `snapshot`                                         | Read a compact state snapshot                      |
+| `proof <output-dir>`                               | Write reviewable local proof artifacts             |
+| `package --out <zip-path>`                         | Create a sideload ZIP from the current app root    |
+| `install <zip-path>`                               | Publish an existing ZIP to the Roku developer slot |
+| `launch <app-id>`                                  | Launch an app by id with optional params           |
+| `press <key...>`                                   | Send Roku remote keys                              |
+| `query <ecp-path>`                                 | Print a raw ECP response                           |
+| `sgnodes`                                          | Print the raw SceneGraph tree                      |
+| `assert-node` / `wait-node`                        | Check generic SceneGraph node state                |
+| `wait-active` / `wait-media-player` / `wait-ready` | Poll generic runtime readiness                     |
+| `screenshot <output-path>`                         | Save a developer screenshot                        |
+
+Mutating commands support `--dry-run` where the platform can validate without
+changing device or filesystem state. ECP paths reject query strings, fragments,
+traversal, backslashes, control characters, and percent-encoded path segments.
+Generated output paths must stay within the current working directory.
+
+## Library Use
+
+App-specific scenario scripts can import the generic helpers:
 
 ```ts
 import {
-  assertNamedNodeState,
-  assertNamedNodeTranslation,
+  assertMediaPlayerContainer,
   assertSceneGraphNode,
   pressKey,
   querySceneGraph,
@@ -55,7 +109,6 @@ import {
 } from "@putdotio/rokit";
 
 const target = process.env.ROKIT_TARGET;
-
 if (!target) {
   throw new Error("ROKIT_TARGET is not set");
 }
@@ -67,103 +120,28 @@ const context: RokuContext = {
 };
 
 await pressKey(context, "Info");
-const xml = await querySceneGraph(context, { attempts: 3 });
+await querySceneGraph(context, { attempts: 3, requireComplete: true });
 await assertSceneGraphNode(context, "videoPlayerScreen", { state: "visible" });
-assertNamedNodeTranslation(xml, "videoPlayerScreen", 0, 0);
-await waitForSceneGraphAssertion(context, "expected player", (xml) => {
-  assertNamedNodeState(xml, "videoPlayerScreen", "visible");
+await assertMediaPlayerContainer(context, "mp4");
+await waitForSceneGraphAssertion(context, "player ready", (xml) => {
+  if (!xml.includes("videoPlayerScreen")) {
+    throw new Error("expected player screen");
+  }
 });
 ```
 
-## Commands
-
-```bash
-rokit check
-rokit device-info
-rokit active-app
-rokit media-player
-rokit wait-active <app-id> [--timeout-ms <ms>]
-rokit wait-media-player <state> [--timeout-ms <ms>]
-rokit launch <app-id> [--param key=value]
-rokit press [--delay-ms <ms>] <key> [key...]
-rokit query <ecp-path>
-rokit sgnodes
-rokit assert-node <node-name> <visible|hidden|absent|text|attr> [value]
-rokit wait-node <node-name> <visible|hidden|absent|text|attr> [value] [--timeout-ms <ms>]
-rokit screenshot <output-path>
-rokit install <zip-path>
-rokit --version
-```
-
-Global options:
-
-```bash
-rokit --json <command>
-rokit --output json <command>
-```
-
-JSON mode wraps command output as `{ "status": "ok", "command": "...", ... }`
-and reports failures as `{ "status": "failed", "error": { "message": "..." } }`.
-
-- `check` confirms the Roku ECP endpoint responds and the developer installer
-  is reachable.
-- `device-info` prints enhanced Roku device metadata as JSON.
-- `active-app` prints the foreground app.
-- `media-player` prints parsed `/query/media-player` playback state, including
-  state, container, position, duration, and format metadata.
-- `wait-active` waits until the requested app is foregrounded and tolerates
-  transient ECP read failures while polling.
-- `wait-media-player` waits until `/query/media-player` reports a target state
-  such as `play`, `pause`, or `buffer`.
-- `launch` opens an app and waits until it is active. Use repeated `--param`
-  values for deeplink parameters. Roku launch responses can race app startup, so
-  launch accepts transient timeout/fetch failures and then verifies foreground
-  state.
-- `press` sends Roku remote keys through ECP. Use `--delay-ms` for navigation
-  sequences that need a stable gap between keys.
-- `query` prints a raw ECP response such as `/query/sgnodes/all`.
-- `sgnodes` prints the raw SceneGraph tree from `/query/sgnodes/all`. Library
-  callers can pass retry options to `querySceneGraph`.
-- `assert-node` checks a named SceneGraph node once.
-- `wait-node` polls SceneGraph until a named node condition matches.
-- `screenshot` saves a developer screenshot. It requires `ROKIT_PASSWORD`.
-- `install` publishes an existing ZIP through `roku-deploy`. It requires
-  `ROKIT_PASSWORD`.
-
-## Environment
-
-```bash
-ROKIT_TARGET=<roku-ip>
-ROKIT_PASSWORD=<developer-mode-password>
-ROKIT_USERNAME=rokudev
-ROKIT_TIMEOUT_MS=10000
-```
-
-`ROKU_DEV_TARGET` and `ROKU_DEV_PASSWORD` are accepted as fallbacks for app
-repos that already use Roku dev naming.
-
-Keep `.rokit/` local. Device IPs, Developer Mode passwords, signing keys, user
-tokens, and app-specific media identifiers do not belong in git.
-
 ## Boundaries
 
-`rokit` is the generic Roku harness layer:
+`rokit` owns generic Roku mechanics:
 
-- device info
-- install/publish
-- launch and deeplink parameters
-- remote keypresses
-- raw ECP queries
-- parsed media-player state from `/query/media-player`
+- package, install, launch, deeplink params, and remote keypresses
+- raw ECP queries and parsed media-player state
 - SceneGraph state queries and named-node assertions
-- SceneGraph attribute, numeric geometry, bounds, and translation readers
-- SceneGraph geometry assertions, status/failure readers, and custom assertion
-  wait loops
-- screenshots
-
-App repositories should keep their own scenario commands for product behavior,
-such as opening a specific route, asserting playback state, generating review
-HTML, or checking app-specific UI nodes.
+- screenshots, snapshots, and proof artifacts
+
+Consumer app repos own product behavior: opening specific routes, asserting
+playback for real content, checking app-specific UI nodes, and generating review
+artifacts.
 
 ## Docs
 

package/SECURITY.md

@@ -0,0 +1,38 @@
+# Security
+
+If you believe you have found a security or privacy issue in this project,
+please report it privately.
+
+## Contact
+
+- email: devs@put.io
+
+Private reports are preferred for security and privacy issues.
+
+If you are unsure whether something is sensitive, email first instead of opening
+a public issue.
+
+## Scope
+
+Useful reports usually include issues involving:
+
+- token, secret, or credential exposure
+- unsafe handling of device passwords or signing keys
+- command injection through CLI arguments, env values, or device responses
+- publishing, release, or package integrity problems
+- private device, account, or media identifier exposure
+
+## Guidelines
+
+- test only against devices, accounts, environments, and data you control
+- keep testing non-destructive, low-volume, and service-safe
+- do not include device passwords, signing keys, account tokens, private content IDs, or local device identifiers in public issues, pull requests, examples, or logs
+
+## Supported Versions
+
+Only the latest published version receives routine fixes.
+
+## Disclosure
+
+Please allow a reasonable amount of time to investigate and fix the issue before
+sharing details publicly.

package/dist/index.d.mts

@@ -23,6 +23,9 @@ declare const readNamedNodeTranslation: (xml: string, nodeName: string) => Scene
 declare const readSceneGraphStatus: (xml: string) => SceneGraphStatus;
 declare const readSceneGraphFailure: (xml: string) => string | undefined;
 declare const isNamedNodeVisible: (xml: string, nodeName: string) => boolean;
+declare const isCompleteSceneGraph: (xml: string) => boolean;
+declare const escapeXmlAttribute: (value: string) => string;
+declare const sceneGraphContainsText: (xml: string, text: string) => boolean;
 declare const assertSceneGraphNumberNear: (actual: number | undefined, expected: number, label: string, tolerance?: number) => void;
 declare const assertNamedNodeTranslation: (xml: string, nodeName: string, expectedX: number, expectedY: number, tolerance?: number) => void;
 declare const assertNamedNodeSize: (xml: string, nodeName: string, expectedWidth: number, expectedHeight: number, tolerance?: number) => void;
@@ -57,6 +60,12 @@ type DeviceSummary = {
   readonly model: string;
   readonly name: string;
 };
+type DiscoveredRokuDevice = {
+  readonly location: string;
+  readonly server?: string;
+  readonly target?: string;
+  readonly usn?: string;
+};
 type MediaPlayerState = "buffer" | "close" | "error" | "none" | "open" | "pause" | "play" | "stop" | string;
 type MediaPlayerInfo = {
   readonly audio?: string;
@@ -77,6 +86,7 @@ type MediaPlayerInfo = {
 };
 type RetryOptions = {
   readonly attempts?: number;
+  readonly requireComplete?: boolean;
   readonly retryDelayMs?: number;
 };
 type SceneGraphAssertion = (xml: string) => void;
@@ -84,20 +94,27 @@ type WaitForSceneGraphAssertionOptions = {
   readonly pollIntervalMs?: number;
   readonly timeoutMs?: number;
 };
+type PackageResult = {
+  readonly path: string;
+};
 declare const checkDevice: (context: RokuContext) => Promise<DeviceSummary>;
 declare const getDeviceInfo: (context: RokuContext) => Promise<rokuDeploy.DeviceInfo>;
 declare const queryActiveApp: (context: RokuContext) => Promise<ActiveApp>;
+declare const discoverRokuDevices: (timeoutMs?: number) => Promise<DiscoveredRokuDevice[]>;
 declare const waitForActiveApp: (context: RokuContext, appId: string, timeoutMs?: number) => Promise<ActiveApp>;
 declare const launchApp: (context: RokuContext, appId: string, params?: ReadonlyMap<string, string>) => Promise<ActiveApp>;
 declare const pressKey: (context: RokuContext, key: string) => Promise<void>;
 declare const queryEcp: (context: RokuContext, path: string) => Promise<string>;
 declare const queryMediaPlayerXml: (context: RokuContext) => Promise<string>;
 declare const queryMediaPlayer: (context: RokuContext) => Promise<MediaPlayerInfo>;
+declare const queryMediaPlayerXmlSafe: (context: RokuContext) => Promise<string | undefined>;
+declare const queryMediaPlayerSafe: (context: RokuContext) => Promise<MediaPlayerInfo | undefined>;
 declare const readMediaPlayerInfo: (xml: string) => MediaPlayerInfo;
 declare const readMediaPlayerState: (xml: string) => MediaPlayerState | undefined;
 declare const readMediaPlayerPositionMs: (xml: string) => number | undefined;
 declare const readMediaPlayerContainer: (xml: string) => string | undefined;
 declare const isActiveMediaPlayerState: (state: string | undefined) => boolean;
+declare const assertMediaPlayerContainer: (context: RokuContext, expectedContainer: string) => Promise<MediaPlayerInfo>;
 declare const waitForMediaPlayerState: (context: RokuContext, expectedState: MediaPlayerState, timeoutMs?: number) => Promise<MediaPlayerInfo>;
 declare const querySceneGraph: (context: RokuContext, options?: RetryOptions) => Promise<string>;
 declare const assertSceneGraphNode: (context: RokuContext, nodeName: string, expectation: NodeExpectation) => Promise<void>;
@@ -109,6 +126,8 @@ declare const installPackage: (context: RokuContext & {
 declare const takeScreenshot: (context: RokuContext & {
   readonly password: string;
 }, outputPath: string) => Promise<string>;
+declare const packageChannel: (outputPath: string, rootDir?: string) => Promise<PackageResult>;
+declare const validateEcpPath: (path: string) => string;
 declare const validateRemoteKey: (key: string) => void;
 //#endregion
-export { type ActiveApp, type DeviceSummary, type MediaPlayerInfo, type MediaPlayerState, type NodeExpectation, type NodeState, type RemoteKey, type RetryOptions, type RokuContext, type SceneGraphAssertion, type SceneGraphBounds, type SceneGraphPoint, type SceneGraphStatus, type WaitForSceneGraphAssertionOptions, assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, getDeviceInfo, installPackage, isActiveMediaPlayerState, isNamedNodeVisible, launchApp, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, queryMediaPlayer, queryMediaPlayerXml, querySceneGraph, readActiveApp, readMediaPlayerContainer, readMediaPlayerInfo, readMediaPlayerPositionMs, readMediaPlayerState, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readSceneGraphFailure, readSceneGraphStatus, readXmlAttribute, readXmlTag, takeScreenshot, validateRemoteKey, waitForActiveApp, waitForMediaPlayerState, waitForSceneGraphAssertion, waitForSceneGraphNode };
+export { type ActiveApp, type DeviceSummary, type DiscoveredRokuDevice, type MediaPlayerInfo, type MediaPlayerState, type NodeExpectation, type NodeState, type PackageResult, type RemoteKey, type RetryOptions, type RokuContext, type SceneGraphAssertion, type SceneGraphBounds, type SceneGraphPoint, type SceneGraphStatus, type WaitForSceneGraphAssertionOptions, assertMediaPlayerContainer, assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, discoverRokuDevices, escapeXmlAttribute, getDeviceInfo, installPackage, isActiveMediaPlayerState, isCompleteSceneGraph, isNamedNodeVisible, launchApp, packageChannel, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, queryMediaPlayer, queryMediaPlayerSafe, queryMediaPlayerXml, queryMediaPlayerXmlSafe, querySceneGraph, readActiveApp, readMediaPlayerContainer, readMediaPlayerInfo, readMediaPlayerPositionMs, readMediaPlayerState, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readSceneGraphFailure, readSceneGraphStatus, readXmlAttribute, readXmlTag, sceneGraphContainsText, takeScreenshot, validateEcpPath, validateRemoteKey, waitForActiveApp, waitForMediaPlayerState, waitForSceneGraphAssertion, waitForSceneGraphNode };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { A as parseSceneGraphNumberList, B as readXmlTag, C as assertNamedNode, D as assertNamedNodeTranslation, E as assertNamedNodeText, F as readNamedNodeTranslation, I as readSceneGraphFailure, L as readSceneGraphStatus, M as readNamedNodeAttributes, N as readNamedNodeBounds, O as assertSceneGraphNumberNear, P as readNamedNodeNumber, R as readActiveApp, S as waitForSceneGraphNode, T as assertNamedNodeState, _ as takeScreenshot, a as isActiveMediaPlayerState, b as waitForMediaPlayerState, c as queryActiveApp, d as queryMediaPlayerXml, f as querySceneGraph, g as readMediaPlayerState, h as readMediaPlayerPositionMs, i as installPackage, j as readNamedNodeAttribute, k as isNamedNodeVisible, l as queryEcp, m as readMediaPlayerInfo, n as checkDevice, o as launchApp, p as readMediaPlayerContainer, r as getDeviceInfo, s as pressKey, t as assertSceneGraphNode, u as queryMediaPlayer, v as validateRemoteKey, w as assertNamedNodeSize, x as waitForSceneGraphAssertion, y as waitForActiveApp, z as readXmlAttribute } from "./roku-CXHAzYR-.mjs";
-export { assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, getDeviceInfo, installPackage, isActiveMediaPlayerState, isNamedNodeVisible, launchApp, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, queryMediaPlayer, queryMediaPlayerXml, querySceneGraph, readActiveApp, readMediaPlayerContainer, readMediaPlayerInfo, readMediaPlayerPositionMs, readMediaPlayerState, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readSceneGraphFailure, readSceneGraphStatus, readXmlAttribute, readXmlTag, takeScreenshot, validateRemoteKey, waitForActiveApp, waitForMediaPlayerState, waitForSceneGraphAssertion, waitForSceneGraphNode };
+import { A as assertNamedNode, B as readNamedNodeAttribute, C as takeScreenshot, D as waitForMediaPlayerState, E as waitForActiveApp, F as assertSceneGraphNumberNear, G as readSceneGraphFailure, H as readNamedNodeBounds, I as escapeXmlAttribute, J as readActiveApp, K as readSceneGraphStatus, L as isCompleteSceneGraph, M as assertNamedNodeState, N as assertNamedNodeText, O as waitForSceneGraphAssertion, P as assertNamedNodeTranslation, R as isNamedNodeVisible, T as validateRemoteKey, U as readNamedNodeNumber, V as readNamedNodeAttributes, W as readNamedNodeTranslation, X as readXmlTag, Y as readXmlAttribute, _ as querySceneGraph, a as getDeviceInfo, b as readMediaPlayerPositionMs, c as launchApp, d as queryActiveApp, f as queryEcp, g as queryMediaPlayerXmlSafe, h as queryMediaPlayerXml, i as discoverRokuDevices, j as assertNamedNodeSize, k as waitForSceneGraphNode, l as packageChannel, m as queryMediaPlayerSafe, n as assertSceneGraphNode, o as installPackage, p as queryMediaPlayer, q as sceneGraphContainsText, r as checkDevice, s as isActiveMediaPlayerState, t as assertMediaPlayerContainer, u as pressKey, v as readMediaPlayerContainer, w as validateEcpPath, x as readMediaPlayerState, y as readMediaPlayerInfo, z as parseSceneGraphNumberList } from "./roku-BxnS6Axs.mjs";
+export { assertMediaPlayerContainer, assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, discoverRokuDevices, escapeXmlAttribute, getDeviceInfo, installPackage, isActiveMediaPlayerState, isCompleteSceneGraph, isNamedNodeVisible, launchApp, packageChannel, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, queryMediaPlayer, queryMediaPlayerSafe, queryMediaPlayerXml, queryMediaPlayerXmlSafe, querySceneGraph, readActiveApp, readMediaPlayerContainer, readMediaPlayerInfo, readMediaPlayerPositionMs, readMediaPlayerState, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readSceneGraphFailure, readSceneGraphStatus, readXmlAttribute, readXmlTag, sceneGraphContainsText, takeScreenshot, validateEcpPath, validateRemoteKey, waitForActiveApp, waitForMediaPlayerState, waitForSceneGraphAssertion, waitForSceneGraphNode };