taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/adapters/adb/adb-adapter.js

@@ -1,5 +1,7 @@
 import { parseObservedActivityComponent } from "../../domain/activity.js";
 import { isAppProcessName } from "../../domain/app-process.js";
+import { WindowTopologySchema } from "../../domain/window-hierarchy.js";
+import { parseWindowTopology } from "./window-topology-parser.js";
 const PROCESS_ROW = /^(\d+)\s+(\S+)$/;
 function deviceArgs(deviceSerial) {
     return deviceSerial === undefined ? [] : ["-s", deviceSerial];
@@ -30,6 +32,30 @@ function inputTextChunks(text) {
     chunks.push(text.slice(start));
     return chunks;
 }
+const DEVICEKIT_PACKAGE_NAME = "com.mobilenext.devicekit";
+const DEVICEKIT_CLIPBOARD_RECEIVER = `${DEVICEKIT_PACKAGE_NAME}/.ClipboardBroadcastReceiver`;
+function isAsciiText(text) {
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) > 0x7f) {
+            return false;
+        }
+    }
+    return true;
+}
+function inputTextUnsupportedResult() {
+    return {
+        exitCode: 1,
+        signal: null,
+        stdout: "",
+        stderr: "ADB input text cannot type non-ASCII characters; install the"
+            + " mobilenext devicekit app"
+            + " (https://github.com/mobile-next/devicekit-android) to deliver"
+            + " non-ASCII text through the clipboard",
+        durationMs: 0,
+        timedOut: false,
+        cancelled: false
+    };
+}
 export class AdbAdapter {
     runner;
     constructor(runner) {
@@ -58,6 +84,30 @@ export class AdbAdapter {
             return { serial, status };
         });
     }
+    async deviceIdentity(identity) {
+        const property = async (name) => {
+            const result = await this.run(["-s", identity.deviceSerial, "shell", "getprop", name], identity.signal, identity.timeoutMs);
+            if (result.exitCode !== 0
+                || result.spawnError !== undefined
+                || result.cancelled
+                || result.timedOut) {
+                throw new Error(`getprop ${name} failed on ${identity.deviceSerial}`);
+            }
+            return result.stdout.trim();
+        };
+        const [manufacturer, model, sdk] = await Promise.all([
+            property("ro.product.manufacturer"),
+            property("ro.product.model"),
+            property("ro.build.version.sdk")
+        ]);
+        const sdkLevel = Number(sdk);
+        if (manufacturer.length === 0
+            || model.length === 0
+            || !Number.isSafeInteger(sdkLevel)) {
+            throw new Error(`Device ${identity.deviceSerial} returned an incomplete identity`);
+        }
+        return { manufacturer, model, sdkLevel };
+    }
     async foregroundComponent(identity) {
         const result = await this.run([
             ...deviceArgs(identity.deviceSerial),
@@ -101,6 +151,43 @@ export class AdbAdapter {
             `${options.packageName}/${options.activity}`
         ], options.signal, options.timeoutMs);
     }
+    async startActivityByIntent(options) {
+        const result = await this.run([
+            ...deviceArgs(options.deviceSerial),
+            "shell",
+            "am",
+            "start",
+            "-W",
+            "-a",
+            options.action
+        ], options.signal, options.timeoutMs);
+        if (result.exitCode === 0 && /^Error(:| type)/m.test(result.stdout)) {
+            return { ...result, exitCode: 1 };
+        }
+        return result;
+    }
+    async resolveLauncherActivity(options) {
+        const result = await this.run([
+            ...deviceArgs(options.deviceSerial),
+            "shell",
+            "cmd",
+            "package",
+            "resolve-activity",
+            "--brief",
+            options.packageName
+        ], options.signal, options.timeoutMs);
+        assertCommandUsable(result, "cmd package resolve-activity");
+        const match = /^(\S+)\/(\S+)$/m.exec(result.stdout);
+        if (match === null) {
+            return undefined;
+        }
+        const packageName = match[1];
+        const activity = match[2];
+        if (packageName === undefined || activity === undefined) {
+            return undefined;
+        }
+        return { packageName, activity };
+    }
     forceStop(identity) {
         return this.run([
             ...deviceArgs(identity.deviceSerial),
@@ -141,6 +228,41 @@ export class AdbAdapter {
         })
             .sort((left, right) => left.pid - right.pid);
     }
+    async windowTopology(identity) {
+        const result = await this.run([
+            ...deviceArgs(identity.deviceSerial),
+            "shell",
+            "dumpsys",
+            "window",
+            "windows"
+        ], identity.signal, identity.timeoutMs);
+        if (result.cancelled) {
+            throw new Error("ADB window topology was cancelled");
+        }
+        if (result.exitCode !== 0
+            || result.timedOut
+            || result.spawnError !== undefined) {
+            return WindowTopologySchema.parse({
+                version: 1,
+                status: "unavailable",
+                windows: [],
+                diagnostic: result.stderr.trim()
+                    || result.spawnError
+                    || (result.timedOut
+                        ? "ADB window topology timed out"
+                        : `ADB window topology exited with code ${String(result.exitCode)}`)
+            });
+        }
+        const topology = parseWindowTopology(result.stdout, identity.packageName);
+        if (topology.windows.length > 0)
+            return topology;
+        return WindowTopologySchema.parse({
+            version: 1,
+            status: "unavailable",
+            windows: [],
+            diagnostic: "ADB window topology contained no visible touchable target-app windows"
+        });
+    }
     tap(point, deviceSerial, signal) {
         return this.run([
             ...deviceArgs(deviceSerial),
@@ -177,6 +299,9 @@ export class AdbAdapter {
         ], signal);
     }
     async inputText(text, deviceSerial, signal) {
+        if (!isAsciiText(text)) {
+            return this.inputNonAsciiText(text, deviceSerial, signal);
+        }
         let result;
         for (const chunk of inputTextChunks(text)) {
             result = await this.run([
@@ -198,21 +323,95 @@ export class AdbAdapter {
         }
         return result;
     }
+    /**
+     * `adb shell input text` cannot type non-ASCII characters (KeyCharacterMap
+     * resolves them to no events and the input command fails), so non-ASCII text
+     * is delivered through the mobilenext devicekit clipboard: set the clipboard
+     * by broadcast, paste it into the focused element with KEYCODE_PASTE, then
+     * clear the clipboard again.
+     */
+    async inputNonAsciiText(text, deviceSerial, signal) {
+        const installed = await this.isInstalled({
+            packageName: DEVICEKIT_PACKAGE_NAME,
+            deviceSerial,
+            signal
+        });
+        if (!installed) {
+            return inputTextUnsupportedResult();
+        }
+        const encoded = Buffer.from(text, "utf8").toString("base64");
+        const commands = [
+            [
+                "am",
+                "broadcast",
+                "-a",
+                "devicekit.clipboard.set",
+                "-e",
+                "encoding",
+                "base64",
+                "-e",
+                "text",
+                quoteRemoteShellArgument(encoded),
+                "-n",
+                DEVICEKIT_CLIPBOARD_RECEIVER
+            ],
+            ["input", "keyevent", "KEYCODE_PASTE"],
+            [
+                "am",
+                "broadcast",
+                "-a",
+                "devicekit.clipboard.clear",
+                "-n",
+                DEVICEKIT_CLIPBOARD_RECEIVER
+            ]
+        ];
+        let result;
+        for (const command of commands) {
+            result = await this.run([
+                ...deviceArgs(deviceSerial),
+                "shell",
+                ...command
+            ], signal);
+            if (result.exitCode !== 0
+                || result.timedOut
+                || result.cancelled
+                || result.spawnError !== undefined) {
+                return result;
+            }
+        }
+        if (result === undefined) {
+            throw new Error("ADB input text produced no command");
+        }
+        return result;
+    }
     startLogcat(options) {
         return this.runner.start({
             executable: "adb",
             args: [
                 ...deviceArgs(options.deviceSerial),
                 "logcat",
+                "-T",
+                "1",
                 "-v",
                 "threadtime"
             ],
             ...(options.signal === undefined ? {} : { signal: options.signal })
         }, {
             onStdoutLine: options.onStdoutLine,
+            captureStdout: false,
+            captureStderr: false,
             ...(options.onStderrLine === undefined
                 ? {}
                 : { onStderrLine: options.onStderrLine })
         });
     }
+    dumpLogcat(options) {
+        return this.run([
+            ...deviceArgs(options.deviceSerial),
+            "logcat",
+            "-d",
+            "-t",
+            String(options.maxLines)
+        ], options.signal, options.timeoutMs);
+    }
 }

package/dist/adapters/adb/system-uiautomator-snapshot-provider.d.ts

@@ -0,0 +1,13 @@
+import type { ProcessRunner } from "../../ports/process-runner.js";
+import type { OpenUiSnapshotProviderOptions, UiSnapshotProvider, UiSnapshotProviderFactory } from "../../ports/ui-snapshot.js";
+import { type UiSnapshotTiming } from "../ui/ui-snapshot-support.js";
+interface SystemUiAutomatorFactoryOptions extends UiSnapshotTiming {
+    createLayoutPath?: (() => string) | undefined;
+}
+export declare class SystemUiAutomatorSnapshotProviderFactory implements UiSnapshotProviderFactory {
+    private readonly runner;
+    private readonly options;
+    constructor(runner: ProcessRunner, options?: SystemUiAutomatorFactoryOptions);
+    open(options: OpenUiSnapshotProviderOptions): Promise<UiSnapshotProvider>;
+}
+export {};

package/dist/adapters/adb/system-uiautomator-snapshot-provider.js

@@ -0,0 +1,122 @@
+import { createHash } from "node:crypto";
+import { performance } from "node:perf_hooks";
+import { parseUiAutomatorLayout } from "./ui-automator-parser.js";
+import { readDeviceUiEnvironment } from "../ui/device-ui-environment.js";
+import { createDeviceLayoutPath, sweepDeviceLayoutTemp } from "../ui/device-layout-temp.js";
+import { UiSnapshotError } from "../ui/ui-snapshot-error.js";
+import { snapshotFromCapture } from "../ui/ui-snapshot-support.js";
+function descriptor(sdkLevel) {
+    return {
+        id: "system-uiautomator",
+        adapterVersion: "system-uiautomator-v1",
+        engineVersion: `android-api-${String(sdkLevel)}`,
+        configSha256: createHash("sha256")
+            .update(JSON.stringify({ command: "uiautomator dump", version: 1 }))
+            .digest("hex")
+    };
+}
+class SystemUiAutomatorSnapshotProvider {
+    runner;
+    deviceSerial;
+    environment;
+    descriptor;
+    createLayoutPath;
+    timing;
+    closed = false;
+    constructor(runner, deviceSerial, environment, descriptor, createLayoutPath, timing) {
+        this.runner = runner;
+        this.deviceSerial = deviceSerial;
+        this.environment = environment;
+        this.descriptor = descriptor;
+        this.createLayoutPath = createLayoutPath;
+        this.timing = timing;
+    }
+    async capture(options) {
+        if (this.closed) {
+            throw new UiSnapshotError("UI_SNAPSHOT_FAILED", this.descriptor.id, "UI snapshot provider is closed");
+        }
+        const startedAt = performance.now();
+        const path = this.createLayoutPath();
+        const deadline = startedAt + options.timeoutMs;
+        const run = (args, timeoutMs) => (this.runner.run({
+            executable: "adb",
+            args: ["-s", this.deviceSerial, ...args],
+            timeoutMs,
+            ...(options.signal === undefined ? {} : { signal: options.signal })
+        }));
+        try {
+            const dumped = await run(["shell", "uiautomator", "dump", path], options.timeoutMs);
+            if (dumped.exitCode !== 0
+                || dumped.timedOut
+                || dumped.cancelled
+                || dumped.spawnError !== undefined) {
+                throw new UiSnapshotError("UI_SNAPSHOT_FAILED", this.descriptor.id, dumped.stderr.trim() || dumped.spawnError || "UIAutomator dump failed", { terminal: dumped.timedOut || dumped.cancelled });
+            }
+            const xml = await run(["exec-out", "cat", path], Math.max(1, deadline - performance.now()));
+            if (xml.exitCode !== 0
+                || xml.timedOut
+                || xml.cancelled
+                || xml.spawnError !== undefined) {
+                throw new UiSnapshotError("UI_SNAPSHOT_FAILED", this.descriptor.id, xml.stderr.trim() || xml.spawnError || "UIAutomator source read failed", { terminal: xml.timedOut || xml.cancelled });
+            }
+            let roots;
+            try {
+                roots = parseUiAutomatorLayout(xml.stdout);
+            }
+            catch (error) {
+                throw new UiSnapshotError("UI_SNAPSHOT_INVALID", this.descriptor.id, "UIAutomator returned malformed page source", { cause: error });
+            }
+            if (roots.length === 0) {
+                throw new UiSnapshotError("UI_SNAPSHOT_INVALID", this.descriptor.id, "UIAutomator returned an empty layout");
+            }
+            return snapshotFromCapture({
+                startedAt,
+                roots,
+                backend: this.descriptor,
+                viewport: this.environment.viewport,
+                timing: this.timing
+            });
+        }
+        finally {
+            await this.runner.run({
+                executable: "adb",
+                args: ["-s", this.deviceSerial, "shell", "rm", "-f", path],
+                timeoutMs: 5000
+            }).catch(() => undefined);
+        }
+    }
+    close() {
+        this.closed = true;
+        return sweepDeviceLayoutTemp(this.runner, this.deviceSerial);
+    }
+}
+export class SystemUiAutomatorSnapshotProviderFactory {
+    runner;
+    options;
+    constructor(runner, options = {}) {
+        this.runner = runner;
+        this.options = options;
+    }
+    async open(options) {
+        const environment = await readDeviceUiEnvironment(this.runner, "system-uiautomator", options);
+        await sweepDeviceLayoutTemp(this.runner, options.deviceSerial, options.signal);
+        const provider = new SystemUiAutomatorSnapshotProvider(this.runner, options.deviceSerial, environment, descriptor(environment.sdkLevel), this.options.createLayoutPath ?? createDeviceLayoutPath, this.options);
+        try {
+            await provider.capture({
+                reason: "evidence",
+                timeoutMs: options.timeoutMs,
+                ...(options.signal === undefined ? {} : { signal: options.signal })
+            });
+        }
+        catch (error) {
+            if (error instanceof UiSnapshotError
+                && error.code === "UI_SNAPSHOT_FAILED"
+                && !error.terminal
+                && options.signal?.aborted !== true) {
+                throw new UiSnapshotError("UI_BACKEND_UNAVAILABLE", "system-uiautomator", error.message, { cause: error });
+            }
+            throw error;
+        }
+        return provider;
+    }
+}

package/dist/adapters/adb/ui-automator-parser.d.ts

@@ -0,0 +1,3 @@
+import { type LayoutElement } from "../../domain/layout.js";
+export declare function parseUiAutomatorLayout(xml: string): readonly LayoutElement[];
+export declare function parseAppiumPageSource(xml: string): readonly LayoutElement[];

package/dist/adapters/adb/ui-automator-parser.js

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { LayoutElementSchema } from "../../domain/layout.js";
+import { normalizeBoundsEdges, normalizeResourceId } from "../ui/layout-normalization.js";
+const NAMED_ENTITIES = {
+    quot: "\"",
+    apos: "'",
+    lt: "<",
+    gt: ">",
+    amp: "&"
+};
+const ENTITY_PATTERN = /&(?:#(\d+)|#x([\da-fA-F]+)|(quot|apos|lt|gt|amp));/g;
+function decodeCodePoint(entity, codePoint) {
+    return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10ffff
+        ? String.fromCodePoint(codePoint)
+        : entity;
+}
+/**
+ * Single-pass XML entity decoding. Android's XML serializer escapes control
+ * characters such as newlines as numeric references (`&#10;`), so multi-line
+ * text must decode them to match Locators authored against the visible text.
+ */
+function decodeXml(value) {
+    if (!value.includes("&"))
+        return value;
+    return value.replace(ENTITY_PATTERN, (entity, decimal, hex, named) => {
+        if (decimal !== undefined) {
+            return decodeCodePoint(entity, Number.parseInt(decimal, 10));
+        }
+        if (hex !== undefined) {
+            return decodeCodePoint(entity, Number.parseInt(hex, 16));
+        }
+        return named === undefined ? entity : NAMED_ENTITIES[named] ?? entity;
+    });
+}
+function attributes(source) {
+    const result = {};
+    const pattern = /([A-Za-z_:][\w:.-]*)=(["'])(.*?)\2/g;
+    for (const match of source.matchAll(pattern)) {
+        const key = match[1];
+        const value = match[3];
+        if (key !== undefined && value !== undefined) {
+            result[key] = decodeXml(value);
+        }
+    }
+    return result;
+}
+function booleanAttribute(values, key) {
+    const value = values[key];
+    return value === undefined ? undefined : value === "true";
+}
+function bounds(value) {
+    if (value === undefined)
+        return undefined;
+    const match = /^\[(\d+),(\d+)]\[(\d+),(\d+)]$/.exec(value);
+    if (match === null) {
+        throw new Error("Invalid UIAutomator bounds");
+    }
+    return normalizeBoundsEdges(Number(match[1]), Number(match[2]), Number(match[3]), Number(match[4]));
+}
+/**
+ * Builds one element without re-validating its subtree: `LayoutElementSchema`
+ * is recursive, so parsing every node would validate each subtree once per
+ * ancestor (O(nodes x depth)). The completed roots are validated exactly once
+ * in `parseAccessibilityLayout`.
+ */
+function node(values, id, children) {
+    const parsedBounds = bounds(values.bounds);
+    const text = values.text;
+    const contentDescription = values["content-desc"];
+    const center = parsedBounds === undefined
+        ? undefined
+        : {
+            x: Math.round((parsedBounds.left + parsedBounds.right) / 2),
+            y: Math.round((parsedBounds.top + parsedBounds.bottom) / 2)
+        };
+    const resourceId = normalizeResourceId(values["resource-id"]);
+    return {
+        id,
+        ...(resourceId === undefined ? {} : { resourceId }),
+        ...(text === undefined || text.length === 0 ? {} : { text }),
+        ...(contentDescription === undefined || contentDescription.length === 0
+            ? {}
+            : { contentDescription }),
+        ...(booleanAttribute(values, "clickable") === undefined
+            ? {}
+            : { clickable: booleanAttribute(values, "clickable") }),
+        ...(booleanAttribute(values, "long-clickable") === undefined
+            ? {}
+            : { longClickable: booleanAttribute(values, "long-clickable") }),
+        ...(booleanAttribute(values, "scrollable") === undefined
+            ? {}
+            : { scrollable: booleanAttribute(values, "scrollable") }),
+        ...(booleanAttribute(values, "focusable") === undefined
+            ? {}
+            : { focusable: booleanAttribute(values, "focusable") }),
+        ...(booleanAttribute(values, "focused") === undefined
+            ? {}
+            : { focused: booleanAttribute(values, "focused") }),
+        enabled: booleanAttribute(values, "enabled") ?? true,
+        ...(center === undefined ? {} : { center }),
+        ...(parsedBounds === undefined ? {} : { bounds: parsedBounds }),
+        children
+    };
+}
+function parseAccessibilityLayout(xml, accepts) {
+    const roots = [];
+    const stack = [];
+    // Quoted attribute values may legally contain an unescaped `>`.
+    const tokenPattern = /<\/?([A-Za-z_][\w:.$-]*)\b(?:[^>"']|"[^"]*"|'[^']*')*\/?>/g;
+    let token;
+    let index = 0;
+    while ((token = tokenPattern.exec(xml)) !== null) {
+        const source = token[0];
+        const tag = token[1];
+        if (tag === undefined || !accepts(tag))
+            continue;
+        if (source.startsWith("</")) {
+            const current = stack.pop();
+            if (current === undefined || current.tag !== tag) {
+                throw new Error("Invalid UIAutomator node nesting");
+            }
+            const parsed = node(current.values, current.id, current.children);
+            const parent = stack.at(-1);
+            if (parent === undefined)
+                roots.push(parsed);
+            else
+                parent.children.push(parsed);
+            continue;
+        }
+        const selfClosing = source.endsWith("/>");
+        const current = {
+            tag,
+            values: attributes(source),
+            children: [],
+            id: `ui-${String(index)}`
+        };
+        index += 1;
+        if (selfClosing) {
+            const parsed = node(current.values, current.id, current.children);
+            const parent = stack.at(-1);
+            if (parent === undefined)
+                roots.push(parsed);
+            else
+                parent.children.push(parsed);
+        }
+        else {
+            stack.push(current);
+        }
+    }
+    if (stack.length > 0) {
+        throw new Error("Invalid UIAutomator node nesting");
+    }
+    return z.array(LayoutElementSchema).parse(roots);
+}
+export function parseUiAutomatorLayout(xml) {
+    return parseAccessibilityLayout(xml, (tag) => tag === "node");
+}
+export function parseAppiumPageSource(xml) {
+    return parseAccessibilityLayout(xml, (tag) => tag !== "hierarchy");
+}

package/dist/adapters/adb/window-topology-parser.d.ts

@@ -0,0 +1,2 @@
+import { type WindowTopology } from "../../domain/window-hierarchy.js";
+export declare function parseWindowTopology(stdout: string, packageName: string): WindowTopology;

package/dist/adapters/adb/window-topology-parser.js

@@ -0,0 +1,101 @@
+import { WindowTopologySchema } from "../../domain/window-hierarchy.js";
+const WINDOW_HEADER = /^\s*Window #\d+ Window\{(\S+)\s+u\d+\s+(.+)}:$/;
+const FRAME = /\bframe=\[(-?\d+),(-?\d+)]\[(-?\d+),(-?\d+)]/;
+function windowBlocks(stdout) {
+    const blocks = [];
+    let current;
+    for (const line of stdout.split(/\r?\n/)) {
+        if (WINDOW_HEADER.test(line)) {
+            current = [line];
+            blocks.push(current);
+        }
+        else {
+            current?.push(line);
+        }
+    }
+    return blocks;
+}
+function value(lines, pattern) {
+    for (const line of lines) {
+        const match = pattern.exec(line);
+        if (match?.[1] !== undefined)
+            return match[1];
+    }
+    return undefined;
+}
+function parseBounds(lines) {
+    const frames = lines.find((line) => line.includes("Frames:"));
+    const match = frames === undefined ? null : FRAME.exec(frames);
+    if (match?.[1] === undefined
+        || match[2] === undefined
+        || match[3] === undefined
+        || match[4] === undefined) {
+        return undefined;
+    }
+    const [left, top, right, bottom] = match.slice(1).map(Number);
+    if (left === undefined
+        || top === undefined
+        || right === undefined
+        || bottom === undefined
+        || left < 0
+        || top < 0
+        || right <= left
+        || bottom <= top) {
+        return undefined;
+    }
+    return { left, top, right, bottom };
+}
+function parseWindow(lines, packageName, focusedWindowId) {
+    const header = lines[0];
+    const headerMatch = header === undefined ? null : WINDOW_HEADER.exec(header);
+    if (headerMatch?.[1] === undefined
+        || headerMatch[2] === undefined
+        || value(lines, /\bpackage=(\S+)/) !== packageName
+        || !lines.some((line) => /\bisVisible=true\b/.test(line))
+        || !lines.some((line) => /\bisOnScreen=true\b/.test(line))
+        || !lines.some((line) => /\bmHasSurface=true\b/.test(line))
+        || !lines.some((line) => /\bisReadyForDisplay\(\)=true\b/.test(line))) {
+        return undefined;
+    }
+    const attrs = lines.findIndex((line) => line.includes("mAttrs={"));
+    const attrsEnd = attrs < 0
+        ? attrs
+        : lines.findIndex((line, index) => (index >= attrs && line.trim().endsWith("}")));
+    const attributeLines = attrs < 0
+        ? []
+        : lines.slice(attrs, attrsEnd < attrs ? attrs + 1 : attrsEnd + 1);
+    const bounds = parseBounds(lines);
+    const layer = value(lines, /\bmBaseLayer=(\d+)/);
+    const type = value(attributeLines, /\bty=([A-Z0-9_]+)/);
+    return {
+        id: headerMatch[1],
+        title: headerMatch[2],
+        packageName,
+        ...(type === undefined ? {} : { type }),
+        ...(layer === undefined ? {} : { layer: Number(layer) }),
+        ...(bounds === undefined ? {} : { bounds }),
+        touchable: !attributeLines.some((line) => /\bNOT_TOUCHABLE\b/.test(line)),
+        ...(attributeLines.some((line) => /\bfl=/.test(line))
+            ? {
+                focusable: !attributeLines.some((line) => /\bNOT_FOCUSABLE\b/.test(line))
+            }
+            : {}),
+        ...(focusedWindowId === undefined
+            ? {}
+            : { focused: focusedWindowId === headerMatch[1] })
+    };
+}
+export function parseWindowTopology(stdout, packageName) {
+    const focusedWindowId = value(stdout.split(/\r?\n/), /\bmCurrentFocus=Window\{(\S+)/);
+    return WindowTopologySchema.parse({
+        version: 1,
+        status: "observed",
+        windows: windowBlocks(stdout)
+            .flatMap((block) => {
+            const window = parseWindow(block, packageName, focusedWindowId);
+            return window === undefined || !window.touchable ? [] : [window];
+        })
+            .sort((left, right) => ((right.layer ?? 0) - (left.layer ?? 0)
+            || left.id.localeCompare(right.id)))
+    });
+}