jupyterpack 0.3.0 → 0.5.1

package/lib/pythonWidget/pythonWidgetModel.js

@@ -1,15 +1,31 @@
 import { PathExt } from '@jupyterlab/coreutils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { PYTHON_SERVER } from '../pythonServer';
+import { Signal } from '@lumino/signaling';
+import { CommBroadcastManager } from './comm';
+import { IS_LITE } from '../tools';
 export class PythonWidgetModel {
     constructor(options) {
+        var _a, _b;
+        this._commBroadcastManager = new CommBroadcastManager();
         this._isDisposed = false;
         this._kernelStarted = false;
+        this._serverReloaded = new Signal(this);
+        this._kernelStatusChanged = new Signal(this);
         this._context = options.context;
         this._manager = options.manager;
         this._connectionManager = options.connectionManager;
         this._contentsManager = options.contentsManager;
         this._jpackModel = options.jpackModel;
+        this._localPath = PathExt.dirname(this._context.localPath);
+        this._autoreload = Boolean((_b = (_a = this._jpackModel) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.autoreload);
+        this._contentsManager.fileChanged.connect(this._onFileChanged, this);
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
     }
     get isDisposed() {
         return this._isDisposed;
@@ -17,22 +33,33 @@ export class PythonWidgetModel {
     get connectionManager() {
         return this._connectionManager;
     }
+    get serverReloaded() {
+        return this._serverReloaded;
+    }
+    get kernelStatusChanged() {
+        return this._kernelStatusChanged;
+    }
+    async reload() {
+        var _a;
+        if (!this._kernelStarted) {
+            return;
+        }
+        const { spkContent, entryContent } = await this._loadData();
+        await ((_a = this._executor) === null || _a === void 0 ? void 0 : _a.reloadPythonServer({
+            entryPath: spkContent.entry,
+            initCode: entryContent.content
+        }));
+        this._serverReloaded.emit();
+    }
     async initialize() {
-        var _a, _b;
+        var _a;
         if (this._kernelStarted) {
             return {
                 success: false,
                 error: 'Server is called twice'
             };
         }
-        const filePath = this._context.localPath;
-        const spkContent = this._jpackModel;
-        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
-        const rootUrl = (_a = spkContent.rootUrl) !== null && _a !== void 0 ? _a : '/';
-        const entryContent = await this._contentsManager.get(entryPath, {
-            content: true,
-            format: 'text'
-        });
+        const { filePath, spkContent, rootUrl, entryContent } = await this._loadData();
         const sessionManager = this._manager.sessions;
         await sessionManager.ready;
         await this._manager.kernelspecs.ready;
@@ -55,7 +82,18 @@ export class PythonWidgetModel {
                 name: kernelName
             },
             type: 'notebook'
+        }, {
+            kernelConnectionOptions: { handleComms: true }
         });
+        const kernel = this._sessionConnection.kernel;
+        if (kernel) {
+            this._kernelStatusChanged.emit('started');
+            this._commBroadcastManager.registerKernel(kernel);
+            kernel.disposed.connect(() => {
+                this._kernelStatusChanged.emit('stopped');
+                this._commBroadcastManager.unregisterKernel(kernel.id);
+            });
+        }
         const framework = spkContent.framework;
         const ServerClass = PYTHON_SERVER.get(framework);
         if (!ServerClass) {
@@ -81,17 +119,43 @@ export class PythonWidgetModel {
                 finish.resolve();
             }
         };
-        (_b = this._sessionConnection.kernel) === null || _b === void 0 ? void 0 : _b.statusChanged.connect(cb);
+        (_a = this._sessionConnection.kernel) === null || _a === void 0 ? void 0 : _a.statusChanged.connect(cb);
         await finish.promise;
         this._kernelStarted = true;
         return { ...data, rootUrl, framework, success: true };
     }
-    dispose() {
-        var _a;
+    async dispose() {
+        var _a, _b, _c;
         if (this._isDisposed) {
             return;
         }
-        void ((_a = this._executor) === null || _a === void 0 ? void 0 : _a.disposePythonServer());
+        if (!IS_LITE) {
+            (_b = (_a = this._sessionConnection) === null || _a === void 0 ? void 0 : _a.kernel) === null || _b === void 0 ? void 0 : _b.shutdown();
+        }
+        void ((_c = this._executor) === null || _c === void 0 ? void 0 : _c.disposePythonServer());
+        this._contentsManager.fileChanged.disconnect(this._onFileChanged);
+        this._commBroadcastManager.dispose();
         this._isDisposed = true;
     }
+    async _loadData() {
+        var _a;
+        const filePath = this._context.localPath;
+        const spkContent = this._jpackModel;
+        const entryPath = PathExt.join(PathExt.dirname(filePath), spkContent.entry);
+        const rootUrl = (_a = spkContent.rootUrl) !== null && _a !== void 0 ? _a : '/';
+        const entryContent = await this._contentsManager.get(entryPath, {
+            content: true,
+            format: 'text'
+        });
+        return { filePath, spkContent, rootUrl, entryContent };
+    }
+    async _onFileChanged(sender, args) {
+        var _a;
+        if (this._autoreload && args.type === 'save') {
+            if (((_a = args.newValue) === null || _a === void 0 ? void 0 : _a.path) &&
+                args.newValue.path.startsWith(this._localPath)) {
+                await this.reload();
+            }
+        }
+    }
 }

package/lib/sandpackWidget/sandpackFilesModel.d.ts

@@ -1,19 +1,22 @@
 import { Contents } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
 import { IDict } from '../type';
-export declare class SandpackFilesModel {
+import { IDisposable } from '@lumino/disposable';
+export declare class SandpackFilesModel implements IDisposable {
     constructor(options: {
         contentsManager: Contents.IManager;
         path: string;
     });
-    getAllFiles(): Promise<IDict<{
+    getAllFiles(force?: boolean): Promise<IDict<{
         code: string;
     }>>;
+    get isDisposed(): boolean;
     get fileChanged(): ISignal<SandpackFilesModel, {
         allFiles: IDict<{
             code: string;
         }>;
     }>;
+    dispose(): void;
     flattenDirectory(dirContent: Contents.IModel): Promise<IDict<{
         code: string;
     }>>;
@@ -24,4 +27,5 @@ export declare class SandpackFilesModel {
     private _fileChanged;
     private _contentManager;
     private _allFiles?;
+    private _isDisposed;
 }

package/lib/sandpackWidget/sandpackFilesModel.js

@@ -3,12 +3,13 @@ import { removePrefix } from '../tools';
 export class SandpackFilesModel {
     constructor(options) {
         this._fileChanged = new Signal(this);
+        this._isDisposed = false;
         this._contentManager = options.contentsManager;
         this._path = options.path;
         this._contentManager.fileChanged.connect(this._onFileChanged, this);
     }
-    async getAllFiles() {
-        if (!this._allFiles) {
+    async getAllFiles(force = false) {
+        if (!this._allFiles || force) {
             const files = await this._contentManager.get(this._path, {
                 content: true
             });
@@ -16,9 +17,19 @@ export class SandpackFilesModel {
         }
         return this._allFiles;
     }
+    get isDisposed() {
+        return this._isDisposed;
+    }
     get fileChanged() {
         return this._fileChanged;
     }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._contentManager.fileChanged.disconnect(this._onFileChanged);
+    }
     async flattenDirectory(dirContent) {
         const flatDict = {};
         const content = dirContent.content;

package/lib/sandpackWidget/sandpackPanel.d.ts

@@ -2,15 +2,24 @@ import { SandpackClient } from '@codesandbox/sandpack-client';
 import { DocumentRegistry } from '@jupyterlab/docregistry';
 import { Contents } from '@jupyterlab/services';
 import { IFramePanel } from '../document/iframePanel';
+import { IJupyterPackFileFormat } from '../type';
 import { SandpackFilesModel } from './sandpackFilesModel';
 export declare class SandpackPanel extends IFramePanel {
     constructor(options: {
         context: DocumentRegistry.IContext<DocumentRegistry.IModel>;
         contentsManager: Contents.IManager;
     });
-    init(localPath: string): Promise<void>;
+    dispose(): void;
+    get isReady(): Promise<void>;
+    get autoreload(): boolean;
+    set autoreload(val: boolean);
+    init(localPath: string, jpackModel: IJupyterPackFileFormat): Promise<void>;
     connectSignals(filesModel: SandpackFilesModel, sandpackClient: SandpackClient): Promise<void>;
+    reload(): Promise<void>;
     private _onFileChanged;
     private _spClient?;
     private _contentsManager;
+    private _fileModel;
+    private _autoreload;
+    private _isReady;
 }

package/lib/sandpackWidget/sandpackPanel.js

@@ -1,20 +1,46 @@
 import { loadSandpackClient } from '@codesandbox/sandpack-client';
 import { IFramePanel } from '../document/iframePanel';
 import { SandpackFilesModel } from './sandpackFilesModel';
+import { PromiseDelegate } from '@lumino/coreutils';
 export class SandpackPanel extends IFramePanel {
     constructor(options) {
         super();
+        this._autoreload = false;
+        this._isReady = new PromiseDelegate();
         this._contentsManager = options.contentsManager;
+        const { context } = options;
         options.context.ready.then(async () => {
-            await this.init(options.context.localPath);
+            const jpackModel = context.model.toJSON();
+            await this.init(context.localPath, jpackModel);
         });
     }
-    async init(localPath) {
+    dispose() {
+        var _a, _b, _c;
+        (_a = this._fileModel) === null || _a === void 0 ? void 0 : _a.fileChanged.disconnect(this._onFileChanged);
+        (_b = this._fileModel) === null || _b === void 0 ? void 0 : _b.dispose();
+        (_c = this._spClient) === null || _c === void 0 ? void 0 : _c.destroy();
+        super.dispose();
+    }
+    get isReady() {
+        return this._isReady.promise;
+    }
+    get autoreload() {
+        return this._autoreload;
+    }
+    set autoreload(val) {
+        this._autoreload = val;
+    }
+    async init(localPath, jpackModel) {
+        var _a;
+        if (((_a = jpackModel === null || jpackModel === void 0 ? void 0 : jpackModel.metadata) === null || _a === void 0 ? void 0 : _a.autoreload) === true) {
+            this._autoreload = true;
+        }
         const currentDir = localPath.split('/').slice(0, -1).join('/');
         const filesModel = new SandpackFilesModel({
             contentsManager: this._contentsManager,
             path: currentDir
         });
+        this._fileModel = filesModel;
         const allFiles = await filesModel.getAllFiles();
         const options = {
             showLoadingScreen: true,
@@ -24,6 +50,7 @@ export class SandpackPanel extends IFramePanel {
             files: allFiles
         }, options);
         await this.connectSignals(filesModel, this._spClient);
+        this._isReady.resolve();
     }
     async connectSignals(filesModel, sandpackClient) {
         filesModel.fileChanged.connect(this._onFileChanged, this);
@@ -42,8 +69,16 @@ export class SandpackPanel extends IFramePanel {
             }
         });
     }
+    async reload() {
+        if (this._spClient && this._fileModel) {
+            const allFiles = await this._fileModel.getAllFiles();
+            this._spClient.updateSandbox({
+                files: allFiles
+            });
+        }
+    }
     _onFileChanged(sender, { allFiles }) {
-        if (this._spClient) {
+        if (this._autoreload && this._spClient) {
             this._spClient.updateSandbox({
                 files: allFiles
             });

package/lib/swConnection/mainConnectionManager.d.ts

@@ -1,4 +1,4 @@
-import { IConnectionManager, IDict, IKernelExecutor } from '../type';
+import { IBasePythonServer, IConnectionManager, IDict } from '../type';
 /**
  * Manages connections between clients and kernel executors.
  * This class handles the registration of kernel executors and the generation of responses
@@ -10,7 +10,7 @@ import { IConnectionManager, IDict, IKernelExecutor } from '../type';
 export declare class ConnectionManager implements IConnectionManager {
     instanceId: string;
     constructor(instanceId: string);
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
+    registerConnection(pythonServer: IBasePythonServer): Promise<{
         instanceId: string;
         kernelClientId: string;
     }>;
@@ -23,6 +23,6 @@ export declare class ConnectionManager implements IConnectionManager {
         params?: string;
     }): Promise<IDict | null>;
     private _initWsChannel;
-    private _kernelExecutors;
-    private _wsBroadcastChannel;
+    private _pythonServers;
+    private _wsBroadcastChannelMap;
 }

package/lib/swConnection/mainConnectionManager.js

@@ -1,4 +1,4 @@
-import { arrayBufferToBase64 } from '../tools';
+import { arrayBufferToBase64, stringToBase64 } from '../tools';
 import { UUID } from '@lumino/coreutils';
 /**
  * Manages connections between clients and kernel executors.
@@ -11,18 +11,20 @@ import { UUID } from '@lumino/coreutils';
 export class ConnectionManager {
     constructor(instanceId) {
         this.instanceId = instanceId;
-        this._kernelExecutors = new Map();
-        this._wsBroadcastChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
-        this._initWsChannel();
+        this._pythonServers = new Map();
+        this._wsBroadcastChannelMap = new Map();
     }
-    async registerConnection(kernelExecutor) {
+    async registerConnection(pythonServer) {
         const uuid = UUID.uuid4();
-        this._kernelExecutors.set(uuid, kernelExecutor);
+        this._pythonServers.set(uuid, pythonServer);
+        const wsbc = new BroadcastChannel(`/jupyterpack/ws/${this.instanceId}/${uuid}`);
+        this._initWsChannel(wsbc);
+        this._wsBroadcastChannelMap.set(`${this.instanceId}/${uuid}`, wsbc);
         return { instanceId: this.instanceId, kernelClientId: uuid };
     }
     async generateResponse(options) {
         const { urlPath, kernelClientId, method, params, requestBody, headers } = options;
-        const executor = this._kernelExecutors.get(kernelClientId);
+        const executor = this._pythonServers.get(kernelClientId);
         if (!executor) {
             return null;
         }
@@ -35,8 +37,8 @@ export class ConnectionManager {
         });
         return response;
     }
-    _initWsChannel() {
-        this._wsBroadcastChannel.onmessage = event => {
+    _initWsChannel(broadcastChannel) {
+        broadcastChannel.onmessage = event => {
             const rawData = event.data;
             let data;
             if (typeof rawData === 'string') {
@@ -46,9 +48,9 @@ export class ConnectionManager {
                 data = rawData;
             }
             const { action, dest, wsUrl, payload } = data;
-            const executor = this._kernelExecutors.get(dest);
+            const executor = this._pythonServers.get(dest);
             if (!executor) {
-                console.error('Missing kernel handle for message', data, dest, this._kernelExecutors);
+                console.error('Missing kernel handle for message', data, dest, this._pythonServers);
                 return;
             }
             switch (action) {
@@ -61,6 +63,14 @@ export class ConnectionManager {
                     });
                     break;
                 }
+                case 'close': {
+                    executor.closeWebsocket({
+                        instanceId: this.instanceId,
+                        kernelId: dest,
+                        wsUrl
+                    });
+                    break;
+                }
                 case 'send': {
                     let serializedData;
                     let isBinary;
@@ -70,7 +80,8 @@ export class ConnectionManager {
                         isBinary = true;
                     }
                     else if (typeof payload === 'string') {
-                        serializedData = payload;
+                        // convert string to base64 string to avoid encoding problem
+                        serializedData = stringToBase64(payload);
                         isBinary = false;
                     }
                     else {

package/lib/token.d.ts

@@ -1,3 +1,4 @@
 import { Token } from '@lumino/coreutils';
-import { IConnectionManager } from './type';
+import { IConnectionManager, IJupyterpackDocTracker } from './type';
 export declare const IConnectionManagerToken: Token<IConnectionManager>;
+export declare const IJupyterpackDocTrackerToken: Token<IJupyterpackDocTracker>;

package/lib/token.js

@@ -1,2 +1,3 @@
 import { Token } from '@lumino/coreutils';
 export const IConnectionManagerToken = new Token('jupyterpack:connection-manager');
+export const IJupyterpackDocTrackerToken = new Token('jupyterpack:dock-tracker');

package/lib/tools.d.ts

@@ -1,6 +1,12 @@
+import { LabIcon } from '@jupyterlab/ui-components';
+export declare const IS_LITE: boolean;
+export declare const logoIcon: LabIcon;
+export declare const autoReloadIcon: LabIcon;
+export declare const linkIcon: LabIcon;
 export declare function removePrefix(path: string, prefix: string): string;
 export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
 export declare function base64ToArrayBuffer(base64: string): Uint8Array;
 export declare function base64ToString(base64: string): string;
+export declare function stringToBase64(str: string): string;
 export declare function stringOrNone(content?: string): string;
 export declare function isBinaryContentType(contentType?: string): boolean;

package/lib/tools.js

@@ -1,3 +1,20 @@
+import logoStr from '../style/icons/box.svg';
+import autoReloadStr from '../style/icons/autoreload.svg';
+import linkStr from '../style/icons/externallink.svg';
+import { LabIcon } from '@jupyterlab/ui-components';
+export const IS_LITE = !!document.getElementById('jupyter-lite-main');
+export const logoIcon = new LabIcon({
+    name: 'jupyterpack:logo',
+    svgstr: logoStr
+});
+export const autoReloadIcon = new LabIcon({
+    name: 'jupyterpack:autoReload',
+    svgstr: autoReloadStr
+});
+export const linkIcon = new LabIcon({
+    name: 'jupyterpack:externalLink',
+    svgstr: linkStr
+});
 export function removePrefix(path, prefix) {
     if (path.startsWith(prefix)) {
         return path.slice(prefix.length);
@@ -27,6 +44,14 @@ export function base64ToString(base64) {
     const bytes = base64ToArrayBuffer(base64);
     return new TextDecoder('utf-8').decode(bytes);
 }
+export function stringToBase64(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+}
 export function stringOrNone(content) {
     return content ? `"${content}"` : 'None';
 }

package/lib/type.d.ts

@@ -1,5 +1,8 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
 import { KernelMessage } from '@jupyterlab/services';
 import { IDisposable } from '@lumino/disposable';
+import { IWidgetTracker } from '@jupyterlab/apputils';
+import { ISignal } from '@lumino/signaling';
 export interface IDict<T = any> {
     [key: string]: T;
 }
@@ -13,13 +16,17 @@ export declare enum JupyterPackFramework {
     REACT = "react",
     DASH = "dash",
     STREAMLIT = "streamlit",
-    TORNADO = "tornado"
+    TORNADO = "tornado",
+    SHINY = "shiny",
+    STARLETTE = "starlette"
 }
 export interface IJupyterPackFileFormat {
     entry: string;
     framework: JupyterPackFramework;
     name?: string;
-    metadata?: IDict;
+    metadata?: {
+        autoreload?: boolean;
+    };
     rootUrl?: string;
 }
 export declare enum MessageAction {
@@ -33,6 +40,9 @@ export interface IKernelExecutorParams {
     requestBody?: ArrayBuffer;
 }
 export interface IKernelExecutor extends IDisposable {
+    executeCode(code: KernelMessage.IExecuteRequestMsg['content'], waitForResult?: boolean): Promise<string | null>;
+}
+export interface IBasePythonServer extends IDisposable {
     getResponse(options: IKernelExecutorParams): Promise<IDict>;
     openWebsocket(options: {
         instanceId: string;
@@ -40,13 +50,17 @@ export interface IKernelExecutor extends IDisposable {
         wsUrl: string;
         protocol?: string;
     }): Promise<void>;
+    closeWebsocket(options: {
+        instanceId: string;
+        kernelId: string;
+        wsUrl: string;
+    }): Promise<void>;
     sendWebsocketMessage(options: {
         instanceId: string;
         kernelId: string;
         wsUrl: string;
         message: string;
     }): Promise<void>;
-    executeCode(code: KernelMessage.IExecuteRequestMsg['content'], waitForResult?: boolean): Promise<string | null>;
     init(options: {
         entryPath?: string;
         initCode?: string;
@@ -54,6 +68,10 @@ export interface IKernelExecutor extends IDisposable {
         kernelClientId: string;
     }): Promise<void>;
     disposePythonServer(): Promise<void>;
+    reloadPythonServer(options: {
+        entryPath?: string;
+        initCode?: string;
+    }): Promise<void>;
     getResponseFunctionFactory(options: {
         urlPath: string;
         method: string;
@@ -63,7 +81,7 @@ export interface IKernelExecutor extends IDisposable {
     }): string;
 }
 export interface IConnectionManager {
-    registerConnection(kernelExecutor: IKernelExecutor): Promise<{
+    registerConnection(kernelExecutor: IBasePythonServer): Promise<{
         instanceId: string;
         kernelClientId: string;
     }>;
@@ -71,3 +89,20 @@ export interface IConnectionManager {
         kernelClientId: string;
     } & IKernelExecutorParams): Promise<IDict | null>;
 }
+export type IJupyterpackDocTracker = IWidgetTracker<DocumentWidget>;
+export interface IPythonWidgetModel extends IDisposable {
+    connectionManager: IConnectionManager;
+    serverReloaded: ISignal<IPythonWidgetModel, void>;
+    kernelStatusChanged: ISignal<IPythonWidgetModel, 'started' | 'stopped'>;
+    reload(): Promise<void>;
+    initialize(): Promise<{
+        success: true;
+        instanceId: string;
+        kernelClientId: string;
+        rootUrl: string;
+        framework: JupyterPackFramework;
+    } | {
+        success: false;
+        error: string;
+    }>;
+}

package/lib/type.js

@@ -4,6 +4,8 @@ export var JupyterPackFramework;
     JupyterPackFramework["DASH"] = "dash";
     JupyterPackFramework["STREAMLIT"] = "streamlit";
     JupyterPackFramework["TORNADO"] = "tornado";
+    JupyterPackFramework["SHINY"] = "shiny";
+    JupyterPackFramework["STARLETTE"] = "starlette";
 })(JupyterPackFramework || (JupyterPackFramework = {}));
 export var MessageAction;
 (function (MessageAction) {

package/lib/websocket/websocket.js

@@ -36,7 +36,7 @@
         }
         return data;
     };
-    const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}`);
+    const bcWsChannel = new BroadcastChannel(`/jupyterpack/ws/${instanceId}/${kernelClientId}`);
     class BroadcastChannelWebSocket {
         constructor(url, protocols) {
             this.onclose = () => {
@@ -128,6 +128,10 @@
                 cb();
             }
             this._eventHandlers['close'] = [];
+            sendTypedMessage({
+                action: 'close',
+                wsUrl: this.url
+            });
             bcWsChannel.removeEventListener('message', this._bcMessageHandler);
             this.readyState = this.CLOSED;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "jupyterpack",
-    "version": "0.3.0",
+    "version": "0.5.1",
     "description": "A JupyterLab extension for serving web app.",
     "keywords": [
         "jupyter",
@@ -29,13 +29,12 @@
         "url": "https://github.com/trungleduc/jupyterpack.git"
     },
     "scripts": {
-        "build:demo": "cd demo && rm -rf .jupyterlite.doit.db _output && jupyter lite build .",
+        "build:demo": "node script/build-demo.mjs",
         "update:demo": "node script/update-demo.mjs",
-        "combine:python": "node script/combine-python.mjs",
         "build:worker": "webpack --config sw.webpack.config.js --mode development",
         "build:worker:prod": "webpack --config sw.webpack.config.js --mode production",
-        "build": "jlpm combine:python && jlpm build:lib && jlpm build:labextension:dev && jlpm build:worker",
-        "build:prod": "jlpm clean && jlpm combine:python && jlpm build:lib:prod && jlpm build:labextension && jlpm build:worker:prod",
+        "build": "jlpm build:lib && jlpm build:labextension:dev && jlpm build:worker",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension && jlpm build:worker:prod",
         "build:labextension": "jupyter labextension build .",
         "build:labextension:dev": "jupyter labextension build --development True .",
         "build:lib": "tsc --sourceMap",
@@ -80,7 +79,7 @@
         "eslint-plugin-prettier": "^5.0.0",
         "npm-run-all2": "^7.0.1",
         "prettier": "^3.0.0",
-        "rimraf": "^5.0.1",
+        "rimraf": "^6.1.0",
         "source-map-loader": "^1.0.2",
         "style-loader": "^3.3.1",
         "stylelint": "^15.10.1",
@@ -88,6 +87,7 @@
         "stylelint-config-standard": "^34.0.0",
         "stylelint-csstree-validator": "^3.0.0",
         "stylelint-prettier": "^4.0.0",
+        "tar": "^7.5.2",
         "ts-loader": "^9.2.6",
         "typescript": "~5.8.0",
         "webpack": "^5.76.3",