numbl 0.4.14 → 0.4.16

package/dist-browser/browser/protocol.d.ts

@@ -16,6 +16,20 @@ export interface BootMessage {
     optimization: "0" | "1";
     maxIterations: number;
     displayResults: boolean;
+    /**
+     * Shared cancellation flag (Int32[0] != 0 ⇒ cancel the running code). The
+     * worker keeps this reference and passes it to every executeCode call, so
+     * the host can interrupt a runaway run cooperatively. Only present when the
+     * page is cross-origin isolated (SharedArrayBuffer available).
+     */
+    cancelSAB?: SharedArrayBuffer;
+    /**
+     * Shared channel for synchronous `input()` (stdin). The worker blocks on it
+     * (Atomics.wait) after asking the host for a line via a `request-input`
+     * message; the host writes the reply back through it (see syncInputChannel).
+     * Only present when the page is cross-origin isolated.
+     */
+    inputSAB?: SharedArrayBuffer;
 }
 export type ToWorker = BootMessage | {
     type: "writeFile";
@@ -51,6 +65,12 @@ export interface ExecuteResult {
     plotInstructions: PlotInstruction[];
     /** Formatted error message when `ok` is false. */
     error?: string;
+    /**
+     * True when the run ended because it was interrupted via
+     * `NumblSession.interrupt()` (rather than finishing or erroring). The
+     * workspace is left at its pre-run state, so variables survive the abort.
+     */
+    aborted?: boolean;
 }
 export type FromWorker = {
     type: "progress";
@@ -70,6 +90,9 @@ export type FromWorker = {
 } | {
     type: "bootError";
     message: string;
+} | {
+    type: "request-input";
+    prompt: string;
 } | {
     type: "htmlSourceEvent";
     compId: string;

package/dist-browser/browser/session.d.ts

@@ -27,6 +27,13 @@ export interface NumblSessionOptions {
     onOutput?: (text: string) => void;
     /** Boot progress (package downloads, engine start). */
     onProgress?: (message: string) => void;
+    /**
+     * Called when running code reaches `input()` and needs a line of input.
+     * The execution is blocked until the host calls `provideInput(text)` with
+     * the user's response. Requires cross-origin isolation (see `canInput`);
+     * without it, `input()` errors instead of calling this.
+     */
+    onInputRequest?: (prompt: string) => void;
     /** A uihtml component was created/updated (Data JSON-encoded + markup). */
     onUihtml?: (compId: string, dataJson: string, html: string) => void;
     /** Script -> host events (MATLAB `sendEventToHTMLSource`). */
@@ -57,6 +64,33 @@ export interface NumblSession {
      * the callback returns; rejects if it errors (the session stays usable).
      */
     dispatchHtmlEvent(compId: string, name: string, data: unknown): Promise<void>;
+    /**
+     * Cooperatively interrupt the currently running `execute` (or boot script):
+     * sets a shared cancel flag the worker polls at loop iterations and function
+     * calls, so it throws and the pending `execute` resolves with
+     * `aborted: true`. The worker and the persistent workspace survive — only
+     * the running command is abandoned. No-op when `canInterrupt` is false.
+     */
+    interrupt(): void;
+    /**
+     * Whether `interrupt()` can actually stop a run. True only when the page is
+     * cross-origin isolated (SharedArrayBuffer available). When false, a runaway
+     * run can only be stopped by disposing the session.
+     */
+    readonly canInterrupt: boolean;
+    /**
+     * Supply the line of input that a pending `onInputRequest` is waiting for.
+     * Unblocks the `input()` call in the running code, which resumes with this
+     * text. Call exactly once per `onInputRequest`. No-op when `canInput` is
+     * false or nothing is waiting.
+     */
+    provideInput(text: string): void;
+    /**
+     * Whether `input()` (stdin) works — true only when the page is cross-origin
+     * isolated. When false, `input()` in executed code throws instead of
+     * calling `onInputRequest`.
+     */
+    readonly canInput: boolean;
     /** Terminate the worker. The session is unusable afterwards. */
     dispose(): void;
 }