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

package/dist/bridge/process.d.ts

@@ -1,5 +1,5 @@
 import type * as nodeProcess from "process";
-import { TextEncoder, TextDecoder } from "./polyfills.js";
+import { TextEncoder, TextDecoder, Event, CustomEvent, EventTarget } from "./polyfills.js";
 import { URL, URLSearchParams } from "./whatwg-url.js";
 /**
  * Process configuration injected by the host before the bridge bundle loads.
@@ -30,6 +30,7 @@ export interface ProcessConfig {
  */
 export declare class ProcessExitError extends Error {
     code: number;
+    _isProcessExit: true;
     constructor(code: number);
 }
 declare const _default: typeof nodeProcess;
@@ -56,7 +57,7 @@ export declare function clearInterval(timer: TimerHandle | number | undefined):
 export declare function setImmediate(callback: (...args: unknown[]) => void, ...args: unknown[]): TimerHandle;
 export declare function clearImmediate(id: TimerHandle | number | undefined): void;
 export { URL, URLSearchParams };
-export { TextEncoder, TextDecoder };
+export { TextEncoder, TextDecoder, Event, CustomEvent, EventTarget };
 export declare const Buffer: BufferConstructor;
 interface SandboxCryptoKeyData {
     type: "public" | "private" | "secret";

package/dist/bridge/process.js

@@ -1,7 +1,7 @@
 // Process module polyfill for the sandbox
 // Provides Node.js process object and global polyfills for sandbox compatibility
-// Re-export TextEncoder/TextDecoder from polyfills (polyfills.ts is imported first in index.ts)
-import { TextEncoder, TextDecoder } from "./polyfills.js";
+// Re-export WHATWG globals from polyfills (polyfills.ts is imported first in index.ts)
+import { TextEncoder, TextDecoder, Event, CustomEvent, EventTarget, } from "./polyfills.js";
 import { URL, URLSearchParams, installWhatwgUrlGlobals, } from "./whatwg-url.js";
 // Use buffer package for spec-compliant Buffer implementation
 import { Buffer as BufferPolyfill } from "buffer";
@@ -115,10 +115,12 @@ let _exited = false;
  */
 export class ProcessExitError extends Error {
     code;
+    _isProcessExit;
     constructor(code) {
         super("process.exit(" + code + ")");
         this.name = "ProcessExitError";
         this.code = code;
+        this._isProcessExit = true;
     }
 }
 // Make available globally
@@ -132,6 +134,8 @@ const _signalNumbers = {
     SIGXCPU: 24, SIGXFSZ: 25, SIGVTALRM: 26, SIGPROF: 27, SIGWINCH: 28,
     SIGIO: 29, SIGPWR: 30, SIGSYS: 31,
 };
+const _signalNamesByNumber = Object.fromEntries(Object.entries(_signalNumbers).map(([name, num]) => [num, name]));
+const _ignoredSelfSignals = new Set(["SIGWINCH", "SIGCHLD", "SIGCONT", "SIGURG"]);
 function _resolveSignal(signal) {
     if (signal === undefined || signal === null)
         return 15; // default SIGTERM
@@ -199,6 +203,35 @@ function _emit(event, ...args) {
     }
     return handled;
 }
+function isProcessExitError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        (error._isProcessExit === true ||
+            error.name === "ProcessExitError"));
+}
+function normalizeAsyncError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function routeAsyncCallbackError(error) {
+    if (isProcessExitError(error)) {
+        return { handled: false, rethrow: error };
+    }
+    const normalized = normalizeAsyncError(error);
+    try {
+        if (_emit("uncaughtException", normalized, "uncaughtException")) {
+            return { handled: true, rethrow: null };
+        }
+    }
+    catch (emitError) {
+        return { handled: false, rethrow: emitError };
+    }
+    return { handled: false, rethrow: normalized };
+}
+function scheduleAsyncRethrow(error) {
+    setTimeout(() => {
+        throw error;
+    }, 0);
+}
 function _getStdinIsTTY() {
     return (typeof __runtimeTtyConfig !== "undefined" && __runtimeTtyConfig.stdinIsTTY) || false;
 }
@@ -208,58 +241,112 @@ function _getStdoutIsTTY() {
 function _getStderrIsTTY() {
     return (typeof __runtimeTtyConfig !== "undefined" && __runtimeTtyConfig.stderrIsTTY) || false;
 }
-// Stdout stream
-const _stdout = {
+function getWriteCallback(encodingOrCallback, callback) {
+    if (typeof encodingOrCallback === "function") {
+        return encodingOrCallback;
+    }
+    if (typeof callback === "function") {
+        return callback;
+    }
+    return undefined;
+}
+function emitListeners(listeners, onceListeners, event, args) {
+    const persistent = listeners[event] ? listeners[event].slice() : [];
+    const once = onceListeners[event] ? onceListeners[event].slice() : [];
+    if (once.length > 0) {
+        onceListeners[event] = [];
+    }
+    for (const listener of persistent) {
+        listener(...args);
+    }
+    for (const listener of once) {
+        listener(...args);
+    }
+    return persistent.length + once.length > 0;
+}
+function createStdioWriteStream(options) {
+    const listeners = {};
+    const onceListeners = {};
+    const remove = (event, listener) => {
+        if (listeners[event]) {
+            const idx = listeners[event].indexOf(listener);
+            if (idx !== -1)
+                listeners[event].splice(idx, 1);
+        }
+        if (onceListeners[event]) {
+            const idx = onceListeners[event].indexOf(listener);
+            if (idx !== -1)
+                onceListeners[event].splice(idx, 1);
+        }
+    };
+    const stream = {
+        write(data, encodingOrCallback, callback) {
+            options.write(String(data));
+            const done = getWriteCallback(encodingOrCallback, callback);
+            if (done) {
+                _queueMicrotask(() => done(null));
+            }
+            return true;
+        },
+        end() {
+            return stream;
+        },
+        on(event, listener) {
+            if (!listeners[event])
+                listeners[event] = [];
+            listeners[event].push(listener);
+            return stream;
+        },
+        once(event, listener) {
+            if (!onceListeners[event])
+                onceListeners[event] = [];
+            onceListeners[event].push(listener);
+            return stream;
+        },
+        off(event, listener) {
+            remove(event, listener);
+            return stream;
+        },
+        removeListener(event, listener) {
+            remove(event, listener);
+            return stream;
+        },
+        addListener(event, listener) {
+            return stream.on(event, listener);
+        },
+        emit(event, ...args) {
+            return emitListeners(listeners, onceListeners, event, args);
+        },
+        writable: true,
+        get isTTY() { return options.isTTY(); },
+        columns: 80,
+        rows: 24,
+    };
+    return stream;
+}
+const _stdout = createStdioWriteStream({
     write(data) {
         if (typeof _log !== "undefined") {
-            _log.applySync(undefined, [String(data).replace(/\n$/, "")]);
+            _log.applySync(undefined, [data]);
         }
-        return true;
-    },
-    end() {
-        return this;
-    },
-    on() {
-        return this;
-    },
-    once() {
-        return this;
     },
-    emit() {
-        return false;
-    },
-    writable: true,
-    get isTTY() { return _getStdoutIsTTY(); },
-    columns: 80,
-    rows: 24,
-};
-// Stderr stream
-const _stderr = {
+    isTTY: _getStdoutIsTTY,
+});
+const _stderr = createStdioWriteStream({
     write(data) {
         if (typeof _error !== "undefined") {
-            _error.applySync(undefined, [String(data).replace(/\n$/, "")]);
+            _error.applySync(undefined, [data]);
         }
-        return true;
-    },
-    end() {
-        return this;
-    },
-    on() {
-        return this;
-    },
-    once() {
-        return this;
-    },
-    emit() {
-        return false;
     },
-    writable: true,
-    get isTTY() { return _getStderrIsTTY(); },
-    columns: 80,
-    rows: 24,
-};
+    isTTY: _getStderrIsTTY,
+});
 const _stdinListeners = {};
 const _stdinOnceListeners = {};
+const _stdinLiveDecoder = new TextDecoder();
+const STDIN_HANDLE_ID = "process.stdin";
+let _stdinLiveBuffer = "";
+let _stdinLiveStarted = false;
+let _stdinLiveHandleRegistered = false;
 // Initialize stdin state as globals for external access
 exposeMutableRuntimeStateGlobal("_stdinData", (typeof _processConfig !== "undefined" && _processConfig.stdin) || "");
 exposeMutableRuntimeStateGlobal("_stdinPosition", 0);
@@ -302,11 +389,100 @@ function _emitStdinData() {
         }
     }
 }
+function emitStdinListeners(event, value) {
+    const listeners = [...(_stdinListeners[event] || []), ...(_stdinOnceListeners[event] || [])];
+    _stdinOnceListeners[event] = [];
+    for (const listener of listeners) {
+        listener(value);
+    }
+}
+function syncLiveStdinHandle(active) {
+    if (active) {
+        if (!_stdinLiveHandleRegistered && typeof _registerHandle === "function") {
+            try {
+                _registerHandle(STDIN_HANDLE_ID, "process.stdin");
+                _stdinLiveHandleRegistered = true;
+            }
+            catch {
+                // Process exit races turn registration into a no-op.
+            }
+        }
+        return;
+    }
+    if (_stdinLiveHandleRegistered && typeof _unregisterHandle === "function") {
+        try {
+            _unregisterHandle(STDIN_HANDLE_ID);
+        }
+        catch {
+            // Process exit races turn unregistration into a no-op.
+        }
+        _stdinLiveHandleRegistered = false;
+    }
+}
+function flushLiveStdinBuffer() {
+    if (!getStdinFlowMode() || _stdinLiveBuffer.length === 0)
+        return;
+    const chunk = _stdinLiveBuffer;
+    _stdinLiveBuffer = "";
+    emitStdinListeners("data", chunk);
+}
+function finishLiveStdin() {
+    if (getStdinEnded())
+        return;
+    setStdinEnded(true);
+    flushLiveStdinBuffer();
+    emitStdinListeners("end");
+    emitStdinListeners("close");
+    syncLiveStdinHandle(false);
+}
+function ensureLiveStdinStarted() {
+    if (_stdinLiveStarted || !_getStdinIsTTY())
+        return;
+    _stdinLiveStarted = true;
+    syncLiveStdinHandle(!_stdin.paused);
+    void (async () => {
+        try {
+            while (!getStdinEnded()) {
+                if (typeof _kernelStdinRead === "undefined") {
+                    break;
+                }
+                const next = await _kernelStdinRead.apply(undefined, [], {
+                    result: { promise: true },
+                });
+                if (next?.done) {
+                    break;
+                }
+                const dataBase64 = String(next?.dataBase64 ?? "");
+                if (!dataBase64) {
+                    continue;
+                }
+                _stdinLiveBuffer += _stdinLiveDecoder.decode(BufferPolyfill.from(dataBase64, "base64"), { stream: true });
+                flushLiveStdinBuffer();
+            }
+        }
+        catch {
+            // Treat bridge-side stdin failures as EOF for sandbox code.
+        }
+        _stdinLiveBuffer += _stdinLiveDecoder.decode();
+        finishLiveStdin();
+    })();
+}
 const _stdin = {
     readable: true,
     paused: true,
     encoding: null,
+    isRaw: false,
     read(size) {
+        if (_stdinLiveBuffer.length > 0) {
+            if (!size || size >= _stdinLiveBuffer.length) {
+                const chunk = _stdinLiveBuffer;
+                _stdinLiveBuffer = "";
+                return chunk;
+            }
+            const chunk = _stdinLiveBuffer.slice(0, size);
+            _stdinLiveBuffer = _stdinLiveBuffer.slice(size);
+            return chunk;
+        }
         if (getStdinPosition() >= getStdinData().length)
             return null;
         const chunk = size ? getStdinData().slice(getStdinPosition(), getStdinPosition() + size) : getStdinData().slice(getStdinPosition());
@@ -317,6 +493,12 @@ const _stdin = {
         if (!_stdinListeners[event])
             _stdinListeners[event] = [];
         _stdinListeners[event].push(listener);
+        if (_getStdinIsTTY() && (event === "data" || event === "end" || event === "close")) {
+            ensureLiveStdinStarted();
+        }
+        if (event === "data" && this.paused) {
+            this.resume();
+        }
         // When 'end' listener is added and we have data, emit everything synchronously
         // This works because typical patterns register 'data' then 'end' listeners
         if (event === "end" && getStdinData() && !getStdinEnded()) {
@@ -354,11 +536,17 @@ const _stdin = {
     pause() {
         this.paused = true;
         setStdinFlowMode(false);
+        syncLiveStdinHandle(false);
         return this;
     },
     resume() {
+        if (_getStdinIsTTY()) {
+            ensureLiveStdinStarted();
+            syncLiveStdinHandle(true);
+        }
         this.paused = false;
         setStdinFlowMode(true);
+        flushLiveStdinBuffer();
         _emitStdinData();
         return this;
     },
@@ -373,6 +561,7 @@ const _stdin = {
         if (typeof _ptySetRawMode !== "undefined") {
             _ptySetRawMode.applySync(undefined, [mode]);
         }
+        this.isRaw = mode;
         return this;
     },
     get isTTY() { return _getStdinIsTTY(); },
@@ -522,12 +711,8 @@ const process = {
         return process.exit(1);
     },
     nextTick(callback, ...args) {
-        if (typeof queueMicrotask === "function") {
-            queueMicrotask(() => callback(...args));
-        }
-        else {
-            Promise.resolve().then(() => callback(...args));
-        }
+        _nextTickQueue.push({ callback, args });
+        scheduleNextTickFlush();
     },
     hrtime: hrtime,
     getuid() {
@@ -612,7 +797,17 @@ const process = {
         }
         // Resolve signal name to number (default SIGTERM)
         const sigNum = _resolveSignal(signal);
-        // Self-kill - exit with 128 + signal number (POSIX convention)
+        if (sigNum === 0) {
+            return true;
+        }
+        const sigName = _signalNamesByNumber[sigNum] ?? `SIG${sigNum}`;
+        if (_emit(sigName, sigName)) {
+            return true;
+        }
+        if (_ignoredSelfSignals.has(sigName)) {
+            return true;
+        }
+        // Unhandled fatal self-signals exit with 128 + signal number.
         return process.exit(128 + sigNum);
     },
     // EventEmitter methods
@@ -827,6 +1022,35 @@ class TimerHandle {
     }
 }
 const _timerEntries = new Map();
+const _nextTickQueue = [];
+let _nextTickScheduled = false;
+function flushNextTickQueue() {
+    _nextTickScheduled = false;
+    while (_nextTickQueue.length > 0) {
+        const entry = _nextTickQueue.shift();
+        if (!entry) {
+            break;
+        }
+        try {
+            entry.callback(...entry.args);
+        }
+        catch (error) {
+            const outcome = routeAsyncCallbackError(error);
+            if (!outcome.handled && outcome.rethrow !== null) {
+                _nextTickQueue.length = 0;
+                scheduleAsyncRethrow(outcome.rethrow);
+            }
+            return;
+        }
+    }
+}
+function scheduleNextTickFlush() {
+    if (_nextTickScheduled) {
+        return;
+    }
+    _nextTickScheduled = true;
+    _queueMicrotask(flushNextTickQueue);
+}
 function timerDispatch(_eventType, payload) {
     const timerId = typeof payload === "number"
         ? payload
@@ -843,8 +1067,12 @@ function timerDispatch(_eventType, payload) {
     try {
         entry.callback(...entry.args);
     }
-    catch (_e) {
-        // Ignore timer callback errors
+    catch (error) {
+        const outcome = routeAsyncCallbackError(error);
+        if (!outcome.handled && outcome.rethrow !== null) {
+            throw outcome.rethrow;
+        }
+        return;
     }
     if (entry.repeat && _timerEntries.has(timerId)) {
         armKernelTimer(timerId);
@@ -899,7 +1127,7 @@ export function clearImmediate(id) {
 }
 // TextEncoder and TextDecoder - re-export from polyfills
 export { URL, URLSearchParams };
-export { TextEncoder, TextDecoder };
+export { TextEncoder, TextDecoder, Event, CustomEvent, EventTarget };
 // Buffer - use buffer package polyfill
 export const Buffer = BufferPolyfill;
 function throwUnsupportedCryptoApi(api) {
@@ -1332,13 +1560,12 @@ export function setupGlobals() {
     }
     // URL globals must override bootstrap fallbacks and stay non-enumerable.
     installWhatwgUrlGlobals(g);
-    // TextEncoder/TextDecoder
-    if (typeof g.TextEncoder === "undefined") {
-        g.TextEncoder = TextEncoder;
-    }
-    if (typeof g.TextDecoder === "undefined") {
-        g.TextDecoder = TextDecoder;
-    }
+    // WHATWG encoding and events
+    g.TextEncoder = TextEncoder;
+    g.TextDecoder = TextDecoder;
+    g.Event = Event;
+    g.CustomEvent = CustomEvent;
+    g.EventTarget = EventTarget;
     // Buffer
     if (typeof g.Buffer === "undefined") {
         g.Buffer = Buffer;

package/dist/bridge-contract.d.ts

@@ -87,6 +87,7 @@ export declare const HOST_BRIDGE_GLOBAL_KEYS: {
     readonly networkHttp2StreamPushStreamRaw: "_networkHttp2StreamPushStreamRaw";
     readonly networkHttp2StreamWriteRaw: "_networkHttp2StreamWriteRaw";
     readonly networkHttp2StreamEndRaw: "_networkHttp2StreamEndRaw";
+    readonly networkHttp2StreamCloseRaw: "_networkHttp2StreamCloseRaw";
     readonly networkHttp2StreamPauseRaw: "_networkHttp2StreamPauseRaw";
     readonly networkHttp2StreamResumeRaw: "_networkHttp2StreamResumeRaw";
     readonly networkHttp2StreamRespondWithFileRaw: "_networkHttp2StreamRespondWithFileRaw";
@@ -120,6 +121,7 @@ export declare const HOST_BRIDGE_GLOBAL_KEYS: {
     readonly resolveModuleSync: "_resolveModuleSync";
     readonly loadFileSync: "_loadFileSync";
     readonly ptySetRawMode: "_ptySetRawMode";
+    readonly kernelStdinRead: "_kernelStdinRead";
     readonly processConfig: "_processConfig";
     readonly osConfig: "_osConfig";
     readonly log: "_log";
@@ -241,6 +243,7 @@ export declare const HOST_BRIDGE_GLOBAL_KEY_LIST: ValueOf<{
     readonly networkHttp2StreamPushStreamRaw: "_networkHttp2StreamPushStreamRaw";
     readonly networkHttp2StreamWriteRaw: "_networkHttp2StreamWriteRaw";
     readonly networkHttp2StreamEndRaw: "_networkHttp2StreamEndRaw";
+    readonly networkHttp2StreamCloseRaw: "_networkHttp2StreamCloseRaw";
     readonly networkHttp2StreamPauseRaw: "_networkHttp2StreamPauseRaw";
     readonly networkHttp2StreamResumeRaw: "_networkHttp2StreamResumeRaw";
     readonly networkHttp2StreamRespondWithFileRaw: "_networkHttp2StreamRespondWithFileRaw";
@@ -274,6 +277,7 @@ export declare const HOST_BRIDGE_GLOBAL_KEY_LIST: ValueOf<{
     readonly resolveModuleSync: "_resolveModuleSync";
     readonly loadFileSync: "_loadFileSync";
     readonly ptySetRawMode: "_ptySetRawMode";
+    readonly kernelStdinRead: "_kernelStdinRead";
     readonly processConfig: "_processConfig";
     readonly osConfig: "_osConfig";
     readonly log: "_log";
@@ -391,6 +395,7 @@ export declare const BRIDGE_GLOBAL_KEY_LIST: readonly (ValueOf<{
     readonly networkHttp2StreamPushStreamRaw: "_networkHttp2StreamPushStreamRaw";
     readonly networkHttp2StreamWriteRaw: "_networkHttp2StreamWriteRaw";
     readonly networkHttp2StreamEndRaw: "_networkHttp2StreamEndRaw";
+    readonly networkHttp2StreamCloseRaw: "_networkHttp2StreamCloseRaw";
     readonly networkHttp2StreamPauseRaw: "_networkHttp2StreamPauseRaw";
     readonly networkHttp2StreamResumeRaw: "_networkHttp2StreamResumeRaw";
     readonly networkHttp2StreamRespondWithFileRaw: "_networkHttp2StreamRespondWithFileRaw";
@@ -424,6 +429,7 @@ export declare const BRIDGE_GLOBAL_KEY_LIST: readonly (ValueOf<{
     readonly resolveModuleSync: "_resolveModuleSync";
     readonly loadFileSync: "_loadFileSync";
     readonly ptySetRawMode: "_ptySetRawMode";
+    readonly kernelStdinRead: "_kernelStdinRead";
     readonly processConfig: "_processConfig";
     readonly osConfig: "_osConfig";
     readonly log: "_log";
@@ -483,6 +489,7 @@ export interface BridgeApplySyncRef<TArgs extends unknown[], TResult> {
 export interface BridgeApplySyncPromiseRef<TArgs extends unknown[], TResult> {
     applySyncPromise(ctx: undefined, args: TArgs): TResult;
 }
+export type ModuleLoadMode = "require" | "import";
 export type DynamicImportBridgeRef = BridgeApplyRef<[
     string,
     string
@@ -491,13 +498,20 @@ export type LoadPolyfillBridgeRef = BridgeApplyRef<[string], string | null>;
 export type ResolveModuleBridgeRef = BridgeApplySyncPromiseRef<[
     string,
     string
-], string | null>;
-export type LoadFileBridgeRef = BridgeApplySyncPromiseRef<[string], string | null>;
+] | [string, string, ModuleLoadMode], string | null>;
+export type LoadFileBridgeRef = BridgeApplySyncPromiseRef<[
+    string
+] | [string, ModuleLoadMode], string | null>;
 export type RequireFromBridgeFn = (request: string, dirname: string) => unknown;
 export type ModuleCacheBridgeRecord = Record<string, unknown>;
 export type ProcessLogBridgeRef = BridgeApplySyncRef<[string], void>;
 export type ProcessErrorBridgeRef = BridgeApplySyncRef<[string], void>;
 export type ScheduleTimerBridgeRef = BridgeApplyRef<[number], void>;
+export type KernelStdinReadBridgeRef = BridgeApplyRef<[
+], {
+    done: boolean;
+    dataBase64?: string;
+}>;
 export type CryptoRandomFillBridgeRef = BridgeApplySyncRef<[number], string>;
 export type CryptoRandomUuidBridgeRef = BridgeApplySyncRef<[], string>;
 export type CryptoHashDigestBridgeRef = BridgeApplySyncRef<[string, string], string>;
@@ -698,7 +712,7 @@ export type NetworkHttp2StreamRespondRawBridgeRef = BridgeApplySyncRef<[
     number,
     string
 ], void>;
-export type NetworkHttp2StreamPushStreamRawBridgeRef = BridgeApplySyncPromiseRef<[
+export type NetworkHttp2StreamPushStreamRawBridgeRef = BridgeApplySyncRef<[
     number,
     string,
     string
@@ -711,6 +725,10 @@ export type NetworkHttp2StreamEndRawBridgeRef = BridgeApplySyncRef<[
     number,
     string | null
 ], void>;
+export type NetworkHttp2StreamCloseRawBridgeRef = BridgeApplySyncRef<[
+    number,
+    number | null
+], void>;
 export type NetworkHttp2StreamPauseRawBridgeRef = BridgeApplySyncRef<[number], void>;
 export type NetworkHttp2StreamResumeRawBridgeRef = BridgeApplySyncRef<[number], void>;
 export type NetworkHttp2StreamRespondWithFileRawBridgeRef = BridgeApplySyncRef<[

package/dist/bridge-contract.js

@@ -89,6 +89,7 @@ export const HOST_BRIDGE_GLOBAL_KEYS = {
     networkHttp2StreamPushStreamRaw: "_networkHttp2StreamPushStreamRaw",
     networkHttp2StreamWriteRaw: "_networkHttp2StreamWriteRaw",
     networkHttp2StreamEndRaw: "_networkHttp2StreamEndRaw",
+    networkHttp2StreamCloseRaw: "_networkHttp2StreamCloseRaw",
     networkHttp2StreamPauseRaw: "_networkHttp2StreamPauseRaw",
     networkHttp2StreamResumeRaw: "_networkHttp2StreamResumeRaw",
     networkHttp2StreamRespondWithFileRaw: "_networkHttp2StreamRespondWithFileRaw",
@@ -122,6 +123,7 @@ export const HOST_BRIDGE_GLOBAL_KEYS = {
     resolveModuleSync: "_resolveModuleSync",
     loadFileSync: "_loadFileSync",
     ptySetRawMode: "_ptySetRawMode",
+    kernelStdinRead: "_kernelStdinRead",
     processConfig: "_processConfig",
     osConfig: "_osConfig",
     log: "_log",

package/dist/bridge-handlers.d.ts

@@ -89,6 +89,7 @@ export interface TimerBridgeDeps {
 }
 /** Build timer bridge handler. */
 export declare function buildTimerBridgeHandlers(deps: TimerBridgeDeps): BridgeHandlers;
+export declare function buildMimeBridgeHandlers(): BridgeHandlers;
 export interface KernelTimerDispatchDeps {
     timerTable: import("@secure-exec/core").TimerTable;
     pid: number;
@@ -98,6 +99,12 @@ export interface KernelTimerDispatchDeps {
     sendStreamEvent(eventType: string, payload: Uint8Array): void;
 }
 export declare function buildKernelTimerDispatchHandlers(deps: KernelTimerDispatchDeps): BridgeHandlers;
+export interface KernelStdinDispatchDeps {
+    liveStdinSource?: import("./isolate-bootstrap.js").LiveStdinSource;
+    budgetState: BudgetState;
+    maxBridgeCalls?: number;
+}
+export declare function buildKernelStdinDispatchHandlers(deps: KernelStdinDispatchDeps): BridgeHandlers;
 export interface KernelHandleDispatchDeps {
     processTable?: import("@secure-exec/core").ProcessTable;
     pid: number;
@@ -144,6 +151,9 @@ export interface NetworkBridgeDeps {
     pendingHttpServerStarts: {
         count: number;
     };
+    activeHttpClientRequests: {
+        count: number;
+    };
     /** Push HTTP server/upgrade events into the V8 isolate. */
     sendStreamEvent: (eventType: string, payload: Uint8Array) => void;
     /** Kernel socket table for all bridge-managed HTTP server routing. */