qsharp-lang 1.6.1-dev → 1.6.2-dev

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import * as wasm from "../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../lib/web/qsc_wasm.js";
+import { IProjectHost, 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";
@@ -8,18 +8,14 @@ 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 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 getProjectLoader(host: IProjectHost): Promise<wasm.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(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
-    manifestDirectory: string;
-} | null>): Promise<ILanguageService>;
+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, IQSharpError, IRange, IStackFrame, IWorkspaceEdit, IStructStepResult, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, ICodeAction, ICodeLens, IDocFile, ILocation, IOperationInfo, IPosition, IProjectConfig, IProjectHost, IQSharpError, IRange, IStackFrame, IStructStepResult, IWorkspaceEdit, ProjectLoader, 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";

package/dist/browser.js

@@ -71,9 +71,9 @@ export async function getDebugService() {
     await instantiateWasm();
     return new QSharpDebugService(wasm);
 }
-export async function getProjectLoader(readFile, loadDirectory, getManifest) {
+export async function getProjectLoader(host) {
     await instantiateWasm();
-    return new wasm.ProjectLoader(readFile, loadDirectory, getManifest);
+    return new wasm.ProjectLoader(host);
 }
 // Create the debugger inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive
@@ -95,9 +95,9 @@ export function getCompilerWorker(worker) {
         throw "Wasm module must be loaded first";
     return createProxy(worker, wasmModule, compilerProtocol);
 }
-export async function getLanguageService(readFile, listDir, getManifest) {
+export async function getLanguageService(host) {
     await instantiateWasm();
-    return new QSharpLanguageService(wasm, readFile, listDir, getManifest);
+    return new QSharpLanguageService(wasm, host);
 }
 // Create the compiler inside a WebWorker and proxy requests.
 // If the Worker was already created via other means and is ready to receive

package/dist/compiler/compiler.d.ts

@@ -1,5 +1,5 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
-import { IDocFile, IOperationInfo, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
+import { IDocFile, IOperationInfo, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
 import { IQscEventTarget, QscEventData } from "./events.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
@@ -7,35 +7,17 @@ export interface ICompiler {
     checkCode(code: string): Promise<VSDiagnostic[]>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    run(sources: [string, string][], expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    run(config: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    getQir(sources: [string, string][], languageFeatures?: string[]): Promise<string>;
-    getQir(config: ProgramConfig): Promise<string>;
-    /** @deprecated -- switch to using `ProgramConfig`-based overload. Instead of passing
-     * sources and language features separately, pass an object with named properties. This change was made
-     * for the sake of extensibility and future-compatibility. Note that only the new API
-     * supports passing language features. If you need to pass language features, you must use
-     * the new API.
-     **/
-    getEstimates(sources: [string, string][], params: string, languageFeatures?: string[]): Promise<string>;
-    getEstimates(config: ProgramConfig, params: string): Promise<string>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
-/** Type definition for the configuration of a program. */
+/**
+ * Type definition for the configuration of a program.
+ * If adding new properties, make them optional to maintain backward compatibility.
+ */
 export type ProgramConfig = {
     /** An array of source objects, each containing a name and contents. */
     sources: [string, string][];
@@ -50,19 +32,20 @@ export declare class Compiler implements ICompiler {
     private wasm;
     constructor(wasm: Wasm);
     checkCode(code: string): Promise<VSDiagnostic[]>;
-    getQir(sourcesOrConfig: [string, string][] | ProgramConfig, languageFeatures?: string[]): Promise<string>;
-    newGetQir({ sources, languageFeatures, profile, }: ProgramConfig): Promise<string>;
-    deprecatedGetQir(sources: [string, string][], languageFeatures: string[]): Promise<string>;
-    getEstimates(sourcesOrConfig: [string, string][] | ProgramConfig, params: string, languageFeatures?: string[]): Promise<string>;
-    newGetEstimates({ sources, languageFeatures, profile }: ProgramConfig, params: string): Promise<string>;
-    deprecatedGetEstimates(sources: [string, string][], params: string, languageFeatures: string[]): Promise<string>;
     getAst(code: string, languageFeatures?: string[], profile?: TargetProfile): Promise<string>;
     getHir(code: string, languageFeatures: string[], profile: TargetProfile): Promise<string>;
-    run(sourcesOrConfig: [string, string][] | ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
-    getCircuit(config: ProgramConfig, target: TargetProfile, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
-    getDocumentation(additionalSources?: [string, string][], targetProfile?: string, languageFeatures?: string[]): Promise<IDocFile[]>;
+    run(program: ProgramConfig, expr: string, shots: number, eventHandler: IQscEventTarget): Promise<void>;
+    getQir(program: ProgramConfig): Promise<string>;
+    getEstimates(program: ProgramConfig, params: string): Promise<string>;
+    getCircuit(program: ProgramConfig, simulate: boolean, operation?: IOperationInfo): Promise<CircuitData>;
+    getDocumentation(additionalProgram?: ProgramConfig): Promise<IDocFile[]>;
     checkExerciseSolution(userCode: string, exerciseSources: string[], eventHandler: IQscEventTarget): Promise<boolean>;
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export declare function toWasmProgramConfig(program: ProgramConfig, defaultProfile: TargetProfile): Required<wasmIProgramConfig>;
 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>;

package/dist/compiler/compiler.js

@@ -16,7 +16,12 @@ export class Compiler {
         const languageService = new this.wasm.LanguageService();
         const work = languageService.start_background_work((uri, version, errors) => {
             diags = errors;
-        }, () => Promise.resolve(null), () => Promise.resolve([]), () => Promise.resolve(null));
+        }, {
+            readFile: async () => null,
+            listDirectory: async () => [],
+            resolvePath: async () => null,
+            findManifestDirectory: async () => null,
+        });
         languageService.update_document("code", 1, code);
         // Yield to let the language service background worker handle the update
         await Promise.resolve();
@@ -25,75 +30,50 @@ export class Compiler {
         languageService.free();
         return diags;
     }
-    async getQir(sourcesOrConfig, languageFeatures) {
-        if (Array.isArray(sourcesOrConfig)) {
-            return this.deprecatedGetQir(sourcesOrConfig, languageFeatures || []);
-        }
-        else {
-            const config = sourcesOrConfig;
-            return this.newGetQir(config);
-        }
-    }
-    async newGetQir({ sources, languageFeatures = [], profile = "base", }) {
-        return this.wasm.get_qir(sources, languageFeatures, profile);
-    }
-    async deprecatedGetQir(sources, languageFeatures) {
-        return this.wasm.get_qir(sources, languageFeatures, "base");
-    }
-    async getEstimates(sourcesOrConfig, params, languageFeatures = []) {
-        if (Array.isArray(sourcesOrConfig)) {
-            return this.deprecatedGetEstimates(sourcesOrConfig, params, languageFeatures);
-        }
-        else {
-            return this.newGetEstimates(sourcesOrConfig, params);
-        }
-    }
-    async newGetEstimates({ sources, languageFeatures, profile = "unrestricted" }, params) {
-        return this.wasm.get_estimates(sources, params, languageFeatures || [], profile);
-    }
-    async deprecatedGetEstimates(sources, params, languageFeatures) {
-        return this.wasm.get_estimates(sources, params, languageFeatures, "unrestricted");
-    }
     async getAst(code, languageFeatures, profile) {
         return this.wasm.get_ast(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
     async getHir(code, languageFeatures, profile) {
         return this.wasm.get_hir(code, languageFeatures ?? [], profile ?? "adaptive_ri");
     }
-    async run(sourcesOrConfig, expr, shots, eventHandler) {
-        let sources;
-        let profile = "unrestricted";
-        let languageFeatures = [];
-        if (Array.isArray(sourcesOrConfig)) {
-            // this is the deprecated API
-            sources = sourcesOrConfig;
-        }
-        else {
-            // this is the new API
-            sources = sourcesOrConfig.sources;
-            languageFeatures = sourcesOrConfig.languageFeatures || [];
-            profile = sourcesOrConfig.profile || "unrestricted";
-        }
+    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(sources, expr, (msg) => onCompilerEvent(msg, eventHandler), shots, languageFeatures, profile);
+        this.wasm.run(toWasmProgramConfig(program, "unrestricted"), expr, (msg) => onCompilerEvent(msg, eventHandler), shots);
+    }
+    async getQir(program) {
+        return this.wasm.get_qir(toWasmProgramConfig(program, "base"));
     }
-    async getCircuit(config, target, simulate, operation) {
-        return this.wasm.get_circuit(config.sources, target, config.languageFeatures || [], simulate, operation);
+    async getEstimates(program, params) {
+        return this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), params);
+    }
+    async getCircuit(program, simulate, operation) {
+        return this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
     }
     // Returns all autogenerated documentation files for the standard library
     // and loaded project (if requested). This include file names and metadata,
     // including specially formatted table of content file.
-    async getDocumentation(additionalSources, targetProfile, languageFeatures) {
-        // Get documentation from wasm layer
-        return this.wasm.generate_docs(additionalSources, targetProfile, languageFeatures);
+    async getDocumentation(additionalProgram) {
+        return this.wasm.generate_docs(additionalProgram &&
+            toWasmProgramConfig(additionalProgram, "unrestricted"));
     }
     async checkExerciseSolution(userCode, exerciseSources, eventHandler) {
         const success = this.wasm.check_exercise_solution(userCode, exerciseSources, (msg) => onCompilerEvent(msg, eventHandler));
         return success;
     }
 }
+/**
+ * Fills in the defaults, to convert from the backwards-compatible ProgramConfig,
+ * to the IProgramConfig type that the wasm layer expects
+ */
+export function toWasmProgramConfig(program, defaultProfile) {
+    return {
+        sources: program.sources,
+        languageFeatures: program.languageFeatures || [],
+        profile: program.profile || defaultProfile,
+    };
+}
 export function onCompilerEvent(msg, eventTarget) {
     const qscMsg = eventStringToMsg(msg);
     if (!qscMsg) {

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

@@ -1,11 +1,11 @@
 import { type Circuit as CircuitData } from "@microsoft/quantum-viz.js/lib/circuit.js";
 import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/web/qsc_wasm.js";
-import { TargetProfile } from "../browser.js";
+import { ProgramConfig } from "../browser.js";
 import { IQscEventTarget, QscEventData } from "../compiler/events.js";
 import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export interface IDebugService {
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;
@@ -22,7 +22,7 @@ export declare class QSharpDebugService implements IDebugService {
     private wasm;
     private debugService;
     constructor(wasm: QscWasm);
-    loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined, language_features: string[]): Promise<string>;
+    loadProgram(program: ProgramConfig, entry: string | undefined): Promise<string>;
     getBreakpoints(path: string): Promise<IBreakpointSpan[]>;
     getLocalVariables(): Promise<Array<IVariable>>;
     captureQuantumState(): Promise<Array<IQuantumState>>;

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

@@ -3,14 +3,15 @@
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
+import { toWasmProgramConfig } from "../compiler/compiler.js";
 export class QSharpDebugService {
     constructor(wasm) {
         log.info("Constructing a QSharpDebugService instance");
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
-    async loadSource(sources, target, entry, language_features) {
-        return this.debugService.load_source(sources, target, entry, language_features);
+    async loadProgram(program, entry) {
+        return this.debugService.load_program(toWasmProgramConfig(program, "unrestricted"), entry);
     }
     async getBreakpoints(path) {
         return this.debugService.get_breakpoints(path).spans;
@@ -85,7 +86,7 @@ export function onCompilerEvent(msg, eventTarget) {
 export const debugServiceProtocol = {
     class: QSharpDebugService,
     methods: {
-        loadSource: "request",
+        loadProgram: "request",
         getBreakpoints: "request",
         getLocalVariables: "request",
         captureQuantumState: "request",

package/dist/katas-content.generated.js

@@ -3655,7 +3655,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_states__orthogonal_states",
                     "title": "Distinguishing Orthogonal States",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>In this lesson, you will practice distinguishing sets of states that are pairwise orthogonal.\nIn this scenario, the states can be distinguished perfectly, with 100% accuracy.</p>\n"
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -3967,7 +3972,7 @@ export default {
                     "title": "Distinguish Four Bell States",
                     "description": {
                         "type": "text-content",
-                        "content": "<p><strong>Input:</strong> Two qubits (stored in an array of length 2) which are guaranteed to be in one of the four Bell states.</p>\n<p>Output:</p>\n<ul>\n<li>0 if they were in the state $\\ket{\\Phi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} + \\ket{11}\\big)$,</li>\n<li>1 if they were in the state $\\ket{\\Phi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} - \\ket{11}\\big)$,</li>\n<li>2 if they were in the state $\\ket{\\Psi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} + \\ket{10}\\big)$,</li>\n<li>3 if they were in the state $\\ket{\\Psi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} - \\ket{10}\\big)$.</li>\n</ul>\n<p>The state of the qubits at the end of the operation does not matter.</p>\n"
+                        "content": "<p><strong>Input:</strong> Two qubits (stored in an array of length 2) which are guaranteed to be in one of the four Bell states.</p>\n<p><strong>Output:</strong></p>\n<ul>\n<li>0 if they were in the state $\\ket{\\Phi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} + \\ket{11}\\big)$,</li>\n<li>1 if they were in the state $\\ket{\\Phi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} - \\ket{11}\\big)$,</li>\n<li>2 if they were in the state $\\ket{\\Psi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} + \\ket{10}\\big)$,</li>\n<li>3 if they were in the state $\\ket{\\Psi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} - \\ket{10}\\big)$.</li>\n</ul>\n<p>The state of the qubits at the end of the operation does not matter.</p>\n"
                     },
                     "sourceIds": [
                         "distinguishing_states__four_bell_states__Verification.qs",
@@ -4079,8 +4084,13 @@ export default {
                 {
                     "type": "lesson",
                     "id": "distinguishing_states__nonorthogonal_states",
-                    "title": "Distinguishing Non-orthogonal States",
-                    "items": []
+                    "title": "Distinguishing Non-Orthogonal States",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>This lesson offers you several variants of the task of distinguishing sets of states that are not orthogonal.</p>\n"
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -4173,7 +4183,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "<p>Congratulations! In this kata you learned to use measurements and basic quantum computing gates to distinguish quantum states. Here are a few key concepts to keep in mind:</p>\n<ul>\n<li>TODO</li>\n</ul>\n"
+                            "content": "<p>Congratulations! In this kata you learned to use measurements and basic quantum computing gates to distinguish quantum states.</p>\n"
                         }
                     ]
                 }
@@ -4199,7 +4209,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_unitaries__single_qubit",
                     "title": "Distinguishing Single-Qubit Gates",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>To start with, let's look at some problems involving distinguishing single-qubit gates.</p>\n"
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -4495,7 +4510,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_unitaries__multi_qubit",
                     "title": "Distinguishing Multi-Qubit Gates",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "<p>In this lesson, the exercises focus on distinguishing multi-qubit gates.</p>\n"
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -7708,7 +7728,7 @@ export default {
         },
         {
             "id": "key_distribution__random_array__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        // The test only checks that the operation returns an array of correct length\n        // and that it's not always the same. It doesn't analyze the distribution of true and false elements.\n        let N = 10;\n        let randomArrays = ForEach(Kata.RandomArray, [N, N, N]);\n\n        for array in randomArrays {\n            if Length(array) != N {\n                Message($\"Returned array should have length {N}, and it had length {Length(array)}.\");\n                return false;\n            }\n        }\n\n        let randomInts = Mapped(BoolArrayAsInt, randomArrays);\n        if randomInts[0] == randomInts[1] or randomInts[1] == randomInts[2] or randomInts[0] == randomInts[2] {\n            Message($\"Random generation should not return a fixed array.\");\n            return false;\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        // The test only checks that the operation returns an array of correct length\n        // and that it's not always the same. It doesn't analyze the distribution of true and false elements.\n        let N = 20;\n        let randomArrays = ForEach(Kata.RandomArray, [N, size = 10]);\n\n        for array in randomArrays {\n            if Length(array) != N {\n                Message($\"Returned array should have length {N}, and it had length {Length(array)}.\");\n                return false;\n            }\n        }\n\n        let randomInts = Mapped(BoolArrayAsInt, randomArrays);\n        mutable allSame = true;\n        for int in randomInts {\n            if int != randomInts[0] {\n                set allSame = false;\n            }\n        }\n        if allSame {\n            Message($\"Random generation should not return a fixed array.\");\n            return false;\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "key_distribution__prepare_qubits__Verification.qs",

package/dist/katas-content.generated.md.js

@@ -3655,7 +3655,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_states__orthogonal_states",
                     "title": "Distinguishing Orthogonal States",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nIn this lesson, you will practice distinguishing sets of states that are pairwise orthogonal.\nIn this scenario, the states can be distinguished perfectly, with 100% accuracy."
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -3967,7 +3972,7 @@ export default {
                     "title": "Distinguish Four Bell States",
                     "description": {
                         "type": "text-content",
-                        "content": "**Input:** Two qubits (stored in an array of length 2) which are guaranteed to be in one of the four Bell states.\n\nOutput:\n* 0 if they were in the state $\\ket{\\Phi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} + \\ket{11}\\big)$,\n* 1 if they were in the state $\\ket{\\Phi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} - \\ket{11}\\big)$,\n* 2 if they were in the state $\\ket{\\Psi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} + \\ket{10}\\big)$,\n* 3 if they were in the state $\\ket{\\Psi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} - \\ket{10}\\big)$.\n  \nThe state of the qubits at the end of the operation does not matter.\n"
+                        "content": "**Input:** Two qubits (stored in an array of length 2) which are guaranteed to be in one of the four Bell states.\n\n**Output:**\n* 0 if they were in the state $\\ket{\\Phi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} + \\ket{11}\\big)$,\n* 1 if they were in the state $\\ket{\\Phi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{00} - \\ket{11}\\big)$,\n* 2 if they were in the state $\\ket{\\Psi^{+}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} + \\ket{10}\\big)$,\n* 3 if they were in the state $\\ket{\\Psi^{-}} = \\frac{1}{\\sqrt{2}} \\big(\\ket{01} - \\ket{10}\\big)$.\n  \nThe state of the qubits at the end of the operation does not matter.\n"
                     },
                     "sourceIds": [
                         "distinguishing_states__four_bell_states__Verification.qs",
@@ -4079,8 +4084,13 @@ export default {
                 {
                     "type": "lesson",
                     "id": "distinguishing_states__nonorthogonal_states",
-                    "title": "Distinguishing Non-orthogonal States",
-                    "items": []
+                    "title": "Distinguishing Non-Orthogonal States",
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nThis lesson offers you several variants of the task of distinguishing sets of states that are not orthogonal."
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -4173,7 +4183,7 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "content": "\nCongratulations! In this kata you learned to use measurements and basic quantum computing gates to distinguish quantum states. Here are a few key concepts to keep in mind:\n\n- TODO"
+                            "content": "\nCongratulations! In this kata you learned to use measurements and basic quantum computing gates to distinguish quantum states."
                         }
                     ]
                 }
@@ -4199,7 +4209,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_unitaries__single_qubit",
                     "title": "Distinguishing Single-Qubit Gates",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nTo start with, let's look at some problems involving distinguishing single-qubit gates."
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -4495,7 +4510,12 @@ export default {
                     "type": "lesson",
                     "id": "distinguishing_unitaries__multi_qubit",
                     "title": "Distinguishing Multi-Qubit Gates",
-                    "items": []
+                    "items": [
+                        {
+                            "type": "text-content",
+                            "content": "\nIn this lesson, the exercises focus on distinguishing multi-qubit gates."
+                        }
+                    ]
                 },
                 {
                     "type": "exercise",
@@ -7708,7 +7728,7 @@ export default {
         },
         {
             "id": "key_distribution__random_array__Verification.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        // The test only checks that the operation returns an array of correct length\n        // and that it's not always the same. It doesn't analyze the distribution of true and false elements.\n        let N = 10;\n        let randomArrays = ForEach(Kata.RandomArray, [N, N, N]);\n\n        for array in randomArrays {\n            if Length(array) != N {\n                Message($\"Returned array should have length {N}, and it had length {Length(array)}.\");\n                return false;\n            }\n        }\n\n        let randomInts = Mapped(BoolArrayAsInt, randomArrays);\n        if randomInts[0] == randomInts[1] or randomInts[1] == randomInts[2] or randomInts[0] == randomInts[2] {\n            Message($\"Random generation should not return a fixed array.\");\n            return false;\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Arrays;\n    open Microsoft.Quantum.Convert;\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        // The test only checks that the operation returns an array of correct length\n        // and that it's not always the same. It doesn't analyze the distribution of true and false elements.\n        let N = 20;\n        let randomArrays = ForEach(Kata.RandomArray, [N, size = 10]);\n\n        for array in randomArrays {\n            if Length(array) != N {\n                Message($\"Returned array should have length {N}, and it had length {Length(array)}.\");\n                return false;\n            }\n        }\n\n        let randomInts = Mapped(BoolArrayAsInt, randomArrays);\n        mutable allSame = true;\n        for int in randomInts {\n            if int != randomInts[0] {\n                set allSame = false;\n            }\n        }\n        if allSame {\n            Message($\"Random generation should not return a fixed array.\");\n            return false;\n        }\n\n        Message(\"Correct!\");\n        true\n    }\n}\n"
         },
         {
             "id": "key_distribution__prepare_qubits__Verification.qs",

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

@@ -1,4 +1,5 @@
 import type { ICodeAction, ICodeLens, ICompletionList, IHover, ILocation, INotebookMetadata, IPosition, IRange, ISignatureHelp, ITextEdit, IWorkspaceConfiguration, IWorkspaceEdit, VSDiagnostic } from "../../lib/web/qsc_wasm.js";
+import { IProjectHost } from "../browser.js";
 import { IServiceProxy, ServiceProtocol } from "../workers/common.js";
 type QscWasm = typeof import("../../lib/web/qsc_wasm.js");
 export type LanguageServiceEvent = {
@@ -40,13 +41,11 @@ export interface ILanguageService {
 export declare const qsharpLibraryUriScheme = "qsharp-library-source";
 export type ILanguageServiceWorker = ILanguageService & IServiceProxy;
 export declare class QSharpLanguageService implements ILanguageService {
+    private wasm;
     private languageService;
     private eventHandler;
-    private readFile;
     private backgroundWork;
-    constructor(wasm: QscWasm, readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
-        manifestDirectory: string;
-    } | null>);
+    constructor(wasm: QscWasm, host?: IProjectHost);
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(documentUri: string, version: number, code: string): Promise<void>;
     updateNotebookDocument(notebookUri: string, version: number, metadata: INotebookMetadata, cells: {

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

@@ -3,12 +3,17 @@
 import { log } from "../log.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
 export class QSharpLanguageService {
-    constructor(wasm, readFile = () => Promise.resolve(null), listDir = () => Promise.resolve([]), getManifest = () => Promise.resolve(null)) {
+    constructor(wasm, host = {
+        readFile: async () => null,
+        listDirectory: async () => [],
+        resolvePath: async () => null,
+        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), readFile, listDir, getManifest);
-        this.readFile = readFile;
+        this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), host);
     }
     async updateConfiguration(config) {
         this.languageService.update_configuration(config);

package/dist/main.d.ts

@@ -2,17 +2,14 @@ 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 type { ProjectLoader } from "../lib/web/qsc_wasm.js";
+import { IProjectHost } from "./browser.js";
 export { qsharpLibraryUriScheme };
 export declare function getLibrarySourceContent(path: string): Promise<string | undefined>;
 export declare function getCompiler(): ICompiler;
-export declare function getProjectLoader(readFile: (path: string) => Promise<string | null>, loadDirectory: (path: string) => Promise<[string, number][]>, getManifest: (path: string) => Promise<{
-    manifestDirectory: string;
-} | null>): ProjectLoader;
+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(readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
-    manifestDirectory: string;
-} | null>): ILanguageService;
+export declare function getLanguageService(host?: IProjectHost): ILanguageService;
 export declare function getLanguageServiceWorker(): ILanguageServiceWorker;
 export * as utils from "./utils.js";

package/dist/main.js

@@ -27,9 +27,9 @@ export function getCompiler() {
     ensureWasm();
     return new Compiler(wasm);
 }
-export function getProjectLoader(readFile, loadDirectory, getManifest) {
+export function getProjectLoader(host) {
     ensureWasm();
-    return new wasm.ProjectLoader(readFile, loadDirectory, getManifest);
+    return new wasm.ProjectLoader(host);
 }
 export function getCompilerWorker() {
     return createProxy("../compiler/worker-node.js", compilerProtocol);
@@ -41,9 +41,9 @@ export function getDebugService() {
 export function getDebugServiceWorker() {
     return createProxy("../debug-service/worker-node.js", debugServiceProtocol);
 }
-export function getLanguageService(readFile, listDir, getManifest) {
+export function getLanguageService(host) {
     ensureWasm();
-    return new QSharpLanguageService(wasm, readFile, listDir, getManifest);
+    return new QSharpLanguageService(wasm, host);
 }
 export function getLanguageServiceWorker() {
     return createProxy("../language-service/worker-node.js", languageServiceProtocol);

package/docs/Microsoft.Quantum.Arrays/All.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.All
 title: All function
-ms.date: 06/13/2024 12:00:00 AM
+ms.date: 06/26/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Any.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Any
 title: Any function
-ms.date: 06/13/2024 12:00:00 AM
+ms.date: 06/26/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/Chunks.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.Chunks
 title: Chunks function
-ms.date: 06/13/2024 12:00:00 AM
+ms.date: 06/26/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/CircularlyShifted.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.CircularlyShifted
 title: CircularlyShifted function
-ms.date: 06/13/2024 12:00:00 AM
+ms.date: 06/26/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays

package/docs/Microsoft.Quantum.Arrays/ColumnAt.md

@@ -1,7 +1,7 @@
 ---
 uid: Qdk.Microsoft.Quantum.Arrays.ColumnAt
 title: ColumnAt function
-ms.date: 06/13/2024 12:00:00 AM
+ms.date: 06/26/2024 12:00:00 AM
 ms.topic: managed-reference
 qsharp.kind: function
 qsharp.namespace: Microsoft.Quantum.Arrays