fixes

Author: jtpio

README.md

@@ -34,7 +34,7 @@ pip uninstall jupyterlite-javascript-kernel
 The extension currently registers two JavaScript kernelspecs:
 
 - `JavaScript`:
-  Runs code in a sandboxed `iframe`. Use this when your code needs browser DOM APIs like `document`, `window`, or canvas access through the page context.
+  Runs code in a hidden runtime `iframe` on the main page thread. Use this when your code needs browser DOM APIs like `document`, `window`, or canvas access through the page context.
 - `JavaScript (Worker)`:
   Runs code in a dedicated Web Worker. Use this for stronger isolation and to avoid blocking the main UI thread.
 

packages/javascript-kernel-extension/src/index.ts

@@ -70,7 +70,6 @@ const kernelIFrame: JupyterFrontEndPlugin<void> = {
   autoStart: true,
   requires: [IKernelSpecs],
   activate: (app: JupyterFrontEnd, kernelspecs: IKernelSpecs) => {
-    void app;
     registerKernel(kernelspecs, {
       name: 'javascript',
       displayName: 'JavaScript',
@@ -87,7 +86,6 @@ const kernelWorker: JupyterFrontEndPlugin<void> = {
   autoStart: true,
   requires: [IKernelSpecs],
   activate: (app: JupyterFrontEnd, kernelspecs: IKernelSpecs) => {
-    void app;
     registerKernel(kernelspecs, {
       name: 'javascript-worker',
       displayName: 'JavaScript (Worker)',

packages/javascript-kernel/src/errors.ts

@@ -0,0 +1,55 @@
+// Copyright (c) Jupyter Development Team.
+// Distributed under the terms of the Modified BSD License.
+
+type ErrorLike = {
+  name?: unknown;
+  message?: unknown;
+  stack?: unknown;
+};
+
+/**
+ * Normalize unknown thrown values into Error instances.
+ *
+ * Supports cross-realm Error objects (for example iframe-thrown errors)
+ * by preserving their name/message/stack fields even when `instanceof Error`
+ * is false in the current realm.
+ */
+export function normalizeError(error: unknown, fallbackName = 'Error'): Error {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  if (isErrorLike(error)) {
+    const normalized = new Error(
+      typeof error.message === 'string' ? error.message : safeToString(error)
+    );
+    normalized.name =
+      typeof error.name === 'string' && error.name ? error.name : fallbackName;
+
+    if (typeof error.stack === 'string' && error.stack.length > 0) {
+      normalized.stack = error.stack;
+    }
+
+    return normalized;
+  }
+
+  const normalized = new Error(safeToString(error));
+  normalized.name = fallbackName;
+  return normalized;
+}
+
+function isErrorLike(error: unknown): error is ErrorLike {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    ('name' in error || 'message' in error || 'stack' in error)
+  );
+}
+
+function safeToString(value: unknown): string {
+  try {
+    return String(value);
+  } catch {
+    return 'Unknown error';
+  }
+}

packages/javascript-kernel/src/kernel.ts

@@ -6,6 +6,7 @@ import type { KernelMessage } from '@jupyterlab/services';
 import { BaseKernel, type IKernel } from '@jupyterlite/services';
 
 import type { JavaScriptExecutor } from './executor';
+import { normalizeError as normalizeUnknownError } from './errors';
 import {
   IFrameRuntimeBackend,
   IRuntimeBackend,
@@ -196,28 +197,28 @@ export class JavaScriptKernel extends BaseKernel implements IKernel {
    * Send an `input_reply` message.
    */
   inputReply(content: KernelMessage.IInputReplyMsg['content']): void {
-    throw new Error('Not implemented');
+    this._logUnsupportedControlMessage('input_reply');
   }
 
   /**
    * Send an `comm_open` message.
    */
   async commOpen(msg: KernelMessage.ICommOpenMsg): Promise<void> {
-    throw new Error('Not implemented');
+    this._logUnsupportedControlMessage('comm_open', msg.content.target_name);
   }
 
   /**
    * Send an `comm_msg` message.
    */
   async commMsg(msg: KernelMessage.ICommMsgMsg): Promise<void> {
-    throw new Error('Not implemented');
+    this._logUnsupportedControlMessage('comm_msg');
   }
 
   /**
    * Send an `comm_close` message.
    */
   async commClose(msg: KernelMessage.ICommCloseMsg): Promise<void> {
-    throw new Error('Not implemented');
+    this._logUnsupportedControlMessage('comm_close');
   }
 
   /**
@@ -248,7 +249,7 @@ export class JavaScriptKernel extends BaseKernel implements IKernel {
             execute: async code => {
               const reply = await context.execute(code);
               if (reply.status === 'error') {
-                throw this.createRuntimeInitializationError(reply);
+                throw this._createRuntimeInitializationError(reply);
               }
               return reply;
             }
@@ -308,17 +309,13 @@ export class JavaScriptKernel extends BaseKernel implements IKernel {
    * Normalize unknown thrown values into Error instances.
    */
   protected normalizeError(error: unknown): Error {
-    if (error instanceof Error) {
-      return error;
-    }
-
-    return new Error(String(error));
+    return normalizeUnknownError(error, 'RuntimeError');
   }
 
   /**
    * Normalize an execute reply error into an Error instance.
    */
-  private createRuntimeInitializationError(
+  private _createRuntimeInitializationError(
     reply: KernelMessage.IExecuteReplyMsg['content']
   ): Error {
     const ename =
@@ -343,6 +340,28 @@ export class JavaScriptKernel extends BaseKernel implements IKernel {
     return error;
   }
 
+  /**
+   * Warn once per unsupported control message type to avoid noisy consoles.
+   */
+  private _logUnsupportedControlMessage(
+    type: 'input_reply' | 'comm_open' | 'comm_msg' | 'comm_close',
+    detail?: string
+  ): void {
+    if (this._unsupportedControlMessages.has(type)) {
+      return;
+    }
+
+    this._unsupportedControlMessages.add(type);
+    const suffix = detail ? ` (${detail})` : '';
+
+    console.warn(
+      `[javascript-kernel] Ignoring unsupported ${type} message${suffix}.`
+    );
+  }
+
+  private _unsupportedControlMessages = new Set<
+    'input_reply' | 'comm_open' | 'comm_msg' | 'comm_close'
+  >();
   private _backend: IRuntimeBackend;
   private _executorFactory?: JavaScriptKernel.IExecutorFactory;
   private _runtimeMode: RuntimeMode;

packages/javascript-kernel/src/runtime_backends.ts

@@ -6,6 +6,7 @@ import type { KernelMessage } from '@jupyterlab/services';
 import { PromiseDelegate } from '@lumino/coreutils';
 
 import type { JavaScriptExecutor } from './executor';
+import { normalizeError } from './errors';
 import { JavaScriptRuntimeEvaluator } from './runtime_evaluator';
 import type {
   RuntimeOutputHandler,
@@ -169,13 +170,11 @@ export class IFrameRuntimeBackend implements IRuntimeBackend {
   private async _init(): Promise<void> {
     try {
       this._container = document.createElement('div');
-      this._container.style.cssText =
-        'position:absolute;width:0;height:0;overflow:hidden;';
+      this._container.style.display = 'none';
       document.body.appendChild(this._container);
 
       this._iframe = document.createElement('iframe');
-      this._iframe.sandbox.add('allow-scripts', 'allow-same-origin');
-      this._iframe.style.cssText = 'border:none;width:100%;height:100%;';
+      this._iframe.style.border = 'none';
       this._iframe.srcdoc = `<!DOCTYPE html>
 <html>
 <head>
@@ -500,7 +499,7 @@ export class WorkerRuntimeBackend implements IRuntimeBackend {
       });
       this._ready.resolve();
     } catch (error) {
-      this._handleWorkerFatal(this._normalizeError(error));
+      this._handleWorkerFatal(normalizeError(error));
     }
   }
 
@@ -524,16 +523,6 @@ export class WorkerRuntimeBackend implements IRuntimeBackend {
     this._pending.clear();
   }
 
-  /**
-   * Normalize unknown values to Error instances.
-   */
-  private _normalizeError(error: unknown): Error {
-    if (error instanceof Error) {
-      return error;
-    }
-    return new Error(String(error));
-  }
-
   private _options: WorkerRuntimeBackend.IOptions;
   private _worker: Worker | null = null;
   private _readyHandled = false;

packages/javascript-kernel/src/runtime_evaluator.ts

@@ -4,6 +4,7 @@
 import type { KernelMessage } from '@jupyterlab/services';
 
 import { JavaScriptExecutor } from './executor';
+import { normalizeError } from './errors';
 import type { RuntimeOutputHandler } from './runtime_protocol';
 
 /**
@@ -82,7 +83,7 @@ export class JavaScriptRuntimeEvaluator {
         user_expressions: {}
       };
     } catch (error) {
-      const normalized = this._normalizeError(error);
+      const normalized = normalizeError(error);
       const cleanedStack = this._executor.cleanStackTrace(normalized);
 
       const content: KernelMessage.IReplyErrorContent = {
@@ -260,17 +261,6 @@ export class JavaScriptRuntimeEvaluator {
     this._globalScope.display = this._previousDisplay;
   }
 
-  /**
-   * Normalize thrown value to an Error instance.
-   */
-  private _normalizeError(error: unknown): Error {
-    if (error instanceof Error) {
-      return error;
-    }
-
-    return new Error(String(error));
-  }
-
   private _globalScope: Record<string, any>;
   private _onOutput: RuntimeOutputHandler;
   private _executor: JavaScriptExecutor;

packages/javascript-kernel/src/worker-runtime.ts

@@ -1,6 +1,7 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
 
+import { normalizeError } from './errors';
 import { JavaScriptRuntimeEvaluator } from './runtime_evaluator';
 import type {
   RuntimeRequest,
@@ -163,13 +164,3 @@ function sanitize(value: any, seen: WeakSet<object>, depth: number): any {
 
   return String(value);
 }
-
-/**
- * Normalize unknown thrown value into Error.
- */
-function normalizeError(error: unknown): Error {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error(String(error));
-}