kernel-checkpoint 0.1.7__tar.gz → 0.1.9__tar.gz

{kernel_checkpoint-0.1.7 → kernel_checkpoint-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernel_checkpoint
-Version: 0.1.7
+Version: 0.1.9
 Summary: An extension for saving and restoring kernel pod state with jupyter enterprise gateway
 Project-URL: Homepage, https://github.com/lehuannhatrang/kernel-checkpoint-extension.git
 Project-URL: Bug Tracker, https://github.com/lehuannhatrang/kernel-checkpoint-extension.git/issues

{kernel_checkpoint-0.1.7 → kernel_checkpoint-0.1.9}/jupyter-notebook-image/Dockerfile

@@ -4,6 +4,6 @@ USER root
 
 RUN pip install --upgrade pip
 
-RUN pip install --no-cache-dir kernel-checkpoint==0.1.6
+RUN pip install --no-cache-dir kernel-checkpoint==0.1.8
 
 USER jovyan

{kernel_checkpoint-0.1.7 → kernel_checkpoint-0.1.9}/kernel_checkpoint/_version.py

@@ -1,4 +1,4 @@
 # This file is auto-generated by Hatchling. As such, do not:
 #   - modify
 #   - track in version control e.g. be sure to add to .gitignore
-__version__ = VERSION = '0.1.7'
+__version__ = VERSION = '0.1.9'

{kernel_checkpoint-0.1.7 → kernel_checkpoint-0.1.9}/kernel_checkpoint/labextension/build_log.json

@@ -700,7 +700,7 @@
               "singleton": true
             },
             "kernel-checkpoint": {
-              "version": "0.1.6",
+              "version": "0.1.8",
               "singleton": true,
               "import": "/home/ubuntu/projects/kernel-checkpoint-extension/lib/index.js"
             }

{kernel_checkpoint-0.1.7 → kernel_checkpoint-0.1.9}/kernel_checkpoint/labextension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernel-checkpoint",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "An extension for saving and restoring kernel pod state with jupyter enterprise gateway",
   "keywords": [
     "jupyter",
@@ -114,7 +114,7 @@
     },
     "outputDir": "kernel_checkpoint/labextension",
     "_build": {
-      "load": "static/remoteEntry.900312eadd6aa5546ed7.js",
+      "load": "static/remoteEntry.e1cc534db6759a5ed255.js",
       "extension": "./extension",
       "style": "./style"
     }

kernel_checkpoint-0.1.7/kernel_checkpoint/labextension/static/lib_index_js.3571ff1d8cbf7ea37b2e.js → kernel_checkpoint-0.1.9/kernel_checkpoint/labextension/static/lib_index_js.b36bed60f63c982f956c.js

@@ -119,7 +119,7 @@ function formatDate(iso) {
     return new Date(iso).toLocaleString();
 }
 function CheckpointPanel(props) {
-    const { namespace, kernelId, kernelSpecName, notebookName, onRestore } = props;
+    const { namespace, kernelId, kernelSpecName, notebookName, sessionId, onRestore, onBeforeCreate } = props;
     const [checkpoints, setCheckpoints] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)([]);
     const [loading, setLoading] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(true);
     const [error, setError] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
@@ -170,6 +170,7 @@ function CheckpointPanel(props) {
         setCreating(true);
         setFlash(null);
         try {
+            const busyCells = onBeforeCreate ? onBeforeCreate() : [];
             await _api__WEBPACK_IMPORTED_MODULE_1__.CheckpointAPI.createCheckpoint({
                 name: newName.trim(),
                 namespace,
@@ -178,7 +179,9 @@ function CheckpointPanel(props) {
                 metadata: {
                     kernelId,
                     kernelName: kernelSpecName,
-                    notebookName
+                    notebookName,
+                    sessionId,
+                    busyCells
                 }
             });
             setNewName('');
@@ -236,7 +239,7 @@ function CheckpointPanel(props) {
         }
     };
     const handleRestore = async (checkpointName) => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         setConfirmRestore(null);
         setRestoring(checkpointName);
         setFlash(null);
@@ -250,7 +253,12 @@ function CheckpointPanel(props) {
             if (!cpKernelId) {
                 throw new Error('No kernel ID found in checkpoint metadata');
             }
-            await onRestore(checkpointName, checkpointFile.storagePath, checkpointFile.containerName, cpKernelId);
+            const cpSessionId = (_e = (_d = detail.metadata) === null || _d === void 0 ? void 0 : _d.sessionId) !== null && _e !== void 0 ? _e : '';
+            if (!cpSessionId) {
+                throw new Error('No session ID found in checkpoint metadata');
+            }
+            const busyCells = (_g = (_f = detail.metadata) === null || _f === void 0 ? void 0 : _f.busyCells) !== null && _g !== void 0 ? _g : [];
+            await onRestore(checkpointName, checkpointFile.storagePath, checkpointFile.containerName, cpKernelId, cpSessionId, busyCells);
             setFlash({
                 type: 'success',
                 text: `Kernel restored from "${checkpointName}". The kernel is restarting.`
@@ -259,7 +267,7 @@ function CheckpointPanel(props) {
         catch (err) {
             setFlash({
                 type: 'error',
-                text: (_d = err.message) !== null && _d !== void 0 ? _d : 'Failed to restore checkpoint'
+                text: (_h = err.message) !== null && _h !== void 0 ? _h : 'Failed to restore checkpoint'
             });
         }
         finally {
@@ -389,6 +397,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_4__);
 /* harmony import */ var _checkpoint_panel__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./checkpoint-panel */ "./lib/checkpoint-panel.js");
 /* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./api */ "./lib/api.js");
+/* harmony import */ var _restore_handler__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./restore-handler */ "./lib/restore-handler.js");
+
 
 
 
@@ -418,11 +428,34 @@ const plugin = {
     requires: [_jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__.INotebookTracker],
     activate: (app, notebookTracker) => {
         console.log('JupyterLab extension kernel-checkpoint is activated!');
+        // ── Per-notebook execution tracking ──────────────────────────────
+        //
+        // Each open notebook gets its own CellExecutionTracker that
+        // continuously records in-flight msg_id → execution_count pairs
+        // from the kernel's iopub channel.  At checkpoint time this map
+        // is consulted to capture the execution counts for busy cells.
+        const trackerMap = new Map();
+        function ensureTracker(panel) {
+            let cellTracker = trackerMap.get(panel.id);
+            if (!cellTracker) {
+                cellTracker = new _restore_handler__WEBPACK_IMPORTED_MODULE_7__.CellExecutionTracker();
+                trackerMap.set(panel.id, cellTracker);
+            }
+            return cellTracker;
+        }
+        function connectTrackerToKernel(panel) {
+            var _a;
+            const kernel = (_a = panel.sessionContext.session) === null || _a === void 0 ? void 0 : _a.kernel;
+            if (kernel) {
+                ensureTracker(panel).connectToKernel(kernel);
+            }
+        }
+        // ── Command ──────────────────────────────────────────────────────
         app.commands.addCommand(COMMAND_ID, {
             label: 'Saving Points',
             caption: 'Manage kernel checkpoints',
             execute: async () => {
-                var _a;
+                var _a, _b;
                 const panel = notebookTracker.currentWidget;
                 if (!panel) {
                     return;
@@ -461,7 +494,14 @@ const plugin = {
                 const kernelId = kernel.id;
                 const kernelSpecName = kernel.name || 'python_kubernetes';
                 const notebookName = panel.title.label || '';
-                const onRestore = async (checkpointName, checkpointFilePath, containerName, cpKernelId) => {
+                const sessionId = ((_b = sessionContext.session) === null || _b === void 0 ? void 0 : _b.id) || '';
+                // ── Restore callback ─────────────────────────────────────────
+                //
+                // Called by the CheckpointPanel when the user confirms a restore.
+                // Creates a new kernel seeded with the checkpoint environment
+                // variables, switches the notebook session to it, and then
+                // activates the RestoreHandler to catch orphaned iopub messages.
+                const onRestore = async (checkpointName, checkpointFilePath, containerName, cpKernelId, cpSessionId, busyCells) => {
                     const settings = _jupyterlab_services__WEBPACK_IMPORTED_MODULE_3__.ServerConnection.makeSettings();
                     const kernelUrl = _jupyterlab_coreutils__WEBPACK_IMPORTED_MODULE_2__.URLExt.join(settings.baseUrl, 'api', 'kernels');
                     const response = await _jupyterlab_services__WEBPACK_IMPORTED_MODULE_3__.ServerConnection.makeRequest(kernelUrl, {
@@ -473,7 +513,8 @@ const plugin = {
                                 KERNEL_CHECKPOINT_NAME: checkpointName,
                                 KERNEL_CHECKPOINT_FILE_PATH: checkpointFilePath,
                                 KERNEL_CHECKPOINT_CONTAINER_NAME: containerName,
-                                KERNEL_ID: cpKernelId
+                                KERNEL_ID: cpKernelId,
+                                KERNEL_SESSION_ID: cpSessionId
                             }
                         })
                     }, settings);
@@ -483,13 +524,38 @@ const plugin = {
                     }
                     const kernelData = await response.json();
                     await sessionContext.changeKernel({ id: kernelData.id });
+                    // ── Activate Catch-and-Render (Steps 3-6) ──────────────────
+                    //
+                    // The restored kernel is now connected.  If there were busy
+                    // cells at checkpoint time, spin up a RestoreHandler that
+                    // hooks iopub and intercepts orphaned messages.
+                    if (busyCells.length > 0) {
+                        console.log(`[kernel-checkpoint] Restore detected ${busyCells.length} ` +
+                            'busy cell(s). Activating RestoreHandler.');
+                        const handler = new _restore_handler__WEBPACK_IMPORTED_MODULE_7__.RestoreHandler();
+                        handler.hookRestoredKernel(panel, busyCells);
+                    }
                 };
+                // ── Dialog construction ──────────────────────────────────────
                 const body = new CheckpointDialogBody({
                     namespace: config.namespace,
                     kernelId,
                     kernelSpecName,
                     notebookName,
-                    onRestore
+                    sessionId,
+                    onRestore,
+                    onBeforeCreate: () => {
+                        const cellTracker = trackerMap.get(panel.id);
+                        if (!cellTracker) {
+                            return [];
+                        }
+                        const busyCells = (0,_restore_handler__WEBPACK_IMPORTED_MODULE_7__.scanBusyCells)(panel, cellTracker);
+                        if (busyCells.length > 0) {
+                            console.log(`[kernel-checkpoint] Scanned ${busyCells.length} busy cell(s) ` +
+                                'before checkpoint:', busyCells);
+                        }
+                        return busyCells;
+                    }
                 });
                 await (0,_jupyterlab_apputils__WEBPACK_IMPORTED_MODULE_1__.showDialog)({
                     title: 'Kernel Checkpoints',
@@ -499,8 +565,9 @@ const plugin = {
                 body.dispose();
             }
         });
-        // Inject a toolbar button into every notebook panel
+        // ── Notebook lifecycle wiring ────────────────────────────────────
         notebookTracker.widgetAdded.connect((_sender, panel) => {
+            // Toolbar button
             const button = new _jupyterlab_apputils__WEBPACK_IMPORTED_MODULE_1__.ToolbarButton({
                 label: 'Saving Points',
                 tooltip: 'Open kernel checkpoint manager',
@@ -509,13 +576,374 @@ const plugin = {
                 }
             });
             panel.toolbar.insertItem(10, 'kernel-checkpoint', button);
+            // Execution tracker setup — connect once the session is ready,
+            // and reconnect whenever the kernel is swapped.
+            panel.sessionContext.ready.then(() => {
+                connectTrackerToKernel(panel);
+            });
+            panel.sessionContext.kernelChanged.connect(() => {
+                connectTrackerToKernel(panel);
+            });
+            panel.disposed.connect(() => {
+                const cellTracker = trackerMap.get(panel.id);
+                if (cellTracker) {
+                    cellTracker.disconnectFromKernel();
+                    trackerMap.delete(panel.id);
+                }
+            });
         });
     }
 };
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (plugin);
 
 
+/***/ },
+
+/***/ "./lib/restore-handler.js"
+/*!********************************!*\
+  !*** ./lib/restore-handler.js ***!
+  \********************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   CellExecutionTracker: () => (/* binding */ CellExecutionTracker),
+/* harmony export */   RestoreHandler: () => (/* binding */ RestoreHandler),
+/* harmony export */   loadCheckpointCellMetadata: () => (/* binding */ loadCheckpointCellMetadata),
+/* harmony export */   saveCheckpointCellMetadata: () => (/* binding */ saveCheckpointCellMetadata),
+/* harmony export */   scanBusyCells: () => (/* binding */ scanBusyCells)
+/* harmony export */ });
+/**
+ * Safely extracts `msg_id` from a kernel message's `parent_header`.
+ * Returns undefined when the parent_header is empty (e.g. unsolicited
+ * kernel-status broadcasts at startup).
+ */
+function getParentMsgId(msg) {
+    const ph = msg.parent_header;
+    return ph && 'msg_id' in ph
+        ? ph.msg_id
+        : undefined;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Mock save / load helpers.
+// These demonstrate the checkpoint-metadata persistence contract.
+// Replace the bodies with real API calls (e.g. CheckpointAPI.updateCheckpoint)
+// when wiring to your backend.
+// ─────────────────────────────────────────────────────────────────────────────
+async function saveCheckpointCellMetadata(_checkpointName, _namespace, busyCells) {
+    console.log(`[RestoreHandler] Would persist ${busyCells.length} busy-cell record(s)`, busyCells);
+}
+async function loadCheckpointCellMetadata(_checkpointName, _namespace) {
+    console.log('[RestoreHandler] Would load busy-cell records from backend');
+    return [];
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// CellExecutionTracker
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Continuously monitors a kernel's iopub channel to maintain a live map of
+ * **in-flight** execute requests:  `msg_id → execution_count`.
+ *
+ * When the kernel broadcasts `execute_input`, the tracker records the
+ * execution count assigned by the kernel (this is the number that will
+ * eventually be shown as `[N]` in the cell prompt).  When `status: idle`
+ * arrives for that same `msg_id`, the entry is removed.
+ *
+ * The tracker must be connected to the kernel **before** any cells are
+ * executed so that the execution count is available at checkpoint time.
+ */
+class CellExecutionTracker {
+    constructor() {
+        this._pendingExecutions = new Map();
+        this._kernel = null;
+    }
+    get pendingExecutions() {
+        return this._pendingExecutions;
+    }
+    connectToKernel(kernel) {
+        this.disconnectFromKernel();
+        this._kernel = kernel;
+        kernel.iopubMessage.connect(this._onIopubMessage, this);
+    }
+    disconnectFromKernel() {
+        if (this._kernel) {
+            this._kernel.iopubMessage.disconnect(this._onIopubMessage, this);
+            this._kernel = null;
+        }
+        this._pendingExecutions.clear();
+    }
+    _onIopubMessage(_sender, msg) {
+        const parentMsgId = getParentMsgId(msg);
+        if (!parentMsgId) {
+            return;
+        }
+        if (msg.header.msg_type === 'execute_input') {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const execCount = msg.content.execution_count;
+            this._pendingExecutions.set(parentMsgId, execCount);
+        }
+        if (msg.header.msg_type === 'status' &&
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            msg.content.execution_state === 'idle') {
+            this._pendingExecutions.delete(parentMsgId);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// scanBusyCells  (Step 1 of the Catch-and-Render architecture)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Scans the active notebook for cells that are currently executing (`[*]`
+ * prompt) and extracts the `msg_id` of each in-flight execution request.
+ *
+ * ### How the msg_id is obtained
+ *
+ * When JupyterLab executes a cell it calls `kernel.requestExecute()` and
+ * stores the resulting `IShellFuture` on the cell's `OutputArea`:
+ *
+ *   `codeCell.outputArea.future = kernel.requestExecute({ code })`
+ *
+ * JupyterLab exposes `future` as a **write-only** setter on `OutputArea`.
+ * The underlying field is `OutputArea._future` (private).  We read it here
+ * because no public getter exists, and the `msg_id` it contains is the only
+ * reliable link between the cell widget and the kernel message stream.
+ *
+ * ### Why we also need the CellExecutionTracker
+ *
+ * The `_future.msg.header.msg_id` gives us the execute-request id, but not
+ * the **execution count** the kernel assigned (the `[N]` prompt number).
+ * During execution the cell's `model.executionCount` is `null` (that is
+ * what produces the `[*]` display).  The actual count was broadcast earlier
+ * in an `execute_input` iopub message which the `CellExecutionTracker`
+ * recorded.  We look it up here so that the restore phase can set the
+ * correct prompt after the cell finishes.
+ */
+function scanBusyCells(panel, tracker) {
+    var _a, _b, _c;
+    const records = [];
+    const cells = panel.content.widgets;
+    for (let i = 0; i < cells.length; i++) {
+        const cell = cells[i];
+        if (cell.model.type !== 'code') {
+            continue;
+        }
+        const codeCell = cell;
+        // `executionCount === null` is the canonical indicator for a busy cell
+        // (the prompt renders `[*]`).  Fresh cells also have `null`, so we
+        // additionally require an active future below.
+        if (codeCell.model.executionCount !== null) {
+            continue;
+        }
+        // Read the private `_future` field.  This is an `IShellFuture` whose
+        // `.msg.header.msg_id` is the id the kernel uses in `parent_header`
+        // for every message belonging to this execution.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const future = codeCell.outputArea._future;
+        if (!((_b = (_a = future === null || future === void 0 ? void 0 : future.msg) === null || _a === void 0 ? void 0 : _a.header) === null || _b === void 0 ? void 0 : _b.msg_id)) {
+            continue;
+        }
+        const msgId = future.msg.header.msg_id;
+        const executionCount = (_c = tracker.pendingExecutions.get(msgId)) !== null && _c !== void 0 ? _c : null;
+        records.push({
+            cellIndex: i,
+            cellId: cell.model.id,
+            msgId,
+            executionCount
+        });
+    }
+    return records;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// RestoreHandler  (Steps 3–6 of the Catch-and-Render architecture)
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Hooks into a **restored** kernel's iopub channel and intercepts "orphaned"
+ * messages whose `parent_header.msg_id` matches a cell that was busy at
+ * checkpoint time.
+ *
+ * For each intercepted message the handler manually injects the output into
+ * the cell's `OutputArea`, replicating what JupyterLab would normally do
+ * if the original execution future were still alive.
+ *
+ * ### Output injection mechanism
+ *
+ * `codeCell.outputArea.model` implements `IOutputAreaModel`.  Calling
+ * `.add(output)` with an `nbformat.IOutput`-shaped object triggers the
+ * following internal chain:
+ *
+ *  1. The model wraps the raw JSON in an `OutputModel` instance.
+ *  2. It appends the model to its internal list.
+ *     – For `stream` outputs with the same `name` (stdout / stderr) as the
+ *       preceding entry, the text is **merged** instead of creating a new
+ *       item.  This matches standard notebook behavior.
+ *  3. A Lumino `changed` signal fires.
+ *  4. The `OutputArea` widget reacts and creates the visual renderer
+ *     (e.g. `<pre>` for streams, a MIME renderer for display_data).
+ *
+ * Because all of this happens through the model's public API the rendered
+ * output is indistinguishable from one produced by the normal future-based
+ * routing.
+ */
+class RestoreHandler {
+    constructor() {
+        this._activeMsgIds = new Map();
+        this._panel = null;
+        this._kernel = null;
+    }
+    /**
+     * Begin intercepting orphaned messages for the given busy cells.
+     * Call immediately after `sessionContext.changeKernel()` resolves.
+     */
+    hookRestoredKernel(panel, busyCells) {
+        var _a;
+        if (busyCells.length === 0) {
+            return;
+        }
+        this.dispose();
+        this._panel = panel;
+        for (const record of busyCells) {
+            this._activeMsgIds.set(record.msgId, record);
+        }
+        // Re-apply the busy indicator ([*]) so the user sees the cells as
+        // still running while output continues to stream in.
+        for (const record of busyCells) {
+            const cell = this._findCell(panel, record);
+            if (cell) {
+                cell.model.executionCount = null;
+            }
+        }
+        const kernel = (_a = panel.sessionContext.session) === null || _a === void 0 ? void 0 : _a.kernel;
+        if (!kernel) {
+            console.warn('[RestoreHandler] No kernel on panel after changeKernel(); ' +
+                'cannot hook iopub. Orphaned outputs will be lost.');
+            return;
+        }
+        this._kernel = kernel;
+        kernel.iopubMessage.connect(this._onIopubMessage, this);
+        console.log(`[RestoreHandler] Hooked into restored kernel iopub. ` +
+            `Tracking ${busyCells.length} busy cell(s):`, busyCells.map(r => `cell[${r.cellIndex}] (${r.cellId}) → ${r.msgId}`));
+    }
+    dispose() {
+        if (this._kernel) {
+            this._kernel.iopubMessage.disconnect(this._onIopubMessage, this);
+            this._kernel = null;
+        }
+        this._activeMsgIds.clear();
+        this._panel = null;
+    }
+    /**
+     * Locate the CodeCell for a given record.  We first try the saved index
+     * (fast path) and verify by cell ID, then fall back to a linear scan.
+     * This handles the case where the user inserted or deleted cells between
+     * checkpoint and restore.
+     */
+    _findCell(panel, record) {
+        const cells = panel.content.widgets;
+        if (record.cellIndex < cells.length) {
+            const candidate = cells[record.cellIndex];
+            if (candidate.model.type === 'code' &&
+                candidate.model.id === record.cellId) {
+                return candidate;
+            }
+        }
+        for (let i = 0; i < cells.length; i++) {
+            const c = cells[i];
+            if (c.model.id === record.cellId && c.model.type === 'code') {
+                return c;
+            }
+        }
+        return null;
+    }
+    // ── iopub signal handler ──────────────────────────────────────────────
+    _onIopubMessage(_sender, msg) {
+        const parentMsgId = getParentMsgId(msg);
+        if (!parentMsgId) {
+            return;
+        }
+        const record = this._activeMsgIds.get(parentMsgId);
+        if (!record) {
+            // Not one of our tracked orphaned executions — let JupyterLab's
+            // normal future-based routing handle this message.
+            return;
+        }
+        if (!this._panel) {
+            return;
+        }
+        const codeCell = this._findCell(this._panel, record);
+        if (!codeCell) {
+            return;
+        }
+        const msgType = msg.header.msg_type;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const content = msg.content;
+        // ── Step 5: Inject output into the cell's OutputArea ────────────
+        //
+        // We construct an nbformat-compatible output object and pass it to
+        // `outputArea.model.add()`.  The model validates the shape, wraps it
+        // in an OutputModel, and emits a `changed` signal that causes the
+        // OutputArea widget to render the new entry.
+        switch (msgType) {
+            case 'stream':
+                codeCell.outputArea.model.add({
+                    output_type: 'stream',
+                    name: content.name,
+                    text: content.text
+                });
+                break;
+            case 'error':
+                codeCell.outputArea.model.add({
+                    output_type: 'error',
+                    ename: content.ename,
+                    evalue: content.evalue,
+                    traceback: content.traceback
+                });
+                break;
+            case 'execute_result':
+                codeCell.outputArea.model.add({
+                    output_type: 'execute_result',
+                    data: content.data,
+                    metadata: content.metadata,
+                    execution_count: content.execution_count
+                });
+                break;
+            case 'display_data':
+                codeCell.outputArea.model.add({
+                    output_type: 'display_data',
+                    data: content.data,
+                    metadata: content.metadata
+                });
+                break;
+            // ── Step 6: Lifecycle Cleanup ─────────────────────────────────
+            //
+            // A `status: idle` message with our tracked msg_id means the
+            // kernel finished executing this cell.  We:
+            //   a) Set the cell's execution count  →  prompt changes [*] → [N]
+            //   b) Remove the msg_id from the tracking map
+            //   c) Disconnect from iopub when no busy cells remain
+            case 'status':
+                if (content.execution_state === 'idle') {
+                    if (record.executionCount !== null) {
+                        codeCell.model.executionCount = record.executionCount;
+                    }
+                    this._activeMsgIds.delete(parentMsgId);
+                    console.log(`[RestoreHandler] Cell[${record.cellIndex}] execution ` +
+                        `complete (exec count: ${record.executionCount}). ` +
+                        `${this._activeMsgIds.size} cell(s) still pending.`);
+                    if (this._activeMsgIds.size === 0) {
+                        console.log('[RestoreHandler] All restored cells complete. ' +
+                            'Disconnecting iopub hook.');
+                        this.dispose();
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+
 /***/ }
 
 }]);
-//# sourceMappingURL=lib_index_js.3571ff1d8cbf7ea37b2e.js.map
+//# sourceMappingURL=lib_index_js.b36bed60f63c982f956c.js.map