qsharp-lang 1.1.3 → 1.1.5-dev

package/dist/browser.d.ts

@@ -11,13 +11,13 @@ export declare function getDebugService(): Promise<IDebugService>;
 export declare function getProjectLoader(readFile: (path: string) => Promise<string | null>, loadDirectory: (path: string) => Promise<[string, number][]>, getManifest: (path: string) => Promise<{
     manifestDirectory: string;
 } | null>): Promise<wasm.ProjectLoader>;
-export declare function getDebugServiceWorker(workerArg: string | Worker): IDebugServiceWorker;
+export declare function getDebugServiceWorker(worker: string | Worker): IDebugServiceWorker;
 export declare function getCompiler(): Promise<ICompiler>;
-export declare function getCompilerWorker(workerArg: string | Worker): ICompilerWorker;
+export declare function getCompilerWorker(worker: string | Worker): ICompilerWorker;
 export declare function getLanguageService(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
     manifestDirectory: string;
 } | null>): Promise<ILanguageService>;
-export declare function getLanguageServiceWorker(workerArg: string | Worker): ILanguageServiceWorker;
+export declare function getLanguageServiceWorker(worker: 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";

package/dist/browser.js

@@ -2,14 +2,13 @@
 // 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 * as wasm from "../lib/web/qsc_wasm.js";
+import initWasm from "../lib/web/qsc_wasm.js";
+import { Compiler, compilerProtocol, } from "./compiler/compiler.js";
+import { QSharpDebugService, debugServiceProtocol, } from "./debug-service/debug-service.js";
+import { QSharpLanguageService, languageServiceProtocol, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
 import { log } from "./log.js";
+import { createProxy } from "./workers/browser.js";
 export { qsharpLibraryUriScheme };
 // Create once. A module is stateless and can be efficiently passed to WebWorkers.
 let wasmModule = null;
@@ -79,25 +78,10 @@ export async function getProjectLoader(readFile, loadDirectory, getManifest) {
 // 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) {
+export function getDebugServiceWorker(worker) {
     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;
+    return createProxy(worker, wasmModule, debugServiceProtocol);
 }
 export async function getCompiler() {
     await instantiateWasm();
@@ -106,25 +90,10 @@ export async function getCompiler() {
 // 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) {
+export function getCompilerWorker(worker) {
     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;
+    return createProxy(worker, wasmModule, compilerProtocol);
 }
 export async function getLanguageService(readFile, listDir, getManifest) {
     await instantiateWasm();
@@ -133,25 +102,10 @@ export async function getLanguageService(readFile, listDir, getManifest) {
 // 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) {
+export function getLanguageServiceWorker(worker) {
     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;
+    return createProxy(worker, wasmModule, languageServiceProtocol);
 }
 export { QscEventTarget } from "./compiler/events.js";
 export { getAllKatas, getExerciseSources, getKata, } from "./katas.js";

package/dist/compiler/compiler.d.ts

@@ -1,6 +1,6 @@
 import { type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
-import { IServiceProxy, ServiceState } from "../worker-proxy.js";
-import { IQscEventTarget } from "./events.js";
+import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
+import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
@@ -23,4 +23,6 @@ export declare class Compiler implements ICompiler {
     checkExerciseSolution(user_code: string, exercise_sources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+/** The protocol definition to allow running the compiler in a worker. */
+export declare const compilerProtocol: ServiceProtocol<ICompiler, QscEventData>;
 export {};

package/dist/compiler/compiler.js

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { log } from "../log.js";
 import { eventStringToMsg } from "./common.js";
-import { makeEvent } from "./events.js";
+import { makeEvent, } from "./events.js";
 export class Compiler {
     constructor(wasm) {
         log.info("Constructing a Compiler instance");
@@ -70,3 +70,16 @@ export function onCompilerEvent(msg, eventTarget) {
     log.debug("worker dispatching event " + JSON.stringify(qscEvent));
     eventTarget.dispatchEvent(qscEvent);
 }
+/** The protocol definition to allow running the compiler in a worker. */
+export const compilerProtocol = {
+    class: Compiler,
+    methods: {
+        checkCode: "request",
+        getHir: "request",
+        getQir: "request",
+        getEstimates: "request",
+        run: "requestWithProgress",
+        checkExerciseSolution: "requestWithProgress",
+    },
+    eventNames: ["DumpMachine", "Message", "Result"],
+};

package/dist/compiler/events.d.ts

@@ -1,6 +1,6 @@
 import { ShotResult, Dump, Result } from "./common.js";
 import { TelemetryEvent } from "../log.js";
-import { IServiceEventTarget } from "../worker-proxy.js";
+import { IServiceEventTarget } from "../workers/common.js";
 export type QscEventData = {
     type: "Message";
     detail: string;

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

@@ -1 +1 @@
-export declare function messageHandler(e: MessageEvent): void;
+export declare const messageHandler: (e: MessageEvent<any>) => void;

package/dist/compiler/worker-browser.js

@@ -1,43 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
-import { log } from "../log.js";
-import { Compiler } from "./compiler.js";
-import { createCompilerDispatcher } from "./worker-proxy.js";
-let invokeCompiler = null;
-function telemetryHandler(telemetry) {
-    self.postMessage({
-        messageType: "event",
-        type: "telemetry-event",
-        detail: telemetry,
-    });
-}
+import { createWorker } from "../workers/browser.js";
+import { compilerProtocol } from "./compiler.js";
 // This export should be assigned to 'self.onmessage' in a WebWorker
-export function messageHandler(e) {
-    const data = e.data;
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: ${data}`);
-        return;
-    }
-    switch (data.type) {
-        case "init":
-            {
-                log.setLogLevel(data.qscLogLevel);
-                log.setTelemetryCollector(telemetryHandler);
-                wasm.initSync(data.wasmModule);
-                // Set up logging and telemetry as soon as possible after instantiating
-                wasm.initLogging(log.logWithLevel, log.getLogLevel());
-                log.onLevelChanged = (level) => wasm.setLogLevel(level);
-                const compiler = new Compiler(wasm);
-                invokeCompiler = createCompilerDispatcher(self.postMessage.bind(self), compiler);
-            }
-            break;
-        default:
-            if (!invokeCompiler) {
-                log.error(`Received message before the compiler was initialized: %o`, data);
-            }
-            else {
-                invokeCompiler(data);
-            }
-    }
-}
+export const messageHandler = createWorker(compilerProtocol);

package/dist/compiler/worker-node.js

@@ -1,41 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-// This module supports running the qsharp compiler in a Node.js worker thread. It should be
-// used in a Node.js module in a manner similar to the below to create it with the right log level:
-//
-//     const worker = new Worker(join(thisDir,"worker-node.js"), {
-//         workerData: {qscLogLevel: log.getLogLevel() }
-//     });
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import * as wasm from "../../lib/node/qsc_wasm.cjs";
-import { log } from "../log.js";
-import { Compiler } from "./compiler.js";
-import { createCompilerDispatcher } from "./worker-proxy.js";
-if (isMainThread)
-    throw "Worker script should be loaded in a Worker thread only";
-if (workerData && typeof workerData.qscLogLevel === "number") {
-    log.setLogLevel(workerData.qscLogLevel);
-}
-const port = parentPort; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-const postMessage = port.postMessage.bind(port);
-function telemetryHandler(telemetry) {
-    postMessage({
-        messageType: "event",
-        type: "telemetry-event",
-        detail: telemetry,
-    });
-}
-// Set up logging and telemetry as soon as possible after instantiating
-log.onLevelChanged = (level) => wasm.setLogLevel(level);
-log.setTelemetryCollector(telemetryHandler);
-wasm.initLogging(log.logWithLevel, log.getLogLevel());
-const compiler = new Compiler(wasm);
-const invokeCompiler = createCompilerDispatcher(postMessage, compiler);
-function messageHandler(data) {
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: %O"`, data);
-        return;
-    }
-    invokeCompiler(data);
-}
-port.addListener("message", messageHandler);
+import { createWorker } from "../workers/node.js";
+import { compilerProtocol } from "./compiler.js";
+createWorker(compilerProtocol);

package/dist/debug-service/debug-service.d.ts

@@ -1,7 +1,7 @@
-import type { IBreakpointSpan, IStackFrame, IStructStepResult, IVariable, IQuantumState } from "../../lib/node/qsc_wasm.cjs";
+import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/node/qsc_wasm.cjs";
 import { TargetProfile } from "../browser.js";
-import { IQscEventTarget } from "../compiler/events.js";
-import { IServiceProxy } from "../worker-proxy.js";
+import { IQscEventTarget, QscEventData } from "../compiler/events.js";
+import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export interface IDebugService {
     loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined): Promise<string>;
@@ -32,4 +32,6 @@ export declare class QSharpDebugService implements IDebugService {
     dispose(): Promise<void>;
 }
 export declare function onCompilerEvent(msg: string, eventTarget: IQscEventTarget): void;
+/** The protocol definition to allow running the debugger in a worker. */
+export declare const debugServiceProtocol: ServiceProtocol<IDebugService, QscEventData>;
 export {};

package/dist/debug-service/debug-service.js

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { eventStringToMsg } from "../compiler/common.js";
-import { makeEvent } from "../compiler/events.js";
+import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
 export class QSharpDebugService {
     constructor(wasm) {
@@ -75,3 +75,20 @@ export function onCompilerEvent(msg, eventTarget) {
     log.debug("worker dispatching event " + JSON.stringify(qscEvent));
     eventTarget.dispatchEvent(qscEvent);
 }
+/** The protocol definition to allow running the debugger in a worker. */
+export const debugServiceProtocol = {
+    class: QSharpDebugService,
+    methods: {
+        loadSource: "request",
+        getBreakpoints: "request",
+        getLocalVariables: "request",
+        captureQuantumState: "request",
+        getStackFrames: "request",
+        evalContinue: "requestWithProgress",
+        evalNext: "requestWithProgress",
+        evalStepIn: "requestWithProgress",
+        evalStepOut: "requestWithProgress",
+        dispose: "request",
+    },
+    eventNames: ["DumpMachine", "Message", "Result"],
+};

package/dist/debug-service/worker-browser.d.ts

@@ -1 +1 @@
-export declare function messageHandler(e: MessageEvent): void;
+export declare const messageHandler: (e: MessageEvent<any>) => void;

package/dist/debug-service/worker-browser.js

@@ -1,32 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
-import { log } from "../log.js";
-import { QSharpDebugService } from "./debug-service.js";
-import { createDebugServiceDispatcher } from "./worker-proxy.js";
-let invokeDebugger = null;
+import { createWorker } from "../workers/browser.js";
+import { debugServiceProtocol } from "./debug-service.js";
 // This export should be assigned to 'self.onmessage' in a WebWorker
-export function messageHandler(e) {
-    const data = e.data;
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: ${data}`);
-        return;
-    }
-    switch (data.type) {
-        case "init":
-            {
-                log.setLogLevel(data.qscLogLevel);
-                wasm.initSync(data.wasmModule);
-                const debugService = new QSharpDebugService(wasm);
-                invokeDebugger = createDebugServiceDispatcher(self.postMessage.bind(self), debugService);
-            }
-            break;
-        default:
-            if (!invokeDebugger) {
-                log.error(`Received message before the debugger was initialized: %o`, data);
-            }
-            else {
-                invokeDebugger(data);
-            }
-    }
-}
+export const messageHandler = createWorker(debugServiceProtocol);

package/dist/debug-service/worker-node.js

@@ -1,30 +1,5 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-// This module supports running the qsharp debugger in a Node.js worker thread. It should be
-// used in a Node.js module in a manner similar to the below to create it with the right log level:
-//
-//     const worker = new Worker(join(thisDir,"worker-node.js"), {
-//         workerData: {qscLogLevel: log.getLogLevel() }
-//     });
-import { isMainThread, parentPort, workerData } from "node:worker_threads";
-import * as wasm from "../../lib/node/qsc_wasm.cjs";
-import { log } from "../log.js";
-import { QSharpDebugService } from "./debug-service.js";
-import { createDebugServiceDispatcher } from "./worker-proxy.js";
-if (isMainThread)
-    throw "Worker script should be loaded in a Worker thread only";
-if (workerData && typeof workerData.qscLogLevel === "number") {
-    log.setLogLevel(workerData.qscLogLevel);
-}
-const port = parentPort; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-const postMessage = port.postMessage.bind(port);
-const debuggerd = new QSharpDebugService(wasm);
-const invokeDebugger = createDebugServiceDispatcher(postMessage, debuggerd);
-function messageHandler(data) {
-    if (!data.type || typeof data.type !== "string") {
-        log.error(`Unrecognized msg: %O"`, data);
-        return;
-    }
-    invokeDebugger(data);
-}
-port.addListener("message", messageHandler);
+import { createWorker } from "../workers/node.js";
+import { debugServiceProtocol } from "./debug-service.js";
+createWorker(debugServiceProtocol);