qsharp-lang 1.17.1-dev → 1.17.2-dev

package/dist/browser.d.ts

@@ -1,28 +1,30 @@
-import * as wasm from "../lib/web/qsc_wasm.js";
-import { IProjectHost, TargetProfile, ProjectType } 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, qsharpGithubUriScheme, qsharpLibraryUriScheme } from "./language-service/language-service.js";
 import { LogLevel, log } from "./log.js";
+import { ProjectLoader } from "./project.js";
 export { qsharpGithubUriScheme, 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 getProjectLoader(host: IProjectHost): Promise<wasm.ProjectLoader>;
+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 { StepResultId } from "../lib/web/qsc_wasm.js";
-export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, ITestDescriptor, VSDiagnostic, } 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 Dump, type ShotResult } from "./compiler/common.js";
 export { type CompilerState, type ProgramConfig } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";
+export { QdkDiagnostics } from "./diagnostics.js";
 export type { LanguageServiceDiagnosticEvent, LanguageServiceEvent, LanguageServiceTestCallablesEvent, } from "./language-service/language-service.js";
-export { default as samples } from "./samples.generated.js";
 export { default as openqasm_samples } from "./openqasm-samples.generated.js";
-export { log, type LogLevel, type TargetProfile, type ProjectType };
-export type { ICompiler, ICompilerWorker, IDebugService, IDebugServiceWorker, ILanguageService, ILanguageServiceWorker, };
+export type { ProjectLoader } from "./project.js";
+export { default as samples } from "./samples.generated.js";
+export type { CircuitGroup as CircuitData } from "./data-structures/circuit.js";
 export * as utils from "./utils.js";
-export type { CircuitGroup as CircuitData } from "./shared/circuit.js";
+export { log, type LogLevel, type ProjectType, type TargetProfile };
+export type { ICompiler, ICompilerWorker, IDebugService, IDebugServiceWorker, ILanguageService, ILanguageServiceWorker, };

package/dist/browser.js

@@ -8,6 +8,7 @@ import { Compiler, compilerProtocol, } from "./compiler/compiler.js";
 import { QSharpDebugService, debugServiceProtocol, } from "./debug-service/debug-service.js";
 import { QSharpLanguageService, languageServiceProtocol, qsharpGithubUriScheme, qsharpLibraryUriScheme, } from "./language-service/language-service.js";
 import { log } from "./log.js";
+import { ProjectLoader } from "./project.js";
 import { createProxy } from "./workers/browser.js";
 export { qsharpGithubUriScheme, qsharpLibraryUriScheme };
 // Create once. A module is stateless and can be efficiently passed to WebWorkers.
@@ -73,7 +74,7 @@ export async function getDebugService() {
 }
 export async function getProjectLoader(host) {
     await instantiateWasm();
-    return new wasm.ProjectLoader(host);
+    return new ProjectLoader(wasm, host);
 }
 // Create the debugger inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
@@ -109,7 +110,8 @@ export function getLanguageServiceWorker(worker) {
 }
 export { StepResultId } from "../lib/web/qsc_wasm.js";
 export { QscEventTarget } from "./compiler/events.js";
-export { default as samples } from "./samples.generated.js";
+export { QdkDiagnostics } from "./diagnostics.js";
 export { default as openqasm_samples } from "./openqasm-samples.generated.js";
-export { log };
+export { default as samples } from "./samples.generated.js";
 export * as utils from "./utils.js";
+export { log };

package/dist/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { type CircuitGroup as CircuitData } from "../shared/circuit.js";
+import { type CircuitGroup as CircuitData } from "../data-structures/circuit.js";
 import { IDocFile, IOperationInfo, IPackageGraphSources, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic, ProjectType } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
 import { IQscEventTarget, QscEventData } from "./events.js";

package/dist/compiler/compiler.js

@@ -1,9 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { CURRENT_VERSION, } from "../shared/circuit.js";
+import { CURRENT_VERSION, } from "../data-structures/circuit.js";
 import { log } from "../log.js";
 import { eventStringToMsg } from "./common.js";
 import { makeEvent, } from "./events.js";
+import { callAndTransformExceptions } from "../diagnostics.js";
 export class Compiler {
     constructor(wasm) {
         log.info("Constructing a Compiler instance");
@@ -42,25 +43,25 @@ export class Compiler {
     }
     async getRir(program) {
         const config = toWasmProgramConfig(program, program.profile || "adaptive_ri");
-        return this.wasm.get_rir(config);
+        return callAndTransformExceptions(async () => this.wasm.get_rir(config));
     }
     async run(program, 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(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+        await callAndTransformExceptions(async () => this.wasm.run(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots));
     }
     async runWithPauliNoise(program, expr, shots, pauliNoise, eventHandler) {
-        this.wasm.runWithPauliNoise(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots, pauliNoise);
+        await callAndTransformExceptions(async () => this.wasm.runWithPauliNoise(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots, pauliNoise));
     }
     async getQir(program) {
-        return this.wasm.get_qir(toWasmProgramConfig(program, "base"));
+        return callAndTransformExceptions(async () => this.wasm.get_qir(toWasmProgramConfig(program, "base")));
     }
     async getEstimates(program, expr, params) {
-        return this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), expr, params);
+        return callAndTransformExceptions(async () => this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), expr, params));
     }
     async getCircuit(program, simulate, operation) {
-        const circuit = this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
+        const circuit = await callAndTransformExceptions(async () => this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation));
         return {
             circuits: [circuit],
             version: CURRENT_VERSION,

package/dist/{shared → data-structures}/circuit.d.ts

@@ -7,6 +7,10 @@ export interface CircuitGroup {
     circuits: Circuit[];
     version: number;
 }
+/**
+ * Runtime check: is this a valid CircuitGroup?
+ */
+export declare function isCircuitGroup(obj: any): obj is CircuitGroup;
 /**
  * Circuit to be visualized.
  */
@@ -15,10 +19,18 @@ export interface Circuit {
     qubits: Qubit[];
     componentGrid: ComponentGrid;
 }
+/**
+ * Runtime check: is this a valid Circuit?
+ */
+export declare function isCircuit(obj: any): obj is Circuit;
 export type ComponentGrid = Column[];
 export interface Column {
     components: Component[];
 }
+/**
+ * Runtime check: is this a valid Column?
+ */
+export declare function isColumn(obj: any): obj is Column;
 /**
  * Represents a component of a circuit. Currently, the only component is an operation.
  * In the future, this may be extended to include other components.
@@ -33,6 +45,10 @@ export interface Qubit {
     /** Number of measurement results associated to the qubit. */
     numResults?: number;
 }
+/**
+ * Runtime check: is this a valid Qubit?
+ */
+export declare function isQubit(obj: any): obj is Qubit;
 /**
  * Base type for operations.
  */
@@ -90,6 +106,10 @@ export interface Ket extends BaseOperation {
  * Union type for operations.
  */
 export type Operation = Unitary | Measurement | Ket;
+/**
+ * Runtime check: is this a valid Operation?
+ */
+export declare function isOperation(obj: any): obj is Operation;
 /**
  * A parameter for an operation.
  */
@@ -99,6 +119,10 @@ export interface Parameter {
     /** Parameter's Q# type. */
     type: string;
 }
+/**
+ * Runtime check: is this a valid Parameter?
+ */
+export declare function isParameter(obj: any): obj is Parameter;
 /**
  * Conditions on when to render the given operation.
  */

package/dist/data-structures/circuit.js

@@ -0,0 +1,130 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { isRegister } from "./register.js";
+/**
+ * Current format version.
+ */
+export const CURRENT_VERSION = 1;
+/**
+ * Runtime check: is this a valid CircuitGroup?
+ */
+export function isCircuitGroup(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        typeof obj.version === "number" &&
+        Array.isArray(obj.circuits) &&
+        obj.circuits.length > 0 &&
+        obj.circuits.every(isCircuit));
+}
+/**
+ * Runtime check: is this a valid Circuit?
+ */
+export function isCircuit(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        Array.isArray(obj.qubits) &&
+        obj.qubits.every(isQubit) &&
+        Array.isArray(obj.componentGrid) &&
+        obj.componentGrid.every(isColumn));
+}
+/**
+ * Runtime check: is this a valid Column?
+ */
+export function isColumn(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        Array.isArray(obj.components) &&
+        obj.components.every(isOperation));
+}
+/**
+ * Runtime check: is this a valid Qubit?
+ */
+export function isQubit(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        typeof obj.id === "number" &&
+        // numResults is optional, but if present must be a number
+        (obj.numResults === undefined || typeof obj.numResults === "number"));
+}
+/**
+ * Runtime check: is this a valid BaseOperation?
+ */
+function isBaseOperation(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        typeof obj.gate === "string" &&
+        // args is optional, but if present must be an array of strings
+        (obj.args === undefined ||
+            (Array.isArray(obj.args) &&
+                obj.args.every((arg) => typeof arg === "string"))) &&
+        // params is optional, but if present must be an array of Parameter
+        (obj.params === undefined ||
+            (Array.isArray(obj.params) && obj.params.every(isParameter))) &&
+        // children is optional, but if present must be a ComponentGrid
+        (obj.children === undefined ||
+            (Array.isArray(obj.children) && obj.children.every(isColumn))) &&
+        // dataAttributes is optional, but if present must be an object with string values
+        (obj.dataAttributes === undefined ||
+            (typeof obj.dataAttributes === "object" &&
+                obj.dataAttributes !== null &&
+                Object.values(obj.dataAttributes).every((val) => typeof val === "string"))) &&
+        // isConditional is optional, but if present must be boolean
+        (obj.isConditional === undefined ||
+            typeof obj.isConditional === "boolean") &&
+        // conditionalRender is optional, but if present must be a valid enum value
+        (obj.conditionalRender === undefined ||
+            Object.values(ConditionalRender).includes(obj.conditionalRender)));
+}
+/**
+ * Runtime check: is this a valid Operation?
+ */
+export function isOperation(obj) {
+    if (!isBaseOperation(obj))
+        return false;
+    // Re-cast to any so we can check discriminated fields without narrowing
+    const op = obj;
+    if (op.kind === undefined || typeof op.kind !== "string")
+        return false;
+    switch (op.kind) {
+        case "unitary":
+            return (Array.isArray(op.targets) &&
+                op.targets.every(isRegister) &&
+                // controls is optional
+                (op.controls === undefined ||
+                    (Array.isArray(op.controls) && op.controls.every(isRegister))) &&
+                // isAdjoint is optional
+                (op.isAdjoint === undefined || typeof op.isAdjoint === "boolean"));
+        case "measurement":
+            return (Array.isArray(op.qubits) &&
+                op.qubits.every(isRegister) &&
+                Array.isArray(op.results) &&
+                op.results.every(isRegister));
+        case "ket":
+            return Array.isArray(op.targets) && op.targets.every(isRegister);
+        default:
+            return false;
+    }
+}
+/**
+ * Runtime check: is this a valid Parameter?
+ */
+export function isParameter(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        typeof obj.name === "string" &&
+        typeof obj.type === "string");
+}
+/**
+ * Conditions on when to render the given operation.
+ */
+export var ConditionalRender;
+(function (ConditionalRender) {
+    /** Always rendered. */
+    ConditionalRender[ConditionalRender["Always"] = 0] = "Always";
+    /** Render classically-controlled operation when measurement is a zero. */
+    ConditionalRender[ConditionalRender["OnZero"] = 1] = "OnZero";
+    /** Render classically-controlled operation when measurement is a one. */
+    ConditionalRender[ConditionalRender["OnOne"] = 2] = "OnOne";
+    /** Render operation as a group of its nested operations. */
+    ConditionalRender[ConditionalRender["AsGroup"] = 3] = "AsGroup";
+})(ConditionalRender || (ConditionalRender = {}));

package/dist/data-structures/legacyCircuitUpdate.d.ts

@@ -0,0 +1,16 @@
+import { CircuitGroup } from "./circuit.js";
+export type ToCircuitGroupResult = {
+    ok: true;
+    circuitGroup: CircuitGroup;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Ensures that the given circuit object is a CircuitGroup, doing any
+ * necessary conversions from Circuit or legacy formats.
+ *
+ * @param circuit The circuit to convert.
+ * @returns The result of the conversion.
+ */
+export declare function toCircuitGroup(circuit: any): ToCircuitGroupResult;

package/dist/{shared → data-structures}/legacyCircuitUpdate.js

@@ -1,13 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
-import { getMinMaxRegIdx } from "../utils.js";
-import { CURRENT_VERSION, } from "./circuit.js";
+import { CURRENT_VERSION, isCircuit, isCircuitGroup, isOperation, } from "./circuit.js";
 /**
  * Ensures that the given circuit object is a CircuitGroup, doing any
  * necessary conversions from Circuit or legacy formats.
  *
  * @param circuit The circuit to convert.
- * @returns The converted CircuitGroup.
+ * @returns The result of the conversion.
  */
 export function toCircuitGroup(circuit) {
     const emptyCircuit = {
@@ -19,60 +18,96 @@ export function toCircuitGroup(circuit) {
         circuits: [emptyCircuit],
     };
     if (circuit && Object.keys(circuit).length === 0) {
-        return emptyCircuitGroup;
+        return { ok: true, circuitGroup: emptyCircuitGroup };
     }
     if (circuit?.version) {
         const version = circuit.version;
-        // If it has a "version" field, it is up-to-date
         if (isCircuitGroup(circuit)) {
-            // If it's already a CircuitGroup, return it as is
-            return circuit;
+            return { ok: true, circuitGroup: circuit };
         }
         else if (isCircuit(circuit)) {
-            // If it's a Circuit, wrap it in a CircuitGroup
-            return {
-                version,
-                circuits: [circuit],
-            };
+            return { ok: true, circuitGroup: { version, circuits: [circuit] } };
         }
         else {
-            console.error("Unknown schema: circuit is neither a CircuitGroup nor a Circuit.");
-            return emptyCircuitGroup;
+            return {
+                ok: false,
+                error: "Unknown schema: file is neither a CircuitGroup nor a Circuit.",
+            };
         }
     }
     else if (isCircuit(circuit)) {
-        // If it's a Circuit without a version, wrap it in a CircuitGroup
         return {
-            version: CURRENT_VERSION,
-            circuits: [circuit],
+            ok: true,
+            circuitGroup: { version: CURRENT_VERSION, circuits: [circuit] },
         };
     }
-    else if (circuit?.operations) {
-        // Legacy schema: convert to CircuitGroup
-        if (circuit.qubits === undefined || !Array.isArray(circuit.qubits)) {
-            console.error("Unknown schema: circuit is missing qubit information.");
-            return emptyCircuitGroup;
-        }
-        const qubits = circuit.qubits.map((qubit) => {
+    else if (circuit?.operations &&
+        Array.isArray(circuit.operations) &&
+        circuit?.qubits &&
+        Array.isArray(circuit.qubits)) {
+        // If it has "operations" and "qubits", it is a legacy schema
+        return tryConvertLegacySchema(circuit);
+    }
+    else {
+        return {
+            ok: false,
+            error: "Unknown schema: file does not match any known format.",
+        };
+    }
+}
+/**
+ * Attempts to convert a legacy circuit schema to a CircuitGroup.
+ *
+ * @param circuit The legacy circuit object to convert.
+ * @returns A ToCircuitGroupResult containing the converted CircuitGroup on success,
+ *          or an error message on failure.
+ */
+function tryConvertLegacySchema(circuit) {
+    try {
+        const qubits = circuit.qubits.map((qubit, idx) => {
+            if (typeof qubit !== "object" ||
+                qubit === null ||
+                typeof qubit.id !== "number") {
+                throw new Error(`Invalid qubit at index ${idx}.`);
+            }
             return {
                 id: qubit.id,
-                numResults: qubit.numChildren || 0, // Rename "numChildren" to "numResults"
+                numResults: qubit.numChildren || 0,
             };
         });
-        const componentGrid = operationListToGrid(circuit.operations.map(toOperation), qubits.length);
+        const operationList = circuit.operations.map((op, idx) => {
+            try {
+                return toOperation(op);
+            }
+            catch (e) {
+                throw new Error(`Failed to convert operation at index ${idx}: ${e.message}`);
+            }
+        });
+        if (!operationList.every(isOperation)) {
+            return {
+                ok: false,
+                error: "Unknown schema: file contains invalid operations.",
+            };
+        }
+        const componentGrid = operationListToGrid(operationList, qubits.length);
         return {
-            version: CURRENT_VERSION,
-            circuits: [
-                {
-                    qubits,
-                    componentGrid,
-                },
-            ],
+            ok: true,
+            circuitGroup: {
+                version: CURRENT_VERSION,
+                circuits: [
+                    {
+                        qubits,
+                        componentGrid,
+                    },
+                ],
+            },
         };
     }
-    else {
-        console.error("Unknown schema: circuit does not match any known format.");
-        return emptyCircuitGroup;
+    catch (e) {
+        return {
+            ok: false,
+            error: `Legacy schema: ${e instanceof Error ? e.message : String(e)}`,
+        };
     }
 }
 /**
@@ -109,7 +144,7 @@ function toOperation(op) {
         };
     }
     else {
-        const ket = getKetLabel(op.gate);
+        const ket = op.gate === undefined ? "" : getKetLabel(op.gate);
         if (ket.length > 0) {
             return {
                 ...op,
@@ -141,26 +176,6 @@ function toOperation(op) {
         }
     }
 }
-/**
- * Checks if the given object is a CircuitGroup.
- *
- * @param circuit The object to check.
- * @returns True if the object is a CircuitGroup, false otherwise.
- */
-function isCircuitGroup(circuit) {
-    return circuit && Array.isArray(circuit.circuits);
-}
-/**
- * Checks if the given object is a Circuit.
- *
- * @param circuit The object to check.
- * @returns True if the object is a Circuit, false otherwise.
- */
-function isCircuit(circuit) {
-    return (circuit &&
-        Array.isArray(circuit.qubits) &&
-        Array.isArray(circuit.componentGrid));
-}
 /**
  * Get the label from a ket string.
  *
@@ -267,10 +282,12 @@ function groupOperations(operations, numQubits) {
     const groupedOps = Array.from(Array(numQubits), () => new Array(0));
     operations.forEach((operation, instrIdx) => {
         const [minRegIdx, maxRegIdx] = getMinMaxRegIdx(operation, numQubits);
-        // Add operation also to registers that are in-between target registers
-        // so that other gates won't render in the middle.
-        for (let i = minRegIdx; i <= maxRegIdx; i++) {
-            groupedOps[i].push(instrIdx);
+        if (minRegIdx > -1 && maxRegIdx > -1) {
+            // Add operation also to registers that are in-between target registers
+            // so that other gates won't render in the middle.
+            for (let i = minRegIdx; i <= maxRegIdx; i++) {
+                groupedOps[i].push(instrIdx);
+            }
         }
     });
     return groupedOps;
@@ -311,3 +328,42 @@ function alignOps(ops) {
     }
     return paddedOps;
 }
+/**
+ * Get the minimum and maximum register indices for a given operation.
+ *
+ * @param operation The operation for which to get the register indices.
+ * @param numQubits The number of qubits in the circuit.
+ * @returns A tuple containing the minimum and maximum register indices.
+ */
+function getMinMaxRegIdx(operation, numQubits) {
+    let targets;
+    let controls;
+    switch (operation.kind) {
+        case "measurement":
+            targets = operation.results;
+            controls = operation.qubits;
+            break;
+        case "unitary":
+            targets = operation.targets;
+            controls = operation.controls || [];
+            break;
+        case "ket":
+            targets = operation.targets;
+            controls = [];
+            break;
+    }
+    const qRegs = [...controls, ...targets]
+        .filter(({ result }) => result === undefined)
+        .map(({ qubit }) => qubit);
+    const clsControls = controls.filter(({ result }) => result !== undefined);
+    const isClassicallyControlled = clsControls.length > 0;
+    if (!isClassicallyControlled && qRegs.length === 0)
+        return [-1, -1];
+    // If operation is classically-controlled, pad all qubit registers. Otherwise, only pad
+    // the contiguous range of registers that it covers.
+    const minRegIdx = isClassicallyControlled ? 0 : Math.min(...qRegs);
+    const maxRegIdx = isClassicallyControlled
+        ? numQubits - 1
+        : Math.max(...qRegs);
+    return [minRegIdx, maxRegIdx];
+}

package/dist/{shared → data-structures}/register.d.ts

@@ -14,6 +14,10 @@ export interface Register {
     /** Classical register ID. If present, register is classical register. */
     result?: number;
 }
+/**
+ * Runtime check: is this a valid Register?
+ */
+export declare function isRegister(obj: any): obj is Register;
 /**
  * Rendering data for qubit register.
  */

package/dist/data-structures/register.js

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+/**
+ * Type of register.
+ */
+export var RegisterType;
+(function (RegisterType) {
+    RegisterType[RegisterType["Qubit"] = 0] = "Qubit";
+    RegisterType[RegisterType["Classical"] = 1] = "Classical";
+})(RegisterType || (RegisterType = {}));
+/**
+ * Runtime check: is this a valid Register?
+ */
+export function isRegister(obj) {
+    return (obj &&
+        typeof obj === "object" &&
+        typeof obj.qubit === "number" &&
+        // result is optional, but if present must be a number
+        (obj.result === undefined || typeof obj.result === "number"));
+}

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

@@ -1,4 +1,4 @@
-import { type CircuitGroup as CircuitData } from "../shared/circuit.js";
+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 { IQscEventTarget, QscEventData } from "../compiler/events.js";

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

@@ -1,6 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import { CURRENT_VERSION, } from "../shared/circuit.js";
+import { CURRENT_VERSION, } from "../data-structures/circuit.js";
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";

package/dist/diagnostics.d.ts

@@ -0,0 +1,21 @@
+import type { IQSharpError } from "../lib/web/qsc_wasm.js";
+/**
+ * Public error type for most `qsharp-lang` functions.
+ *
+ * This is typically thrown by functions that deal with compiling and
+ * running code. Contains one or more VS Code-like diagnostics.
+ */
+export declare class QdkDiagnostics extends Error {
+    readonly diagnostics: IQSharpError[];
+    constructor(diagnostics: IQSharpError[]);
+}
+/**
+ * Wrapper around QDK WASM functions to convert exceptions to a more ergonomic type.
+ *
+ * Many of the WASM functions throw exceptions that are of type `string`,
+ * which are really just JSON-serialized `IQSharpError[]`s.
+ *
+ * This function converts those exceptions into `QdkDiagnostics` instances
+ * that properly inherit from `Error`.
+ */
+export declare function callAndTransformExceptions<T>(fn: () => Promise<T>): Promise<T>;