wasm-idle 0.7.2 → 1.0.0

package/dist/playground/lldbSession.js

@@ -0,0 +1,1347 @@
+import { ProtocolError } from '@wasm-idle/core';
+import { createBrowserLldbSession, DapProtocolError } from '@wasm-idle/llvm-core/debug';
+import { loadVerifiedDebugRuntimeManifest } from './lldbManifest';
+const MAX_DEBUG_MEMORY_BYTES = 256;
+const MAX_DEBUG_IDENTIFIER_CODE_UNITS = 4096;
+const MAX_DEBUG_DATA_BREAKPOINTS = 256;
+function pauseReason(reason, command) {
+    if (reason === 'breakpoint')
+        return 'breakpoint';
+    if (reason === 'data breakpoint')
+        return 'dataBreakpoint';
+    if (reason === 'entry')
+        return 'entry';
+    if (reason === 'pause')
+        return 'pause';
+    if (command === 'nextLine')
+        return 'nextLine';
+    if (command === 'stepOut')
+        return 'stepOut';
+    return 'step';
+}
+function invalidDapPayload(subject, path, expectation) {
+    throw new ProtocolError(`Invalid LLDB DAP ${subject} at ${path}: ${expectation}.`);
+}
+function invalidDapResponse(command, path, expectation) {
+    invalidDapPayload(`${command} response`, path, expectation);
+}
+function assertDapRecord(value, command, path) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        invalidDapResponse(command, path, 'expected an object');
+    }
+}
+function assertDapString(value, command, path) {
+    if (typeof value !== 'string')
+        invalidDapResponse(command, path, 'expected a string');
+}
+function assertDapBoolean(value, command, path) {
+    if (typeof value !== 'boolean')
+        invalidDapResponse(command, path, 'expected a boolean');
+}
+function assertDapPositiveSafeInteger(value, subject, path) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+        invalidDapPayload(subject, path, 'expected a positive safe integer');
+    }
+}
+function assertDapNonNegativeSafeInteger(value, command, path) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        invalidDapResponse(command, path, 'expected a non-negative safe integer');
+    }
+}
+function dapResponseCollection(response, command, path) {
+    assertDapRecord(response, command, 'body');
+    const collection = response[path];
+    if (!Array.isArray(collection))
+        invalidDapResponse(command, path, 'expected an array');
+    return collection;
+}
+function dapOptionalNonNegativeSafeInteger(record, property, command, path) {
+    const value = record[property];
+    if (value === undefined)
+        return undefined;
+    assertDapNonNegativeSafeInteger(value, command, `${path}.${property}`);
+    return value;
+}
+function snapshotBreakpointLines(lines) {
+    if (lines.some((line) => !Number.isSafeInteger(line) || line < 1)) {
+        throw new RangeError('LLDB breakpoint lines must be positive safe integers.');
+    }
+    return [...lines];
+}
+function assertPositiveSafeIntegerArgument(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new RangeError(`${name} must be a positive safe integer.`);
+    }
+}
+function assertNonNegativeSafeIntegerArgument(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer.`);
+    }
+}
+function assertBoundedNonEmptyStringArgument(value, name) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new TypeError(`${name} must be a non-empty string.`);
+    }
+    if (value.length > MAX_DEBUG_IDENTIFIER_CODE_UNITS) {
+        throw new RangeError(`${name} must not exceed ${MAX_DEBUG_IDENTIFIER_CODE_UNITS} UTF-16 code units.`);
+    }
+}
+function assertOptionalBooleanArgument(value, name) {
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw new TypeError(`${name} must be a boolean.`);
+    }
+}
+export class LldbSandboxSession {
+    options;
+    session;
+    startupAbortController;
+    activeThreadId = 1;
+    activeFrameId;
+    stoppedFrames = [];
+    supportsValueFormatting = false;
+    command = null;
+    pauseRequested = false;
+    pauseRequestVersion = 0;
+    targetStopped = false;
+    entryPhase = 'done';
+    entrySetup;
+    stopped = false;
+    stateVersion = 0;
+    completionResolve;
+    completionReject;
+    sessionDisposal;
+    pendingInput = [];
+    pendingEof = false;
+    inputReady = false;
+    lifecycleVersion = 0;
+    initialized = false;
+    supportsEvaluateExpressions = false;
+    supportsReadMemory = false;
+    supportsWriteMemory = false;
+    supportsDataBreakpoints = false;
+    breakpointVersion = 0;
+    scopeRequestVersion = 0;
+    dapExitCode = null;
+    breakpointsBySource = new Map();
+    breakpointRequestVersions = new Map();
+    sourceContentSha256ByPath = new Map();
+    constructor(options) {
+        this.options = options;
+        const sourceBreakpoints = options.sourceBreakpoints?.length
+            ? options.sourceBreakpoints
+            : [{ sourcePath: options.sourcePath, lines: options.breakpoints }];
+        for (const { sourcePath, lines } of sourceBreakpoints) {
+            this.breakpointsBySource.set(sourcePath, snapshotBreakpointLines(lines));
+        }
+        for (const source of options.artifact.sources) {
+            if (source.contentSha256) {
+                this.sourceContentSha256ByPath.set(source.path, source.contentSha256);
+            }
+        }
+    }
+    async start() {
+        if (this.session || this.startupAbortController) {
+            throw new Error('LLDB sandbox session is already running.');
+        }
+        const previousDisposal = this.sessionDisposal;
+        const lifecycleVersion = ++this.lifecycleVersion;
+        const startupAbortController = new AbortController();
+        this.startupAbortController = startupAbortController;
+        this.targetStopped = false;
+        this.stopped = false;
+        this.entryPhase =
+            this.options.pauseOnEntry && this.options.pauseAtMain ? 'initial' : 'done';
+        this.pauseRequested = false;
+        this.initialized = false;
+        this.dapExitCode = null;
+        let rejectCompletion;
+        const completion = new Promise((resolve, reject) => {
+            this.completionResolve = resolve;
+            this.completionReject = reject;
+            rejectCompletion = reject;
+        });
+        void completion.catch(() => undefined);
+        if (previousDisposal) {
+            try {
+                await previousDisposal;
+            }
+            catch (error) {
+                if (lifecycleVersion !== this.lifecycleVersion)
+                    return completion;
+                if (this.startupAbortController === startupAbortController) {
+                    this.startupAbortController = undefined;
+                }
+                this.stopped = true;
+                rejectCompletion(error instanceof Error
+                    ? error
+                    : new Error('Unable to dispose the previous LLDB debug session.'));
+                return completion;
+            }
+            if (lifecycleVersion !== this.lifecycleVersion ||
+                startupAbortController.signal.aborted) {
+                return completion;
+            }
+        }
+        let manifest;
+        try {
+            manifest = await loadVerifiedDebugRuntimeManifest(this.options.manifestUrl, this.options.manifestReceipt, this.options.fetchImpl ?? fetch, startupAbortController.signal);
+        }
+        catch (error) {
+            if (lifecycleVersion !== this.lifecycleVersion)
+                return completion;
+            throw error;
+        }
+        finally {
+            if (this.startupAbortController === startupAbortController) {
+                this.startupAbortController = undefined;
+            }
+        }
+        this.supportsEvaluateExpressions =
+            manifest.debugger?.capabilities?.evaluateExpressions === true;
+        const manifestSupportsReadMemory = manifest.debugger?.capabilities?.readMemory === true;
+        const manifestSupportsWriteMemory = manifest.debugger?.capabilities?.writeMemory === true;
+        this.supportsReadMemory = false;
+        this.supportsWriteMemory = false;
+        const manifestSupportsDataBreakpoints = manifest.debugger?.capabilities?.dataBreakpoints === true;
+        if (lifecycleVersion !== this.lifecycleVersion)
+            return completion;
+        const artifactCompiler = this.options.artifact.descriptor?.compiler;
+        if (artifactCompiler?.name === 'clang' &&
+            artifactCompiler.revision &&
+            artifactCompiler.revision !== manifest.debugger.lldb.llvmRevision) {
+            throw new Error(`Compiler/LLDB revision mismatch: artifact ${artifactCompiler.revision}, runtime ${manifest.debugger.lldb.llvmRevision}.`);
+        }
+        if (artifactCompiler?.name === 'rustc' &&
+            artifactCompiler.llvmVersion &&
+            artifactCompiler.llvmVersion !== manifest.debugger.lldb.llvmVersion) {
+            throw new Error(`Rust LLVM/LLDB version mismatch: artifact ${artifactCompiler.llvmVersion}, runtime ${manifest.debugger.lldb.llvmVersion}.`);
+        }
+        let session;
+        const sourceBreakpoints = Array.from(this.breakpointsBySource, ([sourcePath, lines]) => ({
+            sourcePath,
+            lines: [...lines]
+        }));
+        const configuredBreakpointVersion = this.breakpointVersion;
+        session = createBrowserLldbSession({
+            manifest,
+            runtimeBaseUrl: this.options.runtimeBaseUrl,
+            module: this.options.artifact.bytes,
+            moduleSha256: this.options.artifact.descriptor?.moduleSha256,
+            sources: this.options.artifact.sources,
+            breakpoints: sourceBreakpoints.map(({ sourcePath, lines }) => ({
+                source: { path: sourcePath },
+                lines
+            })),
+            launch: {
+                program: '/workspace/program.wasm',
+                stopOnEntry: this.options.pauseOnEntry,
+                args: this.options.programArgs
+            },
+            fetchImpl: this.options.fetchImpl,
+            onOutput: (_channel, output) => this.options.onOutput(output),
+            onLifecycle: (event) => {
+                if (lifecycleVersion !== this.lifecycleVersion || this.session !== session) {
+                    return;
+                }
+                if (event.type === 'worker-error') {
+                    this.fail(new Error(`${event.worker} debug worker failed: ${event.message}`));
+                }
+                else {
+                    this.finish(event.exitCode ?? this.dapExitCode);
+                }
+            }
+        });
+        if (lifecycleVersion !== this.lifecycleVersion) {
+            await session.dispose();
+            return completion;
+        }
+        this.session = session;
+        let resolveEntrySetup;
+        this.entrySetup = {
+            ready: new Promise((resolve) => {
+                resolveEntrySetup = resolve;
+            }),
+            resolve: () => resolveEntrySetup()
+        };
+        session.onEvent((event) => {
+            if (lifecycleVersion === this.lifecycleVersion && this.session === session) {
+                try {
+                    this.handleDapEvent(event);
+                }
+                catch (error) {
+                    if (!(error instanceof ProtocolError))
+                        throw error;
+                    this.fail(error);
+                }
+            }
+        });
+        try {
+            const capabilities = await session.initialize();
+            if (lifecycleVersion !== this.lifecycleVersion || this.session !== session) {
+                await session.dispose();
+                return completion;
+            }
+            this.supportsReadMemory =
+                manifestSupportsReadMemory && capabilities.supportsReadMemoryRequest === true;
+            this.supportsWriteMemory =
+                manifestSupportsWriteMemory && capabilities.supportsWriteMemoryRequest === true;
+            this.supportsDataBreakpoints =
+                manifestSupportsDataBreakpoints && capabilities.supportsDataBreakpoints === true;
+            this.supportsValueFormatting = capabilities.supportsValueFormattingOptions === true;
+            this.initialized = true;
+            if (configuredBreakpointVersion === this.breakpointVersion) {
+                for (const { sourcePath, lines } of sourceBreakpoints) {
+                    this.publishResolvedBreakpoints(session.getResolvedBreakpoints(sourcePath), lines, sourcePath);
+                }
+            }
+            else {
+                for (const [sourcePath, lines] of this.breakpointsBySource) {
+                    await this.setBreakpoints(lines, sourcePath);
+                }
+            }
+            // Startup breakpoint edits must reach LLDB before automatic source entry. Do not
+            // wait for stdin to drain: a full input queue needs the guest to run first.
+            resolveEntrySetup();
+            this.inputReady = true;
+            if (this.options.stdin !== undefined) {
+                this.pendingInput.push(this.options.stdin);
+                this.pendingEof = true;
+            }
+            await this.flushInput(session, lifecycleVersion);
+        }
+        catch (error) {
+            if (lifecycleVersion === this.lifecycleVersion &&
+                this.stopped &&
+                this.session !== session) {
+                return completion;
+            }
+            if (lifecycleVersion !== this.lifecycleVersion) {
+                await session.dispose();
+                return completion;
+            }
+            if (this.session === session) {
+                this.fail(this.asProtocolError(error) ??
+                    (error instanceof Error
+                        ? error
+                        : new Error('Unable to initialize the LLDB debug session.')));
+                return completion;
+            }
+            await session.dispose();
+            throw error;
+        }
+        finally {
+            resolveEntrySetup();
+        }
+        return completion;
+    }
+    write(input) {
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        const session = this.session;
+        const lifecycleVersion = this.lifecycleVersion;
+        return this.observeInputFlush(this.flushInput(session, lifecycleVersion), session, lifecycleVersion);
+    }
+    eof() {
+        this.pendingEof = true;
+        const session = this.session;
+        const lifecycleVersion = this.lifecycleVersion;
+        return this.observeInputFlush(this.flushInput(session, lifecycleVersion), session, lifecycleVersion);
+    }
+    async debugCommand(command) {
+        const session = this.requireSession();
+        this.targetStopped = false;
+        this.command = command;
+        this.pauseRequested = false;
+        const dapCommand = command === 'stepInto'
+            ? 'stepIn'
+            : command === 'nextLine'
+                ? 'next'
+                : command === 'stepOut'
+                    ? 'stepOut'
+                    : 'continue';
+        const stateVersion = ++this.stateVersion;
+        const request = session.request(dapCommand, { threadId: this.activeThreadId }, { responseTimeoutMs: null });
+        this.publishActiveDebugEvent({ type: 'resume', command });
+        void request.catch((error) => {
+            if (this.session !== session || this.stateVersion !== stateVersion)
+                return;
+            this.fail(error instanceof Error
+                ? error
+                : new Error(`Unable to send the LLDB ${dapCommand} request.`));
+        });
+    }
+    async pause() {
+        const session = this.requireSession();
+        const requestVersion = ++this.pauseRequestVersion;
+        this.pauseRequested = true;
+        try {
+            await session.request('pause', {
+                threadId: this.activeThreadId
+            });
+        }
+        catch (error) {
+            if (this.session !== session ||
+                this.pauseRequestVersion !== requestVersion ||
+                !this.pauseRequested) {
+                return;
+            }
+            this.pauseRequested = false;
+            throw error;
+        }
+    }
+    async setBreakpoints(lines, sourcePath = this.options.sourcePath) {
+        const requestedLines = snapshotBreakpointLines(lines);
+        this.breakpointsBySource.set(sourcePath, requestedLines);
+        this.breakpointVersion += 1;
+        const requestVersion = (this.breakpointRequestVersions.get(sourcePath) ?? 0) + 1;
+        this.breakpointRequestVersions.set(sourcePath, requestVersion);
+        if (!this.session || !this.initialized)
+            return;
+        const session = this.requireSession();
+        let breakpoints;
+        try {
+            breakpoints = await session.setBreakpoints({ path: sourcePath }, requestedLines);
+        }
+        catch (error) {
+            if (this.session !== session ||
+                this.breakpointRequestVersions.get(sourcePath) !== requestVersion) {
+                return;
+            }
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+        if (this.session !== session ||
+            this.breakpointRequestVersions.get(sourcePath) !== requestVersion) {
+            return;
+        }
+        this.publishResolvedBreakpoints(breakpoints, requestedLines, sourcePath);
+    }
+    async evaluate(expression) {
+        if (!this.supportsEvaluateExpressions || !this.activeFrameId)
+            return '?';
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        const scopeRequestVersion = this.scopeRequestVersion;
+        const frameId = this.activeFrameId;
+        try {
+            const response = await session.request('evaluate', {
+                expression,
+                frameId,
+                context: 'watch'
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion, scopeRequestVersion)) {
+                return '?';
+            }
+            assertDapRecord(response, 'evaluate', 'body');
+            assertDapString(response.result, 'evaluate', 'result');
+            assertDapNonNegativeSafeInteger(response.variablesReference, 'evaluate', 'variablesReference');
+            return response.result;
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion, scopeRequestVersion)) {
+                return '?';
+            }
+            this.rethrowProtocolError(error);
+            return '?';
+        }
+    }
+    async variables(variablesReference, start, count) {
+        assertPositiveSafeIntegerArgument(variablesReference, 'variablesReference');
+        if (start !== undefined)
+            assertNonNegativeSafeIntegerArgument(start, 'start');
+        if (count !== undefined)
+            assertNonNegativeSafeIntegerArgument(count, 'count');
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        const scopeRequestVersion = this.scopeRequestVersion;
+        try {
+            const response = await session.request('variables', {
+                variablesReference,
+                ...(start === undefined ? {} : { start }),
+                ...(count === undefined ? {} : { count })
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion, scopeRequestVersion)) {
+                return [];
+            }
+            return dapResponseCollection(response, 'variables', 'variables').map((variable, index) => {
+                const path = `variables[${index}]`;
+                assertDapRecord(variable, 'variables', path);
+                assertDapString(variable.name, 'variables', `${path}.name`);
+                assertDapString(variable.value, 'variables', `${path}.value`);
+                assertDapNonNegativeSafeInteger(variable.variablesReference, 'variables', `${path}.variablesReference`);
+                const type = variable.type;
+                if (type !== undefined)
+                    assertDapString(type, 'variables', `${path}.type`);
+                const evaluateName = variable.evaluateName;
+                if (evaluateName !== undefined) {
+                    assertDapString(evaluateName, 'variables', `${path}.evaluateName`);
+                }
+                const memoryReference = variable.memoryReference;
+                if (memoryReference !== undefined) {
+                    assertDapString(memoryReference, 'variables', `${path}.memoryReference`);
+                }
+                const namedVariables = dapOptionalNonNegativeSafeInteger(variable, 'namedVariables', 'variables', path);
+                const indexedVariables = dapOptionalNonNegativeSafeInteger(variable, 'indexedVariables', 'variables', path);
+                return {
+                    name: variable.name,
+                    value: variable.value,
+                    type,
+                    ...(evaluateName === undefined ? {} : { evaluateName }),
+                    variablesReference: variable.variablesReference,
+                    memoryReference,
+                    ...(namedVariables === undefined ? {} : { namedVariables }),
+                    ...(indexedVariables === undefined ? {} : { indexedVariables })
+                };
+            });
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion, scopeRequestVersion)) {
+                return [];
+            }
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    /** Ask the adapter to format one stopped frame, without changing evaluation selection. */
+    async formattedFrameName(frameId) {
+        assertPositiveSafeIntegerArgument(frameId, 'frameId');
+        if (!this.targetStopped || !this.supportsValueFormatting || !this.activeThreadId)
+            return null;
+        const index = this.stoppedFrames.findIndex((frame) => frame.id === frameId);
+        if (index < 0)
+            return null;
+        const session = this.requireSession();
+        const version = this.stateVersion;
+        try {
+            const response = await session.request('stackTrace', {
+                threadId: this.activeThreadId,
+                startFrame: index,
+                levels: 1,
+                format: {
+                    parameters: true,
+                    parameterNames: true,
+                    parameterValues: true,
+                    parameterTypes: false,
+                    line: false,
+                    module: false
+                }
+            });
+            if (!this.isCurrentValueRequest(session, version))
+                return null;
+            const frames = dapResponseCollection(response, 'stackTrace', 'stackFrames');
+            if (!frames.length)
+                return null;
+            const frame = frames[0];
+            assertDapRecord(frame, 'stackTrace', 'stackFrames[0]');
+            assertDapPositiveSafeInteger(frame.id, 'stackTrace', 'stackFrames[0].id');
+            assertDapString(frame.name, 'stackTrace', 'stackFrames[0].name');
+            if (frame.id !== frameId || frame.name === this.stoppedFrames[index]?.name)
+                return null;
+            return frame.name.length > 512 ? frame.name.slice(0, 511) + '…' : frame.name;
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, version))
+                return null;
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    /** Scope metadata lookup does not select a frame or retire other value requests. */
+    async frameScopes(frameId) {
+        assertPositiveSafeIntegerArgument(frameId, 'frameId');
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        try {
+            const scopes = await this.requestScopes(session, frameId);
+            return this.isCurrentValueRequest(session, stateVersion) ? scopes : [];
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return [];
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    /** Select the evaluation frame, keeping the existing public debugScopes contract. */
+    async scopes(frameId) {
+        assertPositiveSafeIntegerArgument(frameId, 'frameId');
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        const requestVersion = ++this.scopeRequestVersion;
+        try {
+            const scopes = await this.requestScopes(session, frameId);
+            if (this.session === session &&
+                this.stateVersion === stateVersion &&
+                this.scopeRequestVersion === requestVersion) {
+                this.activeFrameId = frameId;
+            }
+            return scopes;
+        }
+        catch (error) {
+            if (this.session !== session ||
+                this.stateVersion !== stateVersion ||
+                this.scopeRequestVersion !== requestVersion) {
+                throw error;
+            }
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    async readMemory(memoryReference, offset, count) {
+        if (!this.targetStopped || !this.supportsReadMemory)
+            return null;
+        assertBoundedNonEmptyStringArgument(memoryReference, 'memoryReference');
+        if (!Number.isSafeInteger(offset)) {
+            throw new RangeError('offset must be a safe integer.');
+        }
+        assertNonNegativeSafeIntegerArgument(count, 'count');
+        if (count > MAX_DEBUG_MEMORY_BYTES) {
+            throw new RangeError(`count must not exceed ${MAX_DEBUG_MEMORY_BYTES}.`);
+        }
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        try {
+            const response = await session.request('readMemory', {
+                memoryReference,
+                offset,
+                count
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            assertDapRecord(response, 'readMemory', 'body');
+            assertDapString(response.address, 'readMemory', 'address');
+            const encodedData = response.data;
+            if (encodedData !== undefined)
+                assertDapString(encodedData, 'readMemory', 'data');
+            const unreadableBytes = response.unreadableBytes;
+            if (unreadableBytes !== undefined) {
+                assertDapNonNegativeSafeInteger(unreadableBytes, 'readMemory', 'unreadableBytes');
+            }
+            const maximumEncodedDataLength = Math.ceil(count / 3) * 4;
+            if (encodedData !== undefined && encodedData.length > maximumEncodedDataLength) {
+                invalidDapResponse('readMemory', 'data', `encoded data exceeds the ${maximumEncodedDataLength}-character limit for a ${count}-byte request`);
+            }
+            let binary;
+            try {
+                binary = globalThis.atob(encodedData ?? '');
+            }
+            catch {
+                invalidDapResponse('readMemory', 'data', 'expected valid Base64');
+            }
+            if (binary.length > count) {
+                invalidDapResponse('readMemory', 'data', `decoded ${binary.length} bytes for a ${count}-byte request`);
+            }
+            if (binary.length + (unreadableBytes ?? 0) > count) {
+                invalidDapResponse('readMemory', 'unreadableBytes', `reported ${binary.length} readable and ${unreadableBytes ?? 0} unreadable bytes for a ${count}-byte request`);
+            }
+            const data = new Uint8Array(binary.length);
+            for (let index = 0; index < binary.length; index += 1) {
+                data[index] = binary.charCodeAt(index);
+            }
+            return {
+                address: response.address,
+                data,
+                unreadableBytes: unreadableBytes ?? 0
+            };
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    async writeMemory(memoryReference, offset, data, allowPartial = false) {
+        if (!this.targetStopped || !this.supportsWriteMemory)
+            return null;
+        assertBoundedNonEmptyStringArgument(memoryReference, 'memoryReference');
+        if (!Number.isSafeInteger(offset)) {
+            throw new RangeError('offset must be a safe integer.');
+        }
+        if (!(data instanceof Uint8Array)) {
+            throw new TypeError('data must be a Uint8Array.');
+        }
+        if (data.byteLength > MAX_DEBUG_MEMORY_BYTES) {
+            throw new RangeError(`data must not exceed ${MAX_DEBUG_MEMORY_BYTES} bytes.`);
+        }
+        assertOptionalBooleanArgument(allowPartial, 'allowPartial');
+        const chunks = [];
+        for (let start = 0; start < data.byteLength; start += 0x8000) {
+            chunks.push(String.fromCharCode(...data.subarray(start, start + 0x8000)));
+        }
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        try {
+            const response = await session.request('writeMemory', {
+                memoryReference,
+                offset,
+                allowPartial,
+                data: globalThis.btoa(chunks.join(''))
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            if (response !== undefined)
+                assertDapRecord(response, 'writeMemory', 'body');
+            const responseBody = response ?? {};
+            const responseBytesWritten = responseBody.bytesWritten;
+            if (responseBytesWritten !== undefined) {
+                assertDapNonNegativeSafeInteger(responseBytesWritten, 'writeMemory', 'bytesWritten');
+            }
+            const bytesWritten = responseBytesWritten ?? data.byteLength;
+            if (bytesWritten > data.byteLength) {
+                invalidDapResponse('writeMemory', 'bytesWritten', `reported ${bytesWritten} bytes written for ${data.byteLength} input bytes`);
+            }
+            if (!allowPartial && bytesWritten !== data.byteLength) {
+                invalidDapResponse('writeMemory', 'bytesWritten', `reported a partial write of ${bytesWritten} bytes for a required ${data.byteLength}-byte write`);
+            }
+            const responseOffset = responseBody.offset;
+            if (responseOffset !== undefined &&
+                (typeof responseOffset !== 'number' || !Number.isSafeInteger(responseOffset))) {
+                invalidDapResponse('writeMemory', 'offset', 'expected a safe integer');
+            }
+            return {
+                ...(responseOffset === undefined ? {} : { offset: responseOffset }),
+                bytesWritten
+            };
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    async dataBreakpointInfo(arguments_) {
+        if (!this.targetStopped || !this.supportsDataBreakpoints)
+            return null;
+        if (typeof arguments_ !== 'object' || arguments_ === null || Array.isArray(arguments_)) {
+            throw new TypeError('arguments must be an object.');
+        }
+        assertBoundedNonEmptyStringArgument(arguments_.name, 'name');
+        if (arguments_.variablesReference !== undefined) {
+            assertNonNegativeSafeIntegerArgument(arguments_.variablesReference, 'variablesReference');
+        }
+        if (arguments_.frameId !== undefined) {
+            assertPositiveSafeIntegerArgument(arguments_.frameId, 'frameId');
+        }
+        if (arguments_.bytes !== undefined) {
+            assertPositiveSafeIntegerArgument(arguments_.bytes, 'bytes');
+            if (arguments_.bytes > MAX_DEBUG_MEMORY_BYTES) {
+                throw new RangeError(`bytes must not exceed ${MAX_DEBUG_MEMORY_BYTES}.`);
+            }
+        }
+        assertOptionalBooleanArgument(arguments_.asAddress, 'asAddress');
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        try {
+            const response = await session.request('dataBreakpointInfo', {
+                name: arguments_.name,
+                ...(arguments_.variablesReference === undefined
+                    ? {}
+                    : { variablesReference: arguments_.variablesReference }),
+                ...(arguments_.frameId === undefined ? {} : { frameId: arguments_.frameId }),
+                ...(arguments_.asAddress === undefined ? {} : { asAddress: arguments_.asAddress }),
+                ...(arguments_.bytes === undefined ? {} : { bytes: arguments_.bytes })
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            assertDapRecord(response, 'dataBreakpointInfo', 'body');
+            assertDapString(response.description, 'dataBreakpointInfo', 'description');
+            let dataId;
+            if (response.dataId !== undefined && response.dataId !== null) {
+                assertDapString(response.dataId, 'dataBreakpointInfo', 'dataId');
+                if (response.dataId.length === 0) {
+                    invalidDapResponse('dataBreakpointInfo', 'dataId', 'expected a non-empty string');
+                }
+                if (response.dataId.length > MAX_DEBUG_IDENTIFIER_CODE_UNITS) {
+                    invalidDapResponse('dataBreakpointInfo', 'dataId', `expected at most ${MAX_DEBUG_IDENTIFIER_CODE_UNITS} UTF-16 code units`);
+                }
+                dataId = response.dataId;
+            }
+            let accessTypes;
+            if (response.accessTypes !== undefined) {
+                if (!Array.isArray(response.accessTypes)) {
+                    invalidDapResponse('dataBreakpointInfo', 'accessTypes', 'expected an array');
+                }
+                if (response.accessTypes.length > 3) {
+                    invalidDapResponse('dataBreakpointInfo', 'accessTypes', 'expected at most 3 entries');
+                }
+                const seenAccessTypes = new Set();
+                accessTypes = response.accessTypes.map((accessType, index) => {
+                    if (accessType !== 'read' &&
+                        accessType !== 'write' &&
+                        accessType !== 'readWrite') {
+                        invalidDapResponse('dataBreakpointInfo', `accessTypes[${index}]`, 'expected read, write, or readWrite');
+                    }
+                    if (seenAccessTypes.has(accessType)) {
+                        invalidDapResponse('dataBreakpointInfo', `accessTypes[${index}]`, 'expected a unique access type');
+                    }
+                    seenAccessTypes.add(accessType);
+                    return accessType;
+                });
+            }
+            let canPersist;
+            if (response.canPersist !== undefined) {
+                assertDapBoolean(response.canPersist, 'dataBreakpointInfo', 'canPersist');
+                canPersist = response.canPersist;
+            }
+            return {
+                ...(dataId === undefined ? {} : { dataId }),
+                description: response.description,
+                ...(accessTypes === undefined ? {} : { accessTypes }),
+                ...(canPersist === undefined ? {} : { canPersist })
+            };
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return null;
+            this.rethrowProtocolError(error);
+            throw error;
+        }
+    }
+    async setDataBreakpoints(breakpoints) {
+        if (!this.targetStopped || !this.supportsDataBreakpoints)
+            return [];
+        if (!Array.isArray(breakpoints)) {
+            throw new TypeError('breakpoints must be an array.');
+        }
+        if (breakpoints.length > MAX_DEBUG_DATA_BREAKPOINTS) {
+            throw new RangeError(`breakpoints must not contain more than ${MAX_DEBUG_DATA_BREAKPOINTS} entries.`);
+        }
+        for (let index = 0; index < breakpoints.length; index += 1) {
+            const breakpoint = breakpoints[index];
+            if (typeof breakpoint !== 'object' ||
+                breakpoint === null ||
+                Array.isArray(breakpoint)) {
+                throw new TypeError(`breakpoints[${index}] must be an object.`);
+            }
+            if (typeof breakpoint.dataId !== 'string' || breakpoint.dataId.length === 0) {
+                throw new TypeError(`breakpoints[${index}].dataId must be a non-empty string.`);
+            }
+            if (breakpoint.dataId.length > MAX_DEBUG_IDENTIFIER_CODE_UNITS) {
+                throw new RangeError(`breakpoints[${index}].dataId must not exceed ${MAX_DEBUG_IDENTIFIER_CODE_UNITS} UTF-16 code units.`);
+            }
+            if (breakpoint.accessType !== undefined &&
+                breakpoint.accessType !== 'read' &&
+                breakpoint.accessType !== 'write' &&
+                breakpoint.accessType !== 'readWrite') {
+                throw new TypeError(`breakpoints[${index}].accessType must be read, write, or readWrite.`);
+            }
+        }
+        const requestBreakpoints = breakpoints.map((breakpoint) => {
+            return {
+                dataId: breakpoint.dataId,
+                ...(breakpoint.accessType === undefined
+                    ? {}
+                    : { accessType: breakpoint.accessType })
+            };
+        });
+        const session = this.requireSession();
+        const stateVersion = this.stateVersion;
+        try {
+            const response = await session.request('setDataBreakpoints', {
+                breakpoints: requestBreakpoints
+            });
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return [];
+            const responseBreakpoints = dapResponseCollection(response, 'setDataBreakpoints', 'breakpoints');
+            if (responseBreakpoints.length !== requestBreakpoints.length) {
+                invalidDapResponse('setDataBreakpoints', 'breakpoints', `expected ${requestBreakpoints.length} entries`);
+            }
+            return responseBreakpoints.map((breakpoint, index) => {
+                const path = `breakpoints[${index}]`;
+                assertDapRecord(breakpoint, 'setDataBreakpoints', path);
+                assertDapBoolean(breakpoint.verified, 'setDataBreakpoints', `${path}.verified`);
+                const id = dapOptionalNonNegativeSafeInteger(breakpoint, 'id', 'setDataBreakpoints', path);
+                let message;
+                if (breakpoint.message !== undefined) {
+                    assertDapString(breakpoint.message, 'setDataBreakpoints', `${path}.message`);
+                    message = breakpoint.message;
+                }
+                return {
+                    ...(id === undefined ? {} : { id }),
+                    verified: breakpoint.verified,
+                    ...(message === undefined ? {} : { message })
+                };
+            });
+        }
+        catch (error) {
+            if (!this.isCurrentValueRequest(session, stateVersion))
+                return [];
+            const failure = this.asProtocolError(error) ??
+                (error instanceof Error
+                    ? error
+                    : new Error('Unable to replace the LLDB data breakpoints.'));
+            this.fail(failure);
+            throw failure;
+        }
+    }
+    async disconnect() {
+        const completionResolve = this.completionResolve;
+        const completionReject = this.completionReject;
+        this.lifecycleVersion += 1;
+        this.entrySetup?.resolve();
+        this.entrySetup = undefined;
+        const startupAbortController = this.startupAbortController;
+        this.startupAbortController = undefined;
+        startupAbortController?.abort(new Error('LLDB sandbox session disconnected during startup.'));
+        this.stateVersion += 1;
+        this.targetStopped = false;
+        this.retireInput();
+        this.initialized = false;
+        this.supportsEvaluateExpressions = false;
+        this.supportsReadMemory = false;
+        this.supportsWriteMemory = false;
+        this.supportsDataBreakpoints = false;
+        this.dapExitCode = null;
+        const session = this.session;
+        this.session = undefined;
+        const shouldPublishStop = !this.stopped;
+        this.stopped = true;
+        const disposal = session
+            ? this.trackSessionDisposal(session.disconnect({ terminateTarget: true }))
+            : this.sessionDisposal;
+        let disposalFailure;
+        try {
+            await disposal;
+        }
+        catch (error) {
+            disposalFailure =
+                error instanceof Error
+                    ? error
+                    : new Error('Unable to disconnect the LLDB debug session.');
+        }
+        if (disposalFailure) {
+            completionReject?.(disposalFailure);
+            if (shouldPublishStop)
+                this.publishStop();
+            throw disposalFailure;
+        }
+        completionResolve?.(true);
+        if (shouldPublishStop)
+            this.publishStop();
+    }
+    handleDapEvent(event) {
+        if (event.event === 'output') {
+            const body = event.body;
+            if (typeof body?.output === 'string')
+                this.options.onOutput(body.output);
+            return;
+        }
+        if (event.event === 'stopped') {
+            this.targetStopped = false;
+            if (typeof event.body !== 'object' ||
+                event.body === null ||
+                Array.isArray(event.body)) {
+                invalidDapPayload('stopped event', 'body', 'expected an object');
+            }
+            const body = event.body;
+            if (typeof body.reason !== 'string') {
+                invalidDapPayload('stopped event', 'reason', 'expected a string');
+            }
+            const threadId = body.threadId;
+            if (threadId !== undefined) {
+                assertDapPositiveSafeInteger(threadId, 'stopped event', 'threadId');
+            }
+            if (body.allThreadsStopped !== undefined &&
+                typeof body.allThreadsStopped !== 'boolean') {
+                invalidDapPayload('stopped event', 'allThreadsStopped', 'expected a boolean');
+            }
+            const reason = this.pauseRequested && body.reason === 'exception' ? 'pause' : body.reason;
+            this.pauseRequested = false;
+            const session = this.requireSession();
+            const version = ++this.stateVersion;
+            void this.resolveStoppedState(threadId, reason, version).catch((error) => {
+                if (version !== this.stateVersion || this.session !== session)
+                    return;
+                this.fail(error instanceof Error ? error : new Error('Unable to read LLDB stopped state.'));
+            });
+            return;
+        }
+        if (event.event === 'continued') {
+            this.targetStopped = false;
+            if (typeof event.body !== 'object' ||
+                event.body === null ||
+                Array.isArray(event.body)) {
+                invalidDapPayload('continued event', 'body', 'expected an object');
+            }
+            const body = event.body;
+            assertDapPositiveSafeInteger(body.threadId, 'continued event', 'threadId');
+            if (body.allThreadsContinued !== undefined &&
+                typeof body.allThreadsContinued !== 'boolean') {
+                invalidDapPayload('continued event', 'allThreadsContinued', 'expected a boolean');
+            }
+            this.stateVersion += 1;
+            return;
+        }
+        if (event.event === 'breakpoint') {
+            const body = event.body;
+            const breakpointId = body?.breakpoint?.id;
+            const sourcePath = body?.breakpoint?.source?.path;
+            for (const [trackedSourcePath, requestedLines] of this.breakpointsBySource) {
+                const resolved = this.requireSession().getResolvedBreakpoints(trackedSourcePath);
+                if (breakpointId !== undefined) {
+                    if (!resolved.some((breakpoint) => breakpoint.id === breakpointId))
+                        continue;
+                }
+                else {
+                    if (sourcePath && sourcePath !== trackedSourcePath)
+                        continue;
+                }
+                this.publishResolvedBreakpoints(resolved, requestedLines, trackedSourcePath);
+            }
+            return;
+        }
+        if (event.event === 'exited') {
+            if (typeof event.body !== 'object' ||
+                event.body === null ||
+                Array.isArray(event.body)) {
+                invalidDapPayload('exited event', 'body', 'expected an object');
+            }
+            const exitCode = event.body.exitCode;
+            if (typeof exitCode !== 'number' || !Number.isSafeInteger(exitCode)) {
+                invalidDapPayload('exited event', 'exitCode', 'expected a safe integer');
+            }
+            this.dapExitCode = exitCode;
+            return;
+        }
+        if (event.event === 'terminated')
+            return;
+    }
+    async resolveStoppedState(requestedThreadId, reason, version) {
+        const session = this.requireSession();
+        let threadId = requestedThreadId;
+        if (threadId === undefined) {
+            const response = await session.request('threads');
+            const threads = dapResponseCollection(response, 'threads', 'threads').map((thread, index) => {
+                const path = `threads[${index}]`;
+                assertDapRecord(thread, 'threads', path);
+                assertDapPositiveSafeInteger(thread.id, 'threads response', `${path}.id`);
+                assertDapString(thread.name, 'threads', `${path}.name`);
+                return { id: thread.id, name: thread.name };
+            });
+            threadId = threads[0]?.id;
+        }
+        if (!threadId)
+            throw new Error('LLDB stopped without a WebAssembly thread.');
+        const response = await session.request('stackTrace', {
+            threadId,
+            startFrame: 0,
+            levels: 100
+        });
+        const frames = dapResponseCollection(response, 'stackTrace', 'stackFrames').map((frame, index) => {
+            const path = `stackFrames[${index}]`;
+            assertDapRecord(frame, 'stackTrace', path);
+            assertDapPositiveSafeInteger(frame.id, 'stackTrace response', `${path}.id`);
+            assertDapString(frame.name, 'stackTrace', `${path}.name`);
+            assertDapNonNegativeSafeInteger(frame.line, 'stackTrace', `${path}.line`);
+            assertDapNonNegativeSafeInteger(frame.column, 'stackTrace', `${path}.column`);
+            let source;
+            if (frame.source !== undefined) {
+                assertDapRecord(frame.source, 'stackTrace', `${path}.source`);
+                const sourcePath = frame.source.path;
+                if (sourcePath !== undefined) {
+                    assertDapString(sourcePath, 'stackTrace', `${path}.source.path`);
+                }
+                source = sourcePath === undefined ? {} : { path: sourcePath };
+            }
+            return {
+                id: frame.id,
+                name: frame.name,
+                source,
+                line: frame.line,
+                column: frame.column
+            };
+        });
+        const selectedFrame = frames[0];
+        if (!selectedFrame)
+            throw new Error('LLDB stopped without a stack frame.');
+        const isWorkspaceFrame = this.options.artifact.sources.some((source) => source.path === selectedFrame.source?.path);
+        if (!this.isCurrentValueRequest(session, version))
+            return;
+        if (this.entryPhase === 'initial') {
+            await this.entrySetup?.ready;
+            if (!this.isCurrentValueRequest(session, version))
+                return;
+            this.entryPhase = 'done';
+            if (reason === 'entry' && selectedFrame.name === '_start' && !isWorkspaceFrame) {
+                // configurationDone has already installed all user source breakpoints. Function
+                // breakpoints occupy a separate DAP registry owned by this product session.
+                this.entryPhase = 'seeking-main';
+                const verified = await this.setMainEntryBreakpoint(session, true);
+                if (!this.isCurrentValueRequest(session, version))
+                    return;
+                if (verified && !this.pauseRequested) {
+                    this.activeThreadId = threadId;
+                    await this.debugCommand('continue');
+                    return;
+                }
+                await this.setMainEntryBreakpoint(session, false);
+                if (!this.isCurrentValueRequest(session, version))
+                    return;
+                this.entryPhase = 'done';
+                if (this.pauseRequested) {
+                    this.pauseRequested = false;
+                    reason = 'pause';
+                }
+                else {
+                    this.options.onOutput('LLDB could not resolve main; paused at runtime entry.\n');
+                }
+            }
+        }
+        else if (this.entryPhase === 'seeking-main') {
+            // Honor any earlier user breakpoint, trap, or Pause, and never leave a hidden
+            // main breakpoint behind for a later Continue.
+            this.entryPhase = 'done';
+            await this.setMainEntryBreakpoint(session, false);
+            if (!this.isCurrentValueRequest(session, version))
+                return;
+            if (reason === 'breakpoint' && selectedFrame.name === 'main' && isWorkspaceFrame) {
+                reason = 'entry';
+            }
+        }
+        const scopes = isWorkspaceFrame ? await this.requestScopes(session, selectedFrame.id) : [];
+        if (version !== this.stateVersion || this.session !== session)
+            return;
+        this.activeThreadId = threadId;
+        this.activeFrameId = selectedFrame.id;
+        this.stoppedFrames = frames;
+        this.targetStopped = true;
+        const callStack = frames.map((frame) => {
+            const sourcePath = frame.source?.path;
+            const sourceContentSha256 = this.sourceContentSha256ByPath.get(sourcePath || '');
+            return {
+                id: frame.id,
+                functionName: frame.name,
+                line: frame.line,
+                column: frame.column,
+                sourcePath,
+                ...(sourceContentSha256 ? { sourceContentSha256 } : {})
+            };
+        });
+        const sourceContentSha256 = this.sourceContentSha256ByPath.get(selectedFrame.source?.path || '');
+        this.options.onDebugEvent({
+            type: 'pause',
+            capabilities: {
+                readMemory: this.supportsReadMemory,
+                writeMemory: this.supportsWriteMemory,
+                dataBreakpoints: this.supportsDataBreakpoints
+            },
+            line: selectedFrame.line,
+            sourcePath: selectedFrame.source?.path,
+            ...(sourceContentSha256 ? { sourceContentSha256 } : {}),
+            reason: pauseReason(reason, this.command),
+            stoppedReason: reason,
+            threadId,
+            frameId: selectedFrame.id,
+            locals: [],
+            callStack,
+            scopes
+        });
+        this.command = null;
+    }
+    async setMainEntryBreakpoint(session, enabled) {
+        const response = await session.request('setFunctionBreakpoints', {
+            breakpoints: enabled ? [{ name: 'main' }] : []
+        });
+        const breakpoints = dapResponseCollection(response, 'setFunctionBreakpoints', 'breakpoints');
+        if (breakpoints.length !== (enabled ? 1 : 0)) {
+            invalidDapResponse('setFunctionBreakpoints', 'breakpoints', 'unexpected breakpoint count');
+        }
+        if (!enabled)
+            return false;
+        const breakpoint = breakpoints[0];
+        assertDapRecord(breakpoint, 'setFunctionBreakpoints', 'breakpoints[0]');
+        assertDapBoolean(breakpoint.verified, 'setFunctionBreakpoints', 'breakpoints[0].verified');
+        return breakpoint.verified;
+    }
+    async requestScopes(session, frameId) {
+        const response = await session.request('scopes', { frameId });
+        return dapResponseCollection(response, 'scopes', 'scopes').map((scope, index) => {
+            const path = `scopes[${index}]`;
+            assertDapRecord(scope, 'scopes', path);
+            assertDapString(scope.name, 'scopes', `${path}.name`);
+            assertDapNonNegativeSafeInteger(scope.variablesReference, 'scopes', `${path}.variablesReference`);
+            assertDapBoolean(scope.expensive, 'scopes', `${path}.expensive`);
+            const presentationHint = scope.presentationHint;
+            if (presentationHint !== undefined) {
+                assertDapString(presentationHint, 'scopes', `${path}.presentationHint`);
+            }
+            const namedVariables = dapOptionalNonNegativeSafeInteger(scope, 'namedVariables', 'scopes', path);
+            const indexedVariables = dapOptionalNonNegativeSafeInteger(scope, 'indexedVariables', 'scopes', path);
+            return {
+                name: scope.name,
+                ...(presentationHint === undefined ? {} : { presentationHint }),
+                variablesReference: scope.variablesReference,
+                ...(namedVariables === undefined ? {} : { namedVariables }),
+                ...(indexedVariables === undefined ? {} : { indexedVariables }),
+                expensive: scope.expensive,
+                variables: []
+            };
+        });
+    }
+    isCurrentValueRequest(session, stateVersion, scopeRequestVersion) {
+        return (this.session === session &&
+            this.stateVersion === stateVersion &&
+            (scopeRequestVersion === undefined || this.scopeRequestVersion === scopeRequestVersion));
+    }
+    rethrowProtocolError(error) {
+        const protocolError = this.asProtocolError(error);
+        if (!protocolError)
+            return;
+        this.fail(protocolError);
+        throw protocolError;
+    }
+    asProtocolError(error) {
+        if (error instanceof ProtocolError)
+            return error;
+        if (error instanceof DapProtocolError) {
+            return new ProtocolError(error.message, { cause: error });
+        }
+        return null;
+    }
+    finish(exitCode) {
+        if (this.stopped)
+            return;
+        this.entrySetup?.resolve();
+        this.entrySetup = undefined;
+        this.stopped = true;
+        this.stateVersion += 1;
+        this.targetStopped = false;
+        this.retireInput();
+        this.initialized = false;
+        this.supportsEvaluateExpressions = false;
+        this.supportsReadMemory = false;
+        this.supportsWriteMemory = false;
+        this.supportsDataBreakpoints = false;
+        this.dapExitCode = null;
+        const session = this.session;
+        this.session = undefined;
+        const completionResolve = this.completionResolve;
+        const completionReject = this.completionReject;
+        const disposal = session
+            ? this.trackSessionDisposal(session.dispose())
+            : (this.sessionDisposal ?? Promise.resolve());
+        void disposal.then(() => {
+            if (exitCode !== null && exitCode !== 0) {
+                completionReject?.(new Error(`Debug target exited with code ${exitCode}.`));
+            }
+            else {
+                completionResolve?.(true);
+            }
+        }, (error) => completionReject?.(error instanceof Error
+            ? error
+            : new Error('Unable to dispose the LLDB debug session.')));
+        this.publishStop();
+    }
+    fail(error) {
+        if (this.stopped)
+            return;
+        this.entrySetup?.resolve();
+        this.entrySetup = undefined;
+        this.stopped = true;
+        this.stateVersion += 1;
+        this.targetStopped = false;
+        this.retireInput();
+        this.initialized = false;
+        this.supportsEvaluateExpressions = false;
+        this.supportsReadMemory = false;
+        this.supportsWriteMemory = false;
+        this.supportsDataBreakpoints = false;
+        this.dapExitCode = null;
+        const session = this.session;
+        this.session = undefined;
+        const completionReject = this.completionReject;
+        const disposal = session
+            ? this.trackSessionDisposal(session.dispose())
+            : (this.sessionDisposal ?? Promise.resolve());
+        void disposal.then(() => completionReject?.(error), () => completionReject?.(error));
+        this.publishStop();
+    }
+    publishStop() {
+        try {
+            this.options.onDebugEvent({ type: 'stop' });
+        }
+        catch {
+            // Consumer callbacks cannot interrupt target teardown or completion settlement.
+        }
+    }
+    publishActiveDebugEvent(event) {
+        try {
+            this.options.onDebugEvent(event);
+        }
+        catch (error) {
+            const failure = error instanceof Error
+                ? error
+                : new Error('Unable to publish the LLDB debug session state.');
+            this.fail(failure);
+            throw failure;
+        }
+    }
+    trackSessionDisposal(disposal) {
+        this.sessionDisposal = disposal;
+        void disposal.then(() => {
+            if (this.sessionDisposal === disposal)
+                this.sessionDisposal = undefined;
+        }, () => {
+            if (this.sessionDisposal === disposal)
+                this.sessionDisposal = undefined;
+        });
+        return disposal;
+    }
+    requireSession() {
+        if (!this.session)
+            throw new Error('LLDB sandbox session is not running.');
+        return this.session;
+    }
+    publishResolvedBreakpoints(breakpoints, requestedLines, sourcePath = this.options.sourcePath) {
+        const sourceContentSha256 = this.sourceContentSha256ByPath.get(sourcePath);
+        this.publishActiveDebugEvent({
+            type: 'breakpoints',
+            sourcePath,
+            ...(sourceContentSha256 ? { sourceContentSha256 } : {}),
+            breakpoints: requestedLines.map((requestedLine, index) => ({
+                requestedLine,
+                line: breakpoints[index]?.line ?? requestedLine,
+                verified: breakpoints[index]?.verified === true,
+                message: breakpoints[index]?.message
+            }))
+        });
+    }
+    observeInputFlush(flush, session, lifecycleVersion) {
+        void flush.catch((error) => {
+            if (this.stopped ||
+                this.lifecycleVersion !== lifecycleVersion ||
+                this.session !== session) {
+                return;
+            }
+            this.fail(error instanceof Error ? error : new Error('Unable to write LLDB target input.'));
+        });
+        return flush;
+    }
+    retireInput() {
+        this.inputReady = false;
+        this.pendingInput.length = 0;
+        this.pendingEof = false;
+    }
+    async flushInput(session, lifecycleVersion) {
+        if (!this.inputReady ||
+            !session ||
+            this.lifecycleVersion !== lifecycleVersion ||
+            this.session !== session) {
+            return;
+        }
+        while (this.pendingInput.length > 0) {
+            await session.writeStdin(this.pendingInput.shift() || '');
+            if (!this.inputReady ||
+                this.lifecycleVersion !== lifecycleVersion ||
+                this.session !== session) {
+                return;
+            }
+        }
+        if (this.pendingEof) {
+            this.pendingEof = false;
+            await session.closeStdin();
+        }
+    }
+}