@secure-exec/nodejs 0.2.0-rc.1 → 0.2.0-rc.2

package/dist/builtin-modules.js

@@ -41,6 +41,7 @@ const STDLIB_BROWSER_MODULES = new Set([
     "readline",
     "repl",
     "stream",
+    "stream/promises",
     "_stream_duplex",
     "_stream_passthrough",
     "_stream_readable",
@@ -111,6 +112,7 @@ const KNOWN_BUILTIN_MODULES = new Set([
     "path",
     "querystring",
     "stream",
+    "stream/promises",
     "stream/web",
     "string_decoder",
     "timers",
@@ -270,6 +272,10 @@ export const BUILTIN_NAMED_EXPORTS = {
         "addAbortSignal",
         "compose",
     ],
+    "stream/promises": [
+        "finished",
+        "pipeline",
+    ],
     "stream/web": [
         "ReadableStream",
         "ReadableStreamDefaultReader",

package/dist/esm-compiler.d.ts

@@ -6,6 +6,7 @@
  * re-export the bridge-provided globalThis objects as proper ESM modules
  * with both default and named exports.
  */
+export declare function getBuiltinBindingExpression(moduleName: string): string | null;
 /** Get a pre-built ESM wrapper for a bridge-backed built-in, or null if not bridge-handled. */
 export declare function getStaticBuiltinWrapperSource(moduleName: string): string | null;
 /** Build a custom ESM wrapper for a dynamically-resolved module (e.g. polyfills). */

package/dist/esm-compiler.js

@@ -41,19 +41,37 @@ const MODULE_FALLBACK_BINDING = "globalThis.bridge?.module || {" +
     "isBuiltin: () => false," +
     "builtinModules: []" +
     "}";
+const STATIC_BUILTIN_BINDINGS = {
+    fs: "globalThis.bridge?.fs || globalThis.bridge?.default || {}",
+    "fs/promises": "(globalThis.bridge?.fs || globalThis.bridge?.default || {}).promises || {}",
+    "stream/promises": 'globalThis._requireFrom("stream/promises", "/")',
+    module: MODULE_FALLBACK_BINDING,
+    os: "globalThis.bridge?.os || {}",
+    http: "globalThis._httpModule || globalThis.bridge?.network?.http || {}",
+    https: "globalThis._httpsModule || globalThis.bridge?.network?.https || {}",
+    http2: "globalThis._http2Module || {}",
+    dns: "globalThis._dnsModule || globalThis.bridge?.network?.dns || {}",
+    child_process: "globalThis._childProcessModule || globalThis.bridge?.childProcess || {}",
+    process: "globalThis.process || {}",
+    v8: "globalThis._moduleCache?.v8 || {}",
+};
 const STATIC_BUILTIN_WRAPPER_SOURCES = {
-    fs: buildWrapperSource("globalThis.bridge?.fs || globalThis.bridge?.default || {}", BUILTIN_NAMED_EXPORTS.fs),
-    "fs/promises": buildWrapperSource("(globalThis.bridge?.fs || globalThis.bridge?.default || {}).promises || {}", BUILTIN_NAMED_EXPORTS["fs/promises"]),
-    module: buildWrapperSource(MODULE_FALLBACK_BINDING, BUILTIN_NAMED_EXPORTS.module),
-    os: buildWrapperSource("globalThis.bridge?.os || {}", BUILTIN_NAMED_EXPORTS.os),
-    http: buildWrapperSource("globalThis._httpModule || globalThis.bridge?.network?.http || {}", BUILTIN_NAMED_EXPORTS.http),
-    https: buildWrapperSource("globalThis._httpsModule || globalThis.bridge?.network?.https || {}", BUILTIN_NAMED_EXPORTS.https),
-    http2: buildWrapperSource("globalThis._http2Module || {}", []),
-    dns: buildWrapperSource("globalThis._dnsModule || globalThis.bridge?.network?.dns || {}", BUILTIN_NAMED_EXPORTS.dns),
-    child_process: buildWrapperSource("globalThis._childProcessModule || globalThis.bridge?.childProcess || {}", BUILTIN_NAMED_EXPORTS.child_process),
-    process: buildWrapperSource("globalThis.process || {}", BUILTIN_NAMED_EXPORTS.process),
-    v8: buildWrapperSource("globalThis._moduleCache?.v8 || {}", []),
+    fs: buildWrapperSource(STATIC_BUILTIN_BINDINGS.fs, BUILTIN_NAMED_EXPORTS.fs),
+    "fs/promises": buildWrapperSource(STATIC_BUILTIN_BINDINGS["fs/promises"], BUILTIN_NAMED_EXPORTS["fs/promises"]),
+    "stream/promises": buildWrapperSource(STATIC_BUILTIN_BINDINGS["stream/promises"], BUILTIN_NAMED_EXPORTS["stream/promises"]),
+    module: buildWrapperSource(STATIC_BUILTIN_BINDINGS.module, BUILTIN_NAMED_EXPORTS.module),
+    os: buildWrapperSource(STATIC_BUILTIN_BINDINGS.os, BUILTIN_NAMED_EXPORTS.os),
+    http: buildWrapperSource(STATIC_BUILTIN_BINDINGS.http, BUILTIN_NAMED_EXPORTS.http),
+    https: buildWrapperSource(STATIC_BUILTIN_BINDINGS.https, BUILTIN_NAMED_EXPORTS.https),
+    http2: buildWrapperSource(STATIC_BUILTIN_BINDINGS.http2, []),
+    dns: buildWrapperSource(STATIC_BUILTIN_BINDINGS.dns, BUILTIN_NAMED_EXPORTS.dns),
+    child_process: buildWrapperSource(STATIC_BUILTIN_BINDINGS.child_process, BUILTIN_NAMED_EXPORTS.child_process),
+    process: buildWrapperSource(STATIC_BUILTIN_BINDINGS.process, BUILTIN_NAMED_EXPORTS.process),
+    v8: buildWrapperSource(STATIC_BUILTIN_BINDINGS.v8, []),
 };
+export function getBuiltinBindingExpression(moduleName) {
+    return STATIC_BUILTIN_BINDINGS[moduleName] ?? null;
+}
 /** Get a pre-built ESM wrapper for a bridge-backed built-in, or null if not bridge-handled. */
 export function getStaticBuiltinWrapperSource(moduleName) {
     return STATIC_BUILTIN_WRAPPER_SOURCES[moduleName] ?? null;

package/dist/execution-driver.js

@@ -2,14 +2,14 @@ import { createResolutionCache } from "./package-bundler.js";
 import { getConsoleSetupCode } from "@secure-exec/core/internal/shared/console-formatter";
 import { getRequireSetupCode } from "@secure-exec/core/internal/shared/require-setup";
 import { getIsolateRuntimeSource, getInitialBridgeGlobalsSetupCode } from "@secure-exec/core";
-import { transformDynamicImport } from "@secure-exec/core/internal/shared/esm-utils";
 import { createCommandExecutorStub, createFsStub, createNetworkStub, filterEnv, wrapCommandExecutor, wrapFileSystem, wrapNetworkAdapter, } from "@secure-exec/core/internal/shared/permissions";
 import { createV8Runtime } from "@secure-exec/v8";
 import { getRawBridgeCode, getBridgeAttachCode } from "./bridge-loader.js";
 import { createBudgetState, clearActiveHostTimers, killActiveChildProcesses, normalizePayloadLimit, getExecutionTimeoutMs, getTimingMitigation, PAYLOAD_LIMIT_ERROR_CODE, DEFAULT_BRIDGE_BASE64_TRANSFER_BYTES, DEFAULT_ISOLATE_JSON_PAYLOAD_BYTES, DEFAULT_MAX_TIMERS, DEFAULT_MAX_HANDLES, DEFAULT_SANDBOX_CWD, DEFAULT_SANDBOX_HOME, DEFAULT_SANDBOX_TMPDIR, } from "./isolate-bootstrap.js";
+import { transformSourceForRequireSync } from "./module-source.js";
 import { shouldRunAsESM } from "./module-resolver.js";
 import { TIMEOUT_ERROR_MESSAGE, TIMEOUT_EXIT_CODE, ProcessTable, SocketTable, TimerTable, } from "@secure-exec/core";
-import { buildCryptoBridgeHandlers, buildConsoleBridgeHandlers, buildKernelHandleDispatchHandlers, buildKernelTimerDispatchHandlers, buildModuleLoadingBridgeHandlers, buildTimerBridgeHandlers, buildFsBridgeHandlers, buildKernelFdBridgeHandlers, buildChildProcessBridgeHandlers, buildNetworkBridgeHandlers, buildNetworkSocketBridgeHandlers, buildModuleResolutionBridgeHandlers, buildPtyBridgeHandlers, createProcessConfigForExecution, resolveHttpServerResponse, } from "./bridge-handlers.js";
+import { buildCryptoBridgeHandlers, buildConsoleBridgeHandlers, buildKernelHandleDispatchHandlers, buildKernelStdinDispatchHandlers, buildKernelTimerDispatchHandlers, buildModuleLoadingBridgeHandlers, buildMimeBridgeHandlers, buildTimerBridgeHandlers, buildFsBridgeHandlers, buildKernelFdBridgeHandlers, buildChildProcessBridgeHandlers, buildNetworkBridgeHandlers, buildNetworkSocketBridgeHandlers, buildModuleResolutionBridgeHandlers, buildPtyBridgeHandlers, createProcessConfigForExecution, resolveHttpServerResponse, } from "./bridge-handlers.js";
 import { flattenBindingTree, BINDING_PREFIX } from "./bindings.js";
 import { createNodeHostNetworkAdapter } from "./host-network-adapter.js";
 const MAX_ERROR_MESSAGE_CHARS = 8192;
@@ -49,7 +49,62 @@ async function getSharedV8Runtime() {
     return sharedV8RuntimePromise;
 }
 // Minimal polyfills for APIs the bridge IIFE expects but the Rust V8 runtime doesn't provide.
+const REGEXP_COMPAT_POLYFILL = String.raw `
+if (typeof globalThis.RegExp === 'function' && !globalThis.RegExp.__secureExecRgiEmojiCompat) {
+  const NativeRegExp = globalThis.RegExp;
+  const RGI_EMOJI_PATTERN = '^\\p{RGI_Emoji}$';
+  const RGI_EMOJI_BASE_CLASS = '[\\u{00A9}\\u{00AE}\\u{203C}\\u{2049}\\u{2122}\\u{2139}\\u{2194}-\\u{21AA}\\u{231A}-\\u{23FF}\\u{24C2}\\u{25AA}-\\u{27BF}\\u{2934}-\\u{2935}\\u{2B05}-\\u{2B55}\\u{3030}\\u{303D}\\u{3297}\\u{3299}\\u{1F000}-\\u{1FAFF}]';
+  const RGI_EMOJI_KEYCAP = '[#*0-9]\\uFE0F?\\u20E3';
+  const RGI_EMOJI_FALLBACK_SOURCE =
+    '^(?:' +
+    RGI_EMOJI_KEYCAP +
+    '|\\p{Regional_Indicator}{2}|' +
+    RGI_EMOJI_BASE_CLASS +
+    '(?:\\uFE0F|\\u200D(?:' +
+    RGI_EMOJI_KEYCAP +
+    '|' +
+    RGI_EMOJI_BASE_CLASS +
+    ')|[\\u{1F3FB}-\\u{1F3FF}])*)$';
+  try {
+    new NativeRegExp(RGI_EMOJI_PATTERN, 'v');
+  } catch (error) {
+    if (String(error && error.message || error).includes('RGI_Emoji')) {
+      function CompatRegExp(pattern, flags) {
+        const normalizedPattern =
+          pattern instanceof NativeRegExp && flags === undefined
+            ? pattern.source
+            : String(pattern);
+        const normalizedFlags =
+          flags === undefined
+            ? (pattern instanceof NativeRegExp ? pattern.flags : '')
+            : String(flags);
+        try {
+          return new NativeRegExp(pattern, flags);
+        } catch (innerError) {
+          if (normalizedPattern === RGI_EMOJI_PATTERN && normalizedFlags === 'v') {
+            return new NativeRegExp(RGI_EMOJI_FALLBACK_SOURCE, 'u');
+          }
+          throw innerError;
+        }
+      }
+      Object.setPrototypeOf(CompatRegExp, NativeRegExp);
+      CompatRegExp.prototype = NativeRegExp.prototype;
+      Object.defineProperty(CompatRegExp.prototype, 'constructor', {
+        value: CompatRegExp,
+        writable: true,
+        configurable: true,
+      });
+      CompatRegExp.__secureExecRgiEmojiCompat = true;
+      globalThis.RegExp = CompatRegExp;
+    }
+  }
+}
+`;
 const V8_POLYFILLS = `
+if (typeof global === 'undefined') {
+  globalThis.global = globalThis;
+}
+${REGEXP_COMPAT_POLYFILL}
 if (typeof SharedArrayBuffer === 'undefined') {
   globalThis.SharedArrayBuffer = class SharedArrayBuffer extends ArrayBuffer {};
   var _abBL = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength');
@@ -224,9 +279,266 @@ if (
     return controller.signal;
   };
 }
+if (
+  typeof globalThis.AbortSignal === 'function' &&
+  typeof globalThis.AbortController === 'function' &&
+  typeof globalThis.AbortSignal.timeout !== 'function'
+) {
+  globalThis.AbortSignal.timeout = function timeout(milliseconds) {
+    const delay = Number(milliseconds);
+    if (!Number.isFinite(delay) || delay < 0) {
+      throw new RangeError('The value of "milliseconds" is out of range. It must be a finite, non-negative number.');
+    }
+    const controller = new globalThis.AbortController();
+    const timer = setTimeout(() => {
+      controller.abort(
+        new globalThis.DOMException(
+          'The operation was aborted due to timeout',
+          'TimeoutError',
+        ),
+      );
+    }, delay);
+    if (typeof timer?.unref === 'function') {
+      timer.unref();
+    }
+    return controller.signal;
+  };
+}
+if (
+  typeof globalThis.AbortSignal === 'function' &&
+  typeof globalThis.AbortController === 'function' &&
+  typeof globalThis.AbortSignal.any !== 'function'
+) {
+  globalThis.AbortSignal.any = function any(signals) {
+    if (
+      signals === null ||
+      signals === undefined ||
+      typeof signals[Symbol.iterator] !== 'function'
+    ) {
+      throw new TypeError('The "signals" argument must be an iterable.');
+    }
+
+    const controller = new globalThis.AbortController();
+    const cleanup = [];
+    const abortFromSignal = (signal) => {
+      for (const dispose of cleanup) {
+        dispose();
+      }
+      cleanup.length = 0;
+      controller.abort(signal.reason);
+    };
+
+    for (const signal of signals) {
+      if (
+        !signal ||
+        typeof signal.aborted !== 'boolean' ||
+        typeof signal.addEventListener !== 'function' ||
+        typeof signal.removeEventListener !== 'function'
+      ) {
+        throw new TypeError('The "signals" argument must contain only AbortSignal instances.');
+      }
+      if (signal.aborted) {
+        abortFromSignal(signal);
+        break;
+      }
+      const listener = () => {
+        abortFromSignal(signal);
+      };
+      signal.addEventListener('abort', listener, { once: true });
+      cleanup.push(() => {
+        signal.removeEventListener('abort', listener);
+      });
+    }
+
+    return controller.signal;
+  };
+}
 if (typeof navigator === 'undefined') {
   globalThis.navigator = { userAgent: 'secure-exec-v8' };
 }
+if (typeof DOMException === 'undefined') {
+  const DOM_EXCEPTION_LEGACY_CODES = {
+    IndexSizeError: 1,
+    DOMStringSizeError: 2,
+    HierarchyRequestError: 3,
+    WrongDocumentError: 4,
+    InvalidCharacterError: 5,
+    NoDataAllowedError: 6,
+    NoModificationAllowedError: 7,
+    NotFoundError: 8,
+    NotSupportedError: 9,
+    InUseAttributeError: 10,
+    InvalidStateError: 11,
+    SyntaxError: 12,
+    InvalidModificationError: 13,
+    NamespaceError: 14,
+    InvalidAccessError: 15,
+    ValidationError: 16,
+    TypeMismatchError: 17,
+    SecurityError: 18,
+    NetworkError: 19,
+    AbortError: 20,
+    URLMismatchError: 21,
+    QuotaExceededError: 22,
+    TimeoutError: 23,
+    InvalidNodeTypeError: 24,
+    DataCloneError: 25,
+  };
+  class DOMException extends Error {
+    constructor(message = '', name = 'Error') {
+      super(String(message));
+      this.name = String(name);
+      this.code = DOM_EXCEPTION_LEGACY_CODES[this.name] ?? 0;
+    }
+    get [Symbol.toStringTag]() { return 'DOMException'; }
+  }
+  for (const [name, code] of Object.entries(DOM_EXCEPTION_LEGACY_CODES)) {
+    const constantName = name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+    Object.defineProperty(DOMException, constantName, {
+      value: code,
+      writable: false,
+      configurable: false,
+      enumerable: true,
+    });
+    Object.defineProperty(DOMException.prototype, constantName, {
+      value: code,
+      writable: false,
+      configurable: false,
+      enumerable: true,
+    });
+  }
+  Object.defineProperty(globalThis, 'DOMException', {
+    value: DOMException,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+  });
+}
+if (typeof Blob === 'undefined') {
+  globalThis.Blob = class Blob {
+    constructor(parts = [], options = {}) {
+      this._parts = Array.isArray(parts) ? parts.slice() : [];
+      this.type = options && options.type ? String(options.type).toLowerCase() : '';
+      this.size = this._parts.reduce((total, part) => {
+        if (typeof part === 'string') return total + part.length;
+        if (part && typeof part.byteLength === 'number') return total + part.byteLength;
+        return total;
+      }, 0);
+    }
+    arrayBuffer() { return Promise.resolve(new ArrayBuffer(0)); }
+    text() { return Promise.resolve(''); }
+    slice() { return new globalThis.Blob(); }
+    stream() { throw new Error('Blob.stream is not supported in sandbox'); }
+    get [Symbol.toStringTag]() { return 'Blob'; }
+  };
+  Object.defineProperty(globalThis, 'Blob', {
+    value: globalThis.Blob,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+  });
+}
+if (typeof File === 'undefined') {
+  globalThis.File = class File extends globalThis.Blob {
+    constructor(parts = [], name = '', options = {}) {
+      super(parts, options);
+      this.name = String(name);
+      this.lastModified =
+        options && typeof options.lastModified === 'number'
+          ? options.lastModified
+          : Date.now();
+      this.webkitRelativePath = '';
+    }
+    get [Symbol.toStringTag]() { return 'File'; }
+  };
+  Object.defineProperty(globalThis, 'File', {
+    value: globalThis.File,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+  });
+}
+if (typeof FormData === 'undefined') {
+  class FormData {
+    constructor() {
+      this._entries = [];
+    }
+    append(name, value) {
+      this._entries.push([String(name), value]);
+    }
+    get(name) {
+      const key = String(name);
+      for (const entry of this._entries) {
+        if (entry[0] === key) return entry[1];
+      }
+      return null;
+    }
+    getAll(name) {
+      const key = String(name);
+      return this._entries.filter((entry) => entry[0] === key).map((entry) => entry[1]);
+    }
+    has(name) {
+      return this.get(name) !== null;
+    }
+    delete(name) {
+      const key = String(name);
+      this._entries = this._entries.filter((entry) => entry[0] !== key);
+    }
+    entries() {
+      return this._entries[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    get [Symbol.toStringTag]() { return 'FormData'; }
+  }
+  Object.defineProperty(globalThis, 'FormData', {
+    value: FormData,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+  });
+}
+if (typeof MessageEvent === 'undefined') {
+  globalThis.MessageEvent = class MessageEvent {
+    constructor(type, options = {}) {
+      this.type = String(type);
+      this.data = Object.prototype.hasOwnProperty.call(options, 'data')
+        ? options.data
+        : undefined;
+    }
+  };
+}
+if (typeof MessagePort === 'undefined') {
+  globalThis.MessagePort = class MessagePort {
+    constructor() {
+      this.onmessage = null;
+      this._pairedPort = null;
+    }
+    postMessage(data) {
+      const target = this._pairedPort;
+      if (!target) return;
+      const event = new globalThis.MessageEvent('message', { data });
+      if (typeof target.onmessage === 'function') {
+        target.onmessage.call(target, event);
+      }
+    }
+    start() {}
+    close() {
+      this._pairedPort = null;
+    }
+  };
+}
+if (typeof MessageChannel === 'undefined') {
+  globalThis.MessageChannel = class MessageChannel {
+    constructor() {
+      this.port1 = new globalThis.MessagePort();
+      this.port2 = new globalThis.MessagePort();
+      this.port1._pairedPort = this.port2;
+      this.port2._pairedPort = this.port1;
+    }
+  };
+}
 `;
 // Shim for ivm.Reference methods used by bridge code.
 // Bridge globals in the V8 runtime are plain functions, but the bridge code
@@ -353,7 +665,7 @@ export class NodeExecutionDriver {
         const permissions = system.permissions;
         if (!this.socketTable) {
             this.socketTable = new SocketTable({
-                hostAdapter: createNodeHostNetworkAdapter(),
+                hostAdapter: system.network ? createNodeHostNetworkAdapter() : undefined,
                 networkCheck: permissions?.network,
             });
         }
@@ -402,12 +714,14 @@ export class NodeExecutionDriver {
             activeHttpServerIds: new Set(),
             activeHttpServerClosers: new Map(),
             pendingHttpServerStarts: { count: 0 },
+            activeHttpClientRequests: { count: 0 },
             activeChildProcesses: new Map(),
             activeHostTimers: new Set(),
             moduleFormatCache: new Map(),
             packageTypeCache: new Map(),
             resolutionCache: createResolutionCache(),
             onPtySetRawMode: options.onPtySetRawMode,
+            liveStdinSource: options.liveStdinSource,
         };
         // Validate and flatten bindings once at construction time
         if (options.bindings) {
@@ -424,7 +738,19 @@ export class NodeExecutionDriver {
     }
     get unsafeIsolate() { return null; }
     hasManagedResources() {
-        return (this.state.pendingHttpServerStarts.count > 0 ||
+        const hasBridgeHandles = this.pid !== undefined &&
+            this.processTable !== undefined &&
+            (() => {
+                try {
+                    return this.processTable.getHandles(this.pid).size > 0;
+                }
+                catch {
+                    return false;
+                }
+            })();
+        return (hasBridgeHandles ||
+            this.state.pendingHttpServerStarts.count > 0 ||
+            this.state.activeHttpClientRequests.count > 0 ||
             this.state.activeHttpServerIds.size > 0 ||
             this.state.activeChildProcesses.size > 0 ||
             (!this.ownsProcessTable && this.state.activeHostTimers.size > 0));
@@ -526,7 +852,13 @@ export class NodeExecutionDriver {
         const sessionMode = options.mode === "run" || entryIsEsm ? "run" : "exec";
         const userCode = entryIsEsm
             ? options.code
-            : transformDynamicImport(options.code);
+            : (() => {
+                const transformed = transformSourceForRequireSync(options.code, options.filePath ?? "/entry.js");
+                if (options.mode !== "exec") {
+                    return transformed;
+                }
+                return `${transformed}\n;typeof _waitForActiveHandles === "function" ? _waitForActiveHandles() : undefined;`;
+            })();
         // Get or create V8 runtime
         const v8Runtime = await getSharedV8Runtime();
         const cpuTimeLimitMs = getExecutionTimeoutMs(options.cpuTimeLimitMs, s.cpuTimeLimitMs);
@@ -571,6 +903,7 @@ export class NodeExecutionDriver {
                 activeHttpServerIds: s.activeHttpServerIds,
                 activeHttpServerClosers: s.activeHttpServerClosers,
                 pendingHttpServerStarts: s.pendingHttpServerStarts,
+                activeHttpClientRequests: s.activeHttpClientRequests,
                 sendStreamEvent,
                 socketTable: this.socketTable,
                 pid: this.pid,
@@ -594,6 +927,11 @@ export class NodeExecutionDriver {
                 budgetState: s.budgetState,
                 maxBridgeCalls: s.maxBridgeCalls,
             });
+            const kernelStdinDispatchHandlers = buildKernelStdinDispatchHandlers({
+                liveStdinSource: s.liveStdinSource,
+                budgetState: s.budgetState,
+                maxBridgeCalls: s.maxBridgeCalls,
+            });
             const bridgeHandlers = {
                 ...cryptoResult.handlers,
                 ...buildConsoleBridgeHandlers({
@@ -601,6 +939,7 @@ export class NodeExecutionDriver {
                     budgetState: s.budgetState,
                     maxOutputBytes: s.maxOutputBytes,
                 }),
+                ...kernelStdinDispatchHandlers,
                 ...buildModuleLoadingBridgeHandlers({
                     filesystem: s.filesystem,
                     resolutionCache: s.resolutionCache,
@@ -628,6 +967,7 @@ export class NodeExecutionDriver {
                         onPtySetRawMode: s.onPtySetRawMode,
                         stdinIsTTY: s.processConfig.stdinIsTTY,
                     }),
+                    ...buildMimeBridgeHandlers(),
                     // Kernel FD table handlers
                     ...kernelFdResult.handlers,
                     ...kernelTimerDispatchHandlers,
@@ -900,6 +1240,21 @@ function buildPostRestoreScript(processConfig, osConfig, bridgeConfig, timingMit
     }
     // Apply execution overrides (env, cwd, stdin) for exec mode
     if (mode === "exec") {
+        const commonJsFileConfig = (() => {
+            if (filePath) {
+                const dirname = filePath.includes("/")
+                    ? filePath.substring(0, filePath.lastIndexOf("/")) || "/"
+                    : "/";
+                return { filePath, dirname };
+            }
+            if (processConfig.cwd) {
+                return {
+                    filePath: `${processConfig.cwd.replace(/\/$/, "") || "/"}/[eval].js`,
+                    dirname: processConfig.cwd,
+                };
+            }
+            return null;
+        })();
         if (processConfig.env) {
             parts.push(`globalThis.__runtimeProcessEnvOverride = ${JSON.stringify(processConfig.env)};`);
             parts.push(getIsolateRuntimeSource("overrideProcessEnv"));
@@ -914,11 +1269,8 @@ function buildPostRestoreScript(processConfig, osConfig, bridgeConfig, timingMit
         }
         // Set CommonJS globals
         parts.push(getIsolateRuntimeSource("initCommonjsModuleGlobals"));
-        if (filePath) {
-            const dirname = filePath.includes("/")
-                ? filePath.substring(0, filePath.lastIndexOf("/")) || "/"
-                : "/";
-            parts.push(`globalThis.__runtimeCommonJsFileConfig = ${JSON.stringify({ filePath, dirname })};`);
+        if (commonJsFileConfig) {
+            parts.push(`globalThis.__runtimeCommonJsFileConfig = ${JSON.stringify(commonJsFileConfig)};`);
             parts.push(getIsolateRuntimeSource("setCommonjsFileGlobals"));
         }
     }

package/dist/host-network-adapter.js

@@ -2,9 +2,10 @@
  * Concrete HostNetworkAdapter for Node.js, delegating to node:net,
  * node:dgram, and node:dns for real external I/O.
  */
-import * as net from "node:net";
 import * as dgram from "node:dgram";
 import * as dns from "node:dns";
+import * as net from "node:net";
+import { IPPROTO_TCP, SOL_SOCKET, SO_KEEPALIVE, TCP_NODELAY, } from "@secure-exec/core/internal/kernel";
 /**
  * Queued-read adapter: incoming data/EOF/errors are buffered so that
  * each read() call returns the next chunk or null for EOF.
@@ -14,7 +15,6 @@ class NodeHostSocket {
     readQueue = [];
     waiters = [];
     ended = false;
-    errored = null;
     constructor(socket) {
         this.socket = socket;
         socket.on("data", (chunk) => {
@@ -38,7 +38,6 @@ class NodeHostSocket {
             }
         });
         socket.on("error", (err) => {
-            this.errored = err;
             // Wake all pending readers with EOF
             for (const waiter of this.waiters.splice(0)) {
                 waiter(null);
@@ -80,8 +79,13 @@ class NodeHostSocket {
         });
     }
     setOption(level, optname, optval) {
-        // Forward common options to the real socket
-        this.socket.setNoDelay(optval !== 0);
+        if (level === IPPROTO_TCP && optname === TCP_NODELAY) {
+            this.socket.setNoDelay(optval !== 0);
+            return;
+        }
+        if (level === SOL_SOCKET && optname === SO_KEEPALIVE) {
+            this.socket.setKeepAlive(optval !== 0);
+        }
     }
     shutdown(how) {
         if (how === "write" || how === "both") {
@@ -146,7 +150,7 @@ class NodeHostListener {
     async close() {
         this.closed = true;
         // Reject pending accept waiters
-        for (const waiter of this.waiters.splice(0)) {
+        for (const _waiter of this.waiters.splice(0)) {
             // Resolve with a destroyed socket to signal closure — caller handles
             // the error via the socket's error/close events
         }

package/dist/isolate-bootstrap.d.ts

@@ -8,6 +8,8 @@ export interface NodeExecutionDriverOptions extends RuntimeDriverOptions {
     bindings?: BindingTree;
     /** Callback to toggle PTY raw mode — wired by kernel runtime when PTY is attached. */
     onPtySetRawMode?: (mode: boolean) => void;
+    /** Optional live stdin source for PTY-backed interactive processes. */
+    liveStdinSource?: LiveStdinSource;
     /** Kernel socket table — routes net.connect through kernel instead of host TCP. */
     socketTable?: import("@secure-exec/core").SocketTable;
     /** Kernel process table — registers child processes for cross-runtime visibility. */
@@ -23,6 +25,9 @@ export interface BudgetState {
     activeTimers: number;
     childProcesses: number;
 }
+export interface LiveStdinSource {
+    read(): Promise<Uint8Array | null>;
+}
 /** Shared mutable state owned by NodeExecutionDriver, passed to extracted modules. */
 export interface DriverDeps {
     filesystem: VirtualFileSystem;
@@ -51,6 +56,7 @@ export interface DriverDeps {
     resolutionCache: ResolutionCache;
     /** Optional callback for PTY setRawMode — wired by kernel when PTY is attached. */
     onPtySetRawMode?: (mode: boolean) => void;
+    liveStdinSource?: LiveStdinSource;
 }
 export declare const DEFAULT_BRIDGE_BASE64_TRANSFER_BYTES: number;
 export declare const DEFAULT_ISOLATE_JSON_PAYLOAD_BYTES: number;

package/dist/kernel-runtime.d.ts

@@ -21,7 +21,9 @@ export interface NodeRuntimeOptions {
     moduleAccessPaths?: string[];
     /**
      * Bridge permissions for isolate processes. Defaults to allowAllChildProcess
-     * (fs/network/env deny-by-default). Use allowAll for full sandbox access.
+     * plus read-only `/proc/self` metadata access in kernel-mounted mode
+     * (other fs/network/env access deny-by-default). Use allowAll for full
+     * sandbox access.
      */
     permissions?: Partial<Permissions>;
     /**