mobile-debug-mcp 0.31.0 → 0.32.1

package/dist/observe/android.js

@@ -7,17 +7,29 @@ import path from "path";
 import { computeScreenFingerprint } from "../utils/ui/index.js";
 import { parsePngSize } from "../utils/image.js";
 import { deriveSnapshotMetadata } from "./snapshot-metadata.js";
+import { remainingBudget } from '../utils/operation-budget.js';
+import { createObservationMeasurement } from './performance-metrics.js';
+import { androidTreeBridgeEnabled, readAndroidTreeFromBridge } from './android-tree-bridge.js';
 const activeLogStreams = new Map();
 export class AndroidObserve {
     async getDeviceMetadata(appId, deviceId) {
         return getAndroidDeviceMetadata(appId, deviceId);
     }
     async getUITree(deviceId) {
-        const metadata = await getAndroidDeviceMetadata("", deviceId);
+        const measurement = createObservationMeasurement('android');
+        let metadata;
+        try {
+            metadata = await measurement.timed('metadata_ms', () => getAndroidDeviceMetadata("", deviceId));
+        }
+        catch (error) {
+            measurement.setOutcome('unavailable');
+            measurement.finish();
+            throw error;
+        }
         const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
         try {
             // Get screen resolution first
-            const resolution = await getScreenResolution(deviceId);
+            const resolution = await measurement.timed('resolution_ms', () => getScreenResolution(deviceId));
             if (resolution.width === 0 && resolution.height === 0) {
                 throw new Error("Failed to get screen resolution. Is the device connected and authorized?");
             }
@@ -26,20 +38,42 @@ export class AndroidObserve {
             let attempts = 0;
             const maxAttempts = 3;
             while (attempts < maxAttempts) {
+                remainingBudget();
                 attempts++;
                 try {
-                    // Stabilization delay
-                    await delay(300 + (attempts * 100)); // 300ms, 400ms, 500ms...
-                    // Dump UI hierarchy
-                    await execAdb(['shell', 'uiautomator', 'dump', '/sdcard/ui.xml'], deviceId);
-                    // Read the file
-                    xmlContent = await execAdb(['shell', 'cat', '/sdcard/ui.xml'], deviceId);
-                    // Check validity
-                    if (xmlContent && xmlContent.trim().length > 0 && !xmlContent.includes("ERROR:")) {
-                        break; // Success
+                    // The first read starts immediately so it remains fresh for in-place UI changes.
+                    // Delay only a retry after a failed or invalid acquisition.
+                    if (attempts > 1) {
+                        await measurement.timed('observation_wait_ms', () => delay(Math.min(remainingBudget(300 + (attempts * 100)), 300 + (attempts * 100))));
+                    }
+                    remainingBudget();
+                    let bridgeContent = null;
+                    if (androidTreeBridgeEnabled()) {
+                        try {
+                            bridgeContent = await measurement.physicalRead(async () => {
+                                const content = await readAndroidTreeFromBridge(deviceInfo.id);
+                                if (!content)
+                                    throw new Error('Android UI tree bridge unavailable');
+                                return content;
+                            });
+                        }
+                        catch (error) {
+                            if (error instanceof Error && (error.message === 'ACTION_TIMEOUT' || error.message.startsWith('BRIDGE_CLEANUP_UNCONFIRMED')))
+                                throw error;
+                        }
                     }
+                    xmlContent = bridgeContent ?? await measurement.physicalRead(async () => {
+                        await execAdb(['shell', 'uiautomator', 'dump', '/sdcard/ui.xml'], deviceId);
+                        const content = await execAdb(['shell', 'cat', '/sdcard/ui.xml'], deviceId);
+                        if (!content || !content.trim() || content.includes('ERROR:'))
+                            throw new Error('Empty or invalid UI dump');
+                        return content;
+                    });
+                    break;
                 }
                 catch (e) {
+                    if (e instanceof Error && (e.message === 'ACTION_TIMEOUT' || e.message.startsWith('BRIDGE_CLEANUP_UNCONFIRMED')))
+                        throw e;
                     console.error(`Attempt ${attempts} failed: ${e}`);
                 }
                 if (attempts === maxAttempts) {
@@ -50,7 +84,7 @@ export class AndroidObserve {
                 ignoreAttributes: false,
                 attributeNamePrefix: "@_"
             });
-            const result = parser.parse(xmlContent);
+            const result = await measurement.timed('parse_ms', async () => parser.parse(xmlContent));
             const elements = [];
             // The root is usually hierarchy -> node
             if (result.hierarchy && result.hierarchy.node) {
@@ -67,18 +101,23 @@ export class AndroidObserve {
                 resolution,
                 elements
             }, 'ui_tree');
-            return {
+            measurement.setOutcome('observed');
+            const response = measurement.bindObservation({
                 device: deviceInfo,
                 screen: "",
                 resolution,
                 elements,
                 ...snapshotMetadata
-            };
+            });
+            measurement.finish();
+            return response;
         }
         catch (e) {
             const errorMessage = `Failed to get UI tree. ADB Path: '${getAdbCmd()}'. Error: ${e instanceof Error ? e.message : String(e)}`;
             console.error(errorMessage);
             const snapshotMetadata = deriveSnapshotMetadata(`android:${deviceInfo.id}`, null, 'ui_tree');
+            measurement.setOutcome('unavailable');
+            measurement.finish();
             return {
                 device: deviceInfo,
                 screen: "",

package/dist/observe/index.js

@@ -1,7 +1,8 @@
+import { measure } from '../utils/timing.js';
 import { resolveTargetDevice } from '../utils/resolve-device.js';
 import { AndroidObserve } from './android.js';
 import { iOSObserve } from './ios.js';
-import { deriveSnapshotMetadata } from './snapshot-metadata.js';
+import { deriveSnapshotMetadata, getLatestStateDelta, getStateDelta } from './snapshot-metadata.js';
 export { AndroidObserve } from './android.js';
 export { iOSObserve } from './ios.js';
 function normalizeHint(value) {
@@ -110,6 +111,9 @@ function deriveSnapshotSemantic(raw) {
     };
 }
 export class ToolsObserve {
+    static getLatestStateDelta(platform, deviceId) {
+        return getLatestStateDelta(`${platform}:${deviceId}`);
+    }
     // Resolve a target device and return the appropriate observe instance and resolved info.
     static async resolveObserve(platform, deviceId, appId) {
         if (platform === 'android') {
@@ -130,9 +134,22 @@ export class ToolsObserve {
             return { observe: new iOSObserve(), resolved };
         }
     }
-    static async getUITreeHandler({ platform, deviceId }) {
+    static async getUITreeHandler({ platform, deviceId, responseMode = 'debug', sinceSnapshotRevision }) {
         const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId);
-        return await observe.getUITree(resolved.id);
+        const tree = await observe.getUITree(resolved.id);
+        if (responseMode !== 'compact')
+            return tree;
+        const revision = tree?.snapshot_revision ?? null;
+        const baseRevision = sinceSnapshotRevision;
+        if (!Number.isInteger(baseRevision) || revision === null) {
+            return { delta_available: false, snapshot_revision: revision };
+        }
+        const delta = getStateDelta(`${resolved.platform}:${resolved.id}`, baseRevision, revision);
+        return delta ? { delta_available: true, state_delta: delta, snapshot_revision: revision } : {
+            delta_available: false,
+            snapshot_revision: revision,
+            reason: 'BASE_REVISION_UNAVAILABLE'
+        };
     }
     static async getCurrentScreenHandler({ deviceId }) {
         const { observe, resolved } = await ToolsObserve.resolveObserve('android', deviceId);
@@ -199,7 +216,7 @@ export class ToolsObserve {
         // Both observes implement getScreenFingerprint
         return await observe.getScreenFingerprint(resolved.id);
     }
-    static async captureDebugSnapshotHandler({ reason, includeLogs = true, logLines = 200, platform, appId, deviceId, sessionId } = {}) {
+    static async captureDebugSnapshotHandler({ reason, includeLogs = true, includeScreenshot = true, logLines = 200, platform, appId, deviceId, sessionId } = {}) {
         const timestamp = Date.now();
         const raw = {
             timestamp,
@@ -215,7 +232,7 @@ export class ToolsObserve {
         // Parallel fetches for performance: screenshot, current screen, fingerprint, ui tree, and log stream/get logs
         const sid = sessionId || 'default';
         const tasks = {
-            screenshot: ToolsObserve.captureScreenshotHandler({ platform, deviceId }),
+            screenshot: includeScreenshot ? measure('screenshot_ms', () => ToolsObserve.captureScreenshotHandler({ platform, deviceId })) : Promise.resolve(null),
             currentScreen: (!platform || platform === 'android') ? ToolsObserve.getCurrentScreenHandler({ deviceId }) : Promise.resolve(null),
             fingerprint: ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }),
             uiTree: ToolsObserve.getUITreeHandler({ platform, deviceId }),

package/dist/observe/ios.js

@@ -1,4 +1,7 @@
 import { spawn } from "child_process";
+import { remainingBudget } from '../utils/operation-budget.js';
+import { execCmd } from '../utils/exec.js';
+import { createObservationMeasurement } from './performance-metrics.js';
 import { promises as fs } from "fs";
 import { execCommand, getIOSDeviceMetadata, validateBundleId, getIdbCmd, getXcrunCmd, isIDBInstalled } from "../utils/ios/utils.js";
 import { createWriteStream, promises as fsPromises } from 'fs';
@@ -482,11 +485,22 @@ export class iOSObserve {
         }
     }
     async getUITree(deviceId = "booted") {
-        const device = await getIOSDeviceMetadata(deviceId);
+        const measurement = createObservationMeasurement('ios');
+        let device;
+        try {
+            device = await measurement.timed('metadata_ms', () => getIOSDeviceMetadata(deviceId));
+        }
+        catch (error) {
+            measurement.setOutcome('unavailable');
+            measurement.finish();
+            throw error;
+        }
         const deviceKey = `ios:${device.id}`;
-        const idbExists = await isIDBInstalled();
+        const idbExists = await measurement.timed('capability_check_ms', () => isIDBInstalled());
         if (!idbExists) {
             const snapshotMetadata = deriveSnapshotMetadata(deviceKey, null, 'ui_tree');
+            measurement.setOutcome('unavailable');
+            measurement.finish();
             return {
                 device,
                 screen: "",
@@ -501,39 +515,39 @@ export class iOSObserve {
         let attempts = 0;
         const maxAttempts = 3;
         while (attempts < maxAttempts) {
+            remainingBudget();
             attempts++;
             try {
-                await delay(300 + (attempts * 100));
+                await measurement.timed('observation_wait_ms', () => delay(Math.min(remainingBudget(300 + (attempts * 100)), 300 + (attempts * 100))));
+                remainingBudget();
                 const args = ['ui', 'describe-all', '--json'];
                 if (targetUdid) {
                     args.push('--udid', targetUdid);
                 }
-                const output = await new Promise((resolve, reject) => {
-                    const child = spawn(getIdbCmd(), args);
-                    let stdout = '';
-                    let stderr = '';
-                    child.stdout.on('data', (data) => stdout += data.toString());
-                    child.stderr.on('data', (data) => stderr += data.toString());
-                    child.on('error', (err) => reject(new Error(`Failed to execute idb: ${err.message}`)));
-                    child.on('close', (code) => {
-                        if (code !== 0) {
-                            reject(new Error(`idb failed (code ${code}): ${stderr.trim()}`));
-                        }
-                        else {
-                            resolve(stdout);
-                        }
-                    });
+                const output = await measurement.physicalRead(async () => {
+                    const result = await execCmd(getIdbCmd(), args, { timeout: remainingBudget() });
+                    if (result.stderr === 'ACTION_TIMEOUT')
+                        throw new Error('ACTION_TIMEOUT');
+                    if (result.exitCode !== 0)
+                        throw new Error(`idb failed (code ${result.exitCode}): ${result.stderr}`);
+                    if (!result.stdout.trim())
+                        throw new Error('Empty idb UI tree output');
+                    return result.stdout;
                 });
                 if (output && output.trim().length > 0) {
-                    jsonContent = JSON.parse(output);
+                    jsonContent = await measurement.timed('parse_ms', async () => JSON.parse(output));
                     break; // Success
                 }
             }
             catch (e) {
+                if (e instanceof Error && e.message === 'ACTION_TIMEOUT')
+                    throw e;
                 console.error(`Attempt ${attempts} failed: ${e}`);
             }
             if (attempts === maxAttempts) {
                 const snapshotMetadata = deriveSnapshotMetadata(deviceKey, null, 'ui_tree');
+                measurement.setOutcome('unavailable');
+                measurement.finish();
                 return {
                     device,
                     screen: "",
@@ -545,15 +559,17 @@ export class iOSObserve {
             }
         }
         try {
-            const elements = [];
-            if (Array.isArray(jsonContent)) {
-                for (const node of jsonContent) {
-                    traverseIDBNode(node, elements);
+            const elements = await measurement.timed('conversion_ms', async () => {
+                const parsed = [];
+                if (Array.isArray(jsonContent)) {
+                    for (const node of jsonContent)
+                        traverseIDBNode(node, parsed);
                 }
-            }
-            else {
-                traverseIDBNode(jsonContent, elements);
-            }
+                else {
+                    traverseIDBNode(jsonContent, parsed);
+                }
+                return parsed;
+            });
             let width = 0;
             let height = 0;
             if (elements.length > 0) {
@@ -566,16 +582,21 @@ export class iOSObserve {
                 resolution: { width, height },
                 elements
             }, 'ui_tree');
-            return {
+            measurement.setOutcome('observed');
+            const response = measurement.bindObservation({
                 device,
                 screen: "",
                 resolution: { width, height },
                 elements,
                 ...snapshotMetadata
-            };
+            });
+            measurement.finish();
+            return response;
         }
         catch (e) {
             const snapshotMetadata = deriveSnapshotMetadata(deviceKey, null, 'ui_tree');
+            measurement.setOutcome('unavailable');
+            measurement.finish();
             return {
                 device,
                 screen: "",

package/dist/observe/performance-metrics.js

@@ -0,0 +1,124 @@
+import { randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+const context = new AsyncLocalStorage();
+const observationIds = new WeakMap();
+export function withObservationContext(value, operation) {
+    if (process.env.MOBILE_DEBUG_MCP_UI_TREE_METRICS !== '1')
+        return operation();
+    return context.run({ purpose: value.purpose ?? context.getStore()?.purpose ?? 'unspecified', stepId: value.stepId ?? context.getStore()?.stepId }, operation);
+}
+export function recordObservationEvent(event) {
+    if (process.env.MOBILE_DEBUG_MCP_UI_TREE_METRICS !== '1')
+        return;
+    const current = context.getStore();
+    process.stderr.write(`${JSON.stringify({
+        event: 'ui_tree_metric',
+        host_monotonic_ns: process.hrtime.bigint().toString(),
+        type: 'action_observation',
+        step_id: current?.stepId,
+        purpose: current?.purpose ?? 'unspecified',
+        ...event
+    })}\n`);
+}
+export function recordObservationConsumer(observation, purpose, stepId) {
+    if (process.env.MOBILE_DEBUG_MCP_UI_TREE_METRICS !== '1' || !observation || typeof observation !== 'object')
+        return;
+    const acquisitionId = observationIds.get(observation);
+    if (!acquisitionId)
+        return;
+    const current = context.getStore();
+    process.stderr.write(`${JSON.stringify({
+        event: 'ui_tree_metric',
+        host_monotonic_ns: process.hrtime.bigint().toString(),
+        type: 'observation_consumer',
+        acquisition_id: acquisitionId,
+        consumer_step_id: stepId ?? current?.stepId,
+        consumer_purpose: purpose,
+        reused_observations: 1
+    })}\n`);
+}
+export function createObservationMeasurement(platform) {
+    const enabled = process.env.MOBILE_DEBUG_MCP_UI_TREE_METRICS === '1';
+    const startedAt = enabled ? performance.now() : 0;
+    const id = enabled ? randomUUID() : undefined;
+    const current = context.getStore();
+    const durations = {};
+    let successfulOutput = false;
+    let outcome = 'unavailable';
+    let readAttempt = 0;
+    const emit = (event) => {
+        if (!enabled)
+            return;
+        process.stderr.write(`${JSON.stringify({
+            event: 'ui_tree_metric',
+            host_monotonic_ns: process.hrtime.bigint().toString(),
+            acquisition_id: id,
+            platform,
+            step_id: current?.stepId,
+            purpose: current?.purpose ?? 'unspecified',
+            ...event
+        })}\n`);
+    };
+    return {
+        id,
+        bindObservation(observation) {
+            if (enabled && id)
+                observationIds.set(observation, id);
+            return observation;
+        },
+        timed: async (stage, operation) => {
+            if (!enabled)
+                return operation();
+            const start = performance.now();
+            let success = true;
+            try {
+                return await operation();
+            }
+            catch (error) {
+                success = false;
+                throw error;
+            }
+            finally {
+                const elapsed = performance.now() - start;
+                durations[stage] = (durations[stage] ?? 0) + elapsed;
+                emit({ type: 'stage', stage, attempt_index: stage === 'parse_ms' ? readAttempt : undefined, elapsed_ms: elapsed, success });
+            }
+        },
+        physicalRead: async (operation) => {
+            if (!enabled)
+                return operation();
+            const start = performance.now();
+            readAttempt++;
+            emit({ type: 'physical_read_started', attempt_index: readAttempt });
+            try {
+                const result = await operation();
+                successfulOutput = true;
+                emit({ type: 'physical_read_completed', attempt_index: readAttempt, elapsed_ms: performance.now() - start, success: true });
+                return result;
+            }
+            catch (error) {
+                emit({ type: 'physical_read_completed', attempt_index: readAttempt, elapsed_ms: performance.now() - start, success: false });
+                throw error;
+            }
+        },
+        setOutcome(value) { if (enabled)
+            outcome = value; },
+        finish() {
+            if (!enabled)
+                return;
+            emit({
+                type: 'observation_consumer',
+                consumer_step_id: current?.stepId,
+                consumer_purpose: current?.purpose ?? 'unspecified',
+                reused_observations: 0
+            });
+            emit({
+                type: 'acquisition_completed',
+                elapsed_ms: performance.now() - startedAt,
+                successful_output: successfulOutput,
+                outcome,
+                durations_ms: durations
+            });
+        }
+    };
+}

package/dist/observe/snapshot-metadata.js

@@ -1,4 +1,5 @@
 import crypto from 'crypto';
+let nextRevision = 1;
 const snapshotStateByDevice = new Map();
 function normalize(value) {
     if (value === null || value === undefined)
@@ -43,17 +44,19 @@ function stableElementIdentity(element, index) {
         index
     })).digest('hex')}`;
 }
-function buildElementSignatures(tree) {
+function buildElementRecords(tree) {
     const signatures = new Map();
+    const elementsByIdentity = new Map();
     const elements = Array.isArray(tree?.elements) ? tree.elements : [];
-    for (let index = 0; index < elements.length; index++) {
+    for (let index = 0; index < Math.min(elements.length, 500); index++) {
         const element = elements[index];
         if (!element)
             continue;
         const identity = stableElementIdentity(element, index);
         signatures.set(identity, crypto.createHash('sha1').update(JSON.stringify(stableElementSignature(element))).digest('hex'));
+        elementsByIdentity.set(identity, structuredClone(element));
     }
-    return signatures;
+    return { signatures, elementsByIdentity };
 }
 function summarizeSnapshotDelta(previous, currentElements) {
     if (!previous)
@@ -118,24 +121,47 @@ export function detectLoadingState(tree, source) {
 }
 export function deriveSnapshotMetadata(deviceKey, tree, source, signatureOverride) {
     const signature = signatureOverride ?? computeSnapshotSignature(tree);
-    const previous = snapshotStateByDevice.get(deviceKey);
+    const existing = snapshotStateByDevice.get(deviceKey);
+    const previous = existing && Date.now() - existing.updatedAt <= 10 * 60 * 1000 ? existing : undefined;
+    if (!previous && existing)
+        snapshotStateByDevice.delete(deviceKey);
     const hasValidTree = !!tree && !tree.error;
-    const currentElementSignatures = hasValidTree
-        ? buildElementSignatures(tree)
-        : previous?.elementSignatures ?? new Map();
-    let revision = 1;
-    if (previous) {
-        if (signature === null) {
-            revision = previous.revision;
-        }
-        else {
-            revision = previous.signature === signature ? previous.revision : previous.revision + 1;
+    const records = hasValidTree ? buildElementRecords(tree) : null;
+    const currentElementSignatures = records?.signatures ?? previous?.elementSignatures ?? new Map();
+    const currentElements = records?.elementsByIdentity ?? previous?.elements ?? new Map();
+    const revision = previous && (signature === null || previous.signature === signature) ? previous.revision : nextRevision++;
+    const history = previous?.history ?? new Map();
+    const historyTimes = previous?.historyTimes ?? new Map();
+    const oversized = previous?.oversized ?? new Map();
+    if (hasValidTree) {
+        history.set(revision, currentElements);
+        if (!historyTimes.has(revision))
+            historyTimes.set(revision, Date.now());
+        if ((tree.elements?.length ?? 0) > 500)
+            oversized.set(revision, (tree.elements?.length ?? 0) - 500);
+    }
+    for (const [id, timestamp] of historyTimes) {
+        if (Date.now() - timestamp > 10 * 60 * 1000) {
+            history.delete(id);
+            historyTimes.delete(id);
+            oversized.delete(id);
         }
     }
+    while (history.size > 8) {
+        const oldest = history.keys().next().value;
+        if (oldest === undefined)
+            break;
+        history.delete(oldest);
+        historyTimes.delete(oldest);
+        oversized.delete(oldest);
+    }
     snapshotStateByDevice.set(deviceKey, {
         revision,
         signature,
-        elementSignatures: currentElementSignatures
+        elementSignatures: currentElementSignatures,
+        elements: currentElements,
+        history, historyTimes, oversized, previousRevision: previous?.revision ?? null,
+        updatedAt: Date.now()
     });
     return {
         snapshot_revision: revision,
@@ -144,6 +170,59 @@ export function deriveSnapshotMetadata(deviceKey, tree, source, signatureOverrid
         loading_state: detectLoadingState(tree, source)
     };
 }
+export function getStateDelta(deviceKey, baseRevision, currentRevision) {
+    const state = snapshotStateByDevice.get(deviceKey);
+    if (!state || Date.now() - (state.historyTimes.get(baseRevision) ?? 0) > 10 * 60 * 1000 || Date.now() - state.updatedAt > 10 * 60 * 1000)
+        return null;
+    const base = state.history.get(baseRevision);
+    const current = state?.history.get(currentRevision);
+    if (!base || !current)
+        return null;
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const [identity, element] of current) {
+        const before = base.get(identity);
+        if (!before)
+            added.push(element);
+        else if (JSON.stringify(stableElementSignature(before)) !== JSON.stringify(stableElementSignature(element)))
+            changed.push(element);
+    }
+    let index = 0;
+    for (const [identity, element] of base) {
+        if (!current.has(identity))
+            removed.push({ stable_id: element.stable_id ?? undefined, resourceId: element.resourceId ?? undefined, contentDescription: element.contentDescription ?? undefined, text: element.text ?? undefined, index });
+        index++;
+    }
+    const all = added.length + changed.length + removed.length;
+    const limit = 200;
+    return {
+        base_snapshot_revision: baseRevision,
+        snapshot_revision: currentRevision,
+        added: added.slice(0, limit),
+        changed: changed.slice(0, Math.max(0, limit - added.length)),
+        removed: removed.slice(0, Math.max(0, limit - added.length - changed.length)),
+        truncated: all > limit || state.oversized.has(baseRevision) || state.oversized.has(currentRevision),
+        ...((all > limit || state.oversized.has(baseRevision) || state.oversized.has(currentRevision))
+            ? { omitted_changes: Math.max(all - limit, state.oversized.get(baseRevision) ?? 0, state.oversized.get(currentRevision) ?? 0) } : {})
+    };
+}
+export function getLatestStateDelta(deviceKey) {
+    const state = snapshotStateByDevice.get(deviceKey);
+    if (!state || state.previousRevision === null)
+        return null;
+    return getStateDelta(deviceKey, state.previousRevision, state.revision);
+}
+export function retainConnectedDeviceSnapshots(platform, deviceIds) {
+    const keys = new Set(deviceIds.map(id => `${platform}:${id}`));
+    for (const key of snapshotStateByDevice.keys())
+        if (key.startsWith(`${platform}:`) && !keys.has(key))
+            snapshotStateByDevice.delete(key);
+}
+export function clearDeviceSnapshots(deviceKey) {
+    snapshotStateByDevice.delete(deviceKey);
+}
 export function resetSnapshotMetadataForTests() {
     snapshotStateByDevice.clear();
+    nextRevision = 1;
 }

package/dist/server/common.js

@@ -1,13 +1,18 @@
+import { recordTiming } from '../utils/timing.js';
 import { ToolsObserve } from '../observe/index.js';
 export const DEFAULT_MAX_RECOVERY_ATTEMPTS = 3;
 export const DEFAULT_MAX_RETRY_DEPTH = 3;
-export function wrapResponse(data) {
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(data, null, 2)
-            }]
-    };
+export function wrapResponse(data, includeSerializationTiming = true) {
+    const start = performance.now();
+    let text = JSON.stringify(data, null, 2);
+    const elapsed = performance.now() - start;
+    const value = data;
+    if (includeSerializationTiming && value && typeof value === 'object' && value.timing && typeof value.timing === 'object') {
+        value.timing.serialization_ms = (value.timing.serialization_ms ?? 0) + elapsed;
+        recordTiming('serialization_ms', elapsed);
+        text = JSON.stringify(value, null, 2);
+    }
+    return { content: [{ type: 'text', text }] };
 }
 export function getStringArg(args, key) {
     const value = args[key];
@@ -230,6 +235,7 @@ function mapFailureCodeToFailureClass(code) {
         case 'STALE_REFERENCE':
             return 'TargetResolutionFailure';
         case 'ELEMENT_NOT_INTERACTABLE':
+        case 'ACTION_TIMEOUT':
             return 'ExecutionFailure';
         case 'TIMEOUT':
         case 'ACTION_REJECTED':
@@ -238,6 +244,7 @@ function mapFailureCodeToFailureClass(code) {
             return 'ExecutionFailure';
         case 'VERIFICATION_FAILED':
         case 'EXPECT_STATE_MISMATCH':
+        case 'ASSERTION_TIMEOUT':
             return 'VerificationFailure';
         case 'CONTROL_CONVERGENCE_FAILED':
             return 'ControlConvergenceFailure';