@basthon/kernel-base 0.62.20 → 0.62.22

package/lib/commons.d.ts

@@ -0,0 +1,21 @@
+import { Remote } from "comlink";
+import { ProxyFetch } from "./worker/proxy";
+declare global {
+    interface Window {
+        _remoteProxy: Remote<ProxyFetch>;
+        _assetsURL?: string;
+    }
+}
+/**
+ * An error thrown by not implemented API functions.
+ */
+declare class NotImplementedError extends Error {
+    constructor(funcName: string);
+}
+/**
+ * we mock the fetch function to:
+ *  - redirect queries to local FS
+ *  - bypass the worker's opaque origin
+ */
+declare const mockFetch: () => void;
+export { NotImplementedError, mockFetch };

package/lib/commons.js

@@ -0,0 +1,100 @@
+/**
+ * An error thrown by not implemented API functions.
+ */
+class NotImplementedError extends Error {
+    constructor(funcName) {
+        super(`Function ${funcName} not implemented!`);
+        this.name = "NotImplementedError";
+    }
+}
+/* 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;
+    const options = {
+        status: 200,
+        statusText: "OK",
+        headers: new Headers(),
+    };
+    try {
+        //@ts-ignore
+        content = self.Basthon.getFile(path);
+        const dataURL = await toDataURL(content);
+        const mime = dataURL.substring(dataURL.indexOf(":") + 1, dataURL.indexOf(";"));
+        content = content.buffer;
+        options.headers.append("Content-Type", mime);
+        options.headers.append("Content-Length", content.byteLength);
+    }
+    catch (e) {
+        options.status = 404;
+        options.statusText = "Not Found";
+    }
+    return new Response(content, options);
+};
+/**
+ * Get the origin of an url.
+ */
+const origin = (url) => new URL(url).origin;
+/**
+ * Get the parent path of an url.
+ */
+const parent = (url) => {
+    const abs = new URL(url).href;
+    return abs.substring(0, abs.lastIndexOf("/"));
+};
+/**
+ * we mock the fetch function to:
+ *  - redirect queries to local FS
+ *  - bypass the worker's opaque origin
+ */
+const mockFetch = () => {
+    // already mocked?
+    if (self.fetch.name === "mockedFetch")
+        return;
+    const trueFetch = self.fetch;
+    async function mockedFetch(request, init) {
+        if (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
+        init = { ...init, ...{ credentials: "omit" } };
+        const url = request.url ?? request.toString();
+        const localfsScheme = "filesystem:/";
+        try {
+            // requests towards localfs
+            if (url.startsWith(localfsScheme)) {
+                return await fetchFromLocalFS(localfsScheme, url);
+            }
+            else if (origin(url) === origin(self._assetsURL)) {
+                // requests towards same origin
+                // only url under the assets folder are proxyied
+                if (parent(url).startsWith(self._assetsURL)) {
+                    const proxy = self._remoteProxy;
+                    const { body, options } = await proxy.fetch(url, init);
+                    return new Response(body, options);
+                }
+                throw new Error("Ressource is outside the proxy' scope");
+            }
+            return await trueFetch(url, init);
+        }
+        catch (e) {
+            console.error(`security proxy: request to ${url} throw error: ${e.toString()}`);
+            return Response.error();
+        }
+    }
+    self.fetch = mockedFetch;
+};
+export { NotImplementedError, mockFetch };

package/lib/index.d.ts

@@ -1 +1 @@
-export * from './kernel';
+export * from "./kernel";

package/lib/index.js

@@ -1 +1 @@
-export * from './kernel';
+export * from "./kernel";

package/lib/kernel.d.ts

@@ -1,15 +1,26 @@
+import { PromiseDelegate } from "promise-delegate";
+import { VERSION } from "./version";
+export { VERSION };
 /**
  * API that any Basthon kernel should fill to be supported
  * in console/notebook.
  */
 export declare class KernelBase {
     private _rootPath;
+    private _isReady;
     private _ready;
-    private readonly _loaded;
+    private _stopped;
     protected _execution_count: number;
-    protected _pendingInput: boolean;
+    protected _pendingInput?: PromiseDelegate<string>;
     private _listeners;
+    protected _options: any;
+    protected _files: Map<string, ArrayBuffer>;
+    protected _modules: Map<string, ArrayBuffer>;
     constructor(options: any);
+    /**
+     * Is this kernel safe? (loaded from an isolated web worker)
+     */
+    safeKernel(): boolean;
     /**
      * Kernel version number (string).
      */
@@ -28,10 +39,6 @@ export declare class KernelBase {
      * Script (module) file extensions
      */
     moduleExts(): string[];
-    /**
-     * Launch the kernel.
-     */
-    launch(): Promise<void>;
     /**
      * Execution count getter.
      */
@@ -40,7 +47,6 @@ export declare class KernelBase {
      * Async code evaluation that resolves with the result.
      */
     evalAsync(code: string, outCallback: (_: string) => void, errCallback: (_: string) => void, data?: any): Promise<any>;
-    restart(): void;
     putFile(filename: string, content: ArrayBuffer): Promise<void>;
     putModule(filename: string, content: ArrayBuffer): Promise<void>;
     userModules(): string[];
@@ -52,23 +58,48 @@ export declare class KernelBase {
      * Get a user module file content.
      */
     getUserModuleFile(filename: string): Uint8Array;
-    more(source: string): boolean;
-    complete(code: string): [string[], number] | [];
+    more(source: string): Promise<boolean>;
+    complete(code: string): Promise<[string[], number] | []>;
     banner(): string;
     ps1(): string;
     ps2(): string;
     /**
-     * Initialize the kernel.
+     * Launch the kernel (used to wrap a promise around init).
+     */
+    protected _init(): Promise<void>;
+    /**
+     * Initialize the kernel and start it.
      */
     init(): Promise<void>;
+    /**
+     * Start the kernel (used to wrap a promise around start).
+     */
+    protected _start(): Promise<void>;
+    /**
+     * Start the kernel.
+     */
+    start(): Promise<void>;
+    /**
+     * Perform async part of the stoping process.
+     */
+    protected _stop(): Promise<void>;
+    /**
+     * Stop the kernel synchronously (to ensure kernel is stopped after the call).
+     */
+    stop(): void;
+    /**
+     * Restart the kernel (stop and start).
+     * Use await this.ready() to ensure kernel is started
+     */
+    restart(): void;
     /**
      * Is the kernel ready?
      */
-    get ready(): boolean;
+    get isReady(): boolean;
     /**
-     * Promise that resolve when the kernel is loaded.
+     * Promise that resolves when the kernel is ready (started).
      */
-    loaded(): Promise<void>;
+    ready(): Promise<void>;
     /**
      * Root for kernel files. This is always the language directory
      * inside the version number directory inside the kernel directory.
@@ -103,7 +134,11 @@ export declare class KernelBase {
     /**
      * Send eval.input event then wait for the user response and return it.
      */
-    inputAsync(prompt: string | null | undefined, password?: boolean, data?: any): Promise<unknown>;
+    inputAsync(prompt: string | null | undefined, password?: boolean, data?: any): Promise<string>;
+    /**
+     * Close a pending input.
+     */
+    resolvePendingInput(): void;
     /**
      * Simple clone via JSON copy.
      */

package/lib/kernel.js

@@ -1,83 +1,27 @@
 import { PromiseDelegate } from "promise-delegate";
 import { VERSION } from "./version";
-const _localfsScheme = "filesystem:/";
-/* we mock the fetch function to redirect queries to local FS */
-(function () {
-    var _a;
-    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]));
-        });
-    };
-    //@ts-ignore
-    window._fetch = (_a = window._fetch) !== null && _a !== void 0 ? _a : window.fetch;
-    window.fetch = async function (request, opts) {
-        var _a;
-        //@ts-ignore
-        const url = (_a = request.url) !== null && _a !== void 0 ? _a : request.toString();
-        const prefix = _localfsScheme;
-        if (url.startsWith(prefix)) {
-            const path = url.slice(prefix.length);
-            let content = null;
-            const options = {
-                status: 200,
-                statusText: "OK",
-                headers: new Headers(),
-            };
-            try {
-                //@ts-ignore
-                content = window.Basthon.getFile(path);
-                const dataURL = await toDataURL(content);
-                const mime = dataURL.substring(dataURL.indexOf(":") + 1, dataURL.indexOf(";"));
-                content = content.buffer;
-                options.headers.append("Content-Type", mime);
-                options.headers.append("Content-Length", content.byteLength);
-            }
-            catch (e) {
-                options.status = 404;
-                options.statusText = "Not Found";
-            }
-            return new Response(content, options);
-        }
-        //@ts-ignore
-        return await window._fetch(request, opts);
-    };
-    const desc = Object.getOwnPropertyDescriptor(HTMLImageElement.prototype, "src");
-    Object.defineProperty(HTMLImageElement.prototype, "src", {
-        ...desc,
-        get: function () {
-            var _a;
-            return (_a = desc === null || desc === void 0 ? void 0 : desc.get) === null || _a === void 0 ? void 0 : _a.call(this);
-        },
-        set: function (e) {
-            var _a;
-            const prefix = _localfsScheme;
-            if (e.startsWith(prefix)) {
-                const path = e.slice(prefix.length);
-                //@ts-ignore
-                const content = window.Basthon.getFile(path).buffer;
-                (async () => { var _a; return (_a = desc === null || desc === void 0 ? void 0 : desc.set) === null || _a === void 0 ? void 0 : _a.call(this, await toDataURL(content)); })();
-            }
-            else {
-                (_a = desc === null || desc === void 0 ? void 0 : desc.set) === null || _a === void 0 ? void 0 : _a.call(this, e);
-            }
-        },
-    });
-})();
-/**
- * An error thrown by not implemented API functions.
- */
-class NotImplementedError extends Error {
-    constructor(funcName) {
-        super(`Function ${funcName} not implemented!`);
-        this.name = "NotImplementedError";
-    }
-}
+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.
  */
@@ -87,20 +31,34 @@ class BasthonEvent extends Event {
         this.detail = data;
     }
 }
+export { VERSION };
 /**
  * API that any Basthon kernel should fill to be supported
  * in console/notebook.
  */
 export class KernelBase {
     constructor(options) {
-        this._ready = false;
-        this._loaded = new PromiseDelegate();
+        this._isReady = false;
+        this._ready = new PromiseDelegate();
+        this._stopped = Promise.resolve();
         this._execution_count = 0;
-        this._pendingInput = false;
+        this._pendingInput = undefined;
         // a map to register wrapped listeners to allow later remove
         this._listeners = new Map();
+        this._files = new Map();
+        this._modules = new Map();
+        this._options = this.clone(options);
         // root path where kernel is installed
         this._rootPath = options.rootPath;
+        if (!this.safeKernel())
+            console.warn(`%c⚠ DANGER ⚠: kernel ${this.language()} not safe!` +
+                " Please consider using a safe kernel.", "color: red; font-size: 20px;");
+    }
+    /**
+     * Is this kernel safe? (loaded from an isolated web worker)
+     */
+    safeKernel() {
+        return false;
     }
     /**
      * Kernel version number (string).
@@ -128,12 +86,6 @@ export class KernelBase {
     moduleExts() {
         throw new NotImplementedError("moduleExts");
     }
-    /**
-     * Launch the kernel.
-     */
-    async launch() {
-        throw new NotImplementedError("launch");
-    }
     /**
      * Execution count getter.
      */
@@ -146,14 +98,11 @@ export class KernelBase {
     evalAsync(code, outCallback, errCallback, data = null) {
         throw new NotImplementedError("evalAsync");
     }
-    restart() {
-        throw new NotImplementedError("restart");
-    }
     async putFile(filename, content) {
-        throw new NotImplementedError("putFile");
+        this._files.set(filename, content);
     }
     async putModule(filename, content) {
-        throw new NotImplementedError("putModule");
+        this._modules.set(filename, content);
     }
     userModules() {
         return [];
@@ -170,10 +119,10 @@ export class KernelBase {
     getUserModuleFile(filename) {
         throw new NotImplementedError("getUserModuleFile");
     }
-    more(source) {
+    async more(source) {
         throw new NotImplementedError("more");
     }
-    complete(code) {
+    async complete(code) {
         return [];
     }
     banner() {
@@ -186,32 +135,77 @@ export class KernelBase {
         return "... ";
     }
     /**
-     * Initialize the kernel.
+     * Launch the kernel (used to wrap a promise around init).
+     */
+    async _init() { }
+    /**
+     * Initialize the kernel and start it.
      */
     async init() {
         try {
-            await this.launch();
+            await this._init();
         }
         catch (error) {
-            this._loaded.reject(error);
+            this._ready.reject(error);
             return;
         }
         // connecting eval to basthon.eval.request event.
         this.addEventListener("eval.request", this.evalFromEvent.bind(this));
-        this._ready = true;
-        this._loaded.resolve();
+        await this.start();
+    }
+    /**
+     * Start the kernel (used to wrap a promise around start).
+     */
+    async _start() { }
+    /**
+     * Start the kernel.
+     */
+    async start() {
+        await this._stopped;
+        this._execution_count = 0;
+        try {
+            await this._start();
+        }
+        catch (error) {
+            this._ready.reject(error);
+            return;
+        }
+        this._files.forEach((v, k) => this.putFile(k, v));
+        this._modules.forEach((v, k) => this.putModule(k, v));
+        this._isReady = true;
+        this._ready.resolve();
+    }
+    /**
+     * Perform async part of the stoping process.
+     */
+    async _stop() { }
+    /**
+     * Stop the kernel synchronously (to ensure kernel is stopped after the call).
+     */
+    stop() {
+        this._isReady = false;
+        this._ready = new PromiseDelegate();
+        this._stopped = this._stop();
+    }
+    /**
+     * Restart the kernel (stop and start).
+     * Use await this.ready() to ensure kernel is started
+     */
+    restart() {
+        this.stop(); // sync
+        this.start(); // async
     }
     /**
      * Is the kernel ready?
      */
-    get ready() {
-        return this._ready;
+    get isReady() {
+        return this._isReady;
     }
     /**
-     * Promise that resolve when the kernel is loaded.
+     * Promise that resolves when the kernel is ready (started).
      */
-    async loaded() {
-        await this._loaded.promise;
+    async ready() {
+        return this._ready.promise;
     }
     /**
      * Root for kernel files. This is always the language directory
@@ -287,7 +281,7 @@ export class KernelBase {
     removeEventListener(eventName, callback) {
         // get the wrapped callback
         const listeners = this._listeners.get(eventName);
-        document.removeEventListener(`basthon.${eventName}`, listeners === null || listeners === void 0 ? void 0 : listeners.get(callback));
+        document.removeEventListener(`basthon.${eventName}`, listeners?.get(callback));
     }
     /**
      * Send eval.input event then wait for the user response and return it.
@@ -295,16 +289,21 @@ export class KernelBase {
     async inputAsync(prompt, password = false, data = undefined) {
         data = this.clone(data);
         data.content = { prompt, password };
-        const promise = new Promise(function (resolve, reject) {
-            data.resolve = resolve;
-            data.reject = reject;
-        });
-        this._pendingInput = true;
+        const pd = new PromiseDelegate();
+        data.resolve = pd.resolve.bind(pd);
+        data.reject = pd.reject.bind(pd);
+        this._pendingInput = pd;
         this.dispatchEvent("eval.input", data);
-        const res = await promise;
-        this._pendingInput = false;
+        const res = await pd.promise;
+        this._pendingInput = undefined;
         return res;
     }
+    /**
+     * Close a pending input.
+     */
+    resolvePendingInput() {
+        this._pendingInput?.resolve("");
+    }
     /**
      * Simple clone via JSON copy.
      */
@@ -317,8 +316,7 @@ export class KernelBase {
      * Detection is based on extension.
      */
     async putRessource(filename, content) {
-        var _a;
-        const ext = (_a = filename.split(".").pop()) !== null && _a !== void 0 ? _a : "";
+        const ext = filename.split(".").pop() ?? "";
         if (this.moduleExts().includes(ext)) {
             return await this.putModule(filename, content);
         }
@@ -330,7 +328,7 @@ export class KernelBase {
      * Is an input pending?
      */
     pendingInput() {
-        return this._pendingInput;
+        return this._pendingInput != null;
     }
     /**
      * Internal. Code evaluation after an eval.request event.

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.62.20";
+export declare const VERSION = "0.62.22";

package/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.62.20";
+export const VERSION = "0.62.22";

package/lib/worker/comlink-proxy.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/worker/comlink-proxy.js

@@ -0,0 +1,4 @@
+import { expose } from "comlink";
+import { ProxyFetch } from "./proxy";
+const proxy = new ProxyFetch();
+expose(proxy);

package/lib/worker/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./kernel-main";
+export * from "./kernel-worker";

package/lib/worker/index.js

@@ -0,0 +1,2 @@
+export * from "./kernel-main";
+export * from "./kernel-worker";

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

@@ -0,0 +1,60 @@
+import { Remote } from "comlink";
+import { KernelWorkerBase } from "./kernel-worker";
+import { KernelBase } from "../kernel";
+export declare class KernelMainBase<Type extends KernelWorkerBase> extends KernelBase {
+    private _worker?;
+    private _remote?;
+    constructor(options: any);
+    /**
+     * Is this kernel safe? (loaded in an isolated web worker)
+     */
+    safeKernel(): boolean;
+    /**
+     * Get a new worker (should be overloaded).
+     */
+    protected newWorker(): Worker;
+    /**
+     * Start the worker.
+     */
+    _start(): Promise<void>;
+    /**
+     * Comlink remote getter.
+     */
+    protected get remote(): Remote<Type> | undefined;
+    /**
+     * Stop the worker.
+     */
+    _stop(): Promise<void>;
+    /**
+     * Process messages from worker (if any).
+     */
+    protected processWorkerMessage(msg: {
+        data: any;
+        type: string;
+        content: any;
+    }): void;
+    evalAsync(code: string, outCallback: (_: string) => void, errCallback: (_: string) => void, data?: any): Promise<any>;
+    /**
+     * Put a file on the local (emulated) filesystem.
+     */
+    putFile(filename: string, content: ArrayBuffer): Promise<void>;
+    /**
+     * Put an importable module on the local (emulated) filesystem
+     * and load dependencies.
+     */
+    putModule(filename: string, content: ArrayBuffer): Promise<void>;
+    /**
+     * Complete a code at the end (usefull for tab completion).
+     *
+     * Returns an array of two elements: the list of completions
+     * and the start index.
+     */
+    complete(code: string): Promise<[string[], number] | []>;
+    /**
+     * Tell wether we should wait for more code or if it can
+     * be run as is.
+     *
+     * Useful to set ps1/ps2 in console prompt.
+     */
+    more(code: string): Promise<boolean>;
+}

package/lib/worker/kernel-main.js

@@ -0,0 +1,163 @@
+import { wrap, createEndpoint, transfer } from "comlink";
+import { NotImplementedError } from "../commons";
+import { KernelBase } from "../kernel";
+// mock Worker to support sandboxing and keep webpack compatibility
+if (globalThis.Worker.name !== "SandboxedWorker") {
+    class SandboxedWorker extends Worker {
+        constructor(url, options) {
+            if (options.sandboxed) {
+                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;
+}
+export class KernelMainBase extends KernelBase {
+    constructor(options) {
+        super(options);
+    }
+    /**
+     * Is this kernel safe? (loaded in an isolated web worker)
+     */
+    safeKernel() {
+        return true;
+    }
+    /**
+     * Get a new worker (should be overloaded).
+     */
+    newWorker() {
+        throw new NotImplementedError("newWorker");
+    }
+    /**
+     * Start the worker.
+     */
+    async _start() {
+        await super._start();
+        const worker = this.newWorker();
+        // setup the proxy worker
+        const proxyWorker = new Worker(new URL("./comlink-proxy.js", import.meta.url), {
+            type: "module",
+        });
+        const proxy = wrap(proxyWorker);
+        // setup the kernel worker
+        this._worker = worker;
+        worker.onmessage = (e) => this.processWorkerMessage(e.data);
+        const KernelWorker = wrap(worker);
+        // why typescript complains about this call? yet, this is advertised in
+        // https://github.com/GoogleChromeLabs/comlink/blob/dffe9050f63b1b39f30213adeb1dd4b9ed7d2594/docs/examples/03-classes-example/index.html#L15
+        //@ts-ignore
+        this._remote = await new KernelWorker(this._options);
+        // bind ports
+        const port = await proxy[createEndpoint]();
+        await this.remote?.setProxyPort(transfer(port, [port]));
+        // init remote
+        await this.remote?.init();
+    }
+    /**
+     * Comlink remote getter.
+     */
+    get remote() {
+        return this._remote;
+    }
+    /**
+     * Stop the worker.
+     */
+    async _stop() {
+        this._worker?.terminate();
+        this._worker = undefined;
+        this._remote = undefined;
+        await super._stop();
+    }
+    /**
+     * Process messages from worker (if any).
+     */
+    processWorkerMessage(msg) {
+        switch (msg.type) {
+            case "stream":
+                const { stream, text } = msg.content;
+                const dataEvent = this.clone(msg.data);
+                dataEvent.stream = stream;
+                dataEvent.content = text;
+                this.dispatchEvent("eval.output", dataEvent);
+                break;
+            case "download":
+                const { content, filename } = msg.content;
+                this.download(content, filename);
+                break;
+            case "display":
+                this.dispatchEvent("eval.display", msg.data);
+                break;
+            case "input":
+                const { prompt, password, data, sab } = msg.content;
+                (async () => {
+                    const res = (await this.inputAsync(prompt, password, data));
+                    const encodedRes = new TextEncoder().encode(res);
+                    new Uint8Array(sab).set(encodedRes.subarray(0, sab.byteLength));
+                    Atomics.notify(new Int32Array(sab), 0, 1);
+                })();
+                break;
+            default: // ignoring (probably a comlink message)
+        }
+    }
+    async evalAsync(code, outCallback, errCallback, data = null) {
+        // force interactivity in all modes
+        data.interactive = true;
+        this._execution_count++;
+        // evaluation
+        const execResult = (await this.remote?.eval(data, code));
+        // return result
+        let result;
+        switch (execResult?.status) {
+            case "ok":
+                result = execResult.result;
+                break;
+            case "error":
+                break;
+        }
+        return [result, this._execution_count];
+    }
+    /**
+     * Put a file on the local (emulated) filesystem.
+     */
+    async putFile(filename, content) {
+        await super.putFile(filename, content);
+        await this.remote?.putFile(filename, content);
+    }
+    /**
+     * Put an importable module on the local (emulated) filesystem
+     * and load dependencies.
+     */
+    async putModule(filename, content) {
+        await super.putModule(filename, content);
+        await this.remote?.putModule(filename, content);
+    }
+    /**
+     * Complete a code at the end (usefull for tab completion).
+     *
+     * Returns an array of two elements: the list of completions
+     * and the start index.
+     */
+    async complete(code) {
+        return (await this.remote?.complete(code)) ?? [];
+    }
+    /**
+     * Tell wether we should wait for more code or if it can
+     * be run as is.
+     *
+     * Useful to set ps1/ps2 in console prompt.
+     */
+    async more(code) {
+        return (await this.remote?.more(code)) ?? false;
+    }
+}

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

@@ -0,0 +1,109 @@
+import { Remote } from "comlink";
+import { ProxyFetch } from "./proxy";
+declare global {
+    interface DedicatedWorkerGlobalScope {
+        _remoteProxy: Remote<ProxyFetch>;
+        basthon: KernelWorkerBase;
+        _prompt: (p?: string, _d?: string) => string | null;
+    }
+}
+type ExecuteResult = {
+    data: any;
+    status: "ok" | "error";
+    result?: any;
+    error?: any;
+};
+declare class KernelWorkerBase {
+    private _ready;
+    protected __eval_data__: any;
+    constructor(options?: any);
+    protected _init(): Promise<void>;
+    /**
+     * Initialize the kernel. It is called by initWorker in KernelBase.
+     */
+    init(): Promise<void>;
+    /**
+     * Wait for the kernel to be ready.
+     */
+    ready(): Promise<void>;
+    /**
+     * Set the comlink communication port to proxy fetch.
+     */
+    setProxyPort(port: MessagePort): void;
+    /**
+     * Send stream to stdout/stderr.
+     */
+    private sendStream;
+    /**
+     * Send stream to stdout.
+     */
+    protected sendStdoutStream(data: any, text: string): void;
+    /**
+     * Send stream to stderr.
+     */
+    protected sendStderrStream(data: any, text: string): void;
+    protected blobToDataURL(blob: Blob): Promise<string>;
+    /**
+     * Display a blob (only png images are supported).
+     */
+    protected displayBlob(blob: Blob, data: any): Promise<void>;
+    /**
+     * Display an element like a canvas, ... in the frontend.
+     */
+    display(element: any): void;
+    /**
+     * Evaluate code and return an object with mime type keys and string value.
+     * To be overloaded.
+     */
+    protected _eval(data: any, code: string): Promise<undefined | {
+        [key: string]: string;
+    }>;
+    /**
+     * Evaluate a string of code. To be called by main thread (through comlink).
+     */
+    eval(data: any, code: string): Promise<ExecuteResult>;
+    /**
+     * Put a file on the local (emulated) filesystem.
+     */
+    putFile(filename: string, content: ArrayBuffer): void;
+    /**
+     * Put an importable module on the local (emulated) filesystem
+     * and load dependencies.
+     */
+    putModule(filename: string, content: ArrayBuffer): void;
+    /**
+     * Complete the submited code.
+     */
+    complete(code: string): Promise<[string[], number] | []>;
+    /**
+     * Tell wether we should wait for more code or if it can
+     * be run as is.
+     *
+     * Useful to set ps1/ps2 in console prompt.
+     */
+    more(code: string): Promise<boolean>;
+    /**
+     * Send a message to the main thread to download a file.
+     */
+    download(content: Uint8Array | string, filename: string): void;
+    /**
+     * Use JSON stringify/parse to copy an object.
+     */
+    protected clone(data: any): any;
+    /**
+     * Sync sleep for a certain duration in seconds.
+     */
+    sleep(duration: number): void;
+    /**
+     * Decode the string contained in a SharedArrayBuffer to
+     * bypas this issue:
+     * https://github.com/whatwg/encoding/issues/172
+     */
+    private decodeSharedArrayBuffer;
+    /**
+     * Sync input that does not use the ugly prompt but send
+     * an eval.input event tho the main thread and wait for the response.
+     */
+    input(prompt: string | null | undefined, password?: boolean): string;
+}
+export { ExecuteResult, KernelWorkerBase };

package/lib/worker/kernel-worker.js

@@ -0,0 +1,244 @@
+import { PromiseDelegate } from "promise-delegate";
+import { NotImplementedError, mockFetch } from "../commons";
+import { wrap } from "comlink";
+class KernelWorkerBase {
+    constructor(options) {
+        this._ready = new PromiseDelegate();
+        /* we mock the fetch function to:
+         *  - redirect queries to local FS
+         *  - bypass the worker's opaque origin
+         */
+        mockFetch();
+        // useful for ffi
+        self.basthon = this;
+        // global prompt redirected to our input
+        if (self._prompt == null)
+            self._prompt = globalThis.prompt;
+        globalThis.prompt = (prompt) => this.input(prompt);
+    }
+    /*
+     * Initialize the kernel. Should be overloaded.
+     */
+    async _init() { }
+    /**
+     * Initialize the kernel. It is called by initWorker in KernelBase.
+     */
+    async init() {
+        try {
+            await this._init();
+            this._ready.resolve();
+        }
+        catch (e) {
+            this._ready.reject(e);
+        }
+    }
+    /**
+     * Wait for the kernel to be ready.
+     */
+    ready() {
+        return this._ready.promise;
+    }
+    /**
+     * Set the comlink communication port to proxy fetch.
+     */
+    setProxyPort(port) {
+        self._remoteProxy = wrap(port);
+    }
+    /**
+     * Send stream to stdout/stderr.
+     */
+    sendStream(data, stream, text) {
+        globalThis.postMessage({
+            data,
+            type: "stream",
+            content: { stream, text },
+        });
+    }
+    /**
+     * Send stream to stdout.
+     */
+    sendStdoutStream(data, text) {
+        this.sendStream(data, "stdout", text);
+    }
+    /**
+     * Send stream to stderr.
+     */
+    sendStderrStream(data, text) {
+        this.sendStream(data, "stderr", text);
+    }
+    async blobToDataURL(blob) {
+        return await new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result);
+            reader.readAsDataURL(blob);
+        });
+    }
+    /**
+     * Display a blob (only png images are supported).
+     */
+    async displayBlob(blob, data) {
+        if (data == null)
+            data = this.clone(this.__eval_data__);
+        const dataURL = await this.blobToDataURL(blob);
+        const pngPrefix = "data:image/png;base64,";
+        if (dataURL.startsWith(pngPrefix)) {
+            const png = dataURL.slice(pngPrefix.length);
+            data["display_type"] = "multiple";
+            data["content"] = { "image/png": png };
+        }
+        else {
+            return;
+        }
+        globalThis.postMessage({ data, type: "display" });
+    }
+    /**
+     * Display an element like a canvas, ... in the frontend.
+     */
+    display(element) {
+        const data = this.clone(this.__eval_data__);
+        if (globalThis.OffscreenCanvas != null &&
+            element instanceof OffscreenCanvas) {
+            element
+                .convertToBlob()
+                .then((blob) => this.displayBlob(blob, data));
+        }
+        else {
+            data["display_type"] = "multiple";
+            data["content"] = element;
+            globalThis.postMessage({ data, type: "display" });
+        }
+    }
+    /**
+     * Evaluate code and return an object with mime type keys and string value.
+     * To be overloaded.
+     */
+    async _eval(data, code) {
+        throw new NotImplementedError("_eval");
+    }
+    /**
+     * Evaluate a string of code. To be called by main thread (through comlink).
+     */
+    async eval(data, code) {
+        this.__eval_data__ = data;
+        try {
+            const result = await this._eval(data, code);
+            return { data, status: "ok", result };
+        }
+        catch (e) {
+            const { name, stack, message } = e;
+            this.sendStderrStream(data, e.toString());
+            return {
+                data,
+                status: "error",
+                error: {
+                    name: name,
+                    value: message,
+                    traceback: stack?.toString(),
+                },
+            };
+        }
+    }
+    /**
+     * Put a file on the local (emulated) filesystem.
+     */
+    putFile(filename, content) {
+        throw new NotImplementedError("putFile");
+    }
+    /**
+     * Put an importable module on the local (emulated) filesystem
+     * and load dependencies.
+     */
+    putModule(filename, content) {
+        throw new NotImplementedError("putModule");
+    }
+    /**
+     * Complete the submited code.
+     */
+    async complete(code) {
+        return [];
+    }
+    /**
+     * Tell wether we should wait for more code or if it can
+     * be run as is.
+     *
+     * Useful to set ps1/ps2 in console prompt.
+     */
+    async more(code) {
+        throw new NotImplementedError("more");
+    }
+    /**
+     * Send a message to the main thread to download a file.
+     */
+    download(content, filename) {
+        globalThis.postMessage({
+            type: "download",
+            content: { content, filename },
+        });
+    }
+    /**
+     * Use JSON stringify/parse to copy an object.
+     */
+    clone(data) {
+        return JSON.parse(JSON.stringify(data));
+    }
+    /**
+     * Sync sleep for a certain duration in seconds.
+     */
+    sleep(duration) {
+        duration = duration * 1000; // to milliseconds
+        if (globalThis.crossOriginIsolated) {
+            const sab = new Int32Array(new SharedArrayBuffer(4));
+            Atomics.wait(sab, 0, 0, duration);
+            return;
+        }
+        else {
+            const t0 = Date.now();
+            // active sleep
+            while (Date.now() - t0 < duration)
+                ;
+        }
+    }
+    /**
+     * Decode the string contained in a SharedArrayBuffer to
+     * bypas this issue:
+     * https://github.com/whatwg/encoding/issues/172
+     */
+    decodeSharedArrayBuffer(sab) {
+        const array = new Uint8Array(sab);
+        let length = array.length;
+        for (; length > 0 && array[length - 1] === 0; length--)
+            ;
+        if (length === 0)
+            return "";
+        const cropped = new Uint8Array(length);
+        cropped.set(array.subarray(0, length));
+        try {
+            return new TextDecoder().decode(cropped);
+        }
+        catch (e) {
+            if (array.length === length)
+                throw new Error("String too long, can't decode");
+            throw e;
+        }
+    }
+    /**
+     * Sync input that does not use the ugly prompt but send
+     * an eval.input event tho the main thread and wait for the response.
+     */
+    input(prompt, password = false) {
+        if (globalThis.crossOriginIsolated) {
+            const data = this.clone(this.__eval_data__);
+            const sab = new SharedArrayBuffer(1024);
+            globalThis.postMessage({
+                type: "input",
+                content: { data, prompt, password, sab },
+            });
+            Atomics.wait(new Int32Array(sab), 0, 0);
+            return this.decodeSharedArrayBuffer(sab);
+        }
+        else {
+            return self._prompt(prompt ?? "") ?? "";
+        }
+    }
+}
+export { KernelWorkerBase };

package/lib/worker/proxy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A class for a proxy that allows a worker with opaque origin
+ * to fetch assets.
+ */
+export declare class ProxyFetch {
+    fetch(url: string, init: RequestInit | undefined): Promise<{
+        body: any;
+        options: any | undefined;
+    }>;
+}

package/lib/worker/proxy.js

@@ -0,0 +1,30 @@
+import { transfer } from "comlink";
+/**
+ * A class for a proxy that allows a worker with opaque origin
+ * to fetch assets.
+ */
+export class ProxyFetch {
+    async fetch(url, init) {
+        const parentURL = (s) => s.substring(0, s.lastIndexOf("/"));
+        const assetsURL = parentURL(new URL(globalThis.location.toString()).href);
+        const baseURL = parentURL(new URL(url).href);
+        if (!baseURL.startsWith(assetsURL))
+            throw new Error(`URL ${url} is outside of proxy' scope`);
+        // force credentials omition
+        if (init?.credentials !== "omit")
+            throw new Error("Request tries to use credentials");
+        const response = await globalThis.fetch(url, init);
+        const buffer = await response.arrayBuffer();
+        return {
+            body: transfer(buffer, [buffer]),
+            options: {
+                status: response.status,
+                statusText: response.statusText,
+                // wrong types for headers in worker...
+                // see https://github.com/microsoft/TypeScript/pull/15050/files#diff-1fe269c5fa7bcd3a57e9e6a91ce3566d3e3a5c38b21e6ff0d78ad0dd090f8d3aR24
+                // @ts-ignore
+                headers: new Map(response.headers), // Headers are not clonable
+            },
+        };
+    }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@basthon/kernel-base",
-  "version": "0.62.20",
+  "version": "0.62.22",
   "description": "Basthon - Base Kernel",
   "homepage": "https://basthon.fr",
   "bugs": {
-    "url": "https://framagit.org/basthon/basthon-kernel/issues"
+    "url": "https://forge.apps.education.fr/basthon/basthon-kernel/issues"
   },
   "repository": {
     "type": "git",
-    "url": "https://framagit.org/basthon/basthon-kernel.git"
+    "url": "https://forge.apps.education.fr/basthon/basthon-kernel.git"
   },
   "license": "GPL-3.0-or-later",
   "author": "Romain Casati",
@@ -20,21 +20,29 @@
   "files": [
     "lib"
   ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./worker": {
+      "types": "./lib/worker/index.d.ts",
+      "default": "./lib/worker/index.js"
+    }
+  },
   "scripts": {
-    "build": "gulp all",
-    "clean": "rm -rf lib/"
+    "build": "echo \"export const VERSION = \\\"$(json -f ../../lerna.json version)\\\";\" > src/version.ts && tsc",
+    "clean": "rm -rf lib/ src/version.ts"
   },
   "dependencies": {
     "promise-delegate": "^1.0.1"
   },
   "devDependencies": {
-    "gulp": "^4.0.2",
-    "gulp-typescript": "^6.0.0-alpha.1",
-    "typescript": "~4.4.4",
-    "vinyl-buffer": "^1.0.1"
+    "json": "^11.0.0",
+    "typescript": "^5.4.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fdaa2ed08c687a4b4e44f07ff28de1ad4cffeb38"
+  "gitHead": "1dd6225a7caf14cbee203687cac611495f5b18d4"
 }