qsharp-lang 1.27.1-dev → 1.27.3-dev

package/README.md

@@ -11,28 +11,11 @@ to it when calling the `loadWasmModule` method so it may be located and loaded.
 
 ## Node and browser support
 
-wasm-bindgen 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/nodejs/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>).
+This package is platform-agnostic, using a single entry point (`main.ts`) for both browser
+and Node.js environments. The wasm module and JavaScript glue code can be found in `./lib/web/`.
+Consumers must bundle the package for their target platform so that external
+dependencies (such as the `web-worker` package) are resolved correctly for the
+runtime environment.
 
 ## Design
 

package/dist/cancellation.js

@@ -1,8 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 class InternalToken {
+    eventTarget;
+    isCancellationRequested = false;
     constructor() {
-        this.isCancellationRequested = false;
         this.eventTarget = new EventTarget();
     }
     onCancellationRequested(listener) {
@@ -16,6 +17,7 @@ class InternalToken {
     }
 }
 export class CancellationTokenSource {
+    _token;
     constructor(parent) {
         // There are some optimizations you can do here to lazily allocate, but keeping it simple for now.
         this._token = new InternalToken();

package/dist/compiler/compiler.d.ts

@@ -1,6 +1,6 @@
 import { type CircuitGroup as CircuitData } from "../data-structures/circuit.js";
 import { IDocFile, IOperationInfo, ICircuitConfig, IPackageGraphSources, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic, ProjectType } from "../../lib/web/qsc_wasm.js";
-import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
+import type { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/types.js";
 import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface ICompiler {

package/dist/compiler/compiler.js

@@ -6,6 +6,7 @@ import { eventStringToMsg } from "./common.js";
 import { makeEvent, } from "./events.js";
 import { callAndTransformExceptions } from "../diagnostics.js";
 export class Compiler {
+    wasm;
     constructor(wasm) {
         log.info("Constructing a Compiler instance");
         this.wasm = wasm;

package/dist/compiler/events.d.ts

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

package/dist/compiler/events.js

@@ -11,6 +11,10 @@ function makeResultObj() {
     return { success: false, result: "", events: [] };
 }
 export class QscEventTarget {
+    eventTarget = new EventTarget();
+    results = [];
+    shotActive = false;
+    animationFrameId = 0;
     // Overrides for the base EventTarget methods to limit to expected event types
     addEventListener(type, listener) {
         this.eventTarget.addEventListener(type, listener);
@@ -27,10 +31,6 @@ export class QscEventTarget {
      * @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;
         if (captureEvents) {
             this.addEventListener("Message", (ev) => this.onMessage(ev.detail));
             this.addEventListener("DumpMachine", (ev) => this.onDumpMachine(ev.detail));

package/dist/compiler/{worker-browser.js → worker.js}

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { createWorker } from "../workers/browser.js";
+import { createWorker } from "../workers/worker.js";
 import { compilerProtocol } from "./compiler.js";
-// This export should be assigned to 'self.onmessage' in a WebWorker
+// message handler exported for backwards compatibility
 export const messageHandler = createWorker(compilerProtocol);
+addEventListener("message", messageHandler);

package/dist/data-structures/legacyCircuitUpdate.js

@@ -80,7 +80,7 @@ function tryConvertLegacySchema(circuit) {
                 return toOperation(op);
             }
             catch (e) {
-                throw new Error(`Failed to convert operation at index ${idx}: ${e.message}`);
+                throw new Error(`Failed to convert operation at index ${idx}: ${e.message}`, { cause: e });
             }
         });
         if (!operationList.every(isOperation)) {

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

@@ -1,8 +1,8 @@
 import { type CircuitGroup as CircuitData } from "../data-structures/circuit.js";
 import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/web/qsc_wasm.js";
-import { ProgramConfig } from "../browser.js";
+import { ProgramConfig } from "../main.js";
 import { IQscEventTarget, QscEventData } from "../compiler/events.js";
-import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
+import type { IServiceProxy, ServiceProtocol } from "../workers/types.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface IDebugService {
     loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;

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

@@ -6,6 +6,8 @@ import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
 import { toWasmProgramConfig } from "../compiler/compiler.js";
 export class QSharpDebugService {
+    wasm;
+    debugService;
     constructor(wasm) {
         log.info("Constructing a QSharpDebugService instance");
         this.wasm = wasm;

package/dist/debug-service/{worker-browser.js → worker.js}

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { createWorker } from "../workers/browser.js";
+import { createWorker } from "../workers/worker.js";
 import { debugServiceProtocol } from "./debug-service.js";
-// This export should be assigned to 'self.onmessage' in a WebWorker
+// message handler exported for backwards compatibility
 export const messageHandler = createWorker(debugServiceProtocol);
+addEventListener("message", messageHandler);

package/dist/diagnostics.js

@@ -8,6 +8,7 @@ import { log } from "./log.js";
  * running code. Contains one or more VS Code-like diagnostics.
  */
 export class QdkDiagnostics extends Error {
+    diagnostics;
     constructor(diagnostics) {
         const message = shortMessage(diagnostics);
         super(message);

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

@@ -1,6 +1,6 @@
 import type { ICodeAction, ICodeLens, ICompletionList, IHover, ILocation, INotebookMetadata, IPosition, IRange, ISignatureHelp, ITextEdit, IWorkspaceConfiguration, IWorkspaceEdit, VSDiagnostic, ITestDescriptor } from "../../lib/web/qsc_wasm.js";
-import { IProjectHost } from "../browser.js";
-import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
+import { IProjectHost } from "../main.js";
+import type { IServiceProxy, ServiceProtocol } from "../workers/types.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export type LanguageServiceDiagnosticEvent = {
     type: "diagnostics";

package/dist/language-service/language-service.js

@@ -4,6 +4,10 @@ import { log } from "../log.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
 export const qsharpGithubUriScheme = "qsharp-github-source";
 export class QSharpLanguageService {
+    wasm;
+    languageService;
+    eventHandler = new EventTarget();
+    backgroundWork;
     constructor(wasm, host = {
         readFile: async () => null,
         listDirectory: async () => [],
@@ -12,7 +16,6 @@ export class QSharpLanguageService {
         findManifestDirectory: async () => null,
     }) {
         this.wasm = wasm;
-        this.eventHandler = new EventTarget();
         log.info("Constructing a QSharpLanguageService instance");
         this.languageService = new wasm.LanguageService();
         this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), this.onTestCallables.bind(this), host);

package/dist/language-service/{worker-browser.js → worker.js}

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { createWorker } from "../workers/browser.js";
+import { createWorker } from "../workers/worker.js";
 import { languageServiceProtocol } from "./language-service.js";
-// This export should be assigned to 'self.onmessage' in a WebWorker
+// message handler exported for backwards compatibility
 export const messageHandler = createWorker(languageServiceProtocol);
+addEventListener("message", messageHandler);

package/dist/main.d.ts

@@ -1,16 +1,38 @@
+import * as wasm from "../lib/web/qsc_wasm.js";
+import { IProjectHost, ProjectType, TargetProfile } from "../lib/web/qsc_wasm.js";
 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 { ILanguageService, ILanguageServiceWorker } from "./language-service/language-service.js";
 import { ProjectLoader } from "./project.js";
-import type { IProjectHost } from "./browser.js";
-export { qsharpLibraryUriScheme };
+export declare function setWorkerType(type: "classic" | "module"): void;
+export declare function getWasmModule(): WebAssembly.Module;
+export declare function loadWasmModule(uriOrBuffer: string | ArrayBuffer): Promise<void>;
+export declare function instantiateWasm(): Promise<void>;
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
-export declare function getCompiler(): ICompiler;
-export declare function getProjectLoader(host: IProjectHost): ProjectLoader;
-export declare function getCompilerWorker(): ICompilerWorker;
-export declare function getDebugService(): IDebugService;
-export declare function getDebugServiceWorker(): IDebugServiceWorker;
-export declare function getLanguageService(host?: IProjectHost): ILanguageService;
-export declare function getLanguageServiceWorker(): ILanguageServiceWorker;
+export declare function getDebugService(): Promise<IDebugService>;
+export declare function getProjectLoader(host: IProjectHost): Promise<ProjectLoader>;
+export declare function getDebugServiceWorker(worker: string | Worker): IDebugServiceWorker;
+export declare function getCompiler(): Promise<ICompiler>;
+export declare function getCompilerWorker(worker: string | Worker): ICompilerWorker;
+export declare function getLanguageService(host?: IProjectHost): Promise<ILanguageService>;
+export declare function getLanguageServiceWorker(worker: string | Worker): ILanguageServiceWorker;
+export declare function getTargetProfileFromEntryPoint(fileName: string, source: string): Promise<wasm.TargetProfile | undefined>;
+export { StepResultId } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, ITestDescriptor, IWorkspaceEdit, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { ProjectType, TargetProfile };
+export type { IVariable, IVariableChild } from "../lib/web/qsc_wasm.js";
 export * as utils from "./utils.js";
-export type { IVariable, IVariableChild } from "./browser.js";
+export { log } from "./log.js";
+export { QscEventTarget } from "./compiler/events.js";
+export { QdkDiagnostics } from "./diagnostics.js";
+export { default as samples } from "./samples.generated.js";
+export { default as openqasm_samples } from "./openqasm-samples.generated.js";
+export { qsharpGithubUriScheme, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
+export type { Dump, ShotResult } from "./compiler/common.js";
+export type { CompilerState, ProgramConfig } from "./compiler/compiler.js";
+export type { ICompiler, ICompilerWorker } from "./compiler/compiler.js";
+export type { IDebugService, IDebugServiceWorker, } from "./debug-service/debug-service.js";
+export type { ILanguageService, ILanguageServiceWorker, LanguageServiceDiagnosticEvent, LanguageServiceEvent, LanguageServiceTestCallablesEvent, } from "./language-service/language-service.js";
+export type { ProjectLoader } from "./project.js";
+export type { CircuitGroup as CircuitData } from "./data-structures/circuit.js";
+export type { LogLevel } from "./log.js";

package/dist/main.js

@@ -1,52 +1,136 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-// This module is the main entry point for use in Node.js environments. For browser environments,
-// the "./browser.js" file is the entry point module.
-import { createRequire } from "node:module";
+// Main entrypoint. Browsers use this directly; Node.js uses it through the node.ts wrapper.
+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 { callAndTransformExceptions } from "./diagnostics.js";
+import { QSharpLanguageService, languageServiceProtocol, } from "./language-service/language-service.js";
 import { log } from "./log.js";
-import { createProxy } from "./workers/node.js";
 import { ProjectLoader } from "./project.js";
-export { qsharpLibraryUriScheme };
-let wasm = null;
-function ensureWasm() {
-    if (!wasm) {
-        wasm = require("../lib/nodejs/qsc_wasm.cjs");
-        // Set up logging and telemetry as soon as possible after instantiating
-        wasm.initLogging(log.logWithLevel, log.getLogLevel());
-        log.onLevelChanged = (level) => wasm?.setLogLevel(level);
+import { createProxy } from "./workers/main.js";
+let workerType = "classic";
+export function setWorkerType(type) {
+    workerType = type;
+}
+// Create once. A module is stateless and can be efficiently passed to WebWorkers.
+let wasmModule = null;
+let wasmModulePromise = null;
+// Getter for wasmModule that works across CJS/ESM boundaries.
+// Direct `export let` live bindings don't survive CJS bundling.
+export function getWasmModule() {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    return wasmModule;
+}
+// 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 wasmRequest = await fetch(uriOrBuffer);
+        const wasmBuffer = await wasmRequest.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;
+}
+export 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({ module_or_path: 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);
 }
-const require = createRequire(import.meta.url);
 export async function getLibrarySourceContent(path) {
-    ensureWasm();
+    await instantiateWasm();
     return wasm.get_library_source_content(path);
 }
-export function getCompiler() {
-    ensureWasm();
-    return new Compiler(wasm);
+export async function getDebugService() {
+    await instantiateWasm();
+    return new QSharpDebugService(wasm);
 }
-export function getProjectLoader(host) {
-    ensureWasm();
+export async function getProjectLoader(host) {
+    await instantiateWasm();
     return new ProjectLoader(wasm, host);
 }
-export function getCompilerWorker() {
-    return createProxy("../compiler/worker-node.js", compilerProtocol);
+// 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(worker) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    return createProxy(worker, wasmModule, debugServiceProtocol, workerType);
 }
-export function getDebugService() {
-    ensureWasm();
-    return new QSharpDebugService(wasm);
+export async function getCompiler() {
+    await instantiateWasm();
+    return new Compiler(wasm);
 }
-export function getDebugServiceWorker() {
-    return createProxy("../debug-service/worker-node.js", debugServiceProtocol);
+// 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(worker) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    return createProxy(worker, wasmModule, compilerProtocol, workerType);
 }
-export function getLanguageService(host) {
-    ensureWasm();
+export async function getLanguageService(host) {
+    await instantiateWasm();
     return new QSharpLanguageService(wasm, host);
 }
-export function getLanguageServiceWorker() {
-    return createProxy("../language-service/worker-node.js", languageServiceProtocol);
+// 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(worker) {
+    if (!wasmModule)
+        throw "Wasm module must be loaded first";
+    return createProxy(worker, wasmModule, languageServiceProtocol, workerType);
+}
+/// Extracts the target profile from a Q# source file's entry point.
+/// Scans the provided source code for an EntryPoint argument specifying
+/// a profile and returns the corresponding TargetProfile value, if found.
+/// Returns undefined if no profile is specified or if the profile is not recognized.
+export async function getTargetProfileFromEntryPoint(fileName, source) {
+    await instantiateWasm();
+    return callAndTransformExceptions(async () => wasm.get_target_profile_from_entry_point(fileName, source));
 }
+export { StepResultId } from "../lib/web/qsc_wasm.js";
 export * as utils from "./utils.js";
+export { log } from "./log.js";
+export { QscEventTarget } from "./compiler/events.js";
+export { QdkDiagnostics } from "./diagnostics.js";
+export { default as samples } from "./samples.generated.js";
+export { default as openqasm_samples } from "./openqasm-samples.generated.js";
+export { qsharpGithubUriScheme, qsharpLibraryUriScheme, } from "./language-service/language-service.js";

package/dist/node.d.ts

@@ -0,0 +1 @@
+export * from "./main.js";

package/dist/node.js

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+// Node.js entrypoint. Polyfills the Worker global before loading the main module.
+import worker from "web-worker";
+import { setWorkerType } from "./main.js";
+if (typeof globalThis.Worker === "undefined") {
+    globalThis.Worker = worker;
+}
+setWorkerType("module");
+export * from "./main.js";

package/dist/project.js

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 import { callAndTransformExceptions } from "./diagnostics.js";
 export class ProjectLoader {
+    nativeLoader;
     constructor(wasm, host) {
         this.nativeLoader = new wasm.ProjectLoader(host);
     }

package/dist/utils.js

@@ -77,7 +77,7 @@ export function CreateTimeTicks(min, max) {
                     predefinedTimeTicks[l].tick.value));
             do {
                 let i = 1;
-                let val = 0;
+                let val;
                 do {
                     val = predefinedTimeTicks[l].tick.value * i * coeff;
                     if (val >= min && val <= max) {
@@ -101,7 +101,7 @@ export function CreateTimeTicks(min, max) {
                 let coeff = 10 ** Math.floor(Math.log10(max / predefinedTimeTicks[l].tick.value));
                 do {
                     let i = 1;
-                    let val = 0;
+                    let val;
                     do {
                         val = predefinedTimeTicks[l].tick.value * i * coeff;
                         if (val >= min && val <= max) {

package/dist/workers/{browser.d.ts → main.d.ts}

@@ -1,12 +1,4 @@
-import { IServiceEventMessage, IServiceProxy, ServiceMethods, ServiceProtocol } from "./common.js";
-/**
- * Creates an initializes a service, setting it up to receive requests.
- * This function to be is used in the worker.
- *
- * @param serviceProtocol An object that describes the service: its constructor, methods and events
- * @returns A message handler to be assigned to the `self.onmessage` handler in a web worker
- */
-export declare function createWorker<TService extends ServiceMethods<TService>, TServiceEventMsg extends IServiceEventMessage>(serviceProtocol: ServiceProtocol<TService, TServiceEventMsg>): (e: MessageEvent) => void;
+import type { IServiceEventMessage, IServiceProxy, ServiceMethods, ServiceProtocol } from "./types.js";
 /**
  * Creates and initializes a service in a web worker, and returns a proxy for the service
  * to be used from the main thread.
@@ -14,8 +6,9 @@ export declare function createWorker<TService extends ServiceMethods<TService>,
  * @param workerArg The service web worker or the URL of the web worker script.
  * @param wasmModule The wasm module to initialize the service with
  * @param serviceProtocol An object that describes the service: its constructor, methods and events
+ * @param workerType The type of worker to create: "classic" for browsers, "module" for Node.js
  * @returns A proxy object that implements the service interface.
  *   This interface can now be used as if calling into the real service,
  *   and the calls will be proxied to the web worker.
  */
-export declare function createProxy<TService extends ServiceMethods<TService>, TServiceEventMsg extends IServiceEventMessage>(workerArg: string | Worker, wasmModule: WebAssembly.Module, serviceProtocol: ServiceProtocol<TService, TServiceEventMsg>): TService & IServiceProxy;
+export declare function createProxy<TService extends ServiceMethods<TService>, TServiceEventMsg extends IServiceEventMessage>(workerArg: string | Worker, wasmModule: WebAssembly.Module, serviceProtocol: ServiceProtocol<TService, TServiceEventMsg>, workerType: "classic" | "module"): TService & IServiceProxy;