mobile-debug-mcp 0.34.0 → 0.36.0

package/agent-plugin/skills/mobile-debug-mcp/SKILL.md

@@ -90,8 +90,8 @@ When a visible target may still be loading or transitioning, use
 `get_app_readiness` reports loading, transitioning, settled, or unknown with
 supporting evidence. A single tree cannot establish settled state. Settled means
 normalized foreground UI stability, not proven responsiveness, app identity, or
-backend completion. Managed Android debugger sessions can establish
-`debugger_paused`; external-debugger and iOS pause detection remain unsupported.
+backend completion. Managed Android and supported iOS simulator debugger sessions can establish
+`debugger_paused`; external-debugger pause detection remains unsupported.
 Unresponsive detection is unsupported. Timeouts and screenshots alone do not
 establish either state.
 
@@ -118,7 +118,7 @@ For behaviour outside the app's foreground screen, inspect the relevant system
 surface or device state. For content that cannot be established visually, such
 as audio output, use a suitable direct check or state that it was not verified.
 
-## Investigate slow Android journeys
+## Investigate slow mobile journeys
 
 Use system tracing for a reproducible slow or stalled interaction when UI timing,
 state and logs do not explain it. Avoid recording traces for routine navigation.
@@ -126,12 +126,19 @@ Check that the connected server exposes the tracing tools; an older installed
 server may not have them. If absent or unsupported, report that limit and retain
 available UI/log evidence rather than assuming capture is possible.
 
-1. Call `get_system_trace_capabilities` for the explicit Android device and check
-   `supported` and missing prerequisites. iOS tracing is unsupported.
+1. Call `get_system_trace_capabilities` for the explicit device and check
+   `supported` and missing prerequisites. iOS requires macOS/full Xcode, an explicit
+   booted simulator UDID and a running development `appId` for start. Only Time
+   Profiler is initially supported; physical iOS capture is unsupported. Discovery
+   lists installed templates separately and does not prove profiling permissions,
+   symbols, scheduling data or hang detection.
 2. Establish a fresh baseline and a journey with an observable outcome assertion.
    Choose `durationMs` to cover the journey and its observations (default 30,000;
    supported range 1,000–120,000). Android tree reads can take several seconds.
-3. Call `start_system_trace`, retain its `trace_id`, and pass that value as
+3. Call `start_system_trace` (iOS: include `appId`, optionally
+   `template: "Time Profiler"`), check `state: "recording"` and retain its
+   `trace_id`. iOS waits for native recording-start notification; uncertain startup
+   fails without automatic retry. Pass the returned value as
    `systemTraceId` to `run_journey` on the same device.
 4. Stop in cleanup with `stop_system_trace({ traceId })` when retaining diagnostic
    evidence, including after a failed journey. Use `cancel_system_trace` when
@@ -143,9 +150,12 @@ available UI/log evidence rather than assuming capture is possible.
 Report the local `artifact.path`, device, journey outcome, `correlation_ids` and
 journey trace coverage. A completed capture is not proof the app outcome passed.
 Partial coverage and unsynchronised host/device clocks limit conclusions; linked
-IDs do not establish causality. Trace files can contain sensitive device-wide
-annotations. Keep them local unless sharing is authorised, and remove temporary
-artifacts when no longer needed.
+IDs do not establish causality. Perfetto files and Instruments `.trace` bundles
+can contain sensitive system metadata, paths, symbols, logs and signposts even
+with iOS app attachment. Keep these artifacts local unless sharing is authorised,
+and remove temporary artifacts when no longer needed. The iOS artifact includes
+TOC/table validation and sample row count; zero rows do not prove inactivity.
+The profiled app remains pinned if the journey leaves it.
 
 Capture tools do not provide automatic CPU, frame or blocked-thread analysis.
 If a suitable analyser is available, inspect the artifact before making a cause
@@ -153,21 +163,32 @@ claim. Otherwise report capture verified and analysis unrun, and provide the
 artifact for further investigation. Nonempty output alone does not establish
 valid trace contents or a performance diagnosis.
 
-## Investigate Android runtime behaviour
+## Investigate runtime behaviour
 
 Use runtime debugging to test a concrete execution hypothesis when UI and logs
 are insufficient. Check that the connected server exposes the debugger tools;
-an older installed server may lack them. This requires JDK 17+ and a running,
-debuggable Android app. iOS and native debugging are unsupported. Keep ordinary
+an older installed server may lack them or advertise only Android in the platform
+schema. Android requires JDK 17+ and a running debuggable app. When the connected
+server advertises iOS debugging, it requires a booted simulator and Xcode's
+Swift-enabled LLDB/Python. Physical iOS devices and native-specific inspection
+remain unsupported. Keep ordinary
 navigation and UI verification on the existing interaction path.
 
-1. Call `get_debugger_capabilities` with `platform: "android"`, explicit `deviceId`
+For routine debugger calls, opt into `responseMode: "compact"` to omit repeated
+`device`, `target` and `capabilities`. Default `debug` preserves full output;
+attach, capabilities and state remain full in either mode. Use `get_debugger_state`
+to recover the baseline. Errors, diagnostics, IDs, stop/execution state, limits,
+truncation and cleanup remain available. Compact output is not privacy redaction
+and does not establish execution recovery.
+
+1. Call `get_debugger_capabilities` with the advertised `platform` (`android` or `ios`), explicit `deviceId`
    and `appId`. Inspect `supported`, prerequisites and candidate processes. Provide
    `processId` when ambiguous; general system health does not prove attach support.
 2. Call `attach_debugger`, retain `debug_session_id`, then use it as the
    `debugSessionId` input. Set a source breakpoint with `set_debugger_breakpoint`
-   using exact binary `className` and 1-based executable `line`. Check its status:
-   `pending` waits for class loading; only resolved locations establish binding.
+   using Android binary `className` or iOS absolute `sourceFile` (exactly one),
+   plus 1-based executable `line`. For iOS use the exact simulator UDID. Check its
+   status: `pending` waits for class/image loading; actual locations establish binding.
 3. Trigger the reproduction and call `wait_for_debugger_event`, carrying forward
    `next_cursor` as `afterSequence`. A stopped event supplies `stop_id` and
    `thread_id`. Empty event waits do not mean execution stopped; report overflow
@@ -176,12 +197,28 @@ navigation and UI verification on the existing interaction path.
    `get_debugger_locals` with `stopId`/`frameId` from the returned frame. Inspection
    is shallow and bounded; check availability and truncation. ART may return
    `EMPTY_OR_UNAVAILABLE_VARIABLE_METADATA`: an empty table does not prove that
-   the frame has no locals. Values can contain private data; report only what is
+   the frame has no locals. On Kotlin assignment lines, the local may not yet be
+   initialized or in its emitted variable scope; compare a stop after assignment
+   and compiler metadata before diagnosing a worker defect.
+   For Swift async work, inspect `async_execution_inspection` and `async_stepping`
+   capabilities. Breakpoints on either side of await establish separate execution
+   observations; a step acknowledgement does not prove continuation following.
+   Inspect the subsequent source stop. Swift aggregate values (including strings)
+   may supply type summaries, and non-live locals may be unavailable. No suspended
+   task enumeration or complete logical async stack is promised.
+   Values can contain private data; report only what is
    needed for the investigation.
 5. Use `step_debugger` (`kind: into/over/out`) or `resume_debugger` with the current
    `stopId`. Acknowledgement is not proof of a later stop. Discard all old stop,
    thread and frame IDs after execution resumes; acquire fresh IDs from events.
-6. Always finish with `detach_debugger`, including after failed investigations.
+6. On operation failure, inspect `error.diagnostic.stage`, `.reason` and `.recovery`
+   when present. These are bounded classifications and static guidance, not raw
+   worker output or proof of root cause. Capability probes may return ordered
+   `diagnostics` (platform prerequisites, then target) while retaining `success: true` and
+   `supported: false`. Terminal state retains sanitized failure diagnostics.
+   Timeout/cancellation can leave execution uncertain: reconcile state and cleanup
+   before another state-changing command; never automatically retry attach/step/resume.
+7. Always finish with `detach_debugger`, including after failed investigations.
    Inspect `cleanup.status`; retry incomplete detach rather than starting another
    session. Use `get_debugger_state` to reconcile an uncertain command outcome;
    do not automatically repeat attach, step or resume.
@@ -200,6 +237,14 @@ traversal, coroutine reconstruction or heap capture. A successful debugger comma
 establishes only its reported execution/inspection evidence, not the visible app
 outcome or the cause of a bug.
 
+For Kotlin coroutines, use explicit source breakpoints before and after suspension
+and verify each observed location. Thread-based stepping can stop in generated
+state-machine code; it does not promise to follow a coroutine across dispatchers.
+Inspect compiler line/local metadata when source bindings or values are unclear.
+Shallow locals do not expose spilled continuation fields, suspended coroutine
+inventories, parent/child identities or logical asynchronous stacks. Do not enable
+debug probes or add app instrumentation without a separately agreed design.
+
 ## Report evidence precisely
 
 State the device, actions taken, observed result, evidence source, and any

package/dist/contracts/execution-controls.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const verificationModes = ['none', 'light', 'full'];
+export const responseModes = ['compact', 'debug'];
+export const verificationModeSchema = z.enum(verificationModes);
+export const responseModeSchema = z.enum(responseModes);
+export const verificationModeJson = { type: 'string', enum: [...verificationModes] };
+export const responseModeJson = { type: 'string', enum: [...responseModes] };
+export function interactionControls(args) {
+    const verificationMode = (typeof args.verificationMode === 'string' ? args.verificationMode : undefined) ?? 'full';
+    const responseMode = (typeof args.responseMode === 'string' ? args.responseMode : undefined) ?? 'debug';
+    if (!verificationModes.includes(verificationMode) || !responseModes.includes(responseMode))
+        throw new Error('INVALID_ARGUMENT');
+    for (const key of ['verificationMode', 'responseMode'])
+        if (args[key] !== undefined && typeof args[key] !== 'string')
+            throw new Error('INVALID_ARGUMENT');
+    for (const key of ['actionTimeoutMs', 'verificationTimeoutMs'])
+        if (args[key] !== undefined && (typeof args[key] !== 'number' || !Number.isInteger(args[key])))
+            throw new Error('INVALID_ARGUMENT');
+    const actionTimeoutMs = (typeof args.actionTimeoutMs === 'number' && Number.isFinite(args.actionTimeoutMs) ? args.actionTimeoutMs : undefined);
+    const verificationTimeoutMs = (typeof args.verificationTimeoutMs === 'number' && Number.isFinite(args.verificationTimeoutMs) ? args.verificationTimeoutMs : undefined);
+    return { verificationMode, responseMode,
+        actionTimeoutMs: actionTimeoutMs === undefined ? undefined : Math.max(100, Math.min(30000, actionTimeoutMs)),
+        verificationTimeoutMs: verificationTimeoutMs === undefined ? 3000 : Math.max(100, Math.min(60000, verificationTimeoutMs)) };
+}

package/dist/contracts/selector.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const selectorSchema = z.object({
+    text: z.string().min(1).optional(), resource_id: z.string().min(1).optional(),
+    accessibility_id: z.string().min(1).optional(), contains: z.boolean().optional()
+}).strict().refine(value => !!(value.text || value.resource_id || value.accessibility_id), 'Selector requires a target');
+export const selectorJson = { type: 'object', additionalProperties: false, properties: {
+        text: { type: 'string', minLength: 1 }, resource_id: { type: 'string', minLength: 1 }, accessibility_id: { type: 'string', minLength: 1 }, contains: { type: 'boolean' }
+    }, anyOf: ['text', 'resource_id', 'accessibility_id'].map(key => ({ required: [key] })) };

package/dist/contracts/target.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { selectorSchema as selector, selectorJson } from './selector.js';
+const pollIntervalMs = z.number().int().min(50).max(1000).optional();
+export const waitForSchema = z.object({
+    condition: z.enum(['exists', 'visible', 'clickable']).optional(),
+    timeoutMs: z.number().int().min(100).max(10000).optional(), pollIntervalMs,
+    match: z.object({ index: z.number().int().nonnegative().optional() }).strict().optional()
+}).strict();
+export const targetFields = { selector: selector.optional(), elementId: z.string().min(1).optional() };
+export const exactlyOneTarget = (value) => Number(!!value.selector) + Number(!!value.elementId) === 1;
+export const tapElementControlsSchema = z.object({
+    elementId: z.string().min(1).optional(), selector: selector.optional(), waitFor: waitForSchema.optional()
+}).strict().refine(value => Number(!!value.elementId) + Number(!!value.selector) === 1 && (!value.elementId || !value.waitFor));
+export const targetJson = { selector: selectorJson, elementId: { type: 'string', minLength: 1 } };
+export const oneTargetJson = [{ required: ['selector'], not: { required: ['elementId'] } }, { required: ['elementId'], not: { required: ['selector'] } }];

package/dist/contracts/ui.js

@@ -0,0 +1 @@
+export {};

package/dist/debugger/android.js

@@ -41,7 +41,8 @@ export class AndroidDebugNative {
         try {
             jdwpOutput = (await exec(resolveAdbCmd(), ['-s', device, 'jdwp'], { timeout: debuggerRemaining(500), signal: debuggerSignal(), maxBuffer: 1024 * 1024 })).stdout;
         }
-        catch (e) {
+        catch (error) {
+            const e = error;
             if (debuggerSignal()?.aborted)
                 throw new DebuggerError('DEBUGGER_CANCELLED');
             debuggerRemaining(1);

package/dist/debugger/diagnostics.js

@@ -0,0 +1,54 @@
+/** Only catalog values cross the debugger error boundary. Never inspect exception text. */
+export const stages = ['prerequisite', 'compilation', 'worker_start', 'ipc', 'target_resolution', 'forwarding', 'attach', 'command', 'transport', 'cleanup', 'unknown'];
+export const reasons = ['unavailable', 'unsupported', 'spawn_failed', 'process_exited', 'invalid_message', 'message_limit', 'write_failed', 'connection_refused', 'transport_lost', 'timeout', 'cancelled', 'operation_failed', 'unknown'];
+const recovery = {
+    prerequisite: 'Check JDK 17+ availability, including java, javac and jdk.jdi.',
+    compilation: 'Check the JDK compiler and worker source/cache availability.',
+    worker_start: 'Check Java worker launch availability. Inspect session state and cleanup before attaching again.',
+    ipc: 'Inspect session state and cleanup. Detach before attempting a fresh attach.',
+    target_resolution: 'Check the explicit device and running debuggable app/process.',
+    forwarding: 'Check the explicit device and debugger forwarding availability.',
+    attach: 'Check the running debuggable target and whether another debugger is attached. Inspect cleanup before a fresh attach.',
+    command: 'Inspect debugger session state and cleanup before another state-changing command.',
+    transport: 'Inspect session state and cleanup. Detach before attempting a fresh attach; execution state may be unknown.',
+    cleanup: 'Retry detach_debugger and inspect cleanup.remaining_resources. Do not kill the app or ADB server.',
+    unknown: 'Inspect debugger session state and cleanup; the failure cause is unknown.'
+};
+export function diagnostic(stage, reason) {
+    const guidance = reason === 'timeout' || reason === 'cancelled'
+        ? 'Execution may be uncertain. Inspect session state and cleanup before another state-changing command.' : recovery[stage];
+    return { stage, reason, recovery: guidance };
+}
+export function parseDiagnostic(value) {
+    if (!value || typeof value !== 'object')
+        throw new Error('INVALID_WORKER_DIAGNOSTIC');
+    const { stage, reason } = value;
+    if (!stages.includes(stage) || !reasons.includes(reason))
+        throw new Error('INVALID_WORKER_DIAGNOSTIC');
+    return diagnostic(stage, reason);
+}
+export class DebuggerError extends Error {
+    code;
+    diagnostic;
+    constructor(code, diagnostic) {
+        super(code);
+        this.code = code;
+        this.diagnostic = diagnostic;
+    }
+}
+const validationCodes = new Set(['INVALID_ARGUMENT', 'DEBUGGER_BUSY', 'DEBUGGER_NOT_FOUND', 'DEBUGGER_PAUSED', 'DEBUGGER_NOT_PAUSED', 'DEBUGGER_STALE_REFERENCE']);
+export function classify(error, stage, fallback, reason = 'unknown') {
+    const existing = error instanceof DebuggerError ? error : new DebuggerError(fallback);
+    if (existing.diagnostic || validationCodes.has(existing.code))
+        return existing;
+    const knownReason = existing.code === 'DEBUGGER_TIMEOUT' ? 'timeout' : existing.code === 'DEBUGGER_CANCELLED' ? 'cancelled' : reason;
+    return new DebuggerError(existing.code, diagnostic(stage, knownReason));
+}
+export async function atStage(stage, fallback, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        throw classify(error, stage, fallback);
+    }
+}

package/dist/debugger/guard.js

@@ -9,16 +9,16 @@ export function withDebuggerGuard(platform, device, operation) {
 // Synchronous checks and native submission share a JS turn with pause updates.
 export function checkDebuggerGuard(dispatch = false) {
     const current = context.getStore();
-    if (!current || current.platform !== 'android')
+    if (!current)
         return;
-    if (pauseProvider(current.device))
+    if (pauseProvider(current.device, current.platform))
         throw new DebuggerError('DEBUGGER_PAUSED');
     if (dispatch)
         current.dispatched = true;
 }
 export function guardDispatched() { return context.getStore()?.dispatched ?? false; }
-export function pausedReadiness(device) {
-    const paused = pauseProvider(device);
+export function pausedReadiness(device, platform = 'android') {
+    const paused = pauseProvider(device, platform);
     if (!paused)
         return null;
     return { state: 'debugger_paused', scope: 'device_ui', basis: 'observed',

package/dist/debugger/ios-worker.js

@@ -0,0 +1,62 @@
+import { fileURLToPath } from 'node:url';
+import { getXcrunCmd } from '../utils/ios/utils.js';
+import { iosExec } from './ios.js';
+import { DebuggerProcess } from './worker.js';
+import { DebuggerError } from './diagnostics.js';
+export const iosCapabilities = { attach: true, breakpoints: true, stacks: true, locals: true, step: true, resume: true,
+    evaluation: false, mutation: false, coroutines: false, native: false, async_execution_inspection: true, async_stepping: true };
+export const iosLimitations = ['IOS_SIMULATOR_ONLY', 'DEBUG_METADATA_REQUIRED', 'SHALLOW_LOCALS', 'ALL_THREADS_SUSPEND', 'DEVICE_WIDE_UI_GUARD', 'ASYNC_STEPPING_TOOLCHAIN_DEPENDENT', 'AGGREGATE_VALUES_TYPE_ONLY', 'NO_TASK_ENUMERATION'];
+export const iosWorkerSource = fileURLToPath(new URL('../../src/debugger/lldb/worker.py', import.meta.url));
+let prepared;
+export function prepareIOSWorker() {
+    prepared ??= (async () => {
+        if (process.platform !== 'darwin')
+            throw new DebuggerError('DEBUGGER_UNSUPPORTED');
+        const pythonPath = await iosExec(getXcrunCmd(), ['lldb', '-P']);
+        const python = await iosExec(getXcrunCmd(), ['--find', 'python3']);
+        // Ignore user Python startup/customisation and LLDB init files.
+        const env = { PATH: process.env.PATH, HOME: process.env.HOME, PYTHONPATH: pythonPath, PYTHONNOUSERSITE: '1' };
+        const ready = await iosExec(python, ['-s', '-B', '-c', 'import lldb; d=lldb.SBDebugger.Create(False); print("ready" if d.IsValid() else "unavailable"); lldb.SBDebugger.Destroy(d)'], env);
+        if (ready !== 'ready')
+            throw new DebuggerError('DEBUGGER_UNSUPPORTED');
+        return { python, env };
+    })().catch(error => { prepared = undefined; throw error; });
+    return prepared;
+}
+export async function createIOSWorker(onEvent) {
+    const { python, env } = await prepareIOSWorker();
+    let released = false;
+    const worker = new DebuggerProcess(python, '', event => {
+        if (event.event === 'terminated' && ['process_exit', 'detached', 'pause_limit', 'idle_limit', 'session_limit'].includes(String(event.reason)))
+            released = true;
+        onEvent(event);
+    }, { args: ['-u', '-s', '-B', iosWorkerSource], env });
+    return new IOSWorker(worker, () => released);
+}
+/** A dead worker is not proof that its owned suspension was released. */
+export class IOSWorker {
+    worker;
+    released;
+    detached = false;
+    constructor(worker, released) {
+        this.worker = worker;
+        this.released = released;
+    }
+    async call(command, args = {}, timeout = 10000) {
+        const result = await this.worker.call(command, args, timeout);
+        if (command === 'detach' && result.detached === true)
+            this.detached = true;
+        return result;
+    }
+    async close() {
+        if (!this.detached && !this.released()) {
+            try {
+                await this.call('detach', {}, 1000);
+            }
+            catch { /* Report uncertainty after bounded transport shutdown. */ }
+        }
+        await this.worker.close();
+        if (!this.detached && !this.released())
+            throw new DebuggerError('DEBUGGER_CLEANUP_FAILED');
+    }
+}

package/dist/debugger/ios.js

@@ -0,0 +1,57 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import path from 'node:path';
+import { realpath } from 'node:fs/promises';
+import { getXcrunCmd } from '../utils/ios/utils.js';
+import { DebuggerError, debuggerRemaining, debuggerSignal, nativeError } from './worker.js';
+const exec = promisify(execFile);
+export async function iosExec(file, args, env) {
+    try {
+        return (await exec(file, args, { timeout: debuggerRemaining(5000), signal: debuggerSignal(), maxBuffer: 1024 * 1024, ...(env ? { env } : {}) })).stdout.trim();
+    }
+    catch (e) {
+        throw nativeError(e, 'DEVICE_UNAVAILABLE');
+    }
+}
+export class IOSDebugNative {
+    run;
+    constructor(run = iosExec) {
+        this.run = run;
+    }
+    sim(args) { return this.run(getXcrunCmd(), ['simctl', ...args]); }
+    async candidates(device, app) {
+        if (!/^[A-Fa-f0-9]{8}(?:-[A-Fa-f0-9]{4}){3}-[A-Fa-f0-9]{12}$/.test(device) || !/^[A-Za-z0-9][A-Za-z0-9.-]+$/.test(app))
+            throw new DebuggerError('INVALID_ARGUMENT');
+        const inventory = JSON.parse(await this.sim(['list', 'devices', 'booted', '--json']));
+        if (!Object.values(inventory.devices).flat().some(d => d.udid === device && d.state === 'Booted'))
+            throw new DebuggerError('DEBUGGER_UNSUPPORTED');
+        const services = await this.sim(['spawn', device, 'launchctl', 'list']);
+        const pids = this.processes(services, app);
+        if (!pids.length)
+            return [];
+        const container = await this.sim(['get_app_container', device, app, 'app']);
+        const executable = await this.run('/usr/bin/plutil', ['-extract', 'CFBundleExecutable', 'raw', '-o', '-', path.join(container, 'Info.plist')]);
+        if (path.basename(executable) !== executable || !executable)
+            throw new DebuggerError('PROCESS_NOT_FOUND');
+        const executablePath = await realpath(path.join(container, executable));
+        return Promise.all(pids.map(pid => this.identity(device, { app_id: app, pid, process_name: executable, executable_path: executablePath, start_identity: '', uid: null })));
+    }
+    processes(services, app) {
+        return services.split('\n').flatMap(line => {
+            const [pid, , label] = line.trim().split(/\s+/);
+            return /^\d+$/.test(pid) && label?.startsWith(`UIKitApplication:${app}[`) ? [Number(pid)] : [];
+        });
+    }
+    async identity(device, target) {
+        const services = await this.sim(['spawn', device, 'launchctl', 'list']);
+        if (!this.processes(services, target.app_id).includes(target.pid))
+            throw new DebuggerError('PROCESS_CHANGED');
+        const command = await this.run('/bin/ps', ['-ww', '-p', String(target.pid), '-o', 'comm=']);
+        const started = await this.run('/bin/ps', ['-p', String(target.pid), '-o', 'lstart=']);
+        if (command !== target.executable_path || !started || (target.start_identity && started !== target.start_identity))
+            throw new DebuggerError('PROCESS_CHANGED');
+        return { ...target, start_identity: started };
+    }
+    async forward() { throw new DebuggerError('DEBUGGER_UNSUPPORTED'); }
+    async removeForward() { throw new DebuggerError('DEBUGGER_UNSUPPORTED'); }
+}

package/dist/debugger/protocol.js

@@ -0,0 +1,33 @@
+import { parseDiagnostic } from './diagnostics.js';
+const workerCodes = new Set(['INVALID_ARGUMENT', 'DEBUGGER_BUSY', 'DEBUGGER_NOT_FOUND', 'DEBUGGER_NOT_PAUSED', 'DEBUGGER_STALE_REFERENCE', 'DEBUGGER_DISCONNECTED', 'DEBUGGER_WORKER_FAILED']);
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function parseWorkerMessage(value) {
+    if (!record(value))
+        throw new Error('INVALID_WORKER_MESSAGE');
+    if (value.event) {
+        if (typeof value.event !== 'string')
+            throw new Error('INVALID_WORKER_EVENT');
+        for (const field of ['reason', 'stop_id']) {
+            if (value[field] !== undefined && typeof value[field] !== 'string')
+                throw new Error('INVALID_WORKER_EVENT');
+        }
+        const event = { ...value };
+        if (value.diagnostic !== undefined)
+            event.diagnostic = parseDiagnostic(value.diagnostic);
+        return { kind: 'event', value: event };
+    }
+    if (typeof value.id !== 'number' || !Number.isSafeInteger(value.id) || value.id < 1)
+        throw new Error('INVALID_WORKER_REPLY');
+    if (value.error) {
+        if (!record(value.error) || (value.error.code !== undefined && typeof value.error.code !== 'string'))
+            throw new Error('INVALID_WORKER_ERROR');
+        if (value.error.code !== undefined && !workerCodes.has(value.error.code))
+            throw new Error('INVALID_WORKER_ERROR');
+        return { kind: 'reply', id: value.id, result: {}, error: { ...(value.error.code === undefined ? {} : { code: value.error.code }), ...(value.error.diagnostic === undefined ? {} : { diagnostic: parseDiagnostic(value.error.diagnostic) }) } };
+    }
+    if (!record(value.result))
+        throw new Error('INVALID_WORKER_RESULT');
+    return { kind: 'reply', id: value.id, result: value.result };
+}