@tlockney/cdp-kernel 0.7.1 → 0.8.0

package/dist/browser/target.d.ts

@@ -58,9 +58,11 @@ export declare class BrowserTarget implements KernelTarget {
     evaluate(script: string): Promise<EvaluateResult>;
     /**
      * A cell that's waiting on something leaves the Worker free: it answers a
-     * ping, and the cell is abandoned with its state intact. A busy cell
-     * can't be reached, so the Worker is terminated, and a new one starts on
-     * the next cell.
+     * ping, and the cell is abandoned with its state intact; host requests
+     * in flight are cancelled on the page, and reject in the Worker with an
+     * AbortError (#388), and jupyter.signal is aborted (#418). A busy cell
+     * can't be reached, so the Worker is
+     * terminated, and a new one starts on the next cell.
      */
     interrupt(): Promise<void>;
     /** Output arrives before the reply it precedes. */

package/dist/browser/target.js

@@ -27,7 +27,10 @@ export class BrowserTarget {
     #hostCalls = new Map();
     #host;
     #nextId = 0;
-    #interrupted = false;
+    /** Counts interrupt() calls: a call that saw one start during it was interrupted (#417). */
+    #interrupts = 0;
+    /** Cells running: a comm handler that starts with none gets its own jupyter.signal (#421). */
+    #cells = 0;
     #stopNote;
     #exited = false;
     constructor(worker, events, host) {
@@ -107,6 +110,15 @@ export class BrowserTarget {
             resolve(host({ method: String(msg.method), params: msg.params }, controller.signal));
         }).then((result) => answer({ result }), (err) => answer({ error: describeHostError(err) }));
     }
+    /** Aborts each host request in flight and rejects it in the Worker. */
+    #cancelHostCalls() {
+        const calls = [...this.#hostCalls];
+        this.#hostCalls.clear();
+        for (const [id, controller] of calls) {
+            controller.abort();
+            this.#worker.postMessage({ op: "host", id, error: { name: "AbortError", message: "interrupted" } });
+        }
+    }
     /** Sends `host.onEvent` listeners in the Worker an event (#384). */
     notifyHost(event, value) {
         if (!this.#exited)
@@ -139,27 +151,37 @@ export class BrowserTarget {
         });
     }
     async #interruptibly(op, params, what) {
-        this.#interrupted = false;
+        const interrupts = this.#interrupts;
         try {
             return await this.#request(op, params, true);
         }
         catch (err) {
-            if (err instanceof Abandoned || this.#interrupted)
+            if (err instanceof Abandoned || this.#interrupts !== interrupts)
                 throw new Interrupted(`${what} interrupted`);
             throw err;
         }
     }
     async evaluate(script) {
-        return asEvaluateResult(await this.#interruptibly("eval", { code: script }, "Execution"));
+        this.#cells++;
+        try {
+            return asEvaluateResult(await this.#interruptibly("eval", { code: script }, "Execution"));
+        }
+        finally {
+            this.#cells--;
+        }
     }
     /**
      * A cell that's waiting on something leaves the Worker free: it answers a
-     * ping, and the cell is abandoned with its state intact. A busy cell
-     * can't be reached, so the Worker is terminated, and a new one starts on
-     * the next cell.
+     * ping, and the cell is abandoned with its state intact; host requests
+     * in flight are cancelled on the page, and reject in the Worker with an
+     * AbortError (#388), and jupyter.signal is aborted (#418). A busy cell
+     * can't be reached, so the Worker is
+     * terminated, and a new one starts on the next cell.
      */
     async interrupt() {
-        this.#interrupted = true;
+        this.#interrupts++;
+        // Before abandoning the cell's request, which ends the count.
+        const cellRunning = this.#cells > 0;
         const running = [...this.#interruptible];
         const answered = await Promise.race([
             this.#request("ping").then(() => true, () => false),
@@ -171,6 +193,11 @@ export class BrowserTarget {
                 this.#pending.delete(id);
                 this.#interruptible.delete(id);
             }
+            this.#cancelHostCalls();
+            // After the cell is abandoned, so its reply can't end it first
+            // (#418). Not awaited: requests are answered in order, and an abort
+            // listener that never returns mustn't hold up the interrupt.
+            void this.#request("abort", { cell: cellRunning }).catch(() => { });
             return;
         }
         this.#stopNote = RESTART_NOTE;
@@ -186,7 +213,13 @@ export class BrowserTarget {
         await this.#request("broadcast", { count: executionCount, handle: result.objectId });
     }
     async dispatchComm(msgType, content, metadata, buffers) {
-        const reply = await this.#interruptibly("comm", { msgType, content, metadata, buffers: buffers.map(toBase64) }, "Comm handler");
+        const reply = await this.#interruptibly("comm", {
+            msgType,
+            content,
+            metadata,
+            buffers: buffers.map(toBase64),
+            ownSignal: this.#cells === 0,
+        }, "Comm handler");
         if (isRecord(reply.error)) {
             const { name, message, stack } = reply.error;
             return { error: { name: String(name), message: String(message), stack: String(stack) } };

package/dist/browser/worker.js

@@ -604,8 +604,35 @@ function createJupyter(host2) {
     return answer2 === "" ? defaultValue : answer2;
   }
   const comms = createComms((msgType, content, metadata, buffers) => host2.send(msgType, content, metadata, buffers));
+  let cell = new AbortController();
+  let current = cell;
+  const handlers = /* @__PURE__ */ new Map();
+  function startCell() {
+    current = cell = new AbortController();
+  }
+  function abortSignal(cellRunning = true) {
+    const reason = new DOMException("Execution interrupted", "AbortError");
+    if (cellRunning) cell.abort(reason);
+    for (const controller of handlers.keys()) controller.abort(reason);
+    handlers.clear();
+  }
+  async function commDispatch(msgType, content, metadata, buffers, ownSignal = false) {
+    const controller = ownSignal ? new AbortController() : cell;
+    if (ownSignal) current = controller;
+    handlers.set(controller, (handlers.get(controller) ?? 0) + 1);
+    try {
+      return await comms.dispatch(msgType, content, metadata, buffers);
+    } finally {
+      const left = (handlers.get(controller) ?? 0) - 1;
+      if (left > 0) handlers.set(controller, left);
+      else handlers.delete(controller);
+    }
+  }
   return {
     namespace: {
+      get signal() {
+        return current.signal;
+      },
       broadcast,
       display,
       format: format2,
@@ -621,7 +648,9 @@ function createJupyter(host2) {
     formatNow,
     confirm,
     prompt,
-    commDispatch: comms.dispatch
+    commDispatch,
+    startCell,
+    abortSignal
   };
 }
 
@@ -653,6 +682,7 @@ function createHandler(shim, evaluate = (code) => (0, eval)(code)) {
         return {};
       case "eval": {
         handles.clear();
+        shim.startCell?.();
         try {
           const box = await evaluate(request.code);
           return { result: box === void 0 ? { type: "undefined" } : remote(box[0]) };
@@ -671,7 +701,13 @@ function createHandler(shim, evaluate = (code) => (0, eval)(code)) {
         return { value: shim.describeError(take(request.handle)) };
       case "comm":
         try {
-          const handled = await shim.commDispatch(request.msgType, request.content, request.metadata, request.buffers);
+          const handled = await shim.commDispatch(
+            request.msgType,
+            request.content,
+            request.metadata,
+            request.buffers,
+            request.ownSignal === true
+          );
           return { handled: handled === true };
         } catch (err) {
           return { error: JSON.parse(shim.describeError(err)) };
@@ -693,6 +729,9 @@ function createHandler(shim, evaluate = (code) => (0, eval)(code)) {
         return { text: shim.inspectPath(request.path, request.detail ?? 0) };
       case "barrier":
         return { value: shim.barrier() };
+      case "abort":
+        shim.abortSignal?.(request.cell !== false);
+        return {};
       default:
         throw new Error(`unknown request ${JSON.stringify(request.op)}`);
     }
@@ -1034,9 +1073,13 @@ function install({ base, cdn: cdnBase }) {
     broadcastResult: jupyter.broadcastResult,
     // execute_request's user_expressions (#340).
     formatJson: async (value) => JSON.stringify(await jupyter.namespace.format(value)),
-    async commDispatch(msgType, content, metadata, buffers64) {
+    // jupyter.signal (#418, #421): a new one as each cell starts; the host
+    // aborts the running ones on interrupt.
+    startCell: jupyter.startCell,
+    abortSignal: jupyter.abortSignal,
+    async commDispatch(msgType, content, metadata, buffers64, ownSignal) {
       const buffers = buffers64.map((b) => Uint8Array.from(atob(b), (c) => c.charCodeAt(0)));
-      return await jupyter.commDispatch(msgType, content, metadata, buffers);
+      return await jupyter.commDispatch(msgType, content, metadata, buffers, ownSignal);
     },
     describeError(value) {
       if (value instanceof Error) {