qsharp-lang 1.27.1-dev → 1.27.3-dev

package/dist/workers/{common.js → main.js}

@@ -2,6 +2,45 @@
 // Licensed under the MIT License.
 import { QdkDiagnostics } from "../diagnostics.js";
 import { log } from "../log.js";
+/**
+ * Creates and initializes a service in a web worker, and returns a proxy for the service
+ * to be used from the main thread.
+ *
+ * @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 function createProxy(workerArg, wasmModule, serviceProtocol, workerType) {
+    // Create or use the WebWorker
+    const useModuleWorker = { type: workerType };
+    const worker = typeof workerArg === "string"
+        ? new Worker(workerArg, useModuleWorker)
+        : workerArg;
+    // Log any errors from the worker
+    worker.addEventListener("error", (ev) => {
+        log.error("Worker error:", ev);
+    });
+    // Send it the Wasm module to instantiate
+    worker.postMessage({
+        type: "init",
+        wasmModule,
+        qscLogLevel: log.getLogLevel(),
+    });
+    // If you lose the 'this' binding, some environments have issues
+    const postMessage = worker.postMessage.bind(worker);
+    const onTerminate = () => worker.terminate();
+    // Create the proxy which will forward method calls to the worker
+    const proxy = createProxyInternal(postMessage, onTerminate, serviceProtocol.methods);
+    // Let proxy handle response and event messages from the worker
+    worker.addEventListener("message", (ev) => {
+        proxy.onMsgFromWorker(ev.data);
+    });
+    return proxy;
+}
 /*
 The WorkerProxy works by queuing up requests to send over to the Worker, only
 ever having one in flight at a time. By queuing on the caller side, this allows
@@ -24,7 +63,7 @@ complete the request.
  * @returns The proxy object. The caller should then set the onMsgFromWorker
  * property to a callback that will receive messages from the worker.
  */
-export function createProxyInternal(postMessage, terminator, methods) {
+function createProxyInternal(postMessage, terminator, methods) {
     const queue = [];
     const eventTarget = new EventTarget();
     let curr;
@@ -181,144 +220,6 @@ export function createProxyInternal(postMessage, terminator, methods) {
     proxy.onMsgFromWorker = onMsgFromWorker;
     return proxy;
 }
-/**
- * Function to wrap a service in a dispatcher. To be used in the worker thread.
- *
- * @param service The service to be wrapped
- * @param methods A map of method names. Should match the list passed into @see createProxyInternal.
- * @param eventNames The list of event names that the service can emit
- * @param postMessage A function to post messages back to the main thread
- * @returns A function that takes a message and invokes the corresponding
- * method on the service. The caller should then set this method as a message handler.
- */
-function createDispatcher(postMessage, service, methods, eventNames) {
-    log.trace("Worker: Constructing WorkerEventHandler");
-    function logAndPost(msg) {
-        log.trace("Worker: Sending %s message from worker: %o", msg.messageType, msg);
-        postMessage(msg);
-    }
-    const eventTarget = new EventTarget();
-    eventNames.forEach((eventName) => {
-        // Subscribe to all known events and forward them as messages to the main thread.
-        eventTarget.addEventListener(eventName, (ev) => {
-            logAndPost({
-                messageType: "event",
-                type: ev.type,
-                detail: ev.detail,
-            });
-        });
-        // If there's an addEventListener on the object itself, forward those events as well.
-        if (service.addEventListener) {
-            service.addEventListener(eventName, (ev) => {
-                logAndPost({
-                    messageType: "event",
-                    type: ev.type,
-                    detail: ev.detail,
-                });
-            });
-        }
-    });
-    return function invokeMethod(req) {
-        // Pass the eventTarget to the methods marked as taking progress
-        return service[req.type]
-            .call(service, ...req.args, methods[req.type] === "requestWithProgress" ? eventTarget : undefined)
-            .then((result) => logAndPost({
-            messageType: "response",
-            type: req.type,
-            result: { success: true, result },
-        }))
-            .catch((err) => {
-            // Serialize the error if it's a known type.
-            err = serializeIfError(err);
-            logAndPost({
-                // If this happens then the wasm code likely threw an exception/panicked rather than
-                // completing gracefully and fulfilling the promise. Communicate to the client
-                // that there was an error and it should reject the current request
-                messageType: "response",
-                type: req.type,
-                result: { success: false, error: err },
-            });
-        });
-    };
-}
-/**
- * Creates and initializes the actual service. To be used in the worker thread.
- *
- * @param postMessage A function to post messages back to the main thread
- * @param serviceProtocol An object that describes the service: its constructor, methods and events
- * @param wasm The wasm module to initialize the service with
- * @param qscLogLevel The log level to initialize the service with
- * @returns A function that takes a message and invokes the corresponding
- * method on the service. The caller should then set this method as a message handler.
- */
-export function initService(postMessage, serviceProtocol, wasm, qscLogLevel) {
-    function postTelemetryMessage(telemetry) {
-        postMessage({
-            messageType: "common-event",
-            type: "telemetry-event",
-            detail: telemetry,
-        });
-    }
-    function postLogMessage(level, target, ...args) {
-        if (log.getLogLevel() < level) {
-            return;
-        }
-        let data = args;
-        try {
-            // Only structured cloneable objects can be sent in worker messages.
-            // Test if this is the case.
-            structuredClone(args);
-        }
-        catch {
-            // Uncloneable object.
-            // Use String(args) instead of ${args} to handle all possible values
-            // without throwing. See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion
-            data = ["unsupported log data " + String(args)];
-        }
-        postMessage({
-            messageType: "common-event",
-            type: "log",
-            detail: { level, target, data },
-        });
-    }
-    // Override the global logger
-    log.error = (...args) => postLogMessage(1, "worker", ...args);
-    log.warn = (...args) => postLogMessage(2, "worker", ...args);
-    log.info = (...args) => postLogMessage(3, "worker", ...args);
-    log.debug = (...args) => postLogMessage(4, "worker", ...args);
-    log.trace = (...args) => postLogMessage(5, "worker", ...args);
-    if (qscLogLevel !== undefined) {
-        log.setLogLevel(qscLogLevel);
-    }
-    // Set up logging and telemetry as soon as possible after instantiating
-    log.onLevelChanged = (level) => wasm.setLogLevel(level);
-    log.setTelemetryCollector(postTelemetryMessage);
-    wasm.initLogging(postLogMessage, log.getLogLevel());
-    // Create the actual service and return the dispatcher method
-    const service = new serviceProtocol.class(wasm);
-    return createDispatcher(postMessage, service, serviceProtocol.methods, serviceProtocol.eventNames);
-}
-/**
- * Serializes an error, if it is a known type, so that it can be sent between threads.
- *
- * By default, browsers can only send certain types of errors between the main thread and a worker.
- * See: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm#error_types
- *
- * Serializing our own custom errors allows us to send them between threads.
- */
-function serializeIfError(err) {
-    if (err instanceof QdkDiagnostics) {
-        err = { name: err.name, data: err.diagnostics };
-    }
-    else if (err instanceof WebAssembly.RuntimeError) {
-        err = {
-            name: "WebAssembly.RuntimeError",
-            message: err.message,
-            stack: err.stack,
-        };
-    }
-    return err;
-}
 /**
  * Deserializes an error if it is a known type.
  *

package/dist/workers/{common.d.ts → types.d.ts}

@@ -1,4 +1,4 @@
-import { TelemetryEvent } from "../log.js";
+import type { TelemetryEvent } from "../log.js";
 type Wasm = typeof import("../../lib/web/qsc_wasm.js");
 /**
  * Describes a service that can be run in a worker.
@@ -77,7 +77,7 @@ export interface IServiceEventMessage {
 /**
  * Common event types all workers can send.
  */
-type CommonEvent = {
+export type CommonEvent = {
     type: "telemetry-event";
     detail: TelemetryEvent;
 } | {
@@ -88,7 +88,7 @@ type CommonEvent = {
         data: any[];
     };
 };
-type CommonEventMessage = CommonEvent & {
+export type CommonEventMessage = CommonEvent & {
     messageType: "common-event";
 };
 /**
@@ -104,27 +104,4 @@ export interface IServiceEventTarget<TEvents extends IServiceEventMessage> {
     }>) => void): void;
     dispatchEvent(event: Event & TEvents): boolean;
 }
-/**
- * Function to create the proxy for a type. To be used from the main thread.
- *
- * @param postMessage A function to post messages to the worker
- * @param terminator A function to call to tear down the worker thread
- * @param methods A map of method names to be proxied and some metadata @see MethodMap
- * @returns The proxy object. The caller should then set the onMsgFromWorker
- * property to a callback that will receive messages from the worker.
- */
-export declare function createProxyInternal<TService extends ServiceMethods<TService>, TServiceEventMsg extends IServiceEventMessage>(postMessage: (msg: RequestMessage<TService>) => void, terminator: () => void, methods: MethodMap<TService>): TService & IServiceProxy & {
-    onMsgFromWorker: (msg: ResponseMessage<TService> | EventMessage<TServiceEventMsg>) => void;
-};
-/**
- * Creates and initializes the actual service. To be used in the worker thread.
- *
- * @param postMessage A function to post messages back to the main thread
- * @param serviceProtocol An object that describes the service: its constructor, methods and events
- * @param wasm The wasm module to initialize the service with
- * @param qscLogLevel The log level to initialize the service with
- * @returns A function that takes a message and invokes the corresponding
- * method on the service. The caller should then set this method as a message handler.
- */
-export declare function initService<TService extends ServiceMethods<TService>, TServiceEventMsg extends IServiceEventMessage>(postMessage: (msg: ResponseMessage<TService> | EventMessage<TServiceEventMsg> | CommonEventMessage) => void, serviceProtocol: ServiceProtocol<TService, TServiceEventMsg>, wasm: Wasm, qscLogLevel?: number): (req: RequestMessage<TService>) => Promise<void>;
 export {};

package/dist/workers/types.js

@@ -0,0 +1,3 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};

package/dist/workers/worker.d.ts

@@ -0,0 +1,9 @@
+import type { IServiceEventMessage, ServiceMethods, ServiceProtocol } from "./types.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;

package/dist/workers/worker.js

@@ -0,0 +1,176 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import * as wasm from "../../lib/web/qsc_wasm.js";
+import { QdkDiagnostics } from "../diagnostics.js";
+import { log } from "../log.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 function createWorker(serviceProtocol) {
+    let invokeService = null;
+    // This export should be assigned to 'self.onmessage' in a WebWorker
+    return function messageHandler(e) {
+        const data = e.data;
+        if (!data.type || typeof data.type !== "string") {
+            log.error(`Unrecognized msg: ${data}`);
+            return;
+        }
+        switch (data.type) {
+            case "init":
+                {
+                    wasm.initSync({ module: data.wasmModule });
+                    invokeService = initService(self.postMessage.bind(self), serviceProtocol, wasm, data.qscLogLevel);
+                }
+                break;
+            default:
+                if (!invokeService) {
+                    log.error(`Received message before the service was initialized: %o`, data);
+                }
+                else {
+                    invokeService(data);
+                }
+        }
+    };
+}
+/**
+ * Serializes an error, if it is a known type, so that it can be sent between threads.
+ *
+ * By default, browsers can only send certain types of errors between the main thread and a worker.
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm#error_types
+ *
+ * Serializing our own custom errors allows us to send them between threads.
+ */
+function serializeIfError(err) {
+    if (err instanceof QdkDiagnostics) {
+        err = { name: err.name, data: err.diagnostics };
+    }
+    else if (err instanceof WebAssembly.RuntimeError) {
+        err = {
+            name: "WebAssembly.RuntimeError",
+            message: err.message,
+            stack: err.stack,
+        };
+    }
+    return err;
+}
+/**
+ * Function to wrap a service in a dispatcher. To be used in the worker thread.
+ *
+ * @param service The service to be wrapped
+ * @param methods A map of method names. Should match the list passed into @see createProxyInternal.
+ * @param eventNames The list of event names that the service can emit
+ * @param postMessage A function to post messages back to the main thread
+ * @returns A function that takes a message and invokes the corresponding
+ * method on the service. The caller should then set this method as a message handler.
+ */
+function createDispatcher(postMessage, service, methods, eventNames) {
+    log.trace("Worker: Constructing WorkerEventHandler");
+    function logAndPost(msg) {
+        log.trace("Worker: Sending %s message from worker: %o", msg.messageType, msg);
+        postMessage(msg);
+    }
+    const eventTarget = new EventTarget();
+    eventNames.forEach((eventName) => {
+        // Subscribe to all known events and forward them as messages to the main thread.
+        eventTarget.addEventListener(eventName, (ev) => {
+            logAndPost({
+                messageType: "event",
+                type: ev.type,
+                detail: ev.detail,
+            });
+        });
+        // If there's an addEventListener on the object itself, forward those events as well.
+        if (service.addEventListener) {
+            service.addEventListener(eventName, (ev) => {
+                logAndPost({
+                    messageType: "event",
+                    type: ev.type,
+                    detail: ev.detail,
+                });
+            });
+        }
+    });
+    return function invokeMethod(req) {
+        // Pass the eventTarget to the methods marked as taking progress
+        return service[req.type]
+            .call(service, ...req.args, methods[req.type] === "requestWithProgress" ? eventTarget : undefined)
+            .then((result) => logAndPost({
+            messageType: "response",
+            type: req.type,
+            result: { success: true, result },
+        }))
+            .catch((err) => {
+            // Serialize the error if it's a known type.
+            err = serializeIfError(err);
+            logAndPost({
+                // If this happens then the wasm code likely threw an exception/panicked rather than
+                // completing gracefully and fulfilling the promise. Communicate to the client
+                // that there was an error and it should reject the current request
+                messageType: "response",
+                type: req.type,
+                result: { success: false, error: err },
+            });
+        });
+    };
+}
+/**
+ * Creates and initializes the actual service. To be used in the worker thread.
+ *
+ * @param postMessage A function to post messages back to the main thread
+ * @param serviceProtocol An object that describes the service: its constructor, methods and events
+ * @param wasm The wasm module to initialize the service with
+ * @param qscLogLevel The log level to initialize the service with
+ * @returns A function that takes a message and invokes the corresponding
+ * method on the service. The caller should then set this method as a message handler.
+ */
+function initService(postMessage, serviceProtocol, wasm, qscLogLevel) {
+    function postTelemetryMessage(telemetry) {
+        postMessage({
+            messageType: "common-event",
+            type: "telemetry-event",
+            detail: telemetry,
+        });
+    }
+    function postLogMessage(level, target, ...args) {
+        if (log.getLogLevel() < level) {
+            return;
+        }
+        let data = args;
+        try {
+            // Only structured cloneable objects can be sent in worker messages.
+            // Test if this is the case.
+            structuredClone(args);
+        }
+        catch {
+            // Uncloneable object.
+            // Use String(args) instead of ${args} to handle all possible values
+            // without throwing. See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#string_coercion
+            data = ["unsupported log data " + String(args)];
+        }
+        postMessage({
+            messageType: "common-event",
+            type: "log",
+            detail: { level, target, data },
+        });
+    }
+    // Override the global logger
+    log.error = (...args) => postLogMessage(1, "worker", ...args);
+    log.warn = (...args) => postLogMessage(2, "worker", ...args);
+    log.info = (...args) => postLogMessage(3, "worker", ...args);
+    log.debug = (...args) => postLogMessage(4, "worker", ...args);
+    log.trace = (...args) => postLogMessage(5, "worker", ...args);
+    if (qscLogLevel !== undefined) {
+        log.setLogLevel(qscLogLevel);
+    }
+    // Set up logging and telemetry as soon as possible after instantiating
+    log.onLevelChanged = (level) => wasm.setLogLevel(level);
+    log.setTelemetryCollector(postTelemetryMessage);
+    wasm.initLogging(postLogMessage, log.getLogLevel());
+    // Create the actual service and return the dispatcher method
+    const service = new serviceProtocol.class(wasm);
+    return createDispatcher(postMessage, service, serviceProtocol.methods, serviceProtocol.eventNames);
+}

package/docs/Microsoft.Quantum.Core/IsRangeEmpty.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.IsRangeEmpty
 title: IsRangeEmpty exported item
 description: "Q# IsRangeEmpty exported item: This is an exported item. The actual definition is found here: [Std.Range.IsRangeEmpty](xref:Qdk.Std.Range.IsRangeEmpty)"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

package/docs/Microsoft.Quantum.Core/Length.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length exported item
 description: "Q# Length exported item: This is an exported item. The actual definition is found here: [Std.Core.Length](xref:Qdk.Std.Core.Length)"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

package/docs/Microsoft.Quantum.Core/RangeEnd.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.RangeEnd
 title: RangeEnd exported item
 description: "Q# RangeEnd exported item: This is an exported item. The actual definition is found here: [Std.Range.RangeEnd](xref:Qdk.Std.Range.RangeEnd)"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

package/docs/Microsoft.Quantum.Core/RangeStart.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.RangeStart
 title: RangeStart exported item
 description: "Q# RangeStart exported item: This is an exported item. The actual definition is found here: [Std.Range.RangeStart](xref:Qdk.Std.Range.RangeStart)"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

package/docs/Microsoft.Quantum.Core/Repeated.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Repeated
 title: Repeated exported item
 description: "Q# Repeated exported item: This is an exported item. The actual definition is found here: [Std.Core.Repeated](xref:Qdk.Std.Core.Repeated)"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: export
 qsharp.package: __Std__
 qsharp.namespace: Microsoft.Quantum.Core

package/docs/Microsoft.Quantum.Core/index.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core-toc
 title: Microsoft.Quantum.Core namespace
 description: Table of contents for the Q# Microsoft.Quantum.Core namespace
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 ms.topic: landing-page
 ---
 

package/docs/Std.Arithmetic/AddLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.AddLE
 title: AddLE operation
 description: "Q# AddLE operation: Sets a zero-initialized little-endian register zs to the sum of little-endian registers xs and ys"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualL
 title: ApplyIfEqualL operation
 description: "Q# ApplyIfEqualL operation: Computes `if (c == x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is equal to the little-endian qubit register `x`"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfEqualLE
 title: ApplyIfEqualLE operation
 description: "Q# ApplyIfEqualLE operation: Computes `if x == y { action(target) }`, that is, applies `action` to `target` if register `x` is equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterL
 title: ApplyIfGreaterL operation
 description: "Q# ApplyIfGreaterL operation: Computes `if (c > x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater than the little-endian qubit register `x`"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterLE
 title: ApplyIfGreaterLE operation
 description: "Q# ApplyIfGreaterLE operation: Computes `if x > y { action(target) }`, that is, applies `action` to `target` if register `x` is greater than the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualL
 title: ApplyIfGreaterOrEqualL operation
 description: "Q# ApplyIfGreaterOrEqualL operation: Computes `if (c >= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is greater or equal to the little-endian qubit register `x`"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfGreaterOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfGreaterOrEqualLE
 title: ApplyIfGreaterOrEqualLE operation
 description: "Q# ApplyIfGreaterOrEqualLE operation: Computes `if x >= y { action(target) }`, that is, applies `action` to `target` if register `x` is greater or equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessL
 title: ApplyIfLessL operation
 description: "Q# ApplyIfLessL operation: Computes `if (c < x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less than the little-endian qubit register `x`"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessLE
 title: ApplyIfLessLE operation
 description: "Q# ApplyIfLessLE operation: Computes `if x < y { action(target) }`, that is, applies `action` to `target` if register `x` is less than the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessOrEqualL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualL
 title: ApplyIfLessOrEqualL operation
 description: "Q# ApplyIfLessOrEqualL operation: Computes `if (c <= x) { action(target) }`, that is, applies `action` to `target` if a BigInt value `c` is less or equal to the little-endian qubit register `x`"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/ApplyIfLessOrEqualLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.ApplyIfLessOrEqualLE
 title: ApplyIfLessOrEqualLE operation
 description: "Q# ApplyIfLessOrEqualLE operation: Computes `if x <= y { action(target) }`, that is, applies `action` to `target` if register `x` is less or equal to the register `y`. Both qubit registers should be in a little-endian format."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/FourierTDIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.FourierTDIncByLE
 title: FourierTDIncByLE operation
 description: "Q# FourierTDIncByLE operation: Increments a little-endian register ys by a little-endian register xs using Quantum Fourier Transform."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByI.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByI
 title: IncByI operation
 description: "Q# IncByI operation: Increments a little-endian register ys by an integer number c"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByIUsingIncByLE.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByIUsingIncByLE
 title: IncByIUsingIncByLE operation
 description: "Q# IncByIUsingIncByLE operation: Increments a little-endian register ys by an Int number c using provided adder."
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic

package/docs/Std.Arithmetic/IncByL.md

@@ -2,7 +2,7 @@
 uid: Qdk.Std.Arithmetic.IncByL
 title: IncByL operation
 description: "Q# IncByL operation: Increments a little-endian register ys by a BigInt number c"
-ms.date: 04/13/2026
+ms.date: 04/20/2026
 qsharp.kind: operation
 qsharp.package: __Std__
 qsharp.namespace: Std.Arithmetic