qsharp-lang 0.1.0-dev.1

package/LICENSE.txt

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/README.md

@@ -0,0 +1,74 @@
+# qsharp npm module
+
+This package contains the qsharp compiler and language service functionality shipped for consumption via npm.
+
+The source is written in TypeScript, which is compiled to ECMAScript modules in the ./dist directory.
+The wasm binaries from the Rust builds are copied to the ./lib directory.
+
+Consuming browser projects should import from this module and use a bundler to create their
+own JavaScript bundle, and also copy the wasm file to their project and provide the URL
+to it when calling the `loadWasmModule` method so it may be located and loaded.
+
+## Node and browser support
+
+wasm-pack generates different files for the browser and Node.js environments. The wasm is slightly
+different, and the loader code is quite different. This can be seen in `./lib/web/qsc_wasm.cjs`
+and `./lib/node/qsc_wasm.js` files respectively. Specifically, the web environment loads the wasm
+file using async web APIs such as `fetch` with a URI, and Node.js uses `require` to load the `fs` module
+and calls to `readFileSync`. Once the wasm module is loaded however, the exported APIs are used
+in a similar manner.
+
+To support using this npm package from both environments, the package uses "conditional exports"
+<https://nodejs.org/dist/latest-v18.x/docs/api/packages.html#conditional-exports> to expose one
+entry point for Node.js, and another for browsers. The distinct entry points uses their respective
+loader to load the wasm module for the platform, and then expose functionality that uses the
+loaded module via common code.
+
+When bundling for the web, bundlers such as esbuild will automatically use the default entry point,
+whereas when loaded as a Node.js module, it will use the "node" entry point.
+
+Note that TypeScript seems to add the ['import', 'types', 'node'] conditions by default when
+searching the Node.js `exports`, and so will always find the 'node' export before the 'default'
+export. To resolve this, a 'browser' condition was added (which is same as 'default' but earlier
+than 'node') and the tsconfig compiler option `"customConditions": ["browser"]` should be added
+(requires TypeScript 5.0 or later). esbuild also adds the 'browser' condition when bundling for
+the browser (see <https://esbuild.github.io/api/#how-conditions-work>).
+
+## Design
+
+This package provides two services, the compiler and the language service.
+
+The API for using these services is similar whether using a browser or Node.js,
+and whether running in the main thread or a worker thread. You instantiate the service
+and call operations on it which complete in the order called.
+
+All operations return a Promise which resolves then the operation is complete. Some operations
+may also emit events, such as debug messages or state dumps as they are processed. The service
+itself can also emit events which can be subscribed to using `addEventListener`.
+
+See the Q# playground code at <https://github.com/microsoft/qsharp/tree/main/playground> for
+an example of code that uses this package. The unit tests at
+<https://github.com/microsoft/qsharp/tree/main/npm/test> are also a good reference.
+
+Promises, Events, and Cancellation are based on JavaScript or Web standards, or the VS Code API:
+
+- Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>
+- EventTarget <https://developer.mozilla.org/en-US/docs/Web/API/EventTarget>
+- Event <https://developer.mozilla.org/en-US/docs/Web/API/Event/Event>
+- VS Code API for CancellationToken <https://code.visualstudio.com/api/references/vscode-api#CancellationToken>
+
+The standard Web APIs for custom events were added to Node.js in v16.17. <https://nodejs.org/dist/v16.17.0/docs/api/events.html>, but behind an experimental flag. As CustomEvent is not on
+the global by default until v19 or later, the code will use Event with a 'detail'
+property manually set until v20 is in common use.
+
+The VS Code implementation for cancellation tokens is viewable in their source code
+at <src/vs/base/common/cancellation.ts>. This code uses a simplified version of that API.
+
+## Testing
+
+Node.js tests can be run via `node --test` (see
+<https://nodejs.org/dist/latest-v18.x/docs/api/test.html#test-runner-execution-model>).
+
+The test module was also added to Node.js v16.17.0, and Electron 22 (which VS Code plans to move to
+in first half of 2023) includes v16.17.1, so v16.17 should be our minimum Node.js
+version supported (it shipped in Aug 2022).

package/dist/browser.d.ts

@@ -0,0 +1,26 @@
+import { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
+import { IDebugService, IDebugServiceWorker } from "./debug-service/debug-service.js";
+import { ILanguageService, ILanguageServiceWorker, qsharpLibraryUriScheme } from "./language-service/language-service.js";
+import { LogLevel, log } from "./log.js";
+export { qsharpLibraryUriScheme };
+export declare function loadWasmModule(uriOrBuffer: string | ArrayBuffer): Promise<void>;
+export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
+export declare function getDebugService(): Promise<IDebugService>;
+export declare function getDebugServiceWorker(workerArg: string | Worker): IDebugServiceWorker;
+export declare function getCompiler(): Promise<ICompiler>;
+export declare function getCompilerWorker(workerArg: string | Worker): ICompilerWorker;
+export declare function getLanguageService(): Promise<ILanguageService>;
+export declare function getLanguageServiceWorker(workerArg: string | Worker): ILanguageServiceWorker;
+export { type Dump, type ShotResult } from "./compiler/common.js";
+export { type CompilerState } from "./compiler/compiler.js";
+export { QscEventTarget } from "./compiler/events.js";
+export { getAllKatas, getExerciseSources, getKata, type ContentItem, type Example, type Exercise, type ExplainedSolution, type ExplainedSolutionItem, type Kata, type KataSection, type Lesson, type LessonItem, type Question, } from "./katas.js";
+export { default as samples } from "./samples.generated.js";
+export { type VSDiagnostic } from "./vsdiagnostic.js";
+export { log, type LogLevel };
+export type { ICompilerWorker, ICompiler };
+export type { ILanguageServiceWorker, ILanguageService };
+export type { IDebugServiceWorker, IDebugService };
+export type { IBreakpointSpan, IStackFrame } from "../lib/web/qsc_wasm.js";
+export { type IStructStepResult, StepResultId } from "../lib/web/qsc_wasm.js";
+export { type LanguageServiceEvent } from "./language-service/language-service.js";

package/dist/browser.js

@@ -0,0 +1,156 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// This module is the entry point for browser environments. For Node.js environment,
+// the "./main.js" module is the entry point.
+import initWasm, * as wasm from "../lib/web/qsc_wasm.js";
+import { Compiler } from "./compiler/compiler.js";
+import { createCompilerProxy } from "./compiler/worker-proxy.js";
+import { QSharpDebugService, } from "./debug-service/debug-service.js";
+import { createDebugServiceProxy } from "./debug-service/worker-proxy.js";
+import { QSharpLanguageService, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
+import { createLanguageServiceProxy } from "./language-service/worker-proxy.js";
+import { log } from "./log.js";
+export { qsharpLibraryUriScheme };
+// Create once. A module is stateless and can be efficiently passed to WebWorkers.
+let wasmModule = null;
+let wasmModulePromise = null;
+// Used to track if an instance is already instantiated
+let wasmInstancePromise = null;
+async function wasmLoader(uriOrBuffer) {
+    if (typeof uriOrBuffer === "string") {
+        log.info("Fetching wasm module from %s", uriOrBuffer);
+        performance.mark("fetch-wasm-start");
+        const wasmRequst = await fetch(uriOrBuffer);
+        const wasmBuffer = await wasmRequst.arrayBuffer();
+        const fetchTiming = performance.measure("fetch-wasm", "fetch-wasm-start");
+        log.logTelemetry({
+            id: "fetch-wasm",
+            data: {
+                duration: fetchTiming.duration,
+                uri: uriOrBuffer,
+            },
+        });
+        wasmModule = await WebAssembly.compile(wasmBuffer);
+    }
+    else {
+        log.info("Compiling wasm module from provided buffer");
+        wasmModule = await WebAssembly.compile(uriOrBuffer);
+    }
+}
+export function loadWasmModule(uriOrBuffer) {
+    // Only initiate if not already in flight, to avoid race conditions
+    if (!wasmModulePromise) {
+        wasmModulePromise = wasmLoader(uriOrBuffer);
+    }
+    return wasmModulePromise;
+}
+async function instantiateWasm() {
+    // Ensure loading the module has been initiated, and wait for it.
+    if (!wasmModulePromise)
+        throw "Wasm module must be loaded first";
+    await wasmModulePromise;
+    if (!wasmModule)
+        throw "Wasm module failed to load";
+    if (wasmInstancePromise) {
+        // Either in flight or already complete. The prior request will do the init,
+        // so just wait on that.
+        await wasmInstancePromise;
+        return;
+    }
+    // Set the promise to signal this is in flight, then wait on the result.
+    wasmInstancePromise = initWasm(wasmModule);
+    await wasmInstancePromise;
+    // Once ready, set up logging and telemetry as soon as possible after instantiating
+    wasm.initLogging(log.logWithLevel, log.getLogLevel());
+    log.onLevelChanged = (level) => wasm.setLogLevel(level);
+}
+export async function getLibrarySourceContent(path) {
+    await instantiateWasm();
+    return wasm.get_library_source_content(path);
+}
+export async function getDebugService() {
+    await instantiateWasm();
+    return new QSharpDebugService(wasm);
+}
+// Create the debugger inside a WebWorker and proxy requests.
+// If the Worker was already created via other means and is ready to receive
+// messages, then the worker may be passed in and it will be initialized.
+export function getDebugServiceWorker(workerArg) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    // Create or use the WebWorker
+    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
+    // Send it the Wasm module to instantiate
+    worker.postMessage({
+        type: "init",
+        wasmModule,
+        qscLogLevel: log.getLogLevel(),
+    });
+    // If you lose the 'this' binding, some environments have issues
+    const postMessage = worker.postMessage.bind(worker);
+    const onTerminate = () => worker.terminate();
+    // Create the proxy which will forward method calls to the worker
+    const proxy = createDebugServiceProxy(postMessage, onTerminate);
+    // Let proxy handle response and event messages from the worker
+    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
+    return proxy;
+}
+export async function getCompiler() {
+    await instantiateWasm();
+    return new Compiler(wasm);
+}
+// Create the compiler inside a WebWorker and proxy requests.
+// If the Worker was already created via other means and is ready to receive
+// messages, then the worker may be passed in and it will be initialized.
+export function getCompilerWorker(workerArg) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    // Create or use the WebWorker
+    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
+    // Send it the Wasm module to instantiate
+    worker.postMessage({
+        type: "init",
+        wasmModule,
+        qscLogLevel: log.getLogLevel(),
+    });
+    // If you lose the 'this' binding, some environments have issues
+    const postMessage = worker.postMessage.bind(worker);
+    const onTerminate = () => worker.terminate();
+    // Create the proxy which will forward method calls to the worker
+    const proxy = createCompilerProxy(postMessage, onTerminate);
+    // Let proxy handle response and event messages from the worker
+    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
+    return proxy;
+}
+export async function getLanguageService() {
+    await instantiateWasm();
+    return new QSharpLanguageService(wasm);
+}
+// Create the compiler inside a WebWorker and proxy requests.
+// If the Worker was already created via other means and is ready to receive
+// messages, then the worker may be passed in and it will be initialized.
+export function getLanguageServiceWorker(workerArg) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    // Create or use the WebWorker
+    const worker = typeof workerArg === "string" ? new Worker(workerArg) : workerArg;
+    // Send it the Wasm module to instantiate
+    worker.postMessage({
+        type: "init",
+        wasmModule,
+        qscLogLevel: log.getLogLevel(),
+    });
+    // If you lose the 'this' binding, some environments have issues
+    const postMessage = worker.postMessage.bind(worker);
+    const onTerminate = () => worker.terminate();
+    // Create the proxy which will forward method calls to the worker
+    const proxy = createLanguageServiceProxy(postMessage, onTerminate);
+    // Let proxy handle response and event messages from the worker
+    worker.onmessage = (ev) => proxy.onMsgFromWorker(ev.data);
+    return proxy;
+}
+export { QscEventTarget } from "./compiler/events.js";
+export { getAllKatas, getExerciseSources, getKata, } from "./katas.js";
+export { default as samples } from "./samples.generated.js";
+export { log };
+export { StepResultId } from "../lib/web/qsc_wasm.js";

package/dist/cancellation.d.ts

@@ -0,0 +1,10 @@
+export interface CancellationToken {
+    readonly isCancellationRequested: boolean;
+    readonly onCancellationRequested: (listener: (e: any) => any) => void;
+}
+export declare class CancellationTokenSource {
+    private _token;
+    constructor(parent?: CancellationToken);
+    get token(): CancellationToken;
+    cancel(): void;
+}

package/dist/cancellation.js

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+class InternalToken {
+    constructor() {
+        this.isCancellationRequested = false;
+        this.eventTarget = new EventTarget();
+    }
+    onCancellationRequested(listener) {
+        this.eventTarget.addEventListener("cancelled", listener);
+    }
+    cancel() {
+        if (this.isCancellationRequested)
+            return; // Only fires once
+        this.isCancellationRequested = true;
+        this.eventTarget.dispatchEvent(new Event("cancelled"));
+    }
+}
+export class CancellationTokenSource {
+    constructor(parent) {
+        // There are some optimizations you can do here to lazily allocate, but keeping it simple for now.
+        this._token = new InternalToken();
+        if (parent)
+            parent.onCancellationRequested(() => this.cancel());
+    }
+    get token() {
+        return this._token;
+    }
+    cancel() {
+        this._token.cancel();
+    }
+}

package/dist/compiler/common.d.ts

@@ -0,0 +1,31 @@
+import { VSDiagnostic } from "../vsdiagnostic.js";
+export type Dump = {
+    [index: string]: [number, number];
+};
+export type Result = {
+    success: true;
+    value: string;
+} | {
+    success: false;
+    value: VSDiagnostic;
+};
+interface DumpMsg {
+    type: "DumpMachine";
+    state: Dump;
+}
+interface MessageMsg {
+    type: "Message";
+    message: string;
+}
+interface ResultMsg {
+    type: "Result";
+    result: Result;
+}
+type EventMsg = ResultMsg | DumpMsg | MessageMsg;
+export declare function eventStringToMsg(msg: string): EventMsg | null;
+export type ShotResult = {
+    success: boolean;
+    result: string | VSDiagnostic;
+    events: Array<MessageMsg | DumpMsg>;
+};
+export {};

package/dist/compiler/common.js

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+function outputAsResult(msg) {
+    try {
+        const obj = JSON.parse(msg);
+        if (obj?.type == "Result" && typeof obj.success == "boolean") {
+            return {
+                type: "Result",
+                result: {
+                    success: obj.success,
+                    value: obj.result,
+                },
+            };
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function outputAsMessage(msg) {
+    try {
+        const obj = JSON.parse(msg);
+        if (obj?.type == "Message" && typeof obj.message == "string") {
+            return obj;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function outputAsDump(msg) {
+    try {
+        const obj = JSON.parse(msg);
+        if (obj?.type == "DumpMachine" && typeof obj.state == "object") {
+            return obj;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function eventStringToMsg(msg) {
+    return outputAsResult(msg) || outputAsMessage(msg) || outputAsDump(msg);
+}

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,28 @@
+import { VSDiagnostic } from "../vsdiagnostic.js";
+import { IServiceProxy, ServiceState } from "../worker-proxy.js";
+import { IQscEventTarget } from "./events.js";
+type Wasm = typeof import("../../lib/node/qsc_wasm.cjs");
+export interface ICompiler {
+    /**
+     * @deprecated use the language service for errors and other editor features.
+     */
+    checkCode(code: string): Promise<VSDiagnostic[]>;
+    getHir(code: string): Promise<string>;
+    run(code: string, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
+}
+export type ICompilerWorker = ICompiler & IServiceProxy;
+export type CompilerState = ServiceState;
+export declare class Compiler implements ICompiler {
+    private wasm;
+    constructor(wasm: Wasm);
+    /**
+     * @deprecated use the language service for errors and other editor features.
+     */
+    checkCode(code: string): Promise<VSDiagnostic[]>;
+    getHir(code: string): Promise<string>;
+    run(code: string, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
+}
+export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+export {};

package/dist/compiler/compiler.js

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { log } from "../log.js";
+import { mapDiagnostics } from "../vsdiagnostic.js";
+import { eventStringToMsg } from "./common.js";
+import { makeEvent } from "./events.js";
+export class Compiler {
+    constructor(wasm) {
+        log.info("Constructing a Compiler instance");
+        this.wasm = wasm;
+        globalThis.qscGitHash = this.wasm.git_hash();
+    }
+    /**
+     * @deprecated use the language service for errors and other editor features.
+     */
+    async checkCode(code) {
+        let diags = [];
+        const languageService = new this.wasm.LanguageService((uri, version, errors) => {
+            diags = errors;
+        });
+        languageService.update_document("code", 1, code, true /* exe */);
+        return mapDiagnostics(diags, code);
+    }
+    async getHir(code) {
+        return this.wasm.get_hir(code);
+    }
+    async run(code, expr, shots, eventHandler) {
+        // All results are communicated as events, but if there is a compiler error (e.g. an invalid
+        // entry expression or similar), it may throw on run. The caller should expect this promise
+        // may reject without all shots running or events firing.
+        this.wasm.run(code, expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+    }
+    async checkExerciseSolution(user_code, exercise_sources, eventHandler) {
+        const success = this.wasm.check_exercise_solution(user_code, exercise_sources, (msg) => onCompilerEvent(msg, eventHandler));
+        return success;
+    }
+}
+export function onCompilerEvent(msg, eventTarget) {
+    const qscMsg = eventStringToMsg(msg);
+    if (!qscMsg) {
+        log.error("Unknown event message: %s", msg);
+        return;
+    }
+    let qscEvent;
+    const msgType = qscMsg.type;
+    switch (msgType) {
+        case "Message":
+            qscEvent = makeEvent("Message", qscMsg.message);
+            break;
+        case "DumpMachine":
+            qscEvent = makeEvent("DumpMachine", qscMsg.state);
+            break;
+        case "Result":
+            qscEvent = makeEvent("Result", qscMsg.result);
+            break;
+        default:
+            log.never(msgType);
+            throw "Unexpected message type";
+    }
+    log.debug("worker dispatching event " + JSON.stringify(qscEvent));
+    eventTarget.dispatchEvent(qscEvent);
+}

package/dist/compiler/events.d.ts

@@ -0,0 +1,54 @@
+import { ShotResult, Dump, Result } from "./common.js";
+import { TelemetryEvent } from "../log.js";
+import { IServiceEventTarget } from "../worker-proxy.js";
+export type QscEventData = {
+    type: "Message";
+    detail: string;
+} | {
+    type: "DumpMachine";
+    detail: Dump;
+} | {
+    type: "Result";
+    detail: Result;
+} | {
+    type: "telemetry-event";
+    detail: TelemetryEvent;
+};
+export type QscEvents = Event & QscEventData;
+export type QscEvent<T extends QscEvents["type"]> = Extract<QscEvents, {
+    type: T;
+}>;
+export type IQscEventTarget = IServiceEventTarget<QscEventData>;
+export declare function makeEvent<E extends QscEvents>(type: E["type"], detail: E["detail"]): E;
+type QscUiEvents = QscEvents | (Event & {
+    type: "uiResultsRefresh";
+    detail: undefined;
+});
+export declare class QscEventTarget implements IQscEventTarget {
+    private eventTarget;
+    private results;
+    private shotActive;
+    private animationFrameId;
+    private supportsUiRefresh;
+    addEventListener<T extends QscUiEvents["type"]>(type: T, listener: (event: Extract<QscEvents, {
+        type: T;
+    }>) => void): void;
+    removeEventListener<T extends QscUiEvents["type"]>(type: T, listener: (event: Extract<QscEvents, {
+        type: T;
+    }>) => void): void;
+    dispatchEvent(event: QscUiEvents): boolean;
+    /**
+     * @param captureEvents Set to true if this instance should record events internally
+     */
+    constructor(captureEvents: boolean);
+    private onMessage;
+    private onDumpMachine;
+    private onResult;
+    private ensureActiveShot;
+    private queueUiRefresh;
+    private onUiRefresh;
+    getResults(): ShotResult[];
+    resultCount(): number;
+    clearResults(): void;
+}
+export {};

package/dist/compiler/events.js

@@ -0,0 +1,92 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { log } from "../log.js";
+// Convenience method that also provides type safety
+export function makeEvent(type, detail) {
+    const event = new Event(type);
+    event.detail = detail;
+    return event;
+}
+function makeResultObj() {
+    return { success: false, result: "", events: [] };
+}
+export class QscEventTarget {
+    // Overrides for the base EventTarget methods to limit to expected event types
+    addEventListener(type, listener) {
+        this.eventTarget.addEventListener(type, listener);
+    }
+    removeEventListener(type, listener) {
+        this.eventTarget.removeEventListener(type, listener);
+    }
+    dispatchEvent(event) {
+        if (log.getLogLevel() >= 4)
+            log.debug("Dispatching event: %o", event);
+        return this.eventTarget.dispatchEvent(event);
+    }
+    /**
+     * @param captureEvents Set to true if this instance should record events internally
+     */
+    constructor(captureEvents) {
+        this.eventTarget = new EventTarget();
+        this.results = [];
+        this.shotActive = false;
+        this.animationFrameId = 0;
+        this.supportsUiRefresh = false;
+        this.supportsUiRefresh =
+            typeof globalThis.requestAnimationFrame === "function";
+        if (captureEvents) {
+            this.addEventListener("Message", (ev) => this.onMessage(ev.detail));
+            this.addEventListener("DumpMachine", (ev) => this.onDumpMachine(ev.detail));
+            this.addEventListener("Result", (ev) => this.onResult(ev.detail));
+        }
+    }
+    onMessage(msg) {
+        this.ensureActiveShot();
+        const shotIdx = this.results.length - 1;
+        this.results[shotIdx].events.push({ type: "Message", message: msg });
+        this.queueUiRefresh();
+    }
+    onDumpMachine(dump) {
+        this.ensureActiveShot();
+        const shotIdx = this.results.length - 1;
+        this.results[shotIdx].events.push({ type: "DumpMachine", state: dump });
+        this.queueUiRefresh();
+    }
+    onResult(result) {
+        this.ensureActiveShot();
+        const shotIdx = this.results.length - 1;
+        this.results[shotIdx].success = result.success;
+        this.results[shotIdx].result = result.value;
+        this.shotActive = false;
+        this.queueUiRefresh();
+    }
+    ensureActiveShot() {
+        if (!this.shotActive) {
+            this.results.push(makeResultObj());
+            this.shotActive = true;
+        }
+    }
+    queueUiRefresh() {
+        if (this.supportsUiRefresh && !this.animationFrameId) {
+            this.animationFrameId = requestAnimationFrame(() => {
+                this.onUiRefresh();
+            });
+        }
+    }
+    onUiRefresh() {
+        this.animationFrameId = 0;
+        const uiRefreshEvent = new Event("uiResultsRefresh");
+        this.dispatchEvent(uiRefreshEvent);
+    }
+    getResults() {
+        return this.results;
+    }
+    resultCount() {
+        // May be one less than length if the last is still in flight
+        return this.shotActive ? this.results.length - 1 : this.results.length;
+    }
+    clearResults() {
+        this.results = [];
+        this.shotActive = false;
+    }
+}

package/dist/compiler/worker-browser.d.ts

@@ -0,0 +1 @@
+export declare function messageHandler(e: MessageEvent): void;