@putdotio/rokit 1.5.0 → 1.7.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>
@@ -51,9 +47,11 @@ App-specific scenario scripts can also import the generic helpers:
 import {
   assertNamedNodeState,
   assertNamedNodeTranslation,
+  assertMediaPlayerContainer,
   assertSceneGraphNode,
   pressKey,
   querySceneGraph,
+  sceneGraphContainsText,
   waitForSceneGraphAssertion,
   type RokuContext,
 } from "@putdotio/rokit";
@@ -71,11 +69,15 @@ const context: RokuContext = {
 };
 
 await pressKey(context, "Info");
-const xml = await querySceneGraph(context, { attempts: 3 });
+const xml = await querySceneGraph(context, { attempts: 3, requireComplete: true });
 await assertSceneGraphNode(context, "videoPlayerScreen", { state: "visible" });
 assertNamedNodeTranslation(xml, "videoPlayerScreen", 0, 0);
+await assertMediaPlayerContainer(context, "mp4");
 await waitForSceneGraphAssertion(context, "expected player", (xml) => {
   assertNamedNodeState(xml, "videoPlayerScreen", "visible");
+  if (!sceneGraphContainsText(xml, "Ready")) {
+    throw new Error("expected ready text");
+  }
 });
 ```
 
@@ -85,7 +87,9 @@ await waitForSceneGraphAssertion(context, "expected player", (xml) => {
 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>
@@ -111,8 +115,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
@@ -121,7 +129,9 @@ and reports failures as `{ "status": "failed", "error": { "message": "..." } }`.
   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`.
+  callers can pass retry options to `querySceneGraph`; use
+  `requireComplete: true` when a scenario needs to reject partial SceneGraph
+  dumps that include `<All_Nodes>` but no root `<App>` node yet.
 - `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`.
@@ -152,8 +162,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`
+- media-player active-state and container assertions
 - SceneGraph state queries and named-node assertions
 - SceneGraph attribute, numeric geometry, bounds, and translation readers
+- SceneGraph completeness and escaped-text helpers
 - SceneGraph geometry assertions, status/failure readers, and custom assertion
   wait loops
 - screenshots

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,8 +60,27 @@ 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 requireComplete?: boolean;
   readonly retryDelayMs?: number;
 };
 type SceneGraphAssertion = (xml: string) => void;
@@ -73,6 +95,17 @@ 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 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>;
 declare const waitForSceneGraphNode: (context: RokuContext, nodeName: string, expectation: NodeExpectation, timeoutMs?: number) => Promise<void>;
@@ -85,4 +118,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 SceneGraphAssertion, type SceneGraphBounds, type SceneGraphPoint, type SceneGraphStatus, type WaitForSceneGraphAssertionOptions, assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, getDeviceInfo, installPackage, isNamedNodeVisible, launchApp, parseSceneGraphNumberList, pressKey, queryActiveApp, queryEcp, querySceneGraph, readActiveApp, readNamedNodeAttribute, readNamedNodeAttributes, readNamedNodeBounds, readNamedNodeNumber, readNamedNodeTranslation, readSceneGraphFailure, readSceneGraphStatus, readXmlAttribute, readXmlTag, takeScreenshot, validateRemoteKey, waitForActiveApp, waitForSceneGraphAssertion, 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, assertMediaPlayerContainer, assertNamedNode, assertNamedNodeSize, assertNamedNodeState, assertNamedNodeText, assertNamedNodeTranslation, assertSceneGraphNode, assertSceneGraphNumberNear, checkDevice, escapeXmlAttribute, getDeviceInfo, installPackage, isActiveMediaPlayerState, isCompleteSceneGraph, isNamedNodeVisible, launchApp, 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, validateRemoteKey, waitForActiveApp, waitForMediaPlayerState, waitForSceneGraphAssertion, waitForSceneGraphNode };

package/dist/index.mjs

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

@@ -70,6 +70,9 @@ const isNamedNodeVisible = (xml, nodeName) => {
 	const attributes = readNamedNodeAttributes(xml, nodeName);
 	return attributes !== void 0 && !attributes.includes("visible=\"false\"");
 };
+const isCompleteSceneGraph = (xml) => !xml.includes("<All_Nodes>") || xml.includes("<App ");
+const escapeXmlAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+const sceneGraphContainsText = (xml, text) => xml.includes(escapeXmlAttribute(text));
 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"}`);
 };
@@ -189,16 +192,86 @@ 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 queryMediaPlayerXmlSafe = async (context) => {
+	try {
+		return await queryMediaPlayerXml(context);
+	} catch {
+		return;
+	}
+};
+const queryMediaPlayerSafe = async (context) => {
+	const xml = await queryMediaPlayerXmlSafe(context);
+	return xml === void 0 ? void 0 : readMediaPlayerInfo(xml);
+};
+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 === "buffering" || state === "pause" || state === "play";
+const assertMediaPlayerContainer = async (context, expectedContainer) => {
+	const mediaPlayer = await queryMediaPlayer(context);
+	if (mediaPlayer.container !== expectedContainer) throw new Error(`expected media-player container ${expectedContainer}, got ${mediaPlayer.container ?? "unknown"}`);
+	return mediaPlayer;
+};
+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 requireComplete = options.requireComplete ?? false;
 	const retryDelayMs = options.retryDelayMs ?? 500;
+	let lastXml = "";
 	let lastError;
-	for (let attempt = 0; attempt < attempts; attempt += 1) try {
-		return await queryEcp(context, "/query/sgnodes/all");
-	} catch (error) {
-		lastError = error;
+	for (let attempt = 0; attempt < attempts; attempt += 1) {
+		try {
+			const xml = await queryEcp(context, "/query/sgnodes/all");
+			if (!requireComplete || isCompleteSceneGraph(xml)) return xml;
+			lastXml = xml;
+		} catch (error) {
+			lastError = error;
+			lastXml = "";
+		}
 		if (attempt < attempts - 1) await sleep(retryDelayMs);
 	}
+	if (lastXml !== "") return lastXml;
 	throw new Error(`SceneGraph query failed: ${formatErrorMessage(lastError)}`);
 };
 const assertSceneGraphNode = async (context, nodeName, expectation) => {
@@ -291,9 +364,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 { readActiveApp as A, readNamedNodeAttribute as C, readNamedNodeTranslation as D, readNamedNodeNumber as E, readXmlTag as M, readSceneGraphFailure as O, parseSceneGraphNumberList as S, readNamedNodeBounds as T, assertNamedNodeState as _, launchApp as a, assertSceneGraphNumberNear as b, queryEcp as c, validateRemoteKey as d, waitForActiveApp as f, assertNamedNodeSize as g, assertNamedNode as h, installPackage as i, readXmlAttribute as j, readSceneGraphStatus as k, querySceneGraph as l, waitForSceneGraphNode as m, checkDevice as n, pressKey as o, waitForSceneGraphAssertion as p, getDeviceInfo as r, queryActiveApp as s, assertSceneGraphNode as t, takeScreenshot as u, assertNamedNodeText as v, readNamedNodeAttributes as w, isNamedNodeVisible as x, assertNamedNodeTranslation as y };
+export { assertNamedNodeTranslation as A, readNamedNodeTranslation as B, waitForMediaPlayerState as C, assertNamedNodeSize as D, assertNamedNode as E, parseSceneGraphNumberList as F, readXmlAttribute as G, readSceneGraphStatus as H, readNamedNodeAttribute as I, readXmlTag as K, readNamedNodeAttributes as L, escapeXmlAttribute as M, isCompleteSceneGraph as N, assertNamedNodeState as O, isNamedNodeVisible as P, readNamedNodeBounds as R, waitForActiveApp as S, waitForSceneGraphNode as T, sceneGraphContainsText as U, readSceneGraphFailure as V, readActiveApp as W, readMediaPlayerInfo as _, installPackage as a, takeScreenshot as b, pressKey as c, queryMediaPlayer as d, queryMediaPlayerSafe as f, readMediaPlayerContainer as g, querySceneGraph as h, getDeviceInfo as i, assertSceneGraphNumberNear as j, assertNamedNodeText as k, queryActiveApp as l, queryMediaPlayerXmlSafe as m, assertSceneGraphNode as n, isActiveMediaPlayerState as o, queryMediaPlayerXml as p, checkDevice as r, launchApp as s, assertMediaPlayerContainer as t, queryEcp as u, readMediaPlayerPositionMs as v, waitForSceneGraphAssertion as w, validateRemoteKey as x, readMediaPlayerState as y, readNamedNodeNumber as z };

package/package.json

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