@basthon/kernel-base 0.64.6 → 0.70.1

package/lib/commons.d.ts

@@ -18,4 +18,12 @@ declare class NotImplementedError extends Error {
  *  - bypass the worker's opaque origin
  */
 declare const mockFetch: (legacy: boolean) => void;
-export { NotImplementedError, mockFetch };
+/**
+ * mock Worker to support sandboxing and keep webpack compatibility
+ */
+declare const mockWorker: () => void;
+/**
+ * we mock '(new Image()).src' = to support local fs access
+ */
+declare const mockHTMLImageSrc: () => void;
+export { NotImplementedError, mockFetch, mockWorker, mockHTMLImageSrc };

package/lib/commons.js

@@ -7,18 +7,21 @@ class NotImplementedError extends Error {
         this.name = "NotImplementedError";
     }
 }
+/**
+ * Convert an Uint8Array to a data URL.
+ */
+const toDataURL = async (content) => {
+    return await new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onloadend = () => {
+            resolve(reader.result);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(new Blob([content]));
+    });
+};
 /* fetch from local FS */
 const fetchFromLocalFS = async (localfsScheme, url) => {
-    const toDataURL = async (content) => {
-        return await new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onloadend = () => {
-                resolve(reader.result);
-            };
-            reader.onerror = reject;
-            reader.readAsDataURL(new Blob([content]));
-        });
-    };
     const prefix = localfsScheme;
     const path = url.slice(prefix.length);
     let content = null;
@@ -63,26 +66,34 @@ const mockFetch = (legacy) => {
     if (self.fetch.name === "mockedFetch")
         return;
     const trueFetch = self.fetch;
+    const assetsURL = self._assetsURL;
     async function mockedFetch(request, init) {
-        if (!legacy && (self.importScripts == null || self._assetsURL == null))
-            return Response.error();
         // force all params to init object
         if (request instanceof Request)
             init = { ...request, ...init };
-        // ensure credentials are not sent
-        if (!legacy)
-            init = { ...init, ...{ credentials: "omit" } };
         const url = request.url ?? request.toString();
         const localfsScheme = "filesystem:/";
+        // in legacy mode, only local FS is mocked
+        if (legacy) {
+            if (url.startsWith(localfsScheme))
+                return await fetchFromLocalFS(localfsScheme, url);
+            return await trueFetch(url, init);
+        }
+        // not a true worker? -> error
+        if (self.importScripts == null || assetsURL == null)
+            return Response.error();
+        // non-legacy mode (true isolated secure worker)
+        // ensure credentials are not sent
+        init = { ...init, ...{ credentials: "omit" } };
         try {
             // requests towards localfs
             if (url.startsWith(localfsScheme)) {
                 return await fetchFromLocalFS(localfsScheme, url);
             }
-            else if (!legacy && origin(url) === origin(self._assetsURL)) {
+            else if (origin(url) === origin(assetsURL)) {
                 // requests towards same origin
                 // only url under the assets folder are proxyied
-                if (parent(url).startsWith(self._assetsURL)) {
+                if (parent(url).startsWith(assetsURL)) {
                     const proxy = self._remoteProxy;
                     const { body, options } = await proxy.fetch(url, init);
                     return new Response(body, options);
@@ -98,4 +109,66 @@ const mockFetch = (legacy) => {
     }
     self.fetch = mockedFetch;
 };
-export { NotImplementedError, mockFetch };
+/**
+ * mock Worker to support sandboxing and keep webpack compatibility
+ */
+const mockWorker = () => {
+    // already mocked?
+    if (globalThis.Worker.name === "SandboxedWorker")
+        return;
+    class SandboxedWorker extends Worker {
+        constructor(url, options) {
+            if (options?.sandboxed === true) {
+                const absURL = new URL(url).href;
+                const assetsURL = absURL.substring(0, absURL.lastIndexOf("/"));
+                // worker created with a 'data' url scheme has opaque origin
+                // https://html.spec.whatwg.org/multipage/workers.html#script-settings-for-workers:concept-origin-opaque
+                const workerScript = `
+           self._assetsURL = "${assetsURL}";
+           globalThis = {importScripts: self.importScripts, location: "${url}"};
+           importScripts("${url}");
+           globalThis = self;
+        `.replace(/\s/g, "");
+                super(`data:text/javascript;base64,${btoa(workerScript)}`);
+            }
+            else {
+                super(url, options);
+            }
+        }
+    }
+    globalThis.Worker = SandboxedWorker;
+};
+/**
+ * we mock '(new Image()).src' = to support local fs access
+ */
+const mockHTMLImageSrc = () => {
+    // inside main thread?
+    if (globalThis?.HTMLImageElement == null)
+        return;
+    const desc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "src");
+    // already mocked?
+    if (desc?.set?.name === "mockedSrcSet")
+        return;
+    function mockedSrcSet(e) {
+        const prefix = "filesystem:/";
+        if (e.startsWith(prefix)) {
+            const path = e.slice(prefix.length);
+            (async () => {
+                //@ts-ignore
+                const content = (await globalThis.Basthon?.getFile?.(path))?.buffer;
+                desc?.set?.call(this, await toDataURL(content));
+            })();
+        }
+        else {
+            desc?.set?.call(this, e);
+        }
+    }
+    Object.defineProperty(HTMLImageElement.prototype, "src", {
+        ...desc,
+        get: function () {
+            return desc?.get?.call(this);
+        },
+        set: mockedSrcSet,
+    });
+};
+export { NotImplementedError, mockFetch, mockWorker, mockHTMLImageSrc };

package/lib/kernel.d.ts

@@ -49,15 +49,15 @@ export declare class KernelBase {
     evalAsync(code: string, outCallback: (_: string) => void, errCallback: (_: string) => void, data?: any): Promise<any>;
     putFile(filename: string, content: ArrayBuffer): Promise<void>;
     putModule(filename: string, content: ArrayBuffer): Promise<void>;
-    userModules(): string[];
+    userModules(): Promise<string[]>;
     /**
      * Get a file content from the VFS.
      */
-    getFile(path: string): Uint8Array;
+    getFile(path: string): Promise<Uint8Array>;
     /**
      * Get a user module file content.
      */
-    getUserModuleFile(filename: string): Uint8Array;
+    getUserModuleFile(filename: string): Promise<Uint8Array>;
     more(source: string): Promise<boolean>;
     complete(code: string): Promise<[string[], number] | []>;
     banner(): string;
@@ -100,9 +100,13 @@ export declare class KernelBase {
      * Promise that resolves when the kernel is ready (started).
      */
     ready(): Promise<void>;
+    /**
+     * Root path for assets files.
+     */
+    assetsURL(absolute?: boolean): string;
     /**
      * Root for kernel files. This is always the language directory
-     * inside the version number directory inside the kernel directory.
+     * inside the version number directory inside the assets directory.
      */
     basthonRoot(absolute?: boolean): string;
     /**
@@ -110,10 +114,6 @@ export declare class KernelBase {
      * (opening browser dialog).
      */
     download(data: Uint8Array | string, filename: string): void;
-    /**
-     * Dynamically load a script asynchronously.
-     */
-    static loadScript(url: string): Promise<any>;
     /**
      * Wrapper around document.dispatchEvent.
      * It adds the 'basthon.' prefix to each event name and

package/lib/kernel.js

@@ -1,27 +1,6 @@
 import { PromiseDelegate } from "promise-delegate";
 import { VERSION } from "./version";
 import { NotImplementedError } from "./commons";
-// const desc = Object.getOwnPropertyDescriptor(
-//   HTMLImageElement.prototype,
-//   "src"
-// );
-// Object.defineProperty(HTMLImageElement.prototype, "src", {
-//   ...desc,
-//   get: function () {
-//     return desc?.get?.call(this);
-//   },
-//   set: function (e) {
-//     const prefix = _localfsScheme;
-//     if (e.startsWith(prefix)) {
-//       const path = e.slice(prefix.length);
-//       //@ts-ignore
-//       const content = window.Basthon.getFile(path).buffer;
-//       (async () => desc?.set?.call(this, await toDataURL(content)))();
-//     } else {
-//       desc?.set?.call(this, e);
-//     }
-//   },
-// });
 /**
  * Event for Basthon's dispatch/listen.
  */
@@ -101,19 +80,19 @@ export class KernelBase {
     async putModule(filename, content) {
         this._modules.set(filename, content);
     }
-    userModules() {
+    async userModules() {
         return [];
     }
     /**
      * Get a file content from the VFS.
      */
-    getFile(path) {
+    async getFile(path) {
         throw new NotImplementedError("getFile");
     }
     /**
      * Get a user module file content.
      */
-    getUserModuleFile(filename) {
+    async getUserModuleFile(filename) {
         throw new NotImplementedError("getUserModuleFile");
     }
     async more(source) {
@@ -147,7 +126,7 @@ export class KernelBase {
         }
         catch (error) {
             this._ready.reject(error);
-            return;
+            throw error;
         }
         // connecting eval to basthon.eval.request event.
         this.addEventListener("eval.request", this.evalFromEvent.bind(this));
@@ -168,7 +147,7 @@ export class KernelBase {
         }
         catch (error) {
             this._ready.reject(error);
-            return;
+            throw error;
         }
         this._files.forEach((v, k) => this.putFile(k, v));
         this._modules.forEach((v, k) => this.putModule(k, v));
@@ -208,17 +187,23 @@ export class KernelBase {
         return this._ready.promise;
     }
     /**
-     * Root for kernel files. This is always the language directory
-     * inside the version number directory inside the kernel directory.
+     * Root path for assets files.
      */
-    basthonRoot(absolute = false) {
-        let url = this._rootPath + "/" + this.version() + "/" + this.language();
+    assetsURL(absolute = false) {
+        let url = this._rootPath;
         if (absolute && !url.startsWith("http")) {
             const base = window.location.origin + window.location.pathname;
             url = base.substring(0, base.lastIndexOf("/")) + "/" + url;
         }
         return url;
     }
+    /**
+     * Root for kernel files. This is always the language directory
+     * inside the version number directory inside the assets directory.
+     */
+    basthonRoot(absolute = false) {
+        return (this.assetsURL(absolute) + "/" + this.version() + "/" + this.language());
+    }
     /**
      * Downloading data (bytes array or data URL) as filename
      * (opening browser dialog).
@@ -237,18 +222,6 @@ export class KernelBase {
         anchor.click();
         document.body.removeChild(anchor);
     }
-    /**
-     * Dynamically load a script asynchronously.
-     */
-    static loadScript(url) {
-        return new Promise(function (resolve, reject) {
-            let script = document.createElement("script");
-            script.onload = resolve;
-            script.onerror = reject;
-            script.src = url;
-            document.head.appendChild(script);
-        });
-    }
     /**
      * Wrapper around document.dispatchEvent.
      * It adds the 'basthon.' prefix to each event name and

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.64.6";
+export declare const VERSION = "0.70.1";

package/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.64.6";
+export const VERSION = "0.70.1";

package/lib/worker/kernel-main.d.ts

@@ -4,13 +4,20 @@ import { KernelBase } from "../kernel";
 export declare class KernelMainBase<Type extends KernelWorkerBase> extends KernelBase {
     private _worker?;
     private _remote?;
-    private _legacy;
+    private readonly _legacy;
+    private postMessageToWorker?;
     private _sab?;
+    private _channelSyncer;
     constructor(options: any);
     /**
      * Is this a legacy worker? i.e. not runing in a worker.
      */
     isLegacy(): boolean;
+    /**
+     * Is synchrnous communication with worker available?
+     * (through SharedArrayBuffer atomic waits)
+     */
+    syncCommSupport(): boolean;
     /**
      * Is this kernel safe? (loaded in an isolated web worker)
      */

package/lib/worker/kernel-main.js

@@ -1,33 +1,19 @@
 import { wrap, createEndpoint, transfer } from "comlink";
-import { NotImplementedError } from "../commons";
+import { NotImplementedError, mockWorker, mockHTMLImageSrc } from "../commons";
 import { KernelBase } from "../kernel";
+import { PromiseDelegate } from "promise-delegate";
 // mock Worker to support sandboxing and keep webpack compatibility
-if (globalThis.Worker.name !== "SandboxedWorker") {
-    class SandboxedWorker extends Worker {
-        constructor(url, options) {
-            if (options?.sandboxed === true) {
-                const absURL = new URL(url).href;
-                const assetsURL = absURL.substring(0, absURL.lastIndexOf("/"));
-                // worker created with a 'data' url scheme has opaque origin
-                // https://html.spec.whatwg.org/multipage/workers.html#script-settings-for-workers:concept-origin-opaque
-                const workerScript = `self._assetsURL = "${assetsURL}";
-           globalThis = {importScripts: self.importScripts, location: "${url}"};
-           importScripts("${url}");
-           globalThis = self;`.replace(/\s/g, "");
-                super(`data:text/javascript;base64,${btoa(workerScript)}`);
-            }
-            else {
-                super(url, options);
-            }
-        }
-    }
-    globalThis.Worker = SandboxedWorker;
-}
+mockWorker();
+// mock HTMLImageElement.src to support localfs access
+mockHTMLImageSrc();
 export class KernelMainBase extends KernelBase {
     constructor(options) {
         super(options);
-        this._legacy = false;
+        // synchronise comlink and communication channels
+        this._channelSyncer = new PromiseDelegate();
         this._legacy = options?.legacy === true;
+        // synchronous wait on SAB cannot be used in a legacy context
+        // (atomic wait will block the main thread)
         if (!this.isLegacy() && globalThis.crossOriginIsolated)
             this._sab = new SharedArrayBuffer(1024);
     }
@@ -37,6 +23,13 @@ export class KernelMainBase extends KernelBase {
     isLegacy() {
         return this._legacy;
     }
+    /**
+     * Is synchrnous communication with worker available?
+     * (through SharedArrayBuffer atomic waits)
+     */
+    syncCommSupport() {
+        return this._sab != null;
+    }
     /**
      * Is this kernel safe? (loaded in an isolated web worker)
      */
@@ -64,6 +57,8 @@ export class KernelMainBase extends KernelBase {
             // running in main thread via message channel (fake worker)
             //@ts-ignore
             self._commPort = comlinkChannel.port1;
+            // this global variable will be removed by worker
+            self._assetsURL = this.assetsURL(true);
             await this.importLegacyWorker();
         }
         else {
@@ -79,9 +74,10 @@ export class KernelMainBase extends KernelBase {
         //@ts-ignore
         this._remote = await new KernelWorker(this._options);
         // setup the communication channel
-        const commChannel = new MessageChannel();
-        commChannel.port2.onmessage = (e) => this.processWorkerMessage(e.data);
-        await this.remote?.setCommPort(transfer(commChannel.port1, [commChannel.port1]));
+        const { port1, port2 } = new MessageChannel();
+        port2.onmessage = (e) => this.processWorkerMessage(e.data);
+        this.postMessageToWorker = port2.postMessage.bind(port2);
+        await this.remote?.setCommPort(transfer(port1, [port1]));
         // WARNING: without the setCommPort call, KernelWorker (proxy)
         // is garbage collected and comlink releases the proxy,
         // breaking all the communications... (don't know really why)
@@ -93,6 +89,11 @@ export class KernelMainBase extends KernelBase {
      */
     async _start() {
         await super._start();
+        // kernel restart in legacy mode is lazy, not a full restart
+        if (this.isLegacy() && this.remote != null) {
+            await this.remote?.legacyStart();
+            return;
+        }
         // setup the proxy worker
         const proxyWorker = new Worker(new URL("./comlink-proxy.js", import.meta.url), {
             type: "module",
@@ -100,7 +101,7 @@ export class KernelMainBase extends KernelBase {
         const proxy = wrap(proxyWorker);
         // setup the kernel worker
         await this.setupWorker();
-        if (this._sab != null) {
+        if (this.syncCommSupport()) {
             console.log("Using SharedArrayBuffer for synchronous worker communication.");
             await this._remote?.setSAB(this._sab);
         }
@@ -120,9 +121,14 @@ export class KernelMainBase extends KernelBase {
      * Stop the worker.
      */
     async _stop() {
-        this._worker?.terminate();
-        this._worker = undefined;
-        this._remote = undefined;
+        if (this.isLegacy()) {
+            await this.remote?.legacyStop();
+        }
+        else {
+            this._worker?.terminate();
+            this._worker = undefined;
+            this._remote = undefined;
+        }
         await super._stop();
     }
     /**
@@ -130,6 +136,10 @@ export class KernelMainBase extends KernelBase {
      */
     async processWorkerMessage(msg) {
         switch (msg.type) {
+            case "eval-end":
+                this._channelSyncer.resolve();
+                this._channelSyncer = new PromiseDelegate();
+                break;
             case "stream":
                 const { stream, text } = msg.content;
                 const dataEvent = this.clone(msg.data);
@@ -158,11 +168,25 @@ export class KernelMainBase extends KernelBase {
             case "input":
                 const { prompt, password, data } = msg.content;
                 const res = (await this.inputAsync(prompt, password, data));
-                if (this._sab == null)
-                    return;
-                const encodedRes = new TextEncoder().encode(res);
-                new Uint8Array(this._sab).set(encodedRes.subarray(0, this._sab.byteLength));
-                Atomics.notify(new Int32Array(this._sab), 0, 1);
+                if (msg.content.toplevel === true) {
+                    this.postMessageToWorker({
+                        type: "toplevel-input",
+                        content: res,
+                        data,
+                    });
+                }
+                else if (this.syncCommSupport()) {
+                    const encodedRes = new TextEncoder().encode(res);
+                    new Uint8Array(this._sab).set(encodedRes.subarray(0, this._sab.byteLength));
+                    Atomics.notify(new Int32Array(this._sab), 0, 1);
+                }
+                break;
+            case "breakpoint-move-on":
+                //@ts-ignore
+                const notebook = Jupyter?.notebook;
+                const msg_id = msg.content.data?.parent_msg?.header?.msg_id;
+                const index = notebook?.last_msg_id_to_cell_index?.(msg_id);
+                notebook?.next_breakpoint_cell?.(index);
                 break;
             default: // ignoring (probably a comlink message)
         }
@@ -171,8 +195,12 @@ export class KernelMainBase extends KernelBase {
         // force interactivity in all modes
         data.interactive = true;
         this._execution_count++;
+        // to be sure we do not miss communications
+        const syncChannels = this._channelSyncer.promise;
         // evaluation
         const execResult = (await this.remote?.eval(data, code));
+        // wait for all communications to end
+        await syncChannels;
         // return result
         let result;
         switch (execResult?.status) {

package/lib/worker/kernel-worker.d.ts

@@ -2,6 +2,7 @@ import { Remote } from "comlink";
 import { ProxyFetch } from "./proxy";
 declare global {
     interface DedicatedWorkerGlobalScope {
+        _assetsURL?: string;
         _remoteProxy: Remote<ProxyFetch>;
         basthon: KernelWorkerBase;
         _prompt: (p?: string, _d?: string) => string | null;
@@ -17,21 +18,50 @@ type ExecuteResult = {
 };
 declare class KernelWorkerBase {
     protected _options: any;
-    protected _legacy: boolean;
+    protected readonly _legacy: boolean;
+    private readonly _basthonRoot;
     private _ready;
     protected __eval_data__: any;
     protected postMessage?: InstanceType<typeof MessagePort>["postMessage"];
+    private _evalPromises;
     private _sab?;
     private _domNodeBus?;
+    private _toplevelInputPromise?;
     constructor(options?: any);
+    /**
+     * Language implemented in the kernel (string).
+     * Generally lower case.
+     */
+    language(): string;
     /**
      * Is this a legacy worker? i.e. not runing in a worker.
      */
     isLegacy(): boolean;
+    /**
+     * The basthon's root directory.
+     */
+    basthonRoot(): string;
+    /**
+     * Is synchronous communication with main thread available?
+     * (through SharedArrayBuffer atomic waits)
+     */
+    syncCommSupport(): boolean;
+    /**
+     * Special case of starting a legacy kernel.
+     */
+    legacyStart(): Promise<void>;
+    /**
+     * Special case of stoping a legacy kernel.
+     */
+    legacyStop(): Promise<void>;
     /**
      * Set SharedArrayBuffer from main thread.
      */
     setSAB(sab: SharedArrayBuffer): void;
+    /**
+     * Add a promise we should wait for during eval process.
+     */
+    protected addEvalPromise(promise: Promise<void>): void;
     protected _init(): Promise<void>;
     /**
      * Initialize the kernel. It is called by initWorker in KernelBase.
@@ -133,5 +163,22 @@ declare class KernelWorkerBase {
      * an eval.input event to the main thread and wait for the response.
      */
     input(prompt: string | null | undefined, password?: boolean): string;
+    /**
+     * Process messages from the main thread.
+     */
+    protected processMainThreadMessage(msg: {
+        data: any;
+        type: string;
+        content: any;
+    }): Promise<void>;
+    /**
+     * Ask for an input in the main thread and wait for the answer
+     * then return it.
+     */
+    toplevelInput(prompt: string | null | undefined, password?: boolean, data?: any): Promise<string>;
+    /**
+     * Ask main thread to go to the next breakpoint.
+     */
+    breakpointMoveOn(): void;
 }
 export { ExecuteResult, KernelWorkerBase };

package/lib/worker/kernel-worker.js

@@ -1,12 +1,15 @@
 import { PromiseDelegate } from "promise-delegate";
 import { NotImplementedError, mockFetch } from "../commons";
 import { wrap } from "comlink";
+import { VERSION } from "../version";
 import { DOMNodeBus } from "./worker-utils";
 class KernelWorkerBase {
     constructor(options) {
         this._ready = new PromiseDelegate();
+        this._evalPromises = []; // used to wait all promises emitted during computation
         this._options = options;
         this._legacy = options?.legacy === true;
+        this._basthonRoot = self._assetsURL + "/" + VERSION + "/" + this.language();
         /* we mock the fetch function to:
          *  - redirect queries to local FS
          *  - bypass the worker's opaque origin
@@ -36,6 +39,15 @@ class KernelWorkerBase {
         // (to transfer elements from worker to main thread, they are the same!)
         if (this.isLegacy())
             this._domNodeBus = new DOMNodeBus();
+        // not needed anymore
+        self._assetsURL = undefined;
+    }
+    /**
+     * Language implemented in the kernel (string).
+     * Generally lower case.
+     */
+    language() {
+        throw new NotImplementedError("language");
     }
     /**
      * Is this a legacy worker? i.e. not runing in a worker.
@@ -43,12 +55,43 @@ class KernelWorkerBase {
     isLegacy() {
         return this._legacy;
     }
+    /**
+     * The basthon's root directory.
+     */
+    basthonRoot() {
+        return this._basthonRoot;
+    }
+    /**
+     * Is synchronous communication with main thread available?
+     * (through SharedArrayBuffer atomic waits)
+     */
+    syncCommSupport() {
+        return this._sab != null;
+    }
+    /**
+     * Special case of starting a legacy kernel.
+     */
+    async legacyStart() {
+        throw new NotImplementedError("legacyStart");
+    }
+    /**
+     * Special case of stoping a legacy kernel.
+     */
+    async legacyStop() {
+        throw new NotImplementedError("legacyStop");
+    }
     /**
      * Set SharedArrayBuffer from main thread.
      */
     setSAB(sab) {
         this._sab = sab;
     }
+    /**
+     * Add a promise we should wait for during eval process.
+     */
+    addEvalPromise(promise) {
+        this._evalPromises.push(promise);
+    }
     /*
      * Initialize the kernel. Should be overloaded.
      */
@@ -61,8 +104,9 @@ class KernelWorkerBase {
             await this._init();
             this._ready.resolve();
         }
-        catch (e) {
-            this._ready.reject(e);
+        catch (error) {
+            this._ready.reject(error);
+            throw error;
         }
     }
     /**
@@ -76,6 +120,7 @@ class KernelWorkerBase {
      */
     setCommPort(port) {
         this.postMessage = port.postMessage.bind(port);
+        port.onmessage = (e) => this.processMainThreadMessage(e.data);
     }
     /**
      * Set the comlink communication port to proxy fetch.
@@ -137,9 +182,10 @@ class KernelWorkerBase {
         const data = this.clone(this.__eval_data__);
         if (globalThis.OffscreenCanvas != null &&
             element instanceof OffscreenCanvas) {
-            element
-                .convertToBlob()
-                .then((blob) => this.displayBlob(blob, data));
+            this.addEvalPromise((async () => {
+                const blob = await element.convertToBlob();
+                await this.displayBlob(blob, data);
+            })());
         }
         else {
             // in legacy mode, send HTML elements via DOM node bus
@@ -180,15 +226,17 @@ class KernelWorkerBase {
      * Evaluate a string of code. To be called by main thread (through comlink).
      */
     async eval(data, code) {
+        this._evalPromises = [];
         this.__eval_data__ = data;
+        let res;
         try {
             const result = await this._eval(data, code);
-            return { data, status: "ok", result };
+            res = { data, status: "ok", result };
         }
         catch (e) {
             const { name, stack, message } = e;
             this.sendStderrStream(data, e.toString());
-            return {
+            res = {
                 data,
                 status: "error",
                 error: {
@@ -198,6 +246,9 @@ class KernelWorkerBase {
                 },
             };
         }
+        this.postMessage?.({ type: "eval-end" }); // for channel syncing
+        await Promise.all(this._evalPromises);
+        return res;
     }
     /**
      * Put a file on the local (emulated) filesystem.
@@ -247,15 +298,15 @@ class KernelWorkerBase {
      */
     sleep(duration) {
         duration = duration * 1000; // to milliseconds
-        if (this._sab != null) {
+        if (this.syncCommSupport()) {
             // ensure value before waiting
             Atomics.store(new Int32Array(this._sab), 0, 0);
             Atomics.wait(new Int32Array(this._sab), 0, 0, duration);
             return;
         }
         else {
+            // default to active sleep
             const t0 = Date.now();
-            // active sleep
             while (Date.now() - t0 < duration)
                 ;
         }
@@ -288,7 +339,7 @@ class KernelWorkerBase {
      * an eval.input event to the main thread and wait for the response.
      */
     input(prompt, password = false) {
-        if (this._sab != null) {
+        if (this.syncCommSupport()) {
             const data = this.clone(this.__eval_data__);
             this.postMessage?.({
                 type: "input",
@@ -299,9 +350,47 @@ class KernelWorkerBase {
             Atomics.wait(new Int32Array(this._sab), 0, 0);
             return this.decodeSharedArrayBuffer(this._sab);
         }
-        else {
+        else if (self._prompt != null) {
+            // in legacy context, we default to js' prompt
             return self._prompt(prompt ?? "") ?? "";
         }
+        else {
+            // basthon's API not yet impelemented
+            throw new Error("Your browser does not support SharedArrayBuffer. Please try to update it.");
+        }
+    }
+    /**
+     * Process messages from the main thread.
+     */
+    async processMainThreadMessage(msg) {
+        switch (msg.type) {
+            case "toplevel-input":
+                this._toplevelInputPromise?.resolve(msg.content);
+                break;
+            default: // this should not append...
+                break;
+        }
+    }
+    /**
+     * Ask for an input in the main thread and wait for the answer
+     * then return it.
+     */
+    async toplevelInput(prompt, password = false, data = undefined) {
+        this._toplevelInputPromise = new PromiseDelegate();
+        this.postMessage?.({
+            type: "input",
+            content: { data, prompt, password, toplevel: true },
+        });
+        const res = await this._toplevelInputPromise.promise;
+        this._toplevelInputPromise = undefined;
+        return res;
+    }
+    /**
+     * Ask main thread to go to the next breakpoint.
+     */
+    breakpointMoveOn() {
+        const data = this.clone(this.__eval_data__);
+        this.postMessage?.({ type: "breakpoint-move-on", content: { data } });
     }
 }
 export { KernelWorkerBase };

package/lib/worker/worker-utils.d.ts

@@ -3,12 +3,12 @@ declare global {
         _commPort?: MessagePort;
     }
 }
-export declare const expose: (kwc: any) => void;
+declare const expose: (kwc: any) => void;
 /**
  * DOM node exchanger (Bus) to bypass stringifying
  * messages between frontend and kernel that prevents DOMNode sharing.
  */
-export declare class DOMNodeBus extends Map<number, any> {
+declare class DOMNodeBus extends Map<number, any> {
     /**
      * Push an object to the bus and get back an id to later pop it.
      */
@@ -18,3 +18,8 @@ export declare class DOMNodeBus extends Map<number, any> {
      */
     pop(id: number): any;
 }
+/**
+ * Dynamically load a script (support main thread and worker usage).
+ */
+declare const loadScript: (url: string) => Promise<void>;
+export { expose, DOMNodeBus, loadScript };

package/lib/worker/worker-utils.js

@@ -2,7 +2,7 @@ import { expose as exposeComlink } from "comlink";
 const insideWorker = () => 
 //@ts-ignore
 typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-export const expose = (kwc) => {
+const expose = (kwc) => {
     if (insideWorker()) {
         // worker
         const listener = (msg) => {
@@ -23,7 +23,7 @@ export const expose = (kwc) => {
  * DOM node exchanger (Bus) to bypass stringifying
  * messages between frontend and kernel that prevents DOMNode sharing.
  */
-export class DOMNodeBus extends Map {
+class DOMNodeBus extends Map {
     /**
      * Push an object to the bus and get back an id to later pop it.
      */
@@ -44,3 +44,19 @@ export class DOMNodeBus extends Map {
         return res;
     }
 }
+/**
+ * Dynamically load a script (support main thread and worker usage).
+ */
+const loadScript = async (url) => {
+    if (globalThis.importScripts != null)
+        return importScripts(url);
+    // we are probably in main thread
+    return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.onload = resolve;
+        script.onerror = reject;
+        script.src = url;
+        document.head.appendChild(script);
+    });
+};
+export { expose, DOMNodeBus, loadScript };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basthon/kernel-base",
-  "version": "0.64.6",
+  "version": "0.70.1",
   "description": "Basthon - Base Kernel",
   "homepage": "https://basthon.fr",
   "bugs": {
@@ -39,10 +39,10 @@
   },
   "devDependencies": {
     "json": "^11.0.0",
-    "typescript": "^5.4.5"
+    "typescript": "~5.4.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5f273b81e25ae3699ebf2b8c0a92040d3e4aa2c1"
+  "gitHead": "3c69c676f41da9ffbdabce398e62ac7a758a4582"
 }