@nimbus-sh/core 0.1.0

package/dist/substrate/lifo/commands/system/node.js

@@ -0,0 +1,1241 @@
+import { resolve, dirname, join, extname } from '../../utils/path.js';
+import { createModuleMap, ProcessExitError } from '../../node-compat/index.js';
+import { createProcess } from '../../node-compat/process.js';
+import { createConsole } from '../../node-compat/console.js';
+import { Buffer } from '../../node-compat/buffer.js';
+import { VFSError } from '../../kernel/vfs/index.js';
+import { ACTIVE_SERVERS } from '../../node-compat/http.js';
+const NODE_VERSION = 'v20.0.0';
+// ── Rollup / esbuild CJS-ESM interop helpers ──
+// Bundled npm packages (Vite, Rollup, etc.) reference these helpers at the module
+// scope.  When our ESM→CJS transform converts imports, the helpers may lose their
+// binding.  Making them available on globalThis acts as a fallback – if the module
+// defines its own copy the local declaration naturally shadows the global.
+//
+// Complete set from @rollup/plugin-commonjs interop:
+const _rollupHelpers = {
+    getDefaultExportFromCjs(x) {
+        const o = x;
+        return o && o.__esModule && Object.prototype.hasOwnProperty.call(o, 'default') ? o.default : o;
+    },
+    getDefaultExportFromNamespaceIfPresent(n) {
+        const o = n;
+        return o && Object.prototype.hasOwnProperty.call(o, 'default') && Object.keys(o).length === 1 ? o.default : o;
+    },
+    getAugmentedNamespace(n) {
+        const o = n;
+        if (o.__esModule)
+            return o;
+        const a = Object.defineProperty({}, '__esModule', { value: true });
+        Object.keys(o).forEach(function (k) {
+            const d = Object.getOwnPropertyDescriptor(o, k);
+            Object.defineProperty(a, k, d && d.get ? d : { enumerable: true, get() { return o[k]; } });
+        });
+        a.default = n;
+        return Object.freeze(a);
+    },
+    _mergeNamespaces(n, ...ms) {
+        const o = n;
+        const modules = ms.flat();
+        for (const m of modules) {
+            for (const k of Object.keys(m)) {
+                if (k !== 'default' && !(k in o)) {
+                    Object.defineProperty(o, k, { enumerable: true, get: () => m[k] });
+                }
+            }
+        }
+        return Object.freeze(o);
+    },
+};
+/** Strip shebang line (e.g. #!/usr/bin/env node) – replace with blank to preserve line numbers */
+function stripShebang(src) {
+    if (src.charCodeAt(0) === 0x23 /* # */ && src.charCodeAt(1) === 0x21 /* ! */) {
+        const nl = src.indexOf('\n');
+        if (nl === -1)
+            return '';
+        return '\n' + src.slice(nl + 1);
+    }
+    return src;
+}
+/** Check if source contains ESM import/export syntax */
+function isEsmSource(source) {
+    // Match import/export at line start, after semicolon, or minified (import{, import*)
+    return /(?:^|\n|;)\s*(?:import\s*[\w{*('".]|export\s+|export\s*\{)/.test(source);
+}
+/** Determine if source should be treated as ESM based on filename, content, and package.json type */
+function shouldTreatAsEsm(source, filename, vfs) {
+    const ext = extname(filename);
+    if (ext === '.mjs')
+        return true;
+    if (ext === '.cjs')
+        return false;
+    // Check nearest package.json "type" field (Node.js semantics)
+    if (vfs && ext === '.js') {
+        let dir = dirname(filename);
+        for (;;) {
+            const pkgPath = join(dir, 'package.json');
+            if (vfs.exists(pkgPath)) {
+                try {
+                    const pkg = JSON.parse(vfs.readFileString(pkgPath));
+                    if (pkg.type === 'module')
+                        return true;
+                    if (pkg.type === 'commonjs')
+                        return false;
+                }
+                catch { /* ignore */ }
+                break;
+            }
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    return isEsmSource(source);
+}
+// Names that collide with the new Function() CJS wrapper parameters.
+// Using `const` for these would throw "Identifier X has already been declared",
+// so we emit `var` instead (var can shadow function params in non-strict mode).
+const CJS_WRAPPER_PARAMS = new Set([
+    'exports', 'require', 'module', '__filename', '__dirname',
+    'console', 'process', 'Buffer', 'setTimeout', 'setInterval',
+    'clearTimeout', 'clearInterval', 'global',
+    '__importMetaUrl', '__importMeta', '__importMetaResolve',
+]);
+function cjsDecl(name) {
+    return CJS_WRAPPER_PARAMS.has(name) ? 'var' : 'const';
+}
+/**
+ * Mask string/template literals with safe placeholders so that
+ * import/export regexes don't match keywords inside string content.
+ * Returns the masked source and an array of original literals for restoration.
+ */
+function maskStringLiterals(src) {
+    const literals = [];
+    let masked = '';
+    let i = 0;
+    while (i < src.length) {
+        const ch = src[i];
+        // Skip single-line comments (may contain unmatched quotes)
+        if (ch === '/' && i + 1 < src.length && src[i + 1] === '/') {
+            const nl = src.indexOf('\n', i);
+            const end = nl === -1 ? src.length : nl;
+            masked += src.slice(i, end);
+            i = end;
+            continue;
+        }
+        // Skip multi-line comments
+        if (ch === '/' && i + 1 < src.length && src[i + 1] === '*') {
+            const end = src.indexOf('*/', i + 2);
+            const close = end === -1 ? src.length : end + 2;
+            masked += src.slice(i, close);
+            i = close;
+            continue;
+        }
+        // Regex literals — skip to avoid confusing backticks inside /regex/ with templates
+        if (ch === '/' && i + 1 < src.length && src[i + 1] !== '/' && src[i + 1] !== '*') {
+            // Heuristic: '/' is a regex if preceded by an operator, keyword, or start-of-line.
+            // IMPORTANT: We include ')' and '}' even though they can precede division too,
+            // because under-detection is catastrophic: a backtick inside an undetected
+            // regex triggers the template-literal parser which can eat the rest of the file.
+            // Over-detection is harmless: the regex scanner copies content as-is and stops
+            // at newline, so the output is identical either way.
+            let k = i - 1;
+            while (k >= 0 && (src[k] === ' ' || src[k] === '\t' || src[k] === '\n' || src[k] === '\r'))
+                k--;
+            const prev = k >= 0 ? src[k] : '\0';
+            if ('\0=([{,;!&|^~?:+-*%<>/)]}'.includes(prev) ||
+                (k >= 1 && /\b(?:return|typeof|void|delete|throw|new|case|of|in|yield|await)\s*$/.test(src.slice(Math.max(0, k - 11), k + 1)))) {
+                const regStart = i;
+                i++; // skip opening /
+                while (i < src.length && src[i] !== '\n') {
+                    if (src[i] === '\\') {
+                        i += 2;
+                        continue;
+                    }
+                    if (src[i] === '/') {
+                        i++;
+                        break;
+                    }
+                    if (src[i] === '[') { // character class — / doesn't end regex inside [...]
+                        i++;
+                        while (i < src.length && src[i] !== ']' && src[i] !== '\n') {
+                            if (src[i] === '\\')
+                                i++;
+                            i++;
+                        }
+                        if (i < src.length && src[i] === ']')
+                            i++;
+                        continue;
+                    }
+                    i++;
+                }
+                while (i < src.length && /[gimsuyv]/.test(src[i]))
+                    i++; // flags
+                masked += src.slice(regStart, i);
+                continue;
+            }
+        }
+        // String/template literals
+        if (ch === '"' || ch === "'" || ch === '`') {
+            const start = i;
+            const quote = ch;
+            i++; // skip opening quote
+            while (i < src.length) {
+                if (src[i] === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (src[i] === quote) {
+                    i++;
+                    break;
+                }
+                // Template literal ${...} expressions — skip with depth tracking
+                if (quote === '`' && src[i] === '$' && i + 1 < src.length && src[i + 1] === '{') {
+                    let depth = 1;
+                    i += 2;
+                    while (i < src.length && depth > 0) {
+                        if (src[i] === '{')
+                            depth++;
+                        else if (src[i] === '}')
+                            depth--;
+                        else if (src[i] === '\\')
+                            i++;
+                        else if (src[i] === "'" || src[i] === '"') {
+                            const q = src[i];
+                            i++;
+                            while (i < src.length && src[i] !== q) {
+                                if (src[i] === '\\')
+                                    i++;
+                                i++;
+                            }
+                            if (i < src.length)
+                                i++; // skip closing quote
+                            continue;
+                        }
+                        else if (src[i] === '`') {
+                            // Nested template literal inside expression
+                            i++;
+                            while (i < src.length && src[i] !== '`') {
+                                if (src[i] === '\\')
+                                    i++;
+                                i++;
+                            }
+                            if (i < src.length)
+                                i++;
+                            continue;
+                        }
+                        i++;
+                    }
+                    continue;
+                }
+                i++;
+            }
+            const literal = src.slice(start, i);
+            const idx = literals.length;
+            literals.push(literal);
+            // Placeholder uses same quote style so import regexes that capture
+            // ['"][^'"]+['"] still work (they see e.g. "__LIFO_S0__").
+            masked += quote + '__LIFO_S' + idx + '__' + quote;
+            continue;
+        }
+        masked += ch;
+        i++;
+    }
+    return { masked, literals };
+}
+/**
+ * Restore original string/template literals from masked placeholders.
+ */
+function unmaskStringLiterals(src, literals) {
+    return src.replace(/(['"`])__LIFO_S(\d+)__\1/g, (_match, _quote, idxStr) => literals[parseInt(idxStr, 10)]);
+}
+/** Transform ESM import/export syntax to CJS require/exports equivalents */
+function transformEsmToCjs(source) {
+    // Normalize \r\n → \n so regexes anchored on \n work with Windows line endings
+    let result = source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    // import.meta.* replacements MUST run before masking.
+    // The masker may incorrectly consume code regions (e.g. regex literals with
+    // backticks), so import.meta must be replaced on the raw source first.
+    // These are safe on raw source: replacements are plain identifiers that won't
+    // cause issues even if they accidentally match inside string literals.
+    result = result.split('import.meta.url').join('__importMetaUrl');
+    result = result.split('import.meta.dirname').join('__dirname');
+    result = result.split('import.meta.filename').join('__filename');
+    result = result.split('import.meta.require').join('require');
+    result = result.split('import.meta.resolve').join('__importMetaResolve');
+    // Bare import.meta (catch-all, must come AFTER specific property replacements)
+    result = result.split('import.meta').join('__importMeta');
+    // Mask string/template literal contents so import/export regexes don't
+    // match keywords inside strings (e.g. const HELPERS = `export function ...`)
+    const { masked, literals } = maskStringLiterals(result);
+    result = masked;
+    // Split semicolon-separated import/export onto their own lines
+    // so that the (?:^|\n) anchored regexes below can find them in minified code
+    result = result.replace(/;([ \t]*(?:import\s*[\w${*('".]|export[\s{*]))/g, ';\n$1');
+    const trailingExports = [];
+    let hasDefaultExport = false;
+    let hasNamedExport = false;
+    // Track import sources: localName → { modRef, prop } for live-binding exports
+    const importSources = new Map();
+    // Scan for export types to decide default export strategy
+    hasDefaultExport = /(?:^|\n)\s*export\s+default\s+/.test(result);
+    hasNamedExport = /(?:^|\n)\s*export\s+(?:const|let|var|function|class|\{|\*\s+from)/.test(result);
+    // --- Import transforms ---
+    // NOTE: JS identifiers can contain $ (e.g. fs$8, path$b in esbuild bundles).
+    // We use [\w$]+ instead of \w+ throughout to match these correctly.
+    // Combined: import X, { a, b as c } from 'mod'
+    result = result.replace(/(?:^|\n)([ \t]*)import\s+([\w$]+)\s*,\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g, (match, indent, defaultName, imports, mod) => {
+        // Guard: ${ in captured names means regex matched inside a template literal
+        if (imports.includes('${'))
+            return match;
+        const tmp = '__mod_' + defaultName;
+        const mapped = imports.split(',').map((s) => {
+            const parts = s.trim().split(/\s+as\s+/);
+            const sourceProp = parts[0].trim();
+            const localName = parts.length === 2 ? parts[1].trim() : sourceProp;
+            if (localName)
+                importSources.set(localName, { modRef: tmp, prop: sourceProp });
+            if (parts.length === 2)
+                return `${sourceProp}: ${localName}`;
+            return sourceProp;
+        }).filter((s) => s).join(', ');
+        return `\n${indent}${cjsDecl(tmp)} ${tmp} = require(${mod});\n${indent}${cjsDecl(defaultName)} ${defaultName} = ${tmp}.default || ${tmp};\n${indent}const { ${mapped} } = ${tmp};`;
+    });
+    // Combined: import X, * as Y from 'mod'
+    result = result.replace(/(?:^|\n)([ \t]*)import\s+([\w$]+)\s*,\s*\*\s*as\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g, (_match, indent, defaultName, nsName, mod) => {
+        return `\n${indent}${cjsDecl(nsName)} ${nsName} = require(${mod});\n${indent}${cjsDecl(defaultName)} ${defaultName} = ${nsName}.default || ${nsName};`;
+    });
+    // import { a, b as c } from 'mod'
+    result = result.replace(/(?:^|\n)([ \t]*)import\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g, (match, indent, imports, mod) => {
+        // Guard: ${ in captured names means regex matched inside a template literal
+        if (imports.includes('${'))
+            return match;
+        const modRef = '__imp_' + Math.random().toString(36).slice(2, 8);
+        const mapped = imports.split(',').map((s) => {
+            const parts = s.trim().split(/\s+as\s+/);
+            const sourceProp = parts[0].trim();
+            const localName = parts.length === 2 ? parts[1].trim() : sourceProp;
+            if (localName)
+                importSources.set(localName, { modRef, prop: sourceProp });
+            if (parts.length === 2)
+                return `${sourceProp}: ${localName}`;
+            return sourceProp;
+        }).filter((s) => s).join(', ');
+        return `\n${indent}const ${modRef} = require(${mod});\n${indent}const { ${mapped} } = ${modRef};`;
+    });
+    // import * as X from 'mod'
+    result = result.replace(/(?:^|\n)([ \t]*)import\s*\*\s*as\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g, (_match, indent, name, mod) => `\n${indent}${cjsDecl(name)} ${name} = require(${mod});`);
+    // import X from 'mod' (default import)
+    result = result.replace(/(?:^|\n)([ \t]*)import\s+([\w$]+)\s+from\s*(['"][^'"]+['"])[ \t]*;?/g, (_match, indent, name, mod) => `\n${indent}${cjsDecl(name)} ${name} = require(${mod});`);
+    // import 'mod' (side-effect)
+    result = result.replace(/(?:^|\n)([ \t]*)import\s*(['"][^'"]+['"])[ \t]*;?/g, (_match, indent, mod) => `\n${indent}require(${mod});`);
+    // --- Export transforms ---
+    // Strip empty export{} (bundler ESM marker, no-op)
+    result = result.replace(/(?:^|\n)[ \t]*export\s*\{\s*\}[ \t]*;?/g, '');
+    // export * from 'mod' — use getter-based forwarding for live bindings
+    result = result.replace(/(?:^|\n)([ \t]*)export\s*\*\s*from\s*(['"][^'"]+['"])[ \t]*;?/g, (_match, indent, mod) => {
+        const tmpVar = '__star_' + Math.random().toString(36).slice(2, 8);
+        return `\n${indent}const ${tmpVar} = require(${mod});\n${indent}Object.keys(${tmpVar}).forEach(function(k) { if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, { get: function() { return ${tmpVar}[k]; }, enumerable: true, configurable: true }); });`;
+    });
+    // export { a, b } from 'mod' (re-export) — use getters for live bindings
+    // (handles circular dependencies where source module isn't fully populated yet)
+    result = result.replace(/(?:^|\n)([ \t]*)export\s*\{([^}]+)\}\s*from\s*(['"][^'"]+['"])[ \t]*;?/g, (match, indent, names, mod) => {
+        // Guard: ${ in captured names means regex matched inside a template literal
+        if (names.includes('${'))
+            return match;
+        const tmpVar = '__re_' + Math.random().toString(36).slice(2, 8);
+        const assignments = names.split(',').map((s) => {
+            const parts = s.trim().split(/\s+as\s+/);
+            const local = parts[0].trim();
+            const exported = parts.length === 2 ? parts[1].trim() : local;
+            return `${indent}Object.defineProperty(exports, '${exported}', { get() { return ${tmpVar}.${local}; }, enumerable: true, configurable: true });`;
+        }).join('\n');
+        return `\n${indent}const ${tmpVar} = require(${mod});\n${assignments}`;
+    });
+    // export default <expr> — must come before named export { }
+    if (hasDefaultExport && hasNamedExport) {
+        result = result.replace(/(?:^|\n)([ \t]*)export\s+default\s+/g, (_match, indent) => `\n${indent}exports.default = `);
+    }
+    else {
+        result = result.replace(/(?:^|\n)([ \t]*)export\s+default\s+/g, (_match, indent) => `\n${indent}module.exports = `);
+    }
+    // export const/let/var x = ...
+    result = result.replace(/(?:^|\n)([ \t]*)export\s+(const|let|var)\s+([\w$]+)\s*=/g, (match, indent, keyword, name) => {
+        // Guard: ${ means regex matched inside a template literal
+        if (match.includes('${'))
+            return match;
+        return `\n${indent}${keyword} ${name} = exports.${name} =`;
+    });
+    // export function f(...) / export async function f(...) / export class C
+    result = result.replace(/(?:^|\n)([ \t]*)export\s+(async\s+function\s+([\w$]+)|function\s+([\w$]+)|class\s+([\w$]+))/g, (match, indent, decl, asyncFnName, fnName, className, offset) => {
+        // Guard: if char after match is '{', it's a template literal `export function ${fn}`
+        // Real exports have '(' after function name or '{' after class + whitespace
+        const nextChar = result.charAt(offset + match.length);
+        if (nextChar === '{')
+            return match;
+        const name = asyncFnName || fnName || className;
+        trailingExports.push(`exports.${name} = ${name};`);
+        return `\n${indent}${decl}`;
+    });
+    // export { a, b as c } (local exports, no from)
+    // Use trailing exports to ensure declarations are fully initialized.
+    // For names that were imported from another module, use getters pointing
+    // back to the source module reference — this creates ESM-like live bindings
+    // that survive circular dependencies.
+    result = result.replace(/(?:^|\n)([ \t]*)export\s*\{([^}]+)\}[ \t]*;?/g, (match, _indent, names) => {
+        // Guard: ${ in captured names means regex matched inside a template literal
+        if (names.includes('${'))
+            return match;
+        names.split(',').forEach((s) => {
+            const parts = s.trim().split(/\s+as\s+/);
+            const local = parts[0].trim();
+            const exported = parts.length === 2 ? parts[1].trim() : local;
+            if (!local)
+                return;
+            const src = importSources.get(local);
+            if (src) {
+                // Imported name → lazy getter reading from source module reference
+                trailingExports.push(`Object.defineProperty(exports, '${exported}', { get: function() { return ${src.modRef}.${src.prop}; }, enumerable: true, configurable: true });`);
+            }
+            else {
+                // Locally defined → direct assignment at end of file
+                trailingExports.push(`exports.${exported} = ${local};`);
+            }
+        });
+        return '';
+    });
+    // --- Other transforms ---
+    // Dynamic import() with string literal → Promise.resolve(require())
+    // Negative lookbehind: skip obj.import('...') where '.' precedes import
+    result = result.replace(/(?<!\.)(?<!\w)\bimport\s*\(\s*(['"][^'"]+['"])\s*\)/g, (_match, mod) => `Promise.resolve(require(${mod}))`);
+    // Dynamic import() with any expression (variables, template literals, nested parens, etc.)
+    // Must come AFTER the string-literal version above.
+    // Use programmatic paren-balancing since regex can't handle nested parens.
+    {
+        let i = 0;
+        let out = '';
+        while (i < result.length) {
+            // Look for `import(`
+            const importIdx = result.indexOf('import(', i);
+            if (importIdx === -1) {
+                out += result.slice(i);
+                break;
+            }
+            // Check word boundary: char before 'import' must not be [\w$.] (dot = method call)
+            if (importIdx > 0 && /[\w$.]/.test(result[importIdx - 1])) {
+                out += result.slice(i, importIdx + 7);
+                i = importIdx + 7;
+                continue;
+            }
+            // Skip class/object method definitions like `async import(url) {` or `import(url) {`
+            // Method definitions have `) {` after the parameter list (opening method body).
+            // Dynamic imports NEVER have `{` directly after `)`.
+            {
+                let depth = 1;
+                let k = importIdx + 7;
+                while (k < result.length && depth > 0) {
+                    if (result[k] === '(')
+                        depth++;
+                    else if (result[k] === ')')
+                        depth--;
+                    k++;
+                }
+                if (depth === 0) {
+                    let afterClose = k;
+                    while (afterClose < result.length && /[ \t]/.test(result[afterClose]))
+                        afterClose++;
+                    if (result[afterClose] === '{') {
+                        // This is a method/function definition, not a dynamic import — skip
+                        out += result.slice(i, importIdx + 7);
+                        i = importIdx + 7;
+                        continue;
+                    }
+                }
+            }
+            out += result.slice(i, importIdx);
+            // Find matching close paren with depth tracking
+            let depth = 1;
+            let j = importIdx + 7; // after 'import('
+            while (j < result.length && depth > 0) {
+                if (result[j] === '(')
+                    depth++;
+                else if (result[j] === ')')
+                    depth--;
+                j++;
+            }
+            if (depth === 0) {
+                const arg = result.slice(importIdx + 7, j - 1);
+                out += `Promise.resolve().then(function() { return require(${arg}); })`;
+            }
+            else {
+                // Unbalanced — leave as-is
+                out += result.slice(importIdx, j);
+            }
+            i = j;
+        }
+        result = out;
+    }
+    // --- Final fixups ---
+    // Replace const/let declarations of CJS wrapper param names with var.
+    // esbuild bundles often emit `const __dirname = ...` which collides with
+    // the new Function() wrapper parameters. `var` can shadow them safely.
+    result = result.replace(/\b(const|let)\s+(__dirname|__filename|exports|require|module|console|process|Buffer|global)\b/g, (_match, _kw, name) => `var ${name}`);
+    // Append trailing exports for exported functions/classes
+    if (trailingExports.length > 0) {
+        result += '\n' + trailingExports.join('\n');
+    }
+    // Restore original string/template literal contents
+    result = unmaskStringLiterals(result, literals);
+    return result;
+}
+function createNodeImpl(kernelOrPortRegistry) {
+    return async (ctx) => {
+        // Handle -v/--version
+        if (ctx.args.length > 0 && (ctx.args[0] === '-v' || ctx.args[0] === '--version')) {
+            ctx.stdout.write(NODE_VERSION + '\n');
+            return 0;
+        }
+        // Handle --help
+        if (ctx.args.length > 0 && ctx.args[0] === '--help') {
+            ctx.stdout.write('Usage: node [-e code] [script.js] [args...]\n');
+            ctx.stdout.write('       node -v\n\n');
+            ctx.stdout.write('Options:\n');
+            ctx.stdout.write('  -e, --eval <code>   evaluate code\n');
+            ctx.stdout.write('  -v, --version       print version\n\n');
+            ctx.stdout.write('Limitations:\n');
+            ctx.stdout.write('  - ESM support via auto-transform (import/export → require/exports)\n');
+            ctx.stdout.write('  - No event loop (top-level async does not settle)\n');
+            ctx.stdout.write('  - No native modules\n');
+            ctx.stdout.write('  - require() resolves: built-in modules, relative VFS files, installed packages\n');
+            return 0;
+        }
+        let source;
+        let filename;
+        let scriptArgs;
+        // Handle -e / --eval
+        if (ctx.args.length > 0 && (ctx.args[0] === '-e' || ctx.args[0] === '--eval')) {
+            if (ctx.args.length < 2) {
+                ctx.stderr.write('node: -e requires an argument\n');
+                return 1;
+            }
+            source = ctx.args[1];
+            filename = '[eval]';
+            scriptArgs = ctx.args.slice(2);
+        }
+        else if (ctx.args.length > 0) {
+            // Run script file
+            const scriptPath = resolve(ctx.cwd, ctx.args[0]);
+            try {
+                source = ctx.vfs.readFileString(scriptPath);
+            }
+            catch (e) {
+                if (e instanceof VFSError) {
+                    ctx.stderr.write(`node: ${ctx.args[0]}: ${e.message}\n`);
+                    return 1;
+                }
+                throw e;
+            }
+            filename = scriptPath;
+            scriptArgs = ctx.args.slice(1);
+        }
+        else {
+            // No args -- print usage hint
+            ctx.stderr.write('Usage: node [-e code] [script.js] [args...]\n');
+            return 1;
+        }
+        const dir = filename === '[eval]' ? ctx.cwd : dirname(filename);
+        // Extract portRegistry from either Kernel or direct Map
+        const portRegistry = kernelOrPortRegistry instanceof Map
+            ? kernelOrPortRegistry
+            : kernelOrPortRegistry?.portRegistry;
+        const nodeCtx = {
+            vfs: ctx.vfs,
+            cwd: ctx.cwd,
+            env: ctx.env,
+            stdout: ctx.stdout,
+            stderr: ctx.stderr,
+            argv: [filename, ...scriptArgs],
+            filename,
+            dirname: dir,
+            signal: ctx.signal,
+            portRegistry,
+            routeLoopback: kernelOrPortRegistry instanceof Map
+                ? undefined
+                : kernelOrPortRegistry?.routeLoopback,
+        };
+        const moduleMap = createModuleMap(nodeCtx);
+        const moduleCache = new Map();
+        // Stub for @rollup/rollup-* native binary packages (platform-specific NAPI addons).
+        // These can't work in a browser environment. Provide shims for the exported functions.
+        // Vite's dev server primarily uses es-module-lexer, not rollup's parser, so these
+        // may never be called. If they are, hash stubs return safe defaults; parse stubs throw.
+        const rollupNativeStub = {
+            parse: () => { throw new Error('[lifo] rollup native parser is not available in browser'); },
+            parseAsync: () => Promise.reject(new Error('[lifo] rollup native parser is not available in browser')),
+            xxhashBase64Url: (data) => {
+                // Simple fallback hash — not cryptographically equivalent but sufficient for cache keys
+                const s = typeof data === 'string' ? data : String(data);
+                let h = 0;
+                for (let i = 0; i < s.length; i++)
+                    h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+                return (h >>> 0).toString(36);
+            },
+            xxhashBase36: (data) => {
+                const s = typeof data === 'string' ? data : String(data);
+                let h = 0;
+                for (let i = 0; i < s.length; i++)
+                    h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+                return (h >>> 0).toString(36);
+            },
+            xxhashBase16: (data) => {
+                const s = typeof data === 'string' ? data : String(data);
+                let h = 0;
+                for (let i = 0; i < s.length; i++)
+                    h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;
+                return (h >>> 0).toString(16);
+            },
+        };
+        // Build require function (declared first, module shim overrides below)
+        function nodeRequire(name) {
+            // Strip node: prefix
+            if (name.startsWith('node:'))
+                name = name.slice(5);
+            // Check cache
+            if (moduleCache.has(name))
+                return moduleCache.get(name);
+            // Built-in modules
+            if (moduleMap[name]) {
+                const mod = moduleMap[name]();
+                moduleCache.set(name, mod);
+                return mod;
+            }
+            // Subpath imports (#specifier)
+            if (name.startsWith('#')) {
+                const resolved = resolvePackageImport(name, dir);
+                if (resolved) {
+                    const cached = moduleCache.get(resolved.path);
+                    if (cached)
+                        return cached;
+                    const modSource = ctx.vfs.readFileString(resolved.path);
+                    return executeModule(modSource, resolved.path, resolved.path);
+                }
+                throw new Error(`Cannot find module '${name}'`);
+            }
+            // Relative VFS files
+            if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
+                const resolved = resolveVfsModule(name, dir);
+                if (resolved) {
+                    const cached = moduleCache.get(resolved.path);
+                    if (cached)
+                        return cached;
+                    if (resolved.path.endsWith('.json')) {
+                        const content = ctx.vfs.readFileString(resolved.path);
+                        const parsed = JSON.parse(content);
+                        moduleCache.set(resolved.path, parsed);
+                        return parsed;
+                    }
+                    const modSource = ctx.vfs.readFileString(resolved.path);
+                    return executeModule(modSource, resolved.path, resolved.path);
+                }
+                throw new Error(`Cannot find module '${name}'`);
+            }
+            // Node-modules resolution (walk up node_modules, global, legacy)
+            const nmResolved = resolveNodeModule(name, dir);
+            if (nmResolved) {
+                const cached = moduleCache.get(nmResolved.path);
+                if (cached)
+                    return cached;
+                if (nmResolved.path.endsWith('.json')) {
+                    const content = ctx.vfs.readFileString(nmResolved.path);
+                    const parsed = JSON.parse(content);
+                    moduleCache.set(nmResolved.path, parsed);
+                    return parsed;
+                }
+                const modSource = ctx.vfs.readFileString(nmResolved.path);
+                return executeModule(modSource, nmResolved.path, nmResolved.path);
+            }
+            // Stub for rollup native binary packages
+            if (name.startsWith('@rollup/rollup-'))
+                return rollupNativeStub;
+            throw new Error(`Cannot find module '${name}'`);
+        }
+        // Override module shim so createRequire returns nodeRequire (resolves VFS + node_modules)
+        moduleMap.module = () => {
+            const createRequire = (_filename) => nodeRequire;
+            const builtinNames = Object.keys(moduleMap);
+            const isBuiltin = (s) => {
+                const n = s.startsWith('node:') ? s.slice(5) : s;
+                return builtinNames.includes(n);
+            };
+            return { createRequire, builtinModules: builtinNames, isBuiltin, default: { createRequire } };
+        };
+        function resolveVfsModule(name, fromDir) {
+            const absPath = resolve(fromDir, name);
+            // Try exact path
+            if (ctx.vfs.exists(absPath)) {
+                try {
+                    const stat = ctx.vfs.stat(absPath);
+                    if (stat.type === 'file')
+                        return { path: absPath };
+                    // Directory -- try index.js
+                    const indexPath = join(absPath, 'index.js');
+                    if (ctx.vfs.exists(indexPath))
+                        return { path: indexPath };
+                }
+                catch { /* fall through */ }
+            }
+            // Try .js extension
+            if (!extname(absPath) && ctx.vfs.exists(absPath + '.js')) {
+                return { path: absPath + '.js' };
+            }
+            // Try .mjs extension
+            if (!extname(absPath) && ctx.vfs.exists(absPath + '.mjs')) {
+                return { path: absPath + '.mjs' };
+            }
+            // Try .json extension
+            if (!extname(absPath) && ctx.vfs.exists(absPath + '.json')) {
+                return { path: absPath + '.json' };
+            }
+            return null;
+        }
+        // ── Subpath imports (#specifier) resolution ──
+        // Node.js package.json "imports" field: #name → conditional file path
+        function resolvePackageImport(name, fromDir) {
+            // Walk up to find the nearest package.json with an "imports" field
+            let current = fromDir;
+            for (;;) {
+                const pkgPath = join(current, 'package.json');
+                if (ctx.vfs.exists(pkgPath)) {
+                    try {
+                        const pkg = JSON.parse(ctx.vfs.readFileString(pkgPath));
+                        if (pkg.imports && typeof pkg.imports === 'object') {
+                            const importsMap = pkg.imports;
+                            if (name in importsMap) {
+                                const target = resolveExportsCondition(importsMap[name]);
+                                if (target) {
+                                    return resolveVfsModule(target, current);
+                                }
+                            }
+                        }
+                    }
+                    catch { /* ignore parse errors */ }
+                    break; // Stop at nearest package.json (Node.js semantics)
+                }
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            return null;
+        }
+        // ── Node-modules resolution (walk up, global, legacy) ──
+        function resolveNodeModule(name, fromDir) {
+            // Parse package name and optional subpath
+            let packageName;
+            let subpath = null;
+            if (name.startsWith('@')) {
+                const parts = name.split('/');
+                if (parts.length < 2)
+                    return null;
+                packageName = parts[0] + '/' + parts[1];
+                if (parts.length > 2)
+                    subpath = parts.slice(2).join('/');
+            }
+            else {
+                const slashIdx = name.indexOf('/');
+                if (slashIdx !== -1) {
+                    packageName = name.slice(0, slashIdx);
+                    subpath = name.slice(slashIdx + 1);
+                }
+                else {
+                    packageName = name;
+                }
+            }
+            // Walk up from fromDir
+            let current = fromDir;
+            for (;;) {
+                const candidate = join(current, 'node_modules', packageName);
+                if (ctx.vfs.exists(candidate)) {
+                    const resolved = resolvePackageEntry(candidate, subpath);
+                    if (resolved)
+                        return resolved;
+                }
+                const parent = dirname(current);
+                if (parent === current)
+                    break;
+                current = parent;
+            }
+            // Global modules
+            const globalCandidate = join('/usr/lib/node_modules', packageName);
+            if (ctx.vfs.exists(globalCandidate)) {
+                const resolved = resolvePackageEntry(globalCandidate, subpath);
+                if (resolved)
+                    return resolved;
+            }
+            // Legacy location (pkg command)
+            const legacyCandidate = join('/usr/share/pkg/node_modules', packageName);
+            if (ctx.vfs.exists(legacyCandidate)) {
+                const resolved = resolvePackageEntry(legacyCandidate, subpath);
+                if (resolved)
+                    return resolved;
+            }
+            return null;
+        }
+        /** Resolve a conditional exports value (string | { require, import, default, ... }) */
+        function resolveExportsCondition(value) {
+            if (typeof value === 'string')
+                return value;
+            if (value && typeof value === 'object' && !Array.isArray(value)) {
+                const cond = value;
+                // Prefer require (CJS), then default, then import (ESM)
+                if (typeof cond.require === 'string')
+                    return cond.require;
+                if (typeof cond.default === 'string')
+                    return cond.default;
+                if (typeof cond.import === 'string')
+                    return cond.import;
+                // Recurse into nested conditions (e.g. { node: { require: ... } })
+                for (const key of Object.keys(cond)) {
+                    if (key === 'types')
+                        continue; // skip TS declarations
+                    const nested = resolveExportsCondition(cond[key]);
+                    if (nested)
+                        return nested;
+                }
+            }
+            return null;
+        }
+        function resolvePackageEntry(pkgDir, subpath) {
+            const pkgJsonPath = join(pkgDir, 'package.json');
+            let pkgJson = null;
+            if (ctx.vfs.exists(pkgJsonPath)) {
+                try {
+                    pkgJson = JSON.parse(ctx.vfs.readFileString(pkgJsonPath));
+                }
+                catch { /* ignore */ }
+            }
+            // --- Subpath resolution (e.g. require('rollup/parseAst')) ---
+            if (subpath) {
+                // 1. Check exports map first (Node.js subpath exports)
+                if (pkgJson?.exports && typeof pkgJson.exports === 'object') {
+                    const exportsMap = pkgJson.exports;
+                    const key = './' + subpath;
+                    if (key in exportsMap) {
+                        const target = resolveExportsCondition(exportsMap[key]);
+                        if (target) {
+                            const resolved = resolveVfsModule(target, pkgDir);
+                            if (resolved)
+                                return resolved;
+                        }
+                    }
+                    // Also try wildcard/glob patterns like "./dist/*": "./dist/*"
+                    for (const pattern of Object.keys(exportsMap)) {
+                        if (pattern.endsWith('/*') && key.startsWith(pattern.slice(0, -1))) {
+                            const targetPattern = resolveExportsCondition(exportsMap[pattern]);
+                            if (targetPattern && targetPattern.endsWith('/*')) {
+                                const suffix = key.slice(pattern.length - 1);
+                                const target = targetPattern.slice(0, -1) + suffix;
+                                const resolved = resolveVfsModule(target, pkgDir);
+                                if (resolved)
+                                    return resolved;
+                            }
+                        }
+                    }
+                }
+                // 2. Fall back to direct file resolution
+                return resolveVfsModule('./' + subpath, pkgDir);
+            }
+            // --- Root resolution (e.g. require('rollup')) ---
+            // 1. Check exports["."] first
+            if (pkgJson?.exports) {
+                const exportsVal = pkgJson.exports;
+                let rootExport = null;
+                if (typeof exportsVal === 'string') {
+                    rootExport = exportsVal;
+                }
+                else if (typeof exportsVal === 'object' && !Array.isArray(exportsVal)) {
+                    const exportsMap = exportsVal;
+                    rootExport = exportsMap['.'] ?? null;
+                    // Handle case where exports IS the condition map (no "." key)
+                    if (!rootExport && ('require' in exportsMap || 'import' in exportsMap || 'default' in exportsMap)) {
+                        rootExport = exportsMap;
+                    }
+                }
+                if (rootExport) {
+                    const target = resolveExportsCondition(rootExport);
+                    if (target) {
+                        const resolved = resolveVfsModule(target, pkgDir);
+                        if (resolved)
+                            return resolved;
+                    }
+                }
+            }
+            // 2. Check main field
+            if (pkgJson?.main && typeof pkgJson.main === 'string') {
+                const resolved = resolveVfsModule('./' + pkgJson.main, pkgDir);
+                if (resolved)
+                    return resolved;
+            }
+            // 3. Default to index.js
+            const indexPath = join(pkgDir, 'index.js');
+            if (ctx.vfs.exists(indexPath))
+                return { path: indexPath };
+            return null;
+        }
+        function executeModule(modSource, modFilename, cacheAs) {
+            const modDir = dirname(modFilename);
+            const modModule = { exports: {} };
+            const modExports = modModule.exports;
+            // Pre-cache to handle circular dependencies (Node.js behaviour)
+            if (cacheAs) {
+                moduleCache.set(cacheAs, modExports);
+            }
+            const modNodeCtx = { ...nodeCtx, filename: modFilename, dirname: modDir };
+            const modModuleMap = createModuleMap(modNodeCtx);
+            const modProcess = createProcess({
+                argv: nodeCtx.argv,
+                env: nodeCtx.env,
+                cwd: nodeCtx.cwd,
+                stdout: ctx.stdout,
+                stderr: ctx.stderr,
+            });
+            const modConsole = createConsole(ctx.stdout, ctx.stderr);
+            function modRequire(name) {
+                // Strip node: prefix
+                if (name.startsWith('node:'))
+                    name = name.slice(5);
+                // Built-in modules from child context
+                if (modModuleMap[name]) {
+                    const cached = moduleCache.get(name);
+                    if (cached)
+                        return cached;
+                    const mod = modModuleMap[name]();
+                    moduleCache.set(name, mod);
+                    return mod;
+                }
+                // Subpath imports (#specifier)
+                if (name.startsWith('#')) {
+                    const resolved = resolvePackageImport(name, modDir);
+                    if (resolved) {
+                        const cached = moduleCache.get(resolved.path);
+                        if (cached)
+                            return cached;
+                        const childSource = ctx.vfs.readFileString(resolved.path);
+                        return executeModule(childSource, resolved.path, resolved.path);
+                    }
+                    throw new Error(`Cannot find module '${name}'`);
+                }
+                if (name.startsWith('./') || name.startsWith('../') || name.startsWith('/')) {
+                    const resolved = resolveVfsModule(name, modDir);
+                    if (resolved) {
+                        const cached = moduleCache.get(resolved.path);
+                        if (cached)
+                            return cached;
+                        if (resolved.path.endsWith('.json')) {
+                            const content = ctx.vfs.readFileString(resolved.path);
+                            const parsed = JSON.parse(content);
+                            moduleCache.set(resolved.path, parsed);
+                            return parsed;
+                        }
+                        const childSource = ctx.vfs.readFileString(resolved.path);
+                        return executeModule(childSource, resolved.path, resolved.path);
+                    }
+                    throw new Error(`Cannot find module '${name}'`);
+                }
+                // Node-modules resolution from this module's directory
+                const nmResolved = resolveNodeModule(name, modDir);
+                if (nmResolved) {
+                    const cached = moduleCache.get(nmResolved.path);
+                    if (cached)
+                        return cached;
+                    if (nmResolved.path.endsWith('.json')) {
+                        const content = ctx.vfs.readFileString(nmResolved.path);
+                        const parsed = JSON.parse(content);
+                        moduleCache.set(nmResolved.path, parsed);
+                        return parsed;
+                    }
+                    const childSource = ctx.vfs.readFileString(nmResolved.path);
+                    return executeModule(childSource, nmResolved.path, nmResolved.path);
+                }
+                // Stub for rollup native binary packages
+                if (name.startsWith('@rollup/rollup-'))
+                    return rollupNativeStub;
+                throw new Error(`Cannot find module '${name}'`);
+            }
+            // Override module shim so createRequire returns modRequire (resolves VFS + node_modules too)
+            modModuleMap.module = () => {
+                const createRequire = (_filename) => modRequire;
+                const builtinNames = Object.keys(modModuleMap);
+                const isBuiltin = (s) => {
+                    const n = s.startsWith('node:') ? s.slice(5) : s;
+                    return builtinNames.includes(n);
+                };
+                return { createRequire, builtinModules: builtinNames, isBuiltin, default: { createRequire } };
+            };
+            let cleanSource = stripShebang(modSource);
+            if (shouldTreatAsEsm(cleanSource, modFilename, ctx.vfs)) {
+                cleanSource = transformEsmToCjs(cleanSource);
+            }
+            const wrapped = `(function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {\n${cleanSource}\n})`;
+            let fn;
+            try {
+                fn = new Function('return ' + wrapped)();
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(String(e));
+                ctx.stderr.write(`[ESM-FAIL] file=${modFilename} srcLen=${modSource.length} err=${err.message}\n`);
+                // Binary search for exact error location, matching specific error
+                const lines = cleanSource.split('\n');
+                const targetErr = err.message;
+                let lo = 0, hi = lines.length;
+                while (hi - lo > 3) {
+                    const mid = (lo + hi) >>> 1;
+                    const partial = lines.slice(0, mid).join('\n');
+                    try {
+                        new Function(partial);
+                        lo = mid;
+                    }
+                    catch (e2) {
+                        if (e2 instanceof Error && e2.message === targetErr)
+                            hi = mid;
+                        else
+                            lo = mid; // Different error (e.g. unclosed), keep going
+                    }
+                }
+                ctx.stderr.write(`[ESM-FAIL] error at L${lo}-${hi}, showing L${Math.max(1, lo - 25)} to L${hi + 3}:\n`);
+                for (let li = Math.max(0, lo - 25); li < Math.min(lines.length, hi + 3); li++) {
+                    ctx.stderr.write(`[ESM-FAIL] ${li + 1 === lo || li + 1 === hi ? '>>>' : '   '} L${li + 1}: ${lines[li]?.slice(0, 200)}\n`);
+                }
+                err.message = `[${modFilename}] ${err.message}`;
+                throw err;
+            }
+            const global = { process: modProcess, Buffer, console: modConsole };
+            // Many npm bundles access globalThis.process directly (not the wrapper param).
+            // Only override in browser-like envs; skip in real Node.js (test runner).
+            const ga = globalThis;
+            const isRealNode = typeof ga.process?.pid === 'number';
+            const savedProcess = ga.process;
+            const savedBuffer = ga.Buffer;
+            const savedConsole = ga.console;
+            if (!isRealNode) {
+                ga.process = modProcess;
+                ga.Buffer = Buffer;
+                ga.console = modConsole;
+            }
+            // Inject Rollup/esbuild interop helpers so bundled npm packages can find them
+            const savedHelpers = {};
+            for (const k of Object.keys(_rollupHelpers)) {
+                savedHelpers[k] = ga[k];
+                ga[k] = _rollupHelpers[k];
+            }
+            const importMetaUrl = 'file://' + modFilename;
+            const importMeta = { url: importMetaUrl, dirname: modDir, filename: modFilename };
+            const importMetaResolve = (specifier) => { throw new Error(`import.meta.resolve('${specifier}') is not supported`); };
+            try {
+                fn(modExports, modRequire, modModule, modFilename, modDir, modConsole, modProcess, Buffer, globalThis.setTimeout, globalThis.setInterval, globalThis.clearTimeout, globalThis.clearInterval, global, importMetaUrl, importMeta, importMetaResolve);
+            }
+            catch (e) {
+                if (e instanceof ProcessExitError)
+                    throw e;
+                const err = e instanceof Error ? e : new Error(String(e));
+                if (!err.message.includes('[/')) {
+                    err.message = `[${modFilename}] ${err.message}`;
+                }
+                throw err;
+            }
+            finally {
+                for (const k of Object.keys(savedHelpers))
+                    ga[k] = savedHelpers[k];
+                if (!isRealNode) {
+                    ga.process = savedProcess;
+                    ga.Buffer = savedBuffer;
+                    ga.console = savedConsole;
+                }
+            }
+            // Update cache if module.exports was reassigned (not just mutated)
+            if (cacheAs && modModule.exports !== modExports) {
+                moduleCache.set(cacheAs, modModule.exports);
+            }
+            return modModule.exports;
+        }
+        // Execute main script
+        const process = createProcess({
+            argv: nodeCtx.argv,
+            env: nodeCtx.env,
+            cwd: nodeCtx.cwd,
+            stdout: ctx.stdout,
+            stderr: ctx.stderr,
+        });
+        const nodeConsole = createConsole(ctx.stdout, ctx.stderr);
+        const module = { exports: {} };
+        const exports = module.exports;
+        const global = { process, Buffer, console: nodeConsole };
+        let cleanMainSource = stripShebang(source);
+        const isEsm = shouldTreatAsEsm(cleanMainSource, filename, ctx.vfs);
+        if (isEsm) {
+            cleanMainSource = transformEsmToCjs(cleanMainSource);
+        }
+        // Use async IIFE for ESM (supports top-level await)
+        const wrapped = isEsm
+            ? `(async function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {\n${cleanMainSource}\n})`
+            : `(function(exports, require, module, __filename, __dirname, console, process, Buffer, setTimeout, setInterval, clearTimeout, clearInterval, global, __importMetaUrl, __importMeta, __importMetaResolve) {\n${cleanMainSource}\n})`;
+        // Many npm bundles access globalThis.process directly (not the wrapper param).
+        // Only override in browser-like envs; skip in real Node.js (test runner).
+        const ga = globalThis;
+        const isRealNode = typeof ga.process?.pid === 'number';
+        const savedProcess = ga.process;
+        const savedBuffer = ga.Buffer;
+        const savedConsole = ga.console;
+        if (!isRealNode) {
+            ga.process = process;
+            ga.Buffer = Buffer;
+            ga.console = nodeConsole;
+        }
+        // Inject Rollup/esbuild interop helpers so bundled npm packages can find them
+        const savedHelpers = {};
+        for (const k of Object.keys(_rollupHelpers)) {
+            savedHelpers[k] = ga[k];
+            ga[k] = _rollupHelpers[k];
+        }
+        // Capture unhandled promise rejections from fire-and-forget async actions
+        let pendingRejection = null;
+        const rejectionHandler = (event) => {
+            pendingRejection = event.reason;
+            event.preventDefault(); // prevent browser default logging
+            ctx.stderr.write(`Unhandled promise rejection: ${event.reason instanceof Error ? event.reason.stack || event.reason.message : String(event.reason)}\n`);
+        };
+        if (typeof globalThis.addEventListener === 'function') {
+            globalThis.addEventListener('unhandledrejection', rejectionHandler);
+        }
+        const mainImportMetaUrl = 'file://' + filename;
+        const mainImportMeta = { url: mainImportMetaUrl, dirname: dir, filename };
+        const mainImportMetaResolve = (specifier) => { throw new Error(`import.meta.resolve('${specifier}') is not supported`); };
+        try {
+            const fn = new Function('return ' + wrapped)();
+            const result = fn(exports, nodeRequire, module, filename, dir, nodeConsole, process, Buffer, globalThis.setTimeout, globalThis.setInterval, globalThis.clearTimeout, globalThis.clearInterval, global, mainImportMetaUrl, mainImportMeta, mainImportMetaResolve);
+            // Await if ESM (async IIFE returns a promise)
+            if (isEsm && result && typeof result.then === 'function') {
+                await result;
+            }
+            // Check if any servers were started (long-running process).
+            // Many CLI tools (e.g. vite) fire async actions from cli.parse() whose
+            // promises are discarded. We poll briefly to let those async chains
+            // progress and create servers before deciding the process is done.
+            // Only poll if http was actually loaded (indicating server intent).
+            const getActiveServers = () => {
+                const httpMod = moduleCache.get('http');
+                return httpMod?.[ACTIVE_SERVERS];
+            };
+            let activeServers = getActiveServers();
+            if ((!activeServers || activeServers.length === 0) && isEsm) {
+                // ESM scripts may have fire-and-forget async actions (e.g. vite's
+                // cli.parse() triggers an async action whose promise is discarded).
+                // Yield briefly to let those chains start, then poll for servers.
+                // Phase 1: Quick yield — watch for new modules being loaded, which
+                // indicates async work is in progress. Stop early if nothing changes.
+                let prevCacheSize = moduleCache.size;
+                let staleCount = 0;
+                const quickDeadline = Date.now() + 2000;
+                while (Date.now() < quickDeadline) {
+                    await new Promise((r) => setTimeout(r, 30));
+                    activeServers = getActiveServers();
+                    if (activeServers && activeServers.length > 0)
+                        break;
+                    if (ctx.signal.aborted || pendingRejection)
+                        break;
+                    // If new modules are loading, async work is progressing
+                    const newSize = moduleCache.size;
+                    if (newSize > prevCacheSize) {
+                        staleCount = 0;
+                        prevCacheSize = newSize;
+                    }
+                    else {
+                        staleCount++;
+                        // No new modules for 5 ticks (150ms) — async chain likely done
+                        if (staleCount >= 5)
+                            break;
+                    }
+                }
+                // Phase 2: If http was loaded during Phase 1 (indicating server intent)
+                // but no servers yet, keep polling up to 10s for the full server startup.
+                if ((!activeServers || activeServers.length === 0) && moduleCache.has('http')) {
+                    const longDeadline = Date.now() + 10000;
+                    while (Date.now() < longDeadline) {
+                        await new Promise((r) => setTimeout(r, 50));
+                        activeServers = getActiveServers();
+                        if (activeServers && activeServers.length > 0)
+                            break;
+                        if (ctx.signal.aborted || pendingRejection)
+                            break;
+                    }
+                }
+            }
+            if (activeServers && activeServers.length > 0) {
+                // Collect all server promises
+                const serverPromises = activeServers
+                    .map((s) => s.getPromise())
+                    .filter((p) => p !== null);
+                if (serverPromises.length > 0) {
+                    // Wait for all servers to close OR for abort signal
+                    const abortPromise = new Promise((resolve) => {
+                        if (ctx.signal.aborted) {
+                            resolve();
+                            return;
+                        }
+                        ctx.signal.addEventListener('abort', () => resolve(), { once: true });
+                    });
+                    await Promise.race([
+                        Promise.all(serverPromises),
+                        abortPromise,
+                    ]);
+                    // On abort, close all active servers
+                    if (ctx.signal.aborted) {
+                        for (const server of [...activeServers]) {
+                            server.close();
+                        }
+                    }
+                }
+            }
+            // If an async action failed (e.g. unhandled rejection from ProcessExitError)
+            if (pendingRejection) {
+                if (pendingRejection instanceof ProcessExitError)
+                    return pendingRejection.exitCode;
+                return 1;
+            }
+            return 0;
+        }
+        catch (e) {
+            if (e instanceof ProcessExitError) {
+                return e.exitCode;
+            }
+            if (e instanceof Error) {
+                ctx.stderr.write(`${e.stack || e.message}\n`);
+            }
+            else {
+                ctx.stderr.write(`${String(e)}\n`);
+            }
+            return 1;
+        }
+        finally {
+            for (const k of Object.keys(savedHelpers))
+                ga[k] = savedHelpers[k];
+            if (!isRealNode) {
+                ga.process = savedProcess;
+                ga.Buffer = savedBuffer;
+                ga.console = savedConsole;
+            }
+            // Remove unhandled rejection listener
+            if (typeof globalThis.removeEventListener === 'function') {
+                globalThis.removeEventListener('unhandledrejection', rejectionHandler);
+            }
+        }
+    };
+}
+export function createNodeCommand(kernel) {
+    return createNodeImpl(kernel);
+}
+// Default command with a shared portRegistry so http.createServer works
+const defaultPortRegistry = new Map();
+const command = createNodeImpl(defaultPortRegistry);
+export default command;