@putdotio/rokit 1.4.0 → 1.6.0

package/README.md

@@ -1,8 +1,4 @@
 <div align="center">
-  <p>
-    <img src="https://static.put.io/images/putio-boncuk.png" width="72">
-  </p>
-
   <h1>rokit</h1>
 
   <p>A tiny CLI companion for Roku device harness work.</p>
@@ -49,10 +45,12 @@ App-specific scenario scripts can also import the generic helpers:
 
 ```ts
 import {
+  assertNamedNodeState,
+  assertNamedNodeTranslation,
   assertSceneGraphNode,
   pressKey,
   querySceneGraph,
-  readNamedNodeTranslation,
+  waitForSceneGraphAssertion,
   type RokuContext,
 } from "@putdotio/rokit";
 
@@ -71,7 +69,10 @@ const context: RokuContext = {
 await pressKey(context, "Info");
 const xml = await querySceneGraph(context, { attempts: 3 });
 await assertSceneGraphNode(context, "videoPlayerScreen", { state: "visible" });
-console.log(readNamedNodeTranslation(xml, "videoPlayerScreen"));
+assertNamedNodeTranslation(xml, "videoPlayerScreen", 0, 0);
+await waitForSceneGraphAssertion(context, "expected player", (xml) => {
+  assertNamedNodeState(xml, "videoPlayerScreen", "visible");
+});
 ```
 
 ## Commands
@@ -80,7 +81,9 @@ console.log(readNamedNodeTranslation(xml, "videoPlayerScreen"));
 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>
@@ -106,8 +109,12 @@ and reports failures as `{ "status": "failed", "error": { "message": "..." } }`.
   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
@@ -147,8 +154,11 @@ tokens, and app-specific media identifiers do not belong in git.
 - launch and deeplink parameters
 - remote keypresses
 - raw ECP queries
+- parsed media-player state from `/query/media-player`
 - 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,

package/dist/index.d.mts

@@ -4,6 +4,10 @@ import * as rokuDeploy from "roku-deploy";
 type NodeState = "absent" | "hidden" | "visible";
 type SceneGraphBounds = readonly [x: number, y: number, width: number, height: number];
 type SceneGraphPoint = readonly [x: number, y: number];
+type SceneGraphStatus = {
+  readonly error?: string;
+  readonly status?: string;
+};
 type NodeExpectation = {
   readonly state: NodeState;
   readonly text?: string;
@@ -16,7 +20,12 @@ declare const readNamedNodeAttribute: (xml: string, nodeName: string, attributeN
 declare const readNamedNodeNumber: (xml: string, nodeName: string, attributeName: string) => number | undefined;
 declare const readNamedNodeBounds: (xml: string, nodeName: string) => SceneGraphBounds | undefined;
 declare const readNamedNodeTranslation: (xml: string, nodeName: string) => SceneGraphPoint | undefined;
+declare const readSceneGraphStatus: (xml: string) => SceneGraphStatus;
+declare const readSceneGraphFailure: (xml: string) => string | undefined;
 declare const isNamedNodeVisible: (xml: string, nodeName: 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;
 declare const assertNamedNode: (xml: string, nodeName: string, expectation: NodeExpectation) => void;
 declare const assertNamedNodeState: (xml: string, nodeName: string, state: NodeState) => void;
 declare const assertNamedNodeText: (xml: string, nodeName: string, expectedText: string) => void;
@@ -48,10 +57,33 @@ type DeviceSummary = {
   readonly model: string;
   readonly name: string;
 };
+type MediaPlayerState = "buffer" | "close" | "error" | "none" | "open" | "pause" | "play" | "stop" | string;
+type MediaPlayerInfo = {
+  readonly audio?: string;
+  readonly buffering?: {
+    readonly current?: number;
+    readonly max?: number;
+    readonly target?: number;
+  };
+  readonly captions?: string;
+  readonly container?: string;
+  readonly durationMs?: number;
+  readonly error: boolean;
+  readonly isLive?: boolean;
+  readonly positionMs?: number;
+  readonly state?: MediaPlayerState;
+  readonly video?: string;
+  readonly videoResolution?: string;
+};
 type RetryOptions = {
   readonly attempts?: number;
   readonly retryDelayMs?: number;
 };
+type SceneGraphAssertion = (xml: string) => void;
+type WaitForSceneGraphAssertionOptions = {
+  readonly pollIntervalMs?: number;
+  readonly timeoutMs?: number;
+};
 declare const checkDevice: (context: RokuContext) => Promise<DeviceSummary>;
 declare const getDeviceInfo: (context: RokuContext) => Promise<rokuDeploy.DeviceInfo>;
 declare const queryActiveApp: (context: RokuContext) => Promise<ActiveApp>;
@@ -59,9 +91,18 @@ declare const waitForActiveApp: (context: RokuContext, appId: string, timeoutMs?
 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 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 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>;
 declare const waitForSceneGraphNode: (context: RokuContext, nodeName: string, expectation: NodeExpectation, timeoutMs?: number) => Promise<void>;
+declare const waitForSceneGraphAssertion: (context: RokuContext, description: string, assertXml: SceneGraphAssertion, options?: WaitForSceneGraphAssertionOptions) => Promise<string>;
 declare const installPackage: (context: RokuContext & {
   readonly password: string;
 }, zipPath: string) => Promise<string>;
@@ -70,4 +111,4 @@ declare const takeScreenshot: (context: RokuContext & {
 }, outputPath: string) => Promise<string>;
 declare const validateRemoteKey: (key: string) => void;
 //#endregion
-export { type ActiveApp, type DeviceSummary, type NodeExpectation, type NodeState, type RemoteKey, type RetryOptions, type RokuContext, type SceneGraphBounds, type SceneGraphPoint, assertNamedNode, assertNamedNodeState, assertNamedNodeText, assertSceneGraphNode, checkDevice, getDeviceInfo, installPackage, isNamedNodeVisible, launchApp, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, querySceneGraph, readActiveApp, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readXmlAttribute, readXmlTag, takeScreenshot, validateRemoteKey, waitForActiveApp, waitForSceneGraphNode };
+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 };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { C as readNamedNodeTranslation, E as readXmlTag, S as readNamedNodeNumber, T as readXmlAttribute, _ as isNamedNodeVisible, a as launchApp, b as readNamedNodeAttributes, c as queryEcp, d as validateRemoteKey, f as waitForActiveApp, g as assertNamedNodeText, h as assertNamedNodeState, i as installPackage, l as querySceneGraph, m as assertNamedNode, n as checkDevice, o as pressKey, p as waitForSceneGraphNode, r as getDeviceInfo, s as queryActiveApp, t as assertSceneGraphNode, u as takeScreenshot, v as parseSceneGraphNumberList, w as readActiveApp, x as readNamedNodeBounds, y as readNamedNodeAttribute } from "./roku-7hiM97p0.mjs";
-export { assertNamedNode, assertNamedNodeState, assertNamedNodeText, assertSceneGraphNode, checkDevice, getDeviceInfo, installPackage, isNamedNodeVisible, launchApp, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, querySceneGraph, readActiveApp, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readXmlAttribute, readXmlTag, takeScreenshot, validateRemoteKey, waitForActiveApp, waitForSceneGraphNode };
+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 };

package/dist/rokit.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as launchApp, c as queryEcp, f as waitForActiveApp, i as installPackage, l as querySceneGraph, n as checkDevice, o as pressKey, p as waitForSceneGraphNode, r as getDeviceInfo, s as queryActiveApp, t as assertSceneGraphNode, u as takeScreenshot } from "./roku-7hiM97p0.mjs";
+import { S as waitForSceneGraphNode, _ as takeScreenshot, b as waitForMediaPlayerState, c as queryActiveApp, f as querySceneGraph, i as installPackage, l as queryEcp, n as checkDevice, o as launchApp, r as getDeviceInfo, s as pressKey, t as assertSceneGraphNode, u as queryMediaPlayer, y as waitForActiveApp } from "./roku-CXHAzYR-.mjs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
@@ -98,6 +98,24 @@ const runCommand = async (context, command) => {
 			status: "ok"
 		};
 	}
+	if (command.name === "media-player") {
+		const mediaPlayer = await queryMediaPlayer(context);
+		return {
+			command: command.name,
+			data: mediaPlayer,
+			message: formatMediaPlayerMessage(mediaPlayer),
+			status: "ok"
+		};
+	}
+	if (command.name === "wait-media-player") {
+		const mediaPlayer = await waitForMediaPlayerState(context, command.state, command.timeoutMs);
+		return {
+			command: command.name,
+			data: mediaPlayer,
+			message: formatMediaPlayerMessage(mediaPlayer),
+			status: "ok"
+		};
+	}
 	if (command.name === "wait-active") {
 		const app = await waitForActiveApp(context, command.appId, command.timeoutMs);
 		return {
@@ -254,6 +272,16 @@ const parseCommand = (argv) => {
 	if (name === "check") return { name };
 	if (name === "device-info") return { name };
 	if (name === "active-app") return { name };
+	if (name === "media-player") return { name };
+	if (name === "wait-media-player") {
+		const state = args[0];
+		if (!state) fail("usage: rokit wait-media-player <state> [--timeout-ms <ms>]");
+		return {
+			name,
+			state,
+			timeoutMs: parseTimeoutOption(args.slice(1), "rokit wait-media-player <state>")
+		};
+	}
 	if (name === "wait-active") {
 		const appId = args[0];
 		if (!appId) fail("usage: rokit wait-active <app-id> [--timeout-ms <ms>]");
@@ -382,6 +410,15 @@ const formatNodeData = ({ expectation, nodeName, timeoutMs }) => ({
 	nodeName,
 	timeoutMs
 });
+const formatMediaPlayerMessage = (mediaPlayer) => {
+	return `media-player: ${[
+		`state=${mediaPlayer.state ?? "unknown"}`,
+		`container=${mediaPlayer.container ?? "unknown"}`,
+		`position=${formatMaybeMs(mediaPlayer.positionMs)}`,
+		`duration=${formatMaybeMs(mediaPlayer.durationMs)}`
+	].join(" ")}`;
+};
+const formatMaybeMs = (value) => value === void 0 ? "unknown" : `${value}ms`;
 const sleep = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
@@ -411,7 +448,9 @@ usage:
   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>

package/dist/{roku-7hiM97p0.mjs → roku-CXHAzYR-.mjs}

@@ -58,10 +58,30 @@ const readNamedNodeTranslation = (xml, nodeName) => {
 	if (parts.length < 2) return;
 	return [parts[0], parts[1]];
 };
+const readSceneGraphStatus = (xml) => ({
+	error: readXmlTag(xml, "error"),
+	status: readXmlTag(xml, "status")
+});
+const readSceneGraphFailure = (xml) => {
+	const { error, status } = readSceneGraphStatus(xml);
+	return status === "FAILED" ? error ?? "unknown" : void 0;
+};
 const isNamedNodeVisible = (xml, nodeName) => {
 	const attributes = readNamedNodeAttributes(xml, nodeName);
 	return attributes !== void 0 && !attributes.includes("visible=\"false\"");
 };
+const assertSceneGraphNumberNear = (actual, expected, label, tolerance = 1) => {
+	if (actual === void 0 || Math.abs(actual - expected) > tolerance) throw new Error(`expected ${label} ${expected}, got ${actual ?? "missing"}`);
+};
+const assertNamedNodeTranslation = (xml, nodeName, expectedX, expectedY, tolerance = 1) => {
+	const translation = readNamedNodeTranslation(xml, nodeName);
+	assertSceneGraphNumberNear(translation?.[0], expectedX, `${nodeName} x`, tolerance);
+	assertSceneGraphNumberNear(translation?.[1], expectedY, `${nodeName} y`, tolerance);
+};
+const assertNamedNodeSize = (xml, nodeName, expectedWidth, expectedHeight, tolerance = 1) => {
+	assertSceneGraphNumberNear(readNamedNodeNumber(xml, nodeName, "width"), expectedWidth, `${nodeName} width`, tolerance);
+	assertSceneGraphNumberNear(readNamedNodeNumber(xml, nodeName, "height"), expectedHeight, `${nodeName} height`, tolerance);
+};
 const assertNamedNode = (xml, nodeName, expectation) => {
 	if ("attribute" in expectation) {
 		assertNamedNodeAttribute(xml, nodeName, expectation.attribute, expectation.value);
@@ -169,6 +189,52 @@ const pressKey = async (context, key) => {
 	await postOk(context, ecpUrl(context, `/keypress/${encodeURIComponent(key)}`));
 };
 const queryEcp = async (context, path) => await fetchText(context, path.startsWith("/") ? path : `/${path}`);
+const queryMediaPlayerXml = async (context) => await queryEcp(context, "/query/media-player");
+const queryMediaPlayer = async (context) => readMediaPlayerInfo(await queryMediaPlayerXml(context));
+const readMediaPlayerInfo = (xml) => {
+	const playerAttributes = /<player(?:\s+([^>]*))?>/.exec(xml)?.[1] ?? "";
+	const formatAttributes = /<format(?:\s+([^>]*))?\/>/.exec(xml)?.[1] ?? "";
+	const bufferingAttributes = /<buffering(?:\s+([^>]*))?\/>/.exec(xml)?.[1];
+	return {
+		audio: readXmlAttribute(formatAttributes, "audio"),
+		buffering: bufferingAttributes === void 0 ? void 0 : {
+			current: readXmlNumberAttribute(bufferingAttributes, "current"),
+			max: readXmlNumberAttribute(bufferingAttributes, "max"),
+			target: readXmlNumberAttribute(bufferingAttributes, "target")
+		},
+		captions: readXmlAttribute(formatAttributes, "captions"),
+		container: readXmlAttribute(formatAttributes, "container"),
+		durationMs: readXmlNumberTag(xml, "duration"),
+		error: readXmlAttribute(playerAttributes, "error") === "true",
+		isLive: readXmlBooleanTag(xml, "is_live"),
+		positionMs: readXmlNumberTag(xml, "position"),
+		state: readXmlAttribute(playerAttributes, "state"),
+		video: readXmlAttribute(formatAttributes, "video"),
+		videoResolution: readXmlAttribute(formatAttributes, "video_res")
+	};
+};
+const readMediaPlayerState = (xml) => readMediaPlayerInfo(xml).state;
+const readMediaPlayerPositionMs = (xml) => readMediaPlayerInfo(xml).positionMs;
+const readMediaPlayerContainer = (xml) => readMediaPlayerInfo(xml).container;
+const isActiveMediaPlayerState = (state) => state === "buffer" || state === "pause" || state === "play";
+const waitForMediaPlayerState = async (context, expectedState, timeoutMs = 1e4) => {
+	const start = Date.now();
+	let lastState;
+	let lastError;
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const mediaPlayer = await queryMediaPlayer(context);
+			lastState = mediaPlayer.state;
+			lastError = void 0;
+			if (mediaPlayer.state === expectedState) return mediaPlayer;
+		} catch (error) {
+			lastError = formatErrorMessage(error);
+		}
+		await sleep(500);
+	}
+	const suffix = lastError ? `; last ECP error: ${lastError}` : "";
+	throw new Error(`expected media-player state ${expectedState}, got ${lastState ?? "unknown"}${suffix}`);
+};
 const querySceneGraph = async (context, options = {}) => {
 	const attempts = options.attempts ?? 1;
 	const retryDelayMs = options.retryDelayMs ?? 500;
@@ -199,6 +265,24 @@ const waitForSceneGraphNode = async (context, nodeName, expectation, timeoutMs =
 	const suffix = lastError ? `; last observation: ${lastError}` : "";
 	throw new Error(`expected SceneGraph node "${nodeName}" to match condition${suffix}`);
 };
+const waitForSceneGraphAssertion = async (context, description, assertXml, options = {}) => {
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	const pollIntervalMs = options.pollIntervalMs ?? 500;
+	const start = Date.now();
+	let lastError;
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const xml = await querySceneGraph(context);
+			assertXml(xml);
+			return xml;
+		} catch (error) {
+			lastError = formatErrorMessage(error);
+		}
+		await sleep(pollIntervalMs);
+	}
+	const suffix = lastError ? `; last observation: ${lastError}` : "";
+	throw new Error(`${description}${suffix}`);
+};
 const installPackage = async (context, zipPath) => {
 	const resolvedZip = resolve(zipPath);
 	const extension = extname(resolvedZip);
@@ -253,9 +337,27 @@ const postLaunchMaybeAccepted = async (context, url) => {
 	}
 };
 const ecpUrl = (context, path) => new URL(path, `http://${context.target}:${ecpPort}`);
+const readXmlNumberTag = (xml, tag) => {
+	const rawValue = readXmlTag(xml, tag);
+	if (rawValue === void 0) return;
+	const match = /-?\d+(?:\.\d+)?/.exec(rawValue);
+	if (!match) return;
+	return Number(match[0]);
+};
+const readXmlBooleanTag = (xml, tag) => {
+	const value = readXmlTag(xml, tag);
+	if (value === "true") return true;
+	if (value === "false") return false;
+};
+const readXmlNumberAttribute = (attributes, name) => {
+	const value = readXmlAttribute(attributes, name);
+	if (value === void 0) return;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+};
 const sleep = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
 const formatErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 //#endregion
-export { readNamedNodeTranslation as C, readXmlTag as E, readNamedNodeNumber as S, readXmlAttribute as T, isNamedNodeVisible as _, launchApp as a, readNamedNodeAttributes as b, queryEcp as c, validateRemoteKey as d, waitForActiveApp as f, assertNamedNodeText as g, assertNamedNodeState as h, installPackage as i, querySceneGraph as l, assertNamedNode as m, checkDevice as n, pressKey as o, waitForSceneGraphNode as p, getDeviceInfo as r, queryActiveApp as s, assertSceneGraphNode as t, takeScreenshot as u, parseSceneGraphNumberList as v, readActiveApp as w, readNamedNodeBounds as x, readNamedNodeAttribute as y };
+export { parseSceneGraphNumberList as A, readXmlTag as B, assertNamedNode as C, assertNamedNodeTranslation as D, assertNamedNodeText as E, readNamedNodeTranslation as F, readSceneGraphFailure as I, readSceneGraphStatus as L, readNamedNodeAttributes as M, readNamedNodeBounds as N, assertSceneGraphNumberNear as O, readNamedNodeNumber as P, readActiveApp as R, waitForSceneGraphNode as S, assertNamedNodeState as T, takeScreenshot as _, isActiveMediaPlayerState as a, waitForMediaPlayerState as b, queryActiveApp as c, queryMediaPlayerXml as d, querySceneGraph as f, readMediaPlayerState as g, readMediaPlayerPositionMs as h, installPackage as i, readNamedNodeAttribute as j, isNamedNodeVisible as k, queryEcp as l, readMediaPlayerInfo as m, checkDevice as n, launchApp as o, readMediaPlayerContainer as p, getDeviceInfo as r, pressKey as s, assertSceneGraphNode as t, queryMediaPlayer as u, validateRemoteKey as v, assertNamedNodeSize as w, waitForSceneGraphAssertion as x, waitForActiveApp as y, readXmlAttribute as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putdotio/rokit",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "A tiny CLI companion for Roku device harness work.",
   "keywords": [
     "cli",