@secure-exec/browser 0.0.0-agentos-dylib-base.edaa4a4

package/dist/runtime.js

@@ -0,0 +1,2296 @@
+import { createInMemoryFileSystem, InMemoryFileSystem, } from "./os-filesystem.js";
+import { guestEncodingBootstrapCode } from "./encoding.js";
+import { BROWSER_WASI_POLYFILL_CODE } from "./wasi-polyfill.js";
+import { PROCESS_SIGNAL_NUMBERS } from "./signals.js";
+import { BROWSER_UTIL_POLYFILL_CODE } from "./generated/util-polyfill.js";
+export const allowAllFs = () => true;
+export const allowAllNetwork = () => true;
+export const allowAllChildProcess = () => true;
+export const allowAllEnv = () => true;
+export const allowAll = {
+    fs: allowAllFs,
+    network: allowAllNetwork,
+    childProcess: allowAllChildProcess,
+    env: allowAllEnv,
+};
+function normalizePath(inputPath) {
+    if (!inputPath)
+        return "/";
+    let normalized = inputPath.startsWith("/") ? inputPath : `/${inputPath}`;
+    normalized = normalized.replace(/\/+/g, "/");
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+    }
+    const parts = normalized.split("/");
+    const resolved = [];
+    for (const part of parts) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            resolved.pop();
+            continue;
+        }
+        resolved.push(part);
+    }
+    return resolved.length === 0 ? "/" : `/${resolved.join("/")}`;
+}
+function dirname(inputPath) {
+    const normalized = normalizePath(inputPath);
+    if (normalized === "/")
+        return "/";
+    const parts = normalized.split("/").filter(Boolean);
+    return parts.length <= 1 ? "/" : `/${parts.slice(0, -1).join("/")}`;
+}
+export function permissionAllowed(decision) {
+    if (decision === undefined)
+        return true;
+    if (typeof decision === "boolean")
+        return decision;
+    return "allowed" in decision ? decision.allowed : decision.allow;
+}
+export function filterEnv(env, permissions) {
+    const source = env ?? {};
+    if (!permissions?.env)
+        return { ...source };
+    const output = {};
+    for (const [name, value] of Object.entries(source)) {
+        if (permissionAllowed(permissions.env({ name, value }))) {
+            output[name] = value;
+        }
+    }
+    return output;
+}
+export function createEnosysError(operation) {
+    const error = new Error(`ENOSYS: ${operation} is not supported`);
+    error.code = "ENOSYS";
+    return error;
+}
+export function createFsStub() {
+    return createInMemoryFileSystem();
+}
+export function createNetworkStub() {
+    return {
+        async fetch() {
+            throw createEnosysError("network.fetch");
+        },
+        async dnsLookup() {
+            return { error: "DNS not supported", code: "ENOSYS" };
+        },
+        async httpRequest() {
+            throw createEnosysError("network.httpRequest");
+        },
+    };
+}
+export function createCommandExecutorStub() {
+    return {
+        spawn() {
+            throw createEnosysError("child_process.spawn");
+        },
+    };
+}
+export function wrapCommandExecutor(adapter, permissions) {
+    if (!permissions?.childProcess)
+        return adapter;
+    const check = (command, args, options) => {
+        if (!permissionAllowed(permissions.childProcess?.({
+            command,
+            args,
+            cwd: options?.cwd,
+            env: options?.env,
+        }))) {
+            const error = new Error(`EACCES: blocked child_process spawn '${command}'`);
+            error.code = "EACCES";
+            throw error;
+        }
+    };
+    return {
+        spawn(command, args, options) {
+            check(command, args, options);
+            return adapter.spawn(command, args, options);
+        },
+    };
+}
+export function wrapFileSystem(filesystem, permissions) {
+    if (!permissions?.fs)
+        return filesystem;
+    const check = (path, operation) => {
+        if (!permissionAllowed(permissions.fs?.({ path, operation }))) {
+            throw new Error(`EACCES: blocked ${operation} on '${path}'`);
+        }
+    };
+    return {
+        readFile(path) {
+            check(path, "readFile");
+            return filesystem.readFile(path);
+        },
+        readTextFile(path) {
+            check(path, "readTextFile");
+            return filesystem.readTextFile(path);
+        },
+        readDir(path) {
+            check(path, "readDir");
+            return filesystem.readDir(path);
+        },
+        readDirWithTypes(path) {
+            check(path, "readDirWithTypes");
+            return filesystem.readDirWithTypes(path);
+        },
+        writeFile(path, content) {
+            check(path, "writeFile");
+            return filesystem.writeFile(path, content);
+        },
+        createDir(path) {
+            check(path, "createDir");
+            return filesystem.createDir(path);
+        },
+        mkdir(path, options) {
+            check(path, "mkdir");
+            return filesystem.mkdir(path, options);
+        },
+        exists(path) {
+            check(path, "exists");
+            return filesystem.exists(path);
+        },
+        stat(path) {
+            check(path, "stat");
+            return filesystem.stat(path);
+        },
+        removeFile(path) {
+            check(path, "removeFile");
+            return filesystem.removeFile(path);
+        },
+        removeDir(path) {
+            check(path, "removeDir");
+            return filesystem.removeDir(path);
+        },
+        rename(oldPath, newPath) {
+            check(oldPath, "rename");
+            check(newPath, "rename");
+            return filesystem.rename(oldPath, newPath);
+        },
+        realpath(path) {
+            check(path, "realpath");
+            return filesystem.realpath(path);
+        },
+        symlink(target, linkPath) {
+            check(linkPath, "symlink");
+            return filesystem.symlink(target, linkPath);
+        },
+        readlink(path) {
+            check(path, "readlink");
+            return filesystem.readlink(path);
+        },
+        lstat(path) {
+            check(path, "lstat");
+            return filesystem.lstat(path);
+        },
+        link(oldPath, newPath) {
+            check(oldPath, "link");
+            check(newPath, "link");
+            return filesystem.link(oldPath, newPath);
+        },
+        chmod(path, mode) {
+            check(path, "chmod");
+            return filesystem.chmod(path, mode);
+        },
+        chown(path, uid, gid) {
+            check(path, "chown");
+            return filesystem.chown(path, uid, gid);
+        },
+        utimes(path, atime, mtime) {
+            check(path, "utimes");
+            return filesystem.utimes(path, atime, mtime);
+        },
+        truncate(path, length) {
+            check(path, "truncate");
+            return filesystem.truncate(path, length);
+        },
+        pread(path, offset, length) {
+            check(path, "pread");
+            return filesystem.pread(path, offset, length);
+        },
+        pwrite(path, offset, data) {
+            check(path, "pwrite");
+            return filesystem.pwrite(path, offset, data);
+        },
+    };
+}
+export function wrapNetworkAdapter(adapter, permissions) {
+    if (!permissions?.network)
+        return adapter;
+    const check = (request) => {
+        if (!permissionAllowed(permissions.network?.(request))) {
+            throw new Error(`EACCES: blocked network access to '${request.url ?? request.host ?? ""}'`);
+        }
+    };
+    return {
+        async fetch(url, options) {
+            check({ url });
+            return adapter.fetch(url, options);
+        },
+        async dnsLookup(hostname) {
+            check({ host: hostname });
+            return adapter.dnsLookup(hostname);
+        },
+        async httpRequest(url, options) {
+            check({ url });
+            return adapter.httpRequest(url, options);
+        },
+    };
+}
+export async function mkdir(filesystem, path, options) {
+    if (typeof options === "boolean") {
+        return filesystem.mkdir(path, { recursive: options });
+    }
+    return filesystem.mkdir(path, options);
+}
+export async function loadFile(path, filesystem) {
+    try {
+        return await filesystem.readTextFile(path);
+    }
+    catch {
+        return null;
+    }
+}
+export async function moduleFormat(path, filesystem) {
+    if (path.startsWith("node:")) {
+        return "module";
+    }
+    const normalized = normalizePath(path);
+    if (normalized.endsWith(".mjs") || normalized.endsWith(".mts")) {
+        return "module";
+    }
+    if (normalized.endsWith(".cjs") || normalized.endsWith(".cts")) {
+        return "commonjs";
+    }
+    if (normalized.endsWith(".json")) {
+        return "json";
+    }
+    if (!normalized.endsWith(".js")) {
+        return null;
+    }
+    const packageType = await nearestPackageJsonType(normalized, filesystem);
+    return packageType === "module" ? "module" : "commonjs";
+}
+export async function resolveModule(specifier, fromPath, filesystem, mode = "require") {
+    if (specifier.startsWith("node:")) {
+        return specifier;
+    }
+    const fromDir = await resolveImporterDir(fromPath, filesystem);
+    if (specifier.startsWith("file:")) {
+        const filePath = fileUrlToPath(specifier);
+        return filePath === null ? null : resolvePath(filePath, filesystem, mode);
+    }
+    if (specifier.startsWith(".") || specifier.startsWith("/")) {
+        const base = specifier.startsWith("/")
+            ? specifier
+            : `${fromDir}/${specifier}`;
+        return resolvePath(base, filesystem, mode);
+    }
+    if (specifier.startsWith("#")) {
+        return resolvePackageImports(specifier, fromDir, filesystem, mode);
+    }
+    return ((await resolvePackageSelfReference(specifier, fromDir, filesystem, mode)) ??
+        resolveNodeModules(specifier, fromDir, filesystem, mode));
+}
+function fileUrlToPath(specifier) {
+    let pathname;
+    if (specifier.startsWith("file://")) {
+        pathname = specifier.slice("file://".length);
+    }
+    else {
+        pathname = specifier.slice("file:".length);
+    }
+    const terminator = pathname.search(/[?#]/);
+    if (terminator >= 0) {
+        pathname = pathname.slice(0, terminator);
+    }
+    if (!pathname.startsWith("/")) {
+        const slashIndex = pathname.indexOf("/");
+        if (slashIndex < 0) {
+            return null;
+        }
+        const host = pathname.slice(0, slashIndex);
+        if (host !== "" && host !== "localhost") {
+            return null;
+        }
+        pathname = pathname.slice(slashIndex);
+    }
+    try {
+        return normalizePath(decodeURIComponent(pathname));
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveImporterDir(fromPath, filesystem) {
+    let fromDir = normalizePath(fromPath);
+    try {
+        const stat = await filesystem.stat(fromDir);
+        if (!stat.isDirectory) {
+            return dirname(fromDir);
+        }
+        return await realpathOrSelf(fromDir, filesystem);
+    }
+    catch {
+        const basename = fromDir.split("/").at(-1) ?? "";
+        if (basename.includes(".")) {
+            fromDir = dirname(fromDir);
+        }
+        return fromDir;
+    }
+}
+async function realpathOrSelf(path, filesystem) {
+    try {
+        return normalizePath(await filesystem.realpath(path));
+    }
+    catch {
+        return normalizePath(path);
+    }
+}
+async function resolveNodeModules(specifier, fromDir, filesystem, mode) {
+    const parsed = parsePackageSpecifier(specifier);
+    if (!parsed) {
+        return null;
+    }
+    for (const dir of ancestorDirs(fromDir)) {
+        if (dir === "/node_modules" || dir.endsWith("/node_modules")) {
+            continue;
+        }
+        const packageDir = normalizePath(`${dir}/node_modules/${parsed.name}`);
+        const resolved = await resolvePackageEntry(packageDir, parsed.subpath, filesystem, mode);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    for (const root of ["/root/node_modules", "/node_modules"]) {
+        const resolved = await resolvePackageEntry(normalizePath(`${root}/${parsed.name}`), parsed.subpath, filesystem, mode);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+async function resolvePackageImports(specifier, fromDir, filesystem, mode) {
+    let dir = normalizePath(fromDir);
+    while (true) {
+        const packageJson = await readPackageJson(dir, filesystem);
+        if (packageJson && Object.hasOwn(packageJson, "imports")) {
+            const target = resolveImportsTarget(packageJson.imports, specifier, mode);
+            if (!target) {
+                return null;
+            }
+            const targetPath = target.startsWith("/") ? target : `${dir}/${target}`;
+            return resolvePath(targetPath, filesystem, mode);
+        }
+        if (dir === "/") {
+            break;
+        }
+        dir = dirname(dir);
+    }
+    return null;
+}
+async function resolvePackageSelfReference(specifier, fromDir, filesystem, mode) {
+    const parsed = parsePackageSpecifier(specifier);
+    if (!parsed) {
+        return null;
+    }
+    for (const dir of ancestorDirs(fromDir)) {
+        const packageJson = await readPackageJson(dir, filesystem);
+        if (packageJson && packageJson.name === parsed.name) {
+            return resolvePackageEntry(dir, parsed.subpath, filesystem, mode);
+        }
+    }
+    return null;
+}
+function parsePackageSpecifier(specifier) {
+    const parts = specifier.split("/").filter(Boolean);
+    if (parts.length === 0) {
+        return null;
+    }
+    if (parts[0]?.startsWith("@")) {
+        if (parts.length < 2) {
+            return null;
+        }
+        return {
+            name: `${parts[0]}/${parts[1]}`,
+            subpath: parts.slice(2).join("/"),
+        };
+    }
+    return {
+        name: parts[0] ?? "",
+        subpath: parts.slice(1).join("/"),
+    };
+}
+function ancestorDirs(fromDir) {
+    const dirs = [];
+    let current = normalizePath(fromDir);
+    while (true) {
+        dirs.push(current);
+        if (current === "/") {
+            break;
+        }
+        current = dirname(current);
+    }
+    return dirs;
+}
+async function resolvePackageEntry(packageDir, subpath, filesystem, mode) {
+    const packageJson = await readPackageJson(packageDir, filesystem);
+    if (packageJson && Object.hasOwn(packageJson, "exports")) {
+        const exportsSubpath = subpath ? `./${subpath}` : ".";
+        const exportsTarget = resolveExportsTarget(packageJson.exports, exportsSubpath, mode);
+        if (!exportsTarget) {
+            return null;
+        }
+        const targetPath = normalizePath(`${packageDir}/${exportsTarget}`);
+        return (await resolvePath(targetPath, filesystem, mode)) ?? targetPath;
+    }
+    if (subpath) {
+        return resolvePath(`${packageDir}/${subpath}`, filesystem, mode);
+    }
+    if (typeof packageJson?.main === "string" && packageJson.main.length > 0) {
+        const mainResolved = await resolvePath(`${packageDir}/${packageJson.main}`, filesystem, mode);
+        if (mainResolved) {
+            return mainResolved;
+        }
+    }
+    return resolvePath(`${packageDir}/index`, filesystem, mode);
+}
+async function resolvePath(basePath, filesystem, mode) {
+    return ((await resolveAsFile(basePath, filesystem)) ??
+        resolveAsDirectory(basePath, filesystem, mode));
+}
+async function resolveAsFile(basePath, filesystem) {
+    const normalized = normalizePath(basePath);
+    const candidates = [
+        normalized,
+        `${normalized}.js`,
+        `${normalized}.json`,
+        `${normalized}.mjs`,
+        `${normalized}.cjs`,
+    ];
+    for (const candidate of candidates) {
+        try {
+            const stat = await filesystem.stat(candidate);
+            if (!stat.isDirectory) {
+                return realpathOrSelf(candidate, filesystem);
+            }
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+}
+async function resolveAsDirectory(basePath, filesystem, mode) {
+    const dir = normalizePath(basePath);
+    try {
+        const stat = await filesystem.stat(dir);
+        if (!stat.isDirectory) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    const packageJson = await readPackageJson(dir, filesystem);
+    if (packageJson && Object.hasOwn(packageJson, "exports")) {
+        const exportsTarget = resolveExportsTarget(packageJson.exports, ".", mode);
+        if (exportsTarget) {
+            const resolved = await resolvePath(`${dir}/${exportsTarget}`, filesystem, mode);
+            if (resolved) {
+                return resolved;
+            }
+        }
+    }
+    if (typeof packageJson?.main === "string" && packageJson.main.length > 0) {
+        const mainResolved = await resolvePath(`${dir}/${packageJson.main}`, filesystem, mode);
+        if (mainResolved) {
+            return mainResolved;
+        }
+    }
+    return resolveAsFile(`${dir}/index`, filesystem);
+}
+async function readPackageJson(packageDir, filesystem) {
+    try {
+        const source = await filesystem.readTextFile(normalizePath(`${packageDir}/package.json`));
+        const parsed = JSON.parse(source);
+        return parsed && typeof parsed === "object"
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function nearestPackageJsonType(filePath, filesystem) {
+    for (const dir of ancestorDirs(dirname(filePath))) {
+        const packageJson = await readPackageJson(dir, filesystem);
+        if (packageJson && typeof packageJson.type === "string") {
+            return packageJson.type;
+        }
+    }
+    return null;
+}
+function resolveExportsTarget(exportsField, subpath, mode) {
+    const resolved = resolveExportsValue(exportsField, subpath, mode);
+    if (typeof resolved !== "string" || !resolved.startsWith("./")) {
+        return null;
+    }
+    return resolved.slice(2);
+}
+function resolveExportsValue(value, subpath, mode) {
+    if (typeof value === "string") {
+        return subpath === "." ? value : null;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const resolved = resolveExportsValue(item, subpath, mode);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        return null;
+    }
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const entries = Object.entries(value);
+    const hasSubpathKeys = entries.some(([key]) => key === "." || key.startsWith("./"));
+    if (hasSubpathKeys) {
+        const exact = value[subpath];
+        if (exact !== undefined) {
+            const resolved = resolveExportsValue(exact, ".", mode);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        for (const [key, target] of entries) {
+            if (!key.includes("*")) {
+                continue;
+            }
+            const [prefix, suffix] = key.split("*", 2);
+            if (!prefix || suffix === undefined) {
+                continue;
+            }
+            if (subpath.startsWith(prefix) && subpath.endsWith(suffix)) {
+                const wildcard = subpath.slice(prefix.length, subpath.length - suffix.length);
+                const resolved = resolveExportsValue(target, ".", mode);
+                if (resolved) {
+                    return resolved.replaceAll("*", wildcard);
+                }
+            }
+        }
+        return null;
+    }
+    const conditions = mode === "import"
+        ? ["import", "node", "module", "default", "require"]
+        : ["require", "node", "default", "import", "module"];
+    for (const condition of conditions) {
+        const target = value[condition];
+        if (target === undefined) {
+            continue;
+        }
+        const resolved = resolveExportsValue(target, subpath, mode);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function resolveImportsTarget(importsField, specifier, mode) {
+    if (typeof importsField === "string") {
+        return importsField;
+    }
+    if (Array.isArray(importsField)) {
+        for (const item of importsField) {
+            const resolved = resolveImportsTarget(item, specifier, mode);
+            if (resolved) {
+                return resolved;
+            }
+        }
+        return null;
+    }
+    if (!importsField || typeof importsField !== "object") {
+        return null;
+    }
+    const record = importsField;
+    if (Object.hasOwn(record, specifier)) {
+        return resolveExportsValue(record[specifier], ".", mode);
+    }
+    for (const [key, target] of Object.entries(record)) {
+        const wildcardIndex = key.indexOf("*");
+        if (wildcardIndex < 0) {
+            continue;
+        }
+        const prefix = key.slice(0, wildcardIndex);
+        const suffix = key.slice(wildcardIndex + 1);
+        if (specifier.startsWith(prefix) && specifier.endsWith(suffix)) {
+            const wildcard = specifier.slice(prefix.length, specifier.length - suffix.length);
+            const resolved = resolveExportsValue(target, ".", mode);
+            if (resolved) {
+                return resolved.replaceAll("*", wildcard);
+            }
+        }
+    }
+    return null;
+}
+export function isESM(code, filePath) {
+    if (filePath?.endsWith(".mjs"))
+        return true;
+    return /\b(import|export)\b/.test(code);
+}
+export function transformDynamicImport(code) {
+    return code;
+}
+export const POLYFILL_CODE_MAP = {
+    fs: "module.exports = globalThis._fsModule;",
+    "node:fs": "module.exports = globalThis._fsModule;",
+    util: BROWSER_UTIL_POLYFILL_CODE,
+    "node:util": "module.exports = require('util');",
+    console: "module.exports = globalThis.console;",
+    "node:console": "module.exports = require('console');",
+    child_process: `
+		const callSync = (ref, ...args) => {
+			if (typeof ref === "function") return ref(...args);
+			if (ref && typeof ref.applySync === "function") return ref.applySync(undefined, args);
+			if (ref && typeof ref.applySyncPromise === "function") return ref.applySyncPromise(undefined, args);
+			throw new Error("child_process bridge is not configured");
+		};
+		const encodeBytes = globalThis.__agentOsEncoding.encodeBytesPayload;
+		const decodeBytes = globalThis.__agentOsEncoding.decodeBytesPayload;
+		const text = (bytes) => new TextDecoder().decode(bytes);
+		const bufferLike = (value) => {
+			const bytes = decodeBytes(value);
+			bytes.toString = () => text(bytes);
+			return bytes;
+		};
+		class Emitter {
+			constructor() {
+				this._listeners = new Map();
+			}
+			on(event, listener) {
+				const listeners = this._listeners.get(event) || [];
+				listeners.push(listener);
+				this._listeners.set(event, listeners);
+				return this;
+			}
+			once(event, listener) {
+				const wrapped = (...args) => {
+					this.off(event, wrapped);
+					listener(...args);
+				};
+				return this.on(event, wrapped);
+			}
+			off(event, listener) {
+				const listeners = this._listeners.get(event) || [];
+				this._listeners.set(event, listeners.filter((entry) => entry !== listener));
+				return this;
+			}
+			removeListener(event, listener) {
+				return this.off(event, listener);
+			}
+			emit(event, ...args) {
+				const listeners = this._listeners.get(event) || [];
+				for (const listener of [...listeners]) listener(...args);
+				return listeners.length > 0;
+			}
+		}
+		class ChildProcess extends Emitter {
+			constructor(sessionId) {
+				super();
+				this.pid = Number(sessionId) || -1;
+				this.exitCode = null;
+				this.signalCode = null;
+				this.killed = false;
+				this.stdout = new Emitter();
+				this.stderr = new Emitter();
+				this.stdin = {
+					write: (data) => {
+						callSync(globalThis._childProcessStdinWrite, sessionId, typeof data === "string" ? new TextEncoder().encode(data) : data);
+						return true;
+					},
+					end: (data) => {
+						if (data != null) this.stdin.write(data);
+						callSync(globalThis._childProcessStdinClose, sessionId);
+					},
+				};
+			}
+		}
+		const normalizeArgs = (args, options) => {
+			if (Array.isArray(args)) return { args, options: options || {} };
+			return { args: [], options: args || {} };
+		};
+		const signalNumbers = ${JSON.stringify(PROCESS_SIGNAL_NUMBERS)};
+		const normalizeSignal = (signal) => {
+			if (signal === undefined || signal === null) return 15;
+			if (typeof signal === "number" && Number.isFinite(signal)) {
+				const numeric = Math.trunc(signal);
+				if (numeric >= 0 && numeric <= 31) return numeric;
+				throw unknownSignalError(signal);
+			}
+			const raw = String(signal).trim();
+			if (/^[+-]?\\d+$/.test(raw)) {
+				const numeric = Number.parseInt(raw, 10);
+				if (numeric >= 0 && numeric <= 31) return numeric;
+				throw unknownSignalError(signal);
+			}
+			const upper = raw.toUpperCase();
+			const signalName = upper.startsWith("SIG") ? upper : "SIG" + upper;
+			const numeric = signalNumbers[signalName];
+			if (numeric !== undefined) return numeric;
+			throw unknownSignalError(signal);
+		};
+		const unknownSignalError = (signal) => {
+			const error = new TypeError("Unknown signal: " + String(signal));
+			error.code = "ERR_UNKNOWN_SIGNAL";
+			return error;
+		};
+		function spawn(command, argsOrOptions, maybeOptions) {
+			const { args, options } = normalizeArgs(argsOrOptions, maybeOptions);
+			let sessionId;
+			try {
+				sessionId = callSync(
+					globalThis._childProcessSpawnStart,
+					{
+						command: String(command),
+						args: args.map(String),
+						options: {
+							cwd: options.cwd || (globalThis.process && globalThis.process.cwd ? globalThis.process.cwd() : "/"),
+							env: options.env,
+						},
+					},
+				);
+			} catch (error) {
+				const child = new ChildProcess(-1);
+				queueMicrotask(() => child.emit("error", error));
+				return child;
+			}
+			const child = new ChildProcess(sessionId);
+			child.kill = (signal) => {
+				callSync(globalThis._childProcessKill, sessionId, normalizeSignal(signal));
+				child.killed = true;
+				return true;
+			};
+			const poll = () => {
+				const event = callSync(globalThis._childProcessPoll, sessionId, 0);
+				if (!event) {
+					setTimeout(poll, 0);
+					return;
+				}
+				if (event.type === "stdout") {
+					child.stdout.emit("data", bufferLike(event.data));
+					setTimeout(poll, 0);
+					return;
+				}
+				if (event.type === "stderr") {
+					child.stderr.emit("data", bufferLike(event.data));
+					setTimeout(poll, 0);
+					return;
+				}
+				if (event.type === "exit") {
+					child.exitCode = event.exitCode;
+					child.signalCode = event.signal;
+					child.emit("exit", event.exitCode, event.signal);
+					child.emit("close", event.exitCode, event.signal);
+				}
+			};
+			queueMicrotask(() => {
+				child.emit("spawn");
+				poll();
+			});
+			return child;
+		}
+		function spawnSync(command, argsOrOptions, maybeOptions) {
+			const { args, options } = normalizeArgs(argsOrOptions, maybeOptions);
+			try {
+				const raw = callSync(
+					globalThis._childProcessSpawnSync,
+					{
+						command: String(command),
+						args: args.map(String),
+						options: {
+							cwd: options.cwd || (globalThis.process && globalThis.process.cwd ? globalThis.process.cwd() : "/"),
+							env: options.env,
+							input: encodeBytes(options.input),
+						},
+					},
+				);
+				const result = typeof raw === "string" ? JSON.parse(raw) : raw;
+				const stdout = options.encoding === "utf8" || options.encoding === "utf-8" ? result.stdout : new TextEncoder().encode(result.stdout || "");
+				const stderr = options.encoding === "utf8" || options.encoding === "utf-8" ? result.stderr : new TextEncoder().encode(result.stderr || "");
+				return {
+					pid: -1,
+					output: [null, stdout, stderr],
+					stdout,
+					stderr,
+					status: result.code,
+					signal: null,
+					error: undefined,
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				const stderr = options.encoding === "utf8" || options.encoding === "utf-8" ? message : new TextEncoder().encode(message);
+				return {
+					pid: -1,
+					output: [null, "", stderr],
+					stdout: options.encoding === "utf8" || options.encoding === "utf-8" ? "" : new Uint8Array(0),
+					stderr,
+					status: 1,
+					signal: null,
+					error,
+				};
+			}
+		}
+		module.exports = { spawn, spawnSync, default: { spawn, spawnSync } };
+	`,
+    "node:child_process": "module.exports = require('child_process');",
+    dns: `
+		const callAsync = (ref, ...args) => {
+			if (typeof ref === "function") return Promise.resolve(ref(...args));
+			if (ref && typeof ref.apply === "function") return ref.apply(undefined, args);
+			throw new Error("dns bridge is not configured");
+		};
+		const normalizeLookup = (hostname, options, callback) => {
+			let done = callback;
+			let normalized = {};
+			if (typeof options === "function") {
+				done = options;
+			} else if (typeof options === "number") {
+				normalized.family = options;
+			} else if (options && typeof options === "object") {
+				normalized = { ...options };
+			}
+			const family = normalized.family === 4 || normalized.family === 6 ? normalized.family : undefined;
+			return {
+				callback: done,
+				options: {
+					hostname: String(hostname),
+					family,
+					all: normalized.all === true,
+				},
+			};
+		};
+		const parseLookupRecords = (resultJson) => {
+			let parsed = resultJson;
+			if (typeof parsed === "string") parsed = JSON.parse(parsed);
+			if (parsed && typeof parsed === "object" && Array.isArray(parsed.records)) parsed = parsed.records;
+			else if (parsed && typeof parsed === "object" && typeof parsed.address === "string") parsed = [parsed];
+			if (!Array.isArray(parsed)) return [];
+			return parsed
+				.filter((record) => record && typeof record.address === "string")
+				.map((record) => ({ address: record.address, family: record.family === 6 ? 6 : 4 }));
+		};
+		const lookupRecords = (hostname, options, callback) => {
+			const invocation = normalizeLookup(hostname, options, callback);
+			return callAsync(globalThis._networkDnsLookupRaw, invocation.options)
+				.then(parseLookupRecords)
+				.then((records) => {
+					if (typeof invocation.callback === "function") {
+						if (invocation.options.all) invocation.callback(null, records);
+						else {
+							const first = records[0] || { address: null, family: invocation.options.family || 0 };
+							invocation.callback(null, first.address, first.family);
+						}
+					}
+					return invocation.options.all ? records : records[0] || { address: "", family: invocation.options.family || 0 };
+				})
+				.catch((error) => {
+					if (typeof invocation.callback === "function") {
+						invocation.callback(error);
+						return undefined;
+					}
+					throw error;
+				});
+		};
+		const promises = { lookup: (hostname, options) => lookupRecords(hostname, options) };
+		function lookup(hostname, options, callback) {
+			lookupRecords(hostname, options, callback);
+		}
+		module.exports = { lookup, promises, default: { lookup, promises } };
+	`,
+    "dns/promises": "module.exports = require('dns').promises;",
+    dgram: `
+		const encoder = new TextEncoder();
+		const decoder = new TextDecoder();
+		const callSync = (ref, ...args) => {
+			if (typeof ref === "function") return ref(...args);
+			if (ref && typeof ref.applySync === "function") return ref.applySync(undefined, args);
+			if (ref && typeof ref.applySyncPromise === "function") return ref.applySyncPromise(undefined, args);
+			throw new Error("dgram bridge is not configured");
+		};
+		const parseResult = (value) => {
+			if (typeof value !== "string") return value;
+			try { return JSON.parse(value); } catch { return value; }
+		};
+		const listenersFor = (map, event) => map.get(event) || [];
+		const normalizeType = (optionsOrType) => {
+			const type = typeof optionsOrType === "string" ? optionsOrType : optionsOrType && optionsOrType.type;
+			if (type === "udp6") return "udp6";
+			if (type === "udp4" || type === undefined) return "udp4";
+			const error = new TypeError("Bad socket type specified. Valid types are: udp4, udp6");
+			error.code = "ERR_SOCKET_BAD_TYPE";
+			throw error;
+		};
+		const normalizePort = (port) => {
+			const value = Number(port);
+			if (!Number.isInteger(value) || value < 0 || value > 65535) {
+				const error = new RangeError("Port should be >= 0 and < 65536");
+				error.code = "ERR_SOCKET_BAD_PORT";
+				throw error;
+			}
+			return value;
+		};
+		const normalizeMessage = (value) => {
+			if (typeof value === "string") return encoder.encode(value);
+			if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+			if (value instanceof ArrayBuffer) return new Uint8Array(value);
+			if (Array.isArray(value)) {
+				const parts = value.map(normalizeMessage);
+				const total = parts.reduce((sum, part) => sum + part.byteLength, 0);
+				const output = new Uint8Array(total);
+				let offset = 0;
+				for (const part of parts) {
+					output.set(part, offset);
+					offset += part.byteLength;
+				}
+				return output;
+			}
+			return encoder.encode(String(value ?? ""));
+		};
+		const messageBytes = (value) => {
+			let bytes;
+			if (value && typeof value === "object" && value.__agentOsType === "bytes" && typeof value.base64 === "string") {
+				bytes = globalThis.__agentOsEncoding.base64ToBytes(value.base64);
+			} else {
+				bytes = normalizeMessage(value);
+			}
+			Object.defineProperty(bytes, "toString", {
+				value() { return decoder.decode(bytes); },
+				configurable: true,
+			});
+			return bytes;
+		};
+		class Socket {
+			constructor(optionsOrType, callback) {
+				this._type = normalizeType(optionsOrType);
+				this._listeners = new Map();
+				this._onceListeners = new Map();
+				this._closed = false;
+				this._bound = false;
+				this._polling = false;
+				const created = parseResult(callSync(globalThis._dgramSocketCreateRaw, { type: this._type }));
+				this._socketId = String(created && created.socketId !== undefined ? created.socketId : created);
+				if (typeof callback === "function") this.on("message", callback);
+			}
+			on(event, listener) {
+				const list = listenersFor(this._listeners, event).slice();
+				list.push(listener);
+				this._listeners.set(event, list);
+				return this;
+			}
+			addListener(event, listener) { return this.on(event, listener); }
+			once(event, listener) {
+				const list = listenersFor(this._onceListeners, event).slice();
+				list.push(listener);
+				this._onceListeners.set(event, list);
+				return this;
+			}
+			off(event, listener) { return this.removeListener(event, listener); }
+			removeListener(event, listener) {
+				this._listeners.set(event, listenersFor(this._listeners, event).filter((entry) => entry !== listener));
+				this._onceListeners.set(event, listenersFor(this._onceListeners, event).filter((entry) => entry !== listener));
+				return this;
+			}
+			_emit(event, ...args) {
+				for (const listener of listenersFor(this._listeners, event).slice()) listener(...args);
+				const once = listenersFor(this._onceListeners, event).slice();
+				this._onceListeners.delete(event);
+				for (const listener of once) listener(...args);
+				return once.length > 0 || listenersFor(this._listeners, event).length > 0;
+			}
+			emit(event, ...args) { return this._emit(event, ...args); }
+			bind(...args) {
+				let port = 0;
+				let address = this._type === "udp6" ? "::" : "0.0.0.0";
+				let callback;
+				if (typeof args[0] === "object" && args[0] !== null) {
+					port = normalizePort(args[0].port ?? 0);
+					address = String(args[0].address ?? address);
+					callback = args[1];
+				} else {
+					if (typeof args[0] === "function") callback = args[0];
+					else {
+						port = normalizePort(args[0] ?? 0);
+						if (typeof args[1] === "string") address = args[1];
+						callback = typeof args[1] === "function" ? args[1] : args[2];
+					}
+				}
+				try {
+					parseResult(callSync(globalThis._dgramSocketBindRaw, this._socketId, { port, address }));
+					this._bound = true;
+					queueMicrotask(() => {
+						this._emit("listening");
+						if (typeof callback === "function") callback.call(this);
+						this._poll();
+					});
+				} catch (error) {
+					queueMicrotask(() => this._emit("error", error));
+				}
+				return this;
+			}
+			address() {
+				return parseResult(callSync(globalThis._dgramSocketAddressRaw, this._socketId));
+			}
+			send(message, ...args) {
+				let offset = 0;
+				let length;
+				let port;
+				let address;
+				let callback;
+				if (typeof args[0] === "number" && typeof args[1] === "number" && typeof args[2] === "number") {
+					offset = args[0];
+					length = args[1];
+					port = args[2];
+					address = typeof args[3] === "string" ? args[3] : undefined;
+					callback = typeof args[3] === "function" ? args[3] : args[4];
+				} else {
+					port = args[0];
+					address = typeof args[1] === "string" ? args[1] : undefined;
+					callback = typeof args[1] === "function" ? args[1] : args[2];
+				}
+				const full = normalizeMessage(message);
+				const data = length === undefined ? full : full.subarray(offset, offset + length);
+				try {
+					const result = parseResult(callSync(globalThis._dgramSocketSendRaw, this._socketId, data, {
+						port: normalizePort(port),
+						address: address || (this._type === "udp6" ? "::1" : "127.0.0.1"),
+					}));
+					if (typeof callback === "function") queueMicrotask(() => callback(null, result && typeof result.bytes === "number" ? result.bytes : data.length));
+				} catch (error) {
+					if (typeof callback === "function") queueMicrotask(() => callback(error));
+					else queueMicrotask(() => this._emit("error", error));
+				}
+			}
+			_poll() {
+				if (this._closed || !this._bound || this._polling) return;
+				this._polling = true;
+				try {
+					const event = parseResult(callSync(globalThis._dgramSocketRecvRaw, this._socketId, 10));
+					if (event && event.type === "message") {
+						const message = messageBytes({ __agentOsType: "bytes", base64: String(event.data || "") });
+						this._emit("message", message, {
+							address: event.remoteAddress,
+							port: event.remotePort,
+							family: event.remoteFamily || (String(event.remoteAddress).includes(":") ? "IPv6" : "IPv4"),
+							size: message.length,
+						});
+					}
+				} catch (error) {
+					this._emit("error", error);
+				} finally {
+					this._polling = false;
+				}
+				if (!this._closed && this._bound) setTimeout(() => this._poll(), 10);
+			}
+			close(callback) {
+				if (typeof callback === "function") this.once("close", callback);
+				if (this._closed) return this;
+				this._closed = true;
+				callSync(globalThis._dgramSocketCloseRaw, this._socketId);
+				queueMicrotask(() => this._emit("close"));
+				return this;
+			}
+			ref() { return this; }
+			unref() { return this; }
+			setRecvBufferSize(size) { callSync(globalThis._dgramSocketSetBufferSizeRaw, this._socketId, "recv", Number(size)); }
+			setSendBufferSize(size) { callSync(globalThis._dgramSocketSetBufferSizeRaw, this._socketId, "send", Number(size)); }
+			getRecvBufferSize() { return Number(callSync(globalThis._dgramSocketGetBufferSizeRaw, this._socketId, "recv")); }
+			getSendBufferSize() { return Number(callSync(globalThis._dgramSocketGetBufferSizeRaw, this._socketId, "send")); }
+		}
+		function createSocket(optionsOrType, callback) {
+			return new Socket(optionsOrType, callback);
+		}
+		module.exports = { Socket, createSocket, default: { Socket, createSocket } };
+	`,
+    "node:dgram": "module.exports = require('dgram');",
+    crypto: `
+		const callSync = (ref, ...args) => {
+			if (typeof ref === "function") return ref(...args);
+			if (ref && typeof ref.applySync === "function") return ref.applySync(undefined, args);
+			if (ref && typeof ref.applySyncPromise === "function") return ref.applySyncPromise(undefined, args);
+			throw new Error("crypto bridge is not configured");
+		};
+		const encoder = new TextEncoder();
+		const decoder = new TextDecoder();
+		const toBytes = globalThis.__agentOsEncoding.toBytes;
+		const concat = (chunks) => {
+			const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+			const out = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of chunks) {
+				out.set(chunk, offset);
+				offset += chunk.byteLength;
+			}
+			return out;
+		};
+		const toHex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+		const SUPPORTED_CIPHERS = ["aes-128-cbc", "aes-128-ctr", "aes-128-gcm", "aes-192-cbc", "aes-192-ctr", "aes-192-gcm", "aes-256-cbc", "aes-256-ctr", "aes-256-gcm", "aes128", "aes192", "aes256"];
+		const SUPPORTED_CURVES = ["prime256v1", "secp256k1", "secp384r1", "secp521r1"];
+		const toBase64 = globalThis.__agentOsEncoding.bytesToBase64;
+		const encodeOutput = (bytes, encoding) => {
+			if (!encoding) return makeBuffer(bytes);
+			if (encoding === "hex") return toHex(bytes);
+			if (encoding === "base64") return toBase64(bytes);
+			if (encoding === "utf8" || encoding === "utf-8") return decoder.decode(bytes);
+			throw new Error("Unsupported crypto output encoding: " + encoding);
+		};
+		const makeBuffer = (bytes) => {
+			if (typeof Buffer === "function") return Buffer.from(bytes);
+			const out = new Uint8Array(bytes);
+			out.toString = (encoding = "utf8") => encodeOutput(out, encoding);
+			out.equals = (other) => {
+				const rhs = toBytes(other);
+				if (rhs.byteLength !== out.byteLength) return false;
+				for (let i = 0; i < out.byteLength; i += 1) {
+					if (out[i] !== rhs[i]) return false;
+				}
+				return true;
+			};
+			return out;
+		};
+		class Hash {
+			constructor(algorithm) {
+				this.algorithm = String(algorithm);
+				this.chunks = [];
+			}
+			update(data, inputEncoding) {
+				this.chunks.push(toBytes(data, inputEncoding));
+				return this;
+			}
+			digest(encoding) {
+				const bytes = callSync(globalThis._cryptoHashDigest, this.algorithm, concat(this.chunks));
+				return encodeOutput(bytes, encoding);
+			}
+		}
+		class Hmac {
+			constructor(algorithm, key) {
+				this.algorithm = String(algorithm);
+				this.key = toBytes(key);
+				this.chunks = [];
+			}
+			update(data, inputEncoding) {
+				this.chunks.push(toBytes(data, inputEncoding));
+				return this;
+			}
+			digest(encoding) {
+				const bytes = callSync(globalThis._cryptoHmacDigest, this.algorithm, this.key, concat(this.chunks));
+				return encodeOutput(bytes, encoding);
+			}
+		}
+		const CRYPTO_CONSTANTS = {
+			RSA_PKCS1_PADDING: 1,
+			RSA_PKCS1_OAEP_PADDING: 4,
+		};
+		const normalizeKeyInput = (key) => {
+			if (typeof key === "string") return key;
+			if (key && typeof key === "object" && typeof key.export === "function") return key.export({ format: "pem" });
+			if (key && typeof key === "object" && typeof key.key === "string") return key.key;
+			if (key && typeof key === "object" && key.key && typeof key.key.export === "function") return key.key.export({ format: "pem" });
+			throw new Error("Browser node:crypto RSA key must be a PEM string");
+		};
+		const normalizeAsymmetricOptions = (keyOrOptions) => {
+			if (typeof keyOrOptions === "string") return { key: keyOrOptions };
+			if (keyOrOptions && typeof keyOrOptions === "object" && typeof keyOrOptions.export === "function") return { key: keyOrOptions };
+			if (keyOrOptions && typeof keyOrOptions === "object") return keyOrOptions;
+			throw new Error("Browser node:crypto RSA key must be a PEM string");
+		};
+		class KeyObject {
+			constructor(type, key) {
+				this.type = type;
+				if (type === "secret") {
+					this.symmetricKeySize = toBytes(key).byteLength;
+					this.key = new Uint8Array(toBytes(key));
+				} else if (key && typeof key === "object" && key.asymmetricKeyType === "x25519") {
+					this.asymmetricKeyType = "x25519";
+					this.key = new Uint8Array(toBytes(key.key));
+					this.publicKey = key.publicKey ? new Uint8Array(toBytes(key.publicKey)) : undefined;
+				} else {
+					this.asymmetricKeyType = "rsa";
+					this.key = normalizeKeyInput(key);
+				}
+			}
+			export(options = {}) {
+				if (this.type === "secret") {
+					return makeBuffer(this.key);
+				}
+				if (this.asymmetricKeyType === "x25519") {
+					throw new Error("Browser node:crypto X25519 KeyObject export is not implemented yet");
+				}
+				if (!options || options.format == null || options.format === "pem") return this.key;
+				throw new Error("Browser node:crypto KeyObject only supports PEM export");
+			}
+		}
+		class Sign {
+			constructor(algorithm) {
+				this.algorithm = String(algorithm);
+				this.chunks = [];
+			}
+			update(data, inputEncoding) {
+				this.chunks.push(toBytes(data, inputEncoding));
+				return this;
+			}
+			write(data, inputEncoding) {
+				this.update(data, inputEncoding);
+				return true;
+			}
+			end(data, inputEncoding) {
+				if (data !== undefined) this.update(data, inputEncoding);
+				return this;
+			}
+			sign(key, outputEncoding) {
+				const bytes = callSync(globalThis._cryptoSign, this.algorithm, concat(this.chunks), normalizeKeyInput(key));
+				return encodeOutput(bytes, outputEncoding);
+			}
+		}
+		class Verify extends Sign {
+			verify(key, signature, signatureEncoding) {
+				return Boolean(callSync(
+					globalThis._cryptoVerify,
+					this.algorithm,
+					concat(this.chunks),
+					normalizeKeyInput(key),
+					toBytes(signature, signatureEncoding),
+				));
+			}
+		}
+		function createPrivateKey(key) {
+			return new KeyObject("private", key);
+		}
+		function createPublicKey(key) {
+			return new KeyObject("public", key);
+		}
+		function createSecretKey(key) {
+			return new KeyObject("secret", toBytes(key));
+		}
+		function signOneShot(algorithm, data, key) {
+			const signer = new Sign(algorithm);
+			signer.update(data);
+			return signer.sign(key);
+		}
+		function verifyOneShot(algorithm, data, key, signature) {
+			const verifier = new Verify(algorithm);
+			verifier.update(data);
+			return verifier.verify(key, signature);
+		}
+		function modInverse(value, modulus) {
+			let t = 0n;
+			let newT = 1n;
+			let r = modulus;
+			let newR = mod(value, modulus);
+			while (newR !== 0n) {
+				const quotient = r / newR;
+				const nextT = t - quotient * newT;
+				t = newT;
+				newT = nextT;
+				const nextR = r - quotient * newR;
+				r = newR;
+				newR = nextR;
+			}
+			if (r !== 1n) throw new Error("Browser node:crypto RSA values are not invertible");
+			return t < 0n ? t + modulus : t;
+		}
+		function gcd(left, right) {
+			let a = left < 0n ? -left : left;
+			let b = right < 0n ? -right : right;
+			while (b !== 0n) {
+				const next = a % b;
+				a = b;
+				b = next;
+			}
+			return a;
+		}
+		function derLength(length) {
+			if (length < 0x80) return new Uint8Array([length]);
+			const bytes = [];
+			let remaining = length;
+			while (remaining > 0) {
+				bytes.unshift(remaining & 0xff);
+				remaining >>= 8;
+			}
+			return new Uint8Array([0x80 | bytes.length, ...bytes]);
+		}
+		function der(tag, content) {
+			return concat([new Uint8Array([tag]), derLength(content.byteLength), content]);
+		}
+		function derInteger(value) {
+			let bytes = bigIntToMinimalBytes(value);
+			if ((bytes[0] & 0x80) !== 0) bytes = concat([new Uint8Array([0]), bytes]);
+			return der(0x02, bytes);
+		}
+		function derSequence(items) {
+			return der(0x30, concat(items));
+		}
+		function derOctetString(bytes) {
+			return der(0x04, bytes);
+		}
+		function derBitString(bytes) {
+			return der(0x03, concat([new Uint8Array([0]), bytes]));
+		}
+		function derNull() {
+			return new Uint8Array([0x05, 0x00]);
+		}
+		function derObjectIdentifier(parts) {
+			const out = [parts[0] * 40 + parts[1]];
+			for (const part of parts.slice(2)) {
+				const stack = [part & 0x7f];
+				let remaining = part >> 7;
+				while (remaining > 0) {
+					stack.unshift(0x80 | (remaining & 0x7f));
+					remaining >>= 7;
+				}
+				out.push(...stack);
+			}
+			return der(0x06, new Uint8Array(out));
+		}
+		const RSA_ENCRYPTION_ALGORITHM = derSequence([
+			derObjectIdentifier([1, 2, 840, 113549, 1, 1, 1]),
+			derNull(),
+		]);
+		function pem(label, derBytes) {
+			const body = toBase64(derBytes).replace(/.{1,64}/g, "$&\\n").trimEnd();
+			return "-----BEGIN " + label + "-----\\n" + body + "\\n-----END " + label + "-----";
+		}
+		function normalizePublicExponent(value) {
+			if (value === undefined) return 65537n;
+			if (typeof value === "number") return BigInt(value);
+			if (typeof value === "bigint") return value;
+			return bytesToBigInt(toBytes(value));
+		}
+		function encodeRsaPublicKeyDer(key) {
+			return derSequence([derInteger(key.n), derInteger(key.e)]);
+		}
+		function encodeRsaPrivateKeyDer(key) {
+			return derSequence([
+				derInteger(0n),
+				derInteger(key.n),
+				derInteger(key.e),
+				derInteger(key.d),
+				derInteger(key.p),
+				derInteger(key.q),
+				derInteger(key.d % (key.p - 1n)),
+				derInteger(key.d % (key.q - 1n)),
+				derInteger(modInverse(key.q, key.p)),
+			]);
+		}
+		function encodeRsaSpkiDer(key) {
+			return derSequence([RSA_ENCRYPTION_ALGORITHM, derBitString(encodeRsaPublicKeyDer(key))]);
+		}
+		function encodeRsaPkcs8Der(key) {
+			return derSequence([
+				derInteger(0n),
+				RSA_ENCRYPTION_ALGORITHM,
+				derOctetString(encodeRsaPrivateKeyDer(key)),
+			]);
+		}
+		function encodeGeneratedRsaKey(key, encoding, defaultType) {
+			if (!encoding) {
+				return defaultType === "public"
+					? new KeyObject("public", pem("PUBLIC KEY", encodeRsaSpkiDer(key)))
+					: new KeyObject("private", pem("PRIVATE KEY", encodeRsaPkcs8Der(key)));
+			}
+			const format = encoding.format || "pem";
+			const type = encoding.type || (defaultType === "public" ? "spki" : "pkcs8");
+			let derBytes;
+			let label;
+			if (defaultType === "public" && type === "spki") {
+				derBytes = encodeRsaSpkiDer(key);
+				label = "PUBLIC KEY";
+			} else if (defaultType === "public" && (type === "pkcs1" || type === "rsa")) {
+				derBytes = encodeRsaPublicKeyDer(key);
+				label = "RSA PUBLIC KEY";
+			} else if (defaultType === "private" && type === "pkcs8") {
+				derBytes = encodeRsaPkcs8Der(key);
+				label = "PRIVATE KEY";
+			} else if (defaultType === "private" && (type === "pkcs1" || type === "rsa")) {
+				derBytes = encodeRsaPrivateKeyDer(key);
+				label = "RSA PRIVATE KEY";
+			} else {
+				throw new Error("Browser node:crypto unsupported RSA key encoding type");
+			}
+			if (format === "der") return makeBuffer(derBytes);
+			if (format === "pem") return pem(label, derBytes);
+			throw new Error("Browser node:crypto unsupported RSA key encoding format");
+		}
+		function generateRsaKeyPair(options = {}) {
+			const modulusLength = Number(options.modulusLength || 2048);
+			if (!Number.isInteger(modulusLength) || modulusLength < 512) {
+				throw new Error("Browser node:crypto RSA modulusLength must be at least 512 bits");
+			}
+			const e = normalizePublicExponent(options.publicExponent);
+			const pBits = Math.floor(modulusLength / 2);
+			const qBits = modulusLength - pBits;
+			while (true) {
+				const p = generatePrimeSync(pBits, { bigint: true });
+				const q = generatePrimeSync(qBits, { bigint: true });
+				if (p === q) continue;
+				const phi = (p - 1n) * (q - 1n);
+				if (gcd(e, phi) !== 1n) continue;
+				const n = p * q;
+				if (n.toString(2).length !== modulusLength) continue;
+				const d = modInverse(e, phi);
+				const key = { n, e, d, p, q };
+				return {
+					publicKey: encodeGeneratedRsaKey(key, options.publicKeyEncoding, "public"),
+					privateKey: encodeGeneratedRsaKey(key, options.privateKeyEncoding, "private"),
+				};
+			}
+		}
+		const X25519_PRIME = (1n << 255n) - 19n;
+		const X25519_A24 = 121665n;
+		const X25519_BASE_POINT = new Uint8Array([9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+		function mod(value, modulus) {
+			const result = value % modulus;
+			return result < 0n ? result + modulus : result;
+		}
+		function bytesToLittleEndianBigInt(bytes) {
+			let value = 0n;
+			for (let i = bytes.byteLength - 1; i >= 0; i -= 1) {
+				value = (value << 8n) | BigInt(bytes[i]);
+			}
+			return value;
+		}
+		function littleEndianBigIntToBytes(value, byteLength) {
+			const out = new Uint8Array(byteLength);
+			let cursor = BigInt(value);
+			for (let i = 0; i < byteLength; i += 1) {
+				out[i] = Number(cursor & 0xffn);
+				cursor >>= 8n;
+			}
+			return out;
+		}
+		function normalizeX25519PrivateKey(key) {
+			if (!key || key.type !== "private" || key.asymmetricKeyType !== "x25519" || key.key.byteLength !== 32) {
+				throw new Error("Browser node:crypto diffieHellman requires an X25519 private KeyObject");
+			}
+			return key.key;
+		}
+		function normalizeX25519PublicKey(key) {
+			if (!key || key.type !== "public" || key.asymmetricKeyType !== "x25519" || key.key.byteLength !== 32) {
+				throw new Error("Browser node:crypto diffieHellman requires an X25519 public KeyObject");
+			}
+			return key.key;
+		}
+		function x25519(privateKey, publicKey) {
+			const scalarBytes = new Uint8Array(privateKey);
+			scalarBytes[0] &= 248;
+			scalarBytes[31] &= 127;
+			scalarBytes[31] |= 64;
+			const uBytes = new Uint8Array(publicKey);
+			uBytes[31] &= 127;
+			const scalar = bytesToLittleEndianBigInt(scalarBytes);
+			const x1 = bytesToLittleEndianBigInt(uBytes);
+			let x2 = 1n;
+			let z2 = 0n;
+			let x3 = x1;
+			let z3 = 1n;
+			let swap = 0n;
+			const cswap = (bit) => {
+				if (bit === 0n) return;
+				let tmp = x2;
+				x2 = x3;
+				x3 = tmp;
+				tmp = z2;
+				z2 = z3;
+				z3 = tmp;
+			};
+			for (let t = 254; t >= 0; t -= 1) {
+				const bit = (scalar >> BigInt(t)) & 1n;
+				swap ^= bit;
+				cswap(swap);
+				swap = bit;
+				const a = mod(x2 + z2, X25519_PRIME);
+				const aa = mod(a * a, X25519_PRIME);
+				const b = mod(x2 - z2, X25519_PRIME);
+				const bb = mod(b * b, X25519_PRIME);
+				const e = mod(aa - bb, X25519_PRIME);
+				const c = mod(x3 + z3, X25519_PRIME);
+				const d = mod(x3 - z3, X25519_PRIME);
+				const da = mod(d * a, X25519_PRIME);
+				const cb = mod(c * b, X25519_PRIME);
+				x3 = mod((da + cb) * (da + cb), X25519_PRIME);
+				z3 = mod(x1 * mod((da - cb) * (da - cb), X25519_PRIME), X25519_PRIME);
+				x2 = mod(aa * bb, X25519_PRIME);
+				z2 = mod(e * mod(aa + X25519_A24 * e, X25519_PRIME), X25519_PRIME);
+			}
+			cswap(swap);
+			const result = mod(x2 * modPow(z2, X25519_PRIME - 2n, X25519_PRIME), X25519_PRIME);
+			return littleEndianBigIntToBytes(result, 32);
+		}
+		function generateKeyPairSync(type, options = {}) {
+			const keyType = String(type).toLowerCase();
+			if (keyType === "rsa") {
+				return generateRsaKeyPair(options || {});
+			}
+			if (keyType !== "x25519") {
+				return unsupportedBrowserCrypto("generateKeyPairSync");
+			}
+			const privateBytes = new Uint8Array(callSync(globalThis._cryptoRandomFill, 32));
+			const publicBytes = x25519(privateBytes, X25519_BASE_POINT);
+			return {
+				publicKey: new KeyObject("public", { asymmetricKeyType: "x25519", key: publicBytes }),
+				privateKey: new KeyObject("private", { asymmetricKeyType: "x25519", key: privateBytes, publicKey: publicBytes }),
+			};
+		}
+		function generateKeyPair(type, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = {};
+			}
+			if (typeof callback !== "function") {
+				throw new TypeError('The "callback" argument must be of type function');
+			}
+			queueMicrotask(() => {
+				try {
+					const pair = generateKeyPairSync(type, options || {});
+					callback(null, pair.publicKey, pair.privateKey);
+				} catch (error) {
+					callback(error);
+				}
+			});
+		}
+		function diffieHellman(options) {
+			if (!options || typeof options !== "object") {
+				throw new TypeError("Browser node:crypto diffieHellman options must be an object");
+			}
+			const privateKey = normalizeX25519PrivateKey(options.privateKey);
+			const publicKey = normalizeX25519PublicKey(options.publicKey);
+			return makeBuffer(x25519(privateKey, publicKey));
+		}
+		const P256_P = BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff");
+		const P256_A = P256_P - 3n;
+		const P256_B = BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
+		const P256_N = BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551");
+		const P256_G = {
+			x: BigInt("0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
+			y: BigInt("0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"),
+		};
+		function p256Inverse(value) {
+			return modPow(mod(value, P256_P), P256_P - 2n, P256_P);
+		}
+		function p256PointAdd(left, right) {
+			if (!left) return right;
+			if (!right) return left;
+			if (left.x === right.x) {
+				if (mod(left.y + right.y, P256_P) === 0n) return null;
+				const slope = mod((3n * left.x * left.x + P256_A) * p256Inverse(2n * left.y), P256_P);
+				const x = mod(slope * slope - 2n * left.x, P256_P);
+				const y = mod(slope * (left.x - x) - left.y, P256_P);
+				return { x, y };
+			}
+			const slope = mod((right.y - left.y) * p256Inverse(right.x - left.x), P256_P);
+			const x = mod(slope * slope - left.x - right.x, P256_P);
+			const y = mod(slope * (left.x - x) - left.y, P256_P);
+			return { x, y };
+		}
+		function p256ScalarMult(scalar, point) {
+			let result = null;
+			let addend = point;
+			let remaining = scalar;
+			while (remaining > 0n) {
+				if ((remaining & 1n) === 1n) result = p256PointAdd(result, addend);
+				addend = p256PointAdd(addend, addend);
+				remaining >>= 1n;
+			}
+			return result;
+		}
+		function p256RandomScalar() {
+			while (true) {
+				const scalar = bytesToBigInt(callSync(globalThis._cryptoRandomFill, 32)) % P256_N;
+				if (scalar > 0n) return scalar;
+			}
+		}
+		function p256EncodePoint(point, format = "uncompressed") {
+			if (!point) throw new Error("Browser node:crypto ECDH point is not available");
+			if (format === "compressed") {
+				const out = new Uint8Array(33);
+				out[0] = point.y & 1n ? 0x03 : 0x02;
+				out.set(bigIntToBytes(point.x, 32), 1);
+				return out;
+			}
+			if (format !== "uncompressed" && format !== "hybrid") {
+				throw new Error("Browser node:crypto ECDH only supports uncompressed, compressed, and hybrid public keys");
+			}
+			const out = new Uint8Array(65);
+			out[0] = format === "hybrid" ? (point.y & 1n ? 0x07 : 0x06) : 0x04;
+			out.set(bigIntToBytes(point.x, 32), 1);
+			out.set(bigIntToBytes(point.y, 32), 33);
+			return out;
+		}
+		function p256DecodePoint(value, encoding) {
+			const bytes = toBytes(value, encoding);
+			if (bytes.byteLength !== 65 || (bytes[0] !== 0x04 && bytes[0] !== 0x06 && bytes[0] !== 0x07)) {
+				throw new Error("Browser node:crypto ECDH peer public key must be an uncompressed P-256 point");
+			}
+			const x = bytesToBigInt(bytes.subarray(1, 33));
+			const y = bytesToBigInt(bytes.subarray(33, 65));
+			if (mod(y * y - (x * x * x + P256_A * x + P256_B), P256_P) !== 0n) {
+				throw new Error("Browser node:crypto ECDH peer public key is not on P-256");
+			}
+			return { x, y };
+		}
+		class ECDH {
+			constructor(name) {
+				const curve = String(name);
+				if (curve !== "prime256v1" && curve !== "P-256") {
+					const error = new Error("Invalid EC curve name");
+					error.code = "ERR_CRYPTO_INVALID_CURVE";
+					throw error;
+				}
+				this.privateKey = null;
+				this.publicPoint = null;
+			}
+			generateKeys(encoding, format = "uncompressed") {
+				this.privateKey = p256RandomScalar();
+				this.publicPoint = p256ScalarMult(this.privateKey, P256_G);
+				return encodeOutput(p256EncodePoint(this.publicPoint, format), encoding);
+			}
+			computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
+				if (this.privateKey === null) this.generateKeys();
+				const shared = p256ScalarMult(this.privateKey, p256DecodePoint(otherPublicKey, inputEncoding));
+				if (!shared) throw new Error("Browser node:crypto ECDH failed to compute shared secret");
+				return encodeOutput(bigIntToBytes(shared.x, 32), outputEncoding);
+			}
+			getPublicKey(encoding, format = "uncompressed") {
+				if (!this.publicPoint) throw new Error("Failed to get ECDH public key");
+				return encodeOutput(p256EncodePoint(this.publicPoint, format), encoding);
+			}
+			getPrivateKey(encoding) {
+				if (this.privateKey === null) throw new Error("Failed to get ECDH private key");
+				return encodeOutput(bigIntToBytes(this.privateKey, 32), encoding);
+			}
+			setPrivateKey(privateKey, encoding) {
+				const scalar = bytesToBigInt(toBytes(privateKey, encoding));
+				if (scalar <= 0n || scalar >= P256_N) throw new Error("Invalid ECDH private key");
+				this.privateKey = scalar;
+				this.publicPoint = p256ScalarMult(this.privateKey, P256_G);
+			}
+			setPublicKey(publicKey, encoding) {
+				this.publicPoint = p256DecodePoint(publicKey, encoding);
+			}
+		}
+		function createECDH(name) {
+			return new ECDH(name);
+		}
+		function generateKeySync(type, options = {}) {
+			const keyType = String(type).toLowerCase();
+			const length = Number(options && options.length);
+			if (!Number.isInteger(length) || length <= 0) {
+				throw new Error("Browser node:crypto generateKeySync length must be a positive integer");
+			}
+			if (keyType === "aes" && ![128, 192, 256].includes(length)) {
+				const error = new Error("The property 'options.length' must be one of: 128, 192, 256.");
+				error.code = "ERR_INVALID_ARG_VALUE";
+				throw error;
+			}
+			if (keyType !== "hmac" && keyType !== "aes") {
+				return unsupportedBrowserCrypto("generateKeySync");
+			}
+			return createSecretKey(callSync(globalThis._cryptoRandomFill, Math.ceil(length / 8)));
+		}
+		function bytesToBigInt(bytes) {
+			let value = 0n;
+			for (const byte of bytes) value = (value << 8n) | BigInt(byte);
+			return value;
+		}
+		function bigIntToBytes(value, byteLength) {
+			const out = new Uint8Array(byteLength);
+			let cursor = BigInt(value);
+			for (let i = byteLength - 1; i >= 0; i -= 1) {
+				out[i] = Number(cursor & 0xffn);
+				cursor >>= 8n;
+			}
+			return out;
+		}
+		function normalizePrimeOption(name, value) {
+			if (value === undefined) return undefined;
+			if (typeof value === "bigint") return value;
+			if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer || Array.isArray(value) || (value && value.type === "Buffer" && Array.isArray(value.data))) {
+				return bytesToBigInt(toBytes(value));
+			}
+			const error = new TypeError('The "options.' + name + '" property must be of type bigint or an instance of ArrayBuffer, TypedArray, Buffer, or DataView.');
+			error.code = "ERR_INVALID_ARG_TYPE";
+			throw error;
+		}
+		function modPow(base, exponent, modulus) {
+			let result = 1n;
+			let cursor = base % modulus;
+			let remaining = exponent;
+			while (remaining > 0n) {
+				if ((remaining & 1n) === 1n) result = (result * cursor) % modulus;
+				cursor = (cursor * cursor) % modulus;
+				remaining >>= 1n;
+			}
+			return result;
+		}
+		const SMALL_PRIMES = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
+		const MILLER_RABIN_BASES = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n];
+		function isProbablePrime(value) {
+			if (value < 2n) return false;
+			for (const prime of SMALL_PRIMES) {
+				if (value === prime) return true;
+				if (value % prime === 0n) return false;
+			}
+			let d = value - 1n;
+			let s = 0;
+			while ((d & 1n) === 0n) {
+				d >>= 1n;
+				s += 1;
+			}
+			for (const base of MILLER_RABIN_BASES) {
+				if (base >= value - 2n) continue;
+				let x = modPow(base, d, value);
+				if (x === 1n || x === value - 1n) continue;
+				let witness = false;
+				for (let r = 1; r < s; r += 1) {
+					x = (x * x) % value;
+					if (x === value - 1n) {
+						witness = true;
+						break;
+					}
+				}
+				if (!witness) return false;
+			}
+			return true;
+		}
+		function randomPrimeCandidate(size, add, rem) {
+			const byteLength = Math.ceil(size / 8);
+			const mask = (1n << BigInt(size)) - 1n;
+			const highBit = 1n << BigInt(size - 1);
+			let candidate = (bytesToBigInt(callSync(globalThis._cryptoRandomFill, byteLength)) & mask) | highBit;
+			if (add !== undefined) {
+				const desired = rem === undefined ? 1n : rem;
+				const delta = (desired - (candidate % add) + add) % add;
+				candidate += delta;
+				if (candidate > mask) candidate -= add;
+			} else {
+				candidate |= 1n;
+			}
+			return candidate;
+		}
+		function generatePrimeSync(size, options = {}) {
+			const bitLength = Number(size);
+			if (!Number.isInteger(bitLength) || bitLength < 2) {
+				throw new RangeError("Browser node:crypto generatePrimeSync size must be an integer greater than 1");
+			}
+			if (bitLength > 4096) {
+				throw new RangeError("Browser node:crypto generatePrimeSync supports primes up to 4096 bits");
+			}
+			const primeOptions = options || {};
+			const add = normalizePrimeOption("add", primeOptions.add);
+			const rem = normalizePrimeOption("rem", primeOptions.rem);
+			if (add !== undefined && add <= 0n) {
+				throw new RangeError("Browser node:crypto generatePrimeSync options.add must be greater than zero");
+			}
+			if (rem !== undefined && add === undefined) {
+				throw new RangeError("Browser node:crypto generatePrimeSync options.rem requires options.add");
+			}
+			const safe = primeOptions.safe === true;
+			while (true) {
+				const candidate = randomPrimeCandidate(bitLength, add, rem);
+				if (candidate < 2n || candidate.toString(2).length !== bitLength) continue;
+				if (!isProbablePrime(candidate)) continue;
+				if (safe && !isProbablePrime((candidate - 1n) / 2n)) continue;
+				if (primeOptions.bigint === true) return candidate;
+				const bytes = bigIntToBytes(candidate, Math.ceil(bitLength / 8));
+				return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+			}
+		}
+		const DIFFIE_HELLMAN_GROUPS = {
+			modp14: {
+				prime: "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff",
+				generator: 2n,
+			},
+		};
+		function bigIntToMinimalBytes(value) {
+			if (value === 0n) return new Uint8Array([0]);
+			return bigIntToBytes(value, Math.ceil(value.toString(16).length / 2));
+		}
+		function normalizeDhNumber(value, encoding) {
+			if (typeof value === "bigint") return value;
+			if (typeof value === "number") return BigInt(value);
+			return bytesToBigInt(toBytes(value, encoding));
+		}
+		class DiffieHellman {
+			constructor(prime, generator = 2n) {
+				this.prime = BigInt(prime);
+				this.generator = BigInt(generator);
+				this.primeLength = Math.ceil(this.prime.toString(2).length / 8);
+				this.privateKey = null;
+				this.publicKey = null;
+				this.verifyError = 0;
+			}
+			_generatePrivateKey() {
+				const randomLength = Math.min(this.primeLength, 32);
+				const random = bytesToBigInt(callSync(globalThis._cryptoRandomFill, randomLength));
+				return 2n + (random % (this.prime - 3n));
+			}
+			generateKeys(encoding) {
+				this.privateKey = this._generatePrivateKey();
+				this.publicKey = modPow(this.generator, this.privateKey, this.prime);
+				return encodeOutput(bigIntToBytes(this.publicKey, this.primeLength), encoding);
+			}
+			computeSecret(otherPublicKey, inputEncoding, outputEncoding) {
+				if (this.privateKey === null) this.generateKeys();
+				const peer = normalizeDhNumber(otherPublicKey, inputEncoding);
+				const secret = modPow(peer, this.privateKey, this.prime);
+				return encodeOutput(bigIntToBytes(secret, this.primeLength), outputEncoding);
+			}
+			getPrime(encoding) {
+				return encodeOutput(bigIntToBytes(this.prime, this.primeLength), encoding);
+			}
+			getGenerator(encoding) {
+				return encodeOutput(bigIntToMinimalBytes(this.generator), encoding);
+			}
+			getPublicKey(encoding) {
+				if (this.publicKey === null) this.generateKeys();
+				return encodeOutput(bigIntToBytes(this.publicKey, this.primeLength), encoding);
+			}
+			getPrivateKey(encoding) {
+				if (this.privateKey === null) this.generateKeys();
+				return encodeOutput(bigIntToMinimalBytes(this.privateKey), encoding);
+			}
+			setPublicKey(key, encoding) {
+				this.publicKey = normalizeDhNumber(key, encoding);
+			}
+			setPrivateKey(key, encoding) {
+				this.privateKey = normalizeDhNumber(key, encoding);
+				this.publicKey = modPow(this.generator, this.privateKey, this.prime);
+			}
+		}
+		function createDiffieHellman(prime, primeEncoding, generator, generatorEncoding) {
+			let normalizedGenerator = generator;
+			let normalizedGeneratorEncoding = generatorEncoding;
+			if (typeof primeEncoding !== "string") {
+				normalizedGenerator = primeEncoding === undefined ? generator : primeEncoding;
+				normalizedGeneratorEncoding = typeof generator === "string" ? generator : undefined;
+				primeEncoding = undefined;
+			}
+			const primeValue = normalizeDhNumber(prime, primeEncoding);
+			const generatorValue = normalizedGenerator === undefined
+				? 2n
+				: normalizeDhNumber(normalizedGenerator, normalizedGeneratorEncoding);
+			return new DiffieHellman(primeValue, generatorValue);
+		}
+		function getDiffieHellman(name) {
+			const group = DIFFIE_HELLMAN_GROUPS[String(name).toLowerCase()];
+			if (!group) {
+				const error = new Error("Unknown DH group");
+				error.code = "ERR_CRYPTO_UNKNOWN_DH_GROUP";
+				throw error;
+			}
+			return new DiffieHellman(bytesToBigInt(toBytes(group.prime, "hex")), group.generator);
+		}
+		function publicEncrypt(keyOrOptions, buffer) {
+			const options = normalizeAsymmetricOptions(keyOrOptions);
+			const bytes = callSync(
+				globalThis._cryptoAsymmetricOp,
+				"publicEncrypt",
+				normalizeKeyInput(options.key),
+				toBytes(buffer),
+				JSON.stringify({
+					padding: options.padding,
+					oaepHash: options.oaepHash,
+					oaepLabel: options.oaepLabel ? Array.from(toBytes(options.oaepLabel)) : undefined,
+				}),
+			);
+			return makeBuffer(bytes);
+		}
+		function privateDecrypt(keyOrOptions, buffer) {
+			const options = normalizeAsymmetricOptions(keyOrOptions);
+			const bytes = callSync(
+				globalThis._cryptoAsymmetricOp,
+				"privateDecrypt",
+				normalizeKeyInput(options.key),
+				toBytes(buffer),
+				JSON.stringify({
+					padding: options.padding,
+					oaepHash: options.oaepHash,
+					oaepLabel: options.oaepLabel ? Array.from(toBytes(options.oaepLabel)) : undefined,
+				}),
+			);
+			return makeBuffer(bytes);
+		}
+		function randomBytes(size, callback) {
+			const bytes = makeBuffer(callSync(globalThis._cryptoRandomFill, Number(size)));
+			if (typeof callback === "function") queueMicrotask(() => callback(null, bytes));
+			return bytes;
+		}
+		function randomFillSync(buffer, offset = 0, size) {
+			const view = toBytes(buffer);
+			const start = Number(offset) || 0;
+			const length = size == null ? view.byteLength - start : Number(size);
+			view.set(callSync(globalThis._cryptoRandomFill, length), start);
+			return buffer;
+		}
+		function pbkdf2Sync(password, salt, iterations, keyLength, digest = "sha1") {
+			return makeBuffer(callSync(
+				globalThis._cryptoPbkdf2,
+				toBytes(password),
+				toBytes(salt),
+				Number(iterations),
+				Number(keyLength),
+				String(digest),
+			));
+		}
+		function pbkdf2(password, salt, iterations, keyLength, digest, callback) {
+			if (typeof digest === "function") {
+				callback = digest;
+				digest = "sha1";
+			}
+			queueMicrotask(() => {
+				try {
+					callback(null, pbkdf2Sync(password, salt, iterations, keyLength, digest || "sha1"));
+				} catch (error) {
+					callback(error);
+				}
+			});
+		}
+		function scryptSync(password, salt, keyLength, options = undefined) {
+			return makeBuffer(callSync(
+				globalThis._cryptoScrypt,
+				toBytes(password),
+				toBytes(salt),
+				Number(keyLength),
+				options || {},
+			));
+		}
+		function scrypt(password, salt, keyLength, options, callback) {
+			if (typeof options === "function") {
+				callback = options;
+				options = undefined;
+			}
+			if (typeof callback !== "function") {
+				throw new TypeError('The "callback" argument must be of type function');
+			}
+			queueMicrotask(() => {
+				try {
+					callback(null, scryptSync(password, salt, keyLength, options));
+				} catch (error) {
+					callback(error);
+				}
+			});
+		}
+		class Cipheriv {
+			constructor(mode, algorithm, key, iv, options = {}) {
+				this.mode = mode;
+				this.algorithm = String(algorithm);
+				this.key = toBytes(key);
+				this.iv = toBytes(iv);
+				this.options = { ...(options || {}) };
+				this.chunks = [];
+				this.finished = false;
+				this.authTag = null;
+			}
+			update(data, inputEncoding, outputEncoding) {
+				if (this.finished) throw new Error("Cipheriv final already called");
+				this.chunks.push(toBytes(data, inputEncoding));
+				return encodeOutput(new Uint8Array(0), outputEncoding);
+			}
+			final(outputEncoding) {
+				if (this.finished) throw new Error("Cipheriv final already called");
+				this.finished = true;
+				const input = concat(this.chunks);
+				let result;
+				if (this.mode === "cipher") {
+					result = callSync(globalThis._cryptoCipheriv, this.algorithm, this.key, this.iv, input, this.options);
+					if (this.algorithm.toLowerCase().endsWith("-gcm")) {
+						this.authTag = result.slice(result.byteLength - 16);
+						result = result.slice(0, result.byteLength - 16);
+					}
+				} else {
+					result = callSync(globalThis._cryptoDecipheriv, this.algorithm, this.key, this.iv, input, this.options);
+				}
+				return encodeOutput(result, outputEncoding);
+			}
+			setAutoPadding(autoPadding = true) {
+				if (this.finished) throw new Error("Cipheriv final already called");
+				this.options.autoPadding = autoPadding !== false;
+				return this;
+			}
+			setAAD(aad) {
+				if (this.finished) throw new Error("Cipheriv final already called");
+				this.options.aad = toBytes(aad);
+				return this;
+			}
+			getAuthTag() {
+				if (!this.authTag) throw new Error("Cipheriv auth tag is not available");
+				return makeBuffer(this.authTag);
+			}
+			setAuthTag(tag) {
+				if (this.finished) throw new Error("Cipheriv final already called");
+				this.options.authTag = toBytes(tag);
+				return this;
+			}
+		}
+		function unsupportedBrowserCrypto(operation) {
+			const error = new Error("node:crypto " + operation + " is not implemented in the browser runtime yet");
+			error.code = "ERR_UNSUPPORTED_BROWSER_CRYPTO";
+			throw error;
+		}
+		module.exports = {
+			createCipheriv: (algorithm, key, iv, options) => new Cipheriv("cipher", algorithm, key, iv, options),
+			createDecipheriv: (algorithm, key, iv, options) => new Cipheriv("decipher", algorithm, key, iv, options),
+			createDiffieHellman,
+			createECDH,
+			createHash: (algorithm) => new Hash(algorithm),
+			createHmac: (algorithm, key) => new Hmac(algorithm, key),
+			constants: CRYPTO_CONSTANTS,
+			createPrivateKey,
+			createPublicKey,
+			createSecretKey,
+			createSign: (algorithm) => new Sign(algorithm),
+			createVerify: (algorithm) => new Verify(algorithm),
+			diffieHellman,
+			generateKeyPair,
+			generateKeyPairSync,
+			generateKeySync,
+			generatePrimeSync,
+			getCiphers: () => [...SUPPORTED_CIPHERS],
+			getCurves: () => [...SUPPORTED_CURVES],
+			getDiffieHellman,
+			getHashes: () => ["md5", "sha1", "sha224", "sha256", "sha384", "sha512"],
+			pbkdf2,
+			pbkdf2Sync,
+			privateDecrypt,
+			publicEncrypt,
+			randomBytes,
+			randomFillSync,
+			randomUUID: () => callSync(globalThis._cryptoRandomUUID),
+			scrypt,
+			scryptSync,
+			sign: signOneShot,
+			subtle: globalThis.crypto && globalThis.crypto.subtle,
+			verify: verifyOneShot,
+			webcrypto: globalThis.crypto,
+		};
+	`,
+    "node:crypto": "module.exports = require('crypto');",
+    wasi: BROWSER_WASI_POLYFILL_CODE,
+    "node:wasi": "module.exports = require('wasi');",
+    os: `
+		const virtualOs = globalThis.__agentOsVirtualOs || {};
+		const stringValue = (value, fallback) =>
+			typeof value === "string" && value.length > 0 ? value : fallback;
+		const platform = stringValue(virtualOs.platform, "linux");
+		const arch = stringValue(virtualOs.arch, "x64");
+		const homedir = stringValue(virtualOs.homedir, "/home/user");
+		const tmpdir = stringValue(virtualOs.tmpdir, "/tmp");
+		const username = stringValue(virtualOs.user, "user");
+		const shell = stringValue(virtualOs.shell, "/bin/sh");
+		const positiveInteger = (value, fallback) =>
+			Number.isSafeInteger(value) && value > 0 ? value : fallback;
+		const nonNegativeInteger = (value, fallback) =>
+			Number.isSafeInteger(value) && value >= 0 ? value : fallback;
+		const cpuCount = positiveInteger(virtualOs.cpuCount, 1);
+		const totalmem = positiveInteger(virtualOs.totalmem, 1024 * 1024 * 1024);
+		const freemem = Math.min(
+			positiveInteger(virtualOs.freemem, 512 * 1024 * 1024),
+			totalmem,
+		);
+		const uid = nonNegativeInteger(virtualOs.uid, 1000);
+		const gid = nonNegativeInteger(virtualOs.gid, 1000);
+		const cpuInfo = () => ({
+			model: stringValue(virtualOs.cpuModel, "secure-exec virtual CPU"),
+			speed: 0,
+			times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+		});
+		module.exports = {
+			EOL: "\\n",
+			arch: () => arch,
+			cpus: () => Array.from({ length: cpuCount }, cpuInfo),
+			endianness: () => "LE",
+			freemem: () => freemem,
+			getPriority: () => 0,
+			homedir: () => homedir,
+			hostname: () => stringValue(virtualOs.hostname, "secure-exec"),
+			loadavg: () => [0, 0, 0],
+			machine: () => stringValue(virtualOs.machine, "x86_64"),
+			networkInterfaces: () => ({}),
+			platform: () => platform,
+			release: () => stringValue(virtualOs.release, "6.8.0-secure-exec"),
+			tmpdir: () => tmpdir,
+			totalmem: () => totalmem,
+			type: () => stringValue(virtualOs.type, platform === "win32" ? "Windows_NT" : "Linux"),
+			uptime: () => 0,
+			userInfo: () => ({ username, uid, gid, shell, homedir }),
+			version: () => stringValue(virtualOs.version, "#1 SMP PREEMPT_DYNAMIC secure-exec"),
+		};
+	`,
+    "node:os": "module.exports = require('os');",
+};
+export function exposeCustomGlobal(name, value) {
+    globalThis[name] = value;
+}
+export function exposeMutableRuntimeStateGlobal(name, value) {
+    globalThis[name] = value;
+}
+export function getIsolateRuntimeSource(id) {
+    if (id === "overrideProcessCwd") {
+        return `
+			if (globalThis.process && globalThis.__runtimeProcessCwdOverride) {
+				globalThis.process.cwd = () => String(globalThis.__runtimeProcessCwdOverride);
+			}
+		`;
+    }
+    return "";
+}
+export function getRequireSetupCode() {
+    return `
+		(function () {
+			${guestEncodingBootstrapCode()}
+
+			const callSyncBridge = (ref, ...args) => {
+				if (typeof ref === "function") {
+					return ref(...args);
+				}
+				if (ref && typeof ref.applySync === "function") {
+					return ref.applySync(undefined, args);
+				}
+				if (ref && typeof ref.applySyncPromise === "function") {
+					return ref.applySyncPromise(undefined, args);
+				}
+				return undefined;
+			};
+
+			const pathDirname = (value) => {
+				const normalized = String(value || "/").replace(/\\\\/g, "/");
+				if (normalized === "/") return "/";
+				const parts = normalized.split("/").filter(Boolean);
+				return parts.length <= 1 ? "/" : "/" + parts.slice(0, -1).join("/");
+			};
+
+			globalThis.require = function require(specifier) {
+				const polyfillSource = callSyncBridge(
+					globalThis._loadPolyfill,
+					specifier.replace(/^node:/, ""),
+				);
+				if (polyfillSource) {
+					const module = { exports: {} };
+					const fn = new Function("module", "exports", polyfillSource);
+					fn(module, module.exports);
+					return module.exports;
+				}
+
+				const currentModule = globalThis._currentModule || { dirname: "/" };
+				const resolved = callSyncBridge(
+					globalThis._resolveModuleSync,
+					specifier,
+					currentModule.dirname || "/",
+					"require",
+				);
+				if (!resolved) {
+					throw new Error("Cannot resolve module '" + specifier + "'");
+				}
+
+				const cache = globalThis._moduleCache || (globalThis._moduleCache = {});
+				if (cache[resolved]) {
+					return cache[resolved].exports;
+				}
+
+				const source = callSyncBridge(
+					globalThis._loadFileSync,
+					resolved,
+					"require",
+				);
+				if (source == null) {
+					throw new Error("Cannot load module '" + resolved + "'");
+				}
+
+				const module = { exports: {} };
+				cache[resolved] = module;
+				const previous = globalThis._currentModule;
+				globalThis._currentModule = { filename: resolved, dirname: pathDirname(resolved) };
+				try {
+					const fn = new Function(
+						"require",
+						"module",
+						"exports",
+						"__filename",
+						"__dirname",
+						source,
+					);
+					fn(globalThis.require, module, module.exports, resolved, pathDirname(resolved));
+				} finally {
+					globalThis._currentModule = previous;
+				}
+				return module.exports;
+			};
+
+			const util = globalThis.require("util");
+			const formatConsoleLine = (...args) => {
+				if (!util || typeof util.formatWithOptions !== "function") {
+					throw new Error("console formatting requires util.formatWithOptions");
+				}
+				return util.formatWithOptions({ colors: false }, ...args) + "\\n";
+			};
+			const writeConsole = (ref, args) => {
+				callSyncBridge(ref, formatConsoleLine(...args));
+			};
+			const consoleObject = {
+				log: (...args) => writeConsole(globalThis._log, args),
+				info: (...args) => writeConsole(globalThis._log, args),
+				debug: (...args) => writeConsole(globalThis._log, args),
+				warn: (...args) => writeConsole(globalThis._error, args),
+				error: (...args) => writeConsole(globalThis._error, args),
+				dir: (value) => writeConsole(globalThis._log, [value]),
+				dirxml: (...args) => writeConsole(globalThis._log, args),
+				assert: (condition, ...args) => {
+					if (condition) return;
+					writeConsole(globalThis._error, args.length > 0 ? args : ["Assertion failed"]);
+				},
+				clear: () => {},
+				count: (label = "default") => {
+					const key = String(label);
+					consoleObject._counts.set(key, (consoleObject._counts.get(key) || 0) + 1);
+					consoleObject.log(key + ": " + consoleObject._counts.get(key));
+				},
+				countReset: (label = "default") => {
+					consoleObject._counts.delete(String(label));
+				},
+				group: (...args) => {
+					if (args.length > 0) consoleObject.log(...args);
+				},
+				groupCollapsed: (...args) => {
+					if (args.length > 0) consoleObject.log(...args);
+				},
+				groupEnd: () => {},
+				table: (value) => consoleObject.log(value),
+				time: (label = "default") => {
+					consoleObject._times.set(String(label), Date.now());
+				},
+				timeEnd: (label = "default") => {
+					const key = String(label);
+					if (!consoleObject._times.has(key)) return;
+					const startedAt = consoleObject._times.get(key);
+					consoleObject._times.delete(key);
+					consoleObject.log(key + ": " + (Date.now() - startedAt) + "ms");
+				},
+				timeLog: (label = "default", ...args) => {
+					const key = String(label);
+					if (!consoleObject._times.has(key)) return;
+					consoleObject.log(key + ": " + (Date.now() - consoleObject._times.get(key)) + "ms", ...args);
+				},
+				trace: (...args) => {
+					const message = formatConsoleLine(...args).trimEnd();
+					const error = new Error(message);
+					writeConsole(globalThis._error, [error.stack || message]);
+				},
+				_counts: new Map(),
+				_times: new Map(),
+			};
+			globalThis.console = consoleObject;
+		})();
+	`;
+}
+export { createInMemoryFileSystem, InMemoryFileSystem };