@rivet-dev/agentos-core 0.0.0-abc-fixes-1.d8c4d95 → 0.0.0-agent-acp-codex-session-benchmark.62b1f46

package/dist/packages.js

@@ -1,335 +1,9 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, join, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-/**
- * Resolve a package directory by walking up the directory tree.
- * Supports both nested (pnpm) and flat (npm) node_modules layouts.
- */
-export function resolvePackageDir(startDir, packageName) {
-    const localPkgJson = join(startDir, "package.json");
-    if (existsSync(localPkgJson)) {
-        try {
-            const localPkg = JSON.parse(readFileSync(localPkgJson, "utf-8"));
-            if (localPkg.name === packageName) {
-                return realpathSync(startDir);
-            }
-        }
-        catch {
-            // Ignore malformed local package metadata and continue walking.
-        }
-    }
-    let searchDir = startDir;
-    while (true) {
-        const candidate = join(searchDir, "node_modules", packageName);
-        if (existsSync(join(candidate, "package.json"))) {
-            return realpathSync(candidate);
-        }
-        const parent = dirname(searchDir);
-        if (parent === searchDir)
-            break;
-        searchDir = parent;
-    }
-    throw new Error(`Package "${packageName}" not found starting from ${startDir}. ` +
-        `Ensure it is installed.`);
-}
-const LOCAL_REGISTRY_COMMAND_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../../..", "registry/native/target/wasm32-wasip1/release/commands");
-function readPackageName(packageDir) {
-    const pkg = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf-8"));
-    if (typeof pkg.name !== "string" || pkg.name.length === 0) {
-        throw new Error(`Package at ${packageDir} is missing a valid name`);
-    }
-    return pkg.name;
-}
-function pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    if (seenVmPaths.has(vmPath)) {
-        return;
-    }
-    seenVmPaths.add(vmPath);
-    softwareRoots.push({ hostPath, vmPath });
-}
-function findPnpmStoreRoot(hostPath) {
-    const marker = `${sep}node_modules${sep}.pnpm${sep}`;
-    const markerIndex = hostPath.indexOf(marker);
-    if (markerIndex === -1) {
-        return null;
-    }
-    const nodeModulesRoot = `${hostPath.slice(0, markerIndex)}${sep}node_modules`;
-    const pnpmStoreRoot = join(nodeModulesRoot, ".pnpm");
-    return existsSync(pnpmStoreRoot) ? pnpmStoreRoot : null;
-}
-function pushPackageSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath) {
-    pushSoftwareRoot(softwareRoots, seenVmPaths, hostPath, vmPath);
-    const pnpmStoreRoot = findPnpmStoreRoot(hostPath);
-    if (!pnpmStoreRoot) {
-        return;
-    }
-    pushSoftwareRoot(softwareRoots, seenVmPaths, pnpmStoreRoot, "/root/node_modules/.pnpm");
-}
-/**
- * Create a SoftwareContext for a software descriptor.
- * Resolves npm package paths relative to the descriptor's packageDir.
- */
-function createSoftwareContext(packageDir, requires) {
-    // Pre-resolve all required packages to host paths
-    const resolvedPackages = new Map();
-    for (const reqPkg of requires) {
-        const hostDir = resolvePackageDir(packageDir, reqPkg);
-        const pkg = JSON.parse(readFileSync(join(hostDir, "package.json"), "utf-8"));
-        const vmDir = `/root/node_modules/${reqPkg}`;
-        resolvedPackages.set(reqPkg, { hostDir, vmDir, pkg });
-    }
-    return {
-        resolveBin(packageName, binName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            const { pkg, vmDir } = resolved;
-            let binEntry;
-            const effectiveBinName = binName ?? packageName;
-            if (typeof pkg.bin === "string") {
-                binEntry = pkg.bin;
-            }
-            else if (typeof pkg.bin === "object" && pkg.bin !== null) {
-                const binMap = pkg.bin;
-                binEntry = binMap[effectiveBinName] ?? Object.values(binMap)[0];
-            }
-            if (!binEntry) {
-                throw new Error(`No bin entry "${effectiveBinName}" found in ${packageName}/package.json`);
-            }
-            return `${vmDir}/${binEntry}`;
-        },
-        resolvePackage(packageName) {
-            const resolved = resolvedPackages.get(packageName);
-            if (!resolved) {
-                throw new Error(`Package "${packageName}" is not in the requires list. ` +
-                    `Available: ${[...resolvedPackages.keys()].join(", ")}`);
-            }
-            return resolved.vmDir;
-        },
-    };
-}
 // ── defineSoftware ───────────────────────────────────────────────────
 /**
- * Define a software descriptor. This is a type-safe identity function that
- * validates the descriptor shape at compile time.
+ * Define a software descriptor. A type-safe identity function that validates the
+ * package-dir reference at compile time. The sidecar materializes the package into
+ * the `/opt/agentos` projection.
  */
 export function defineSoftware(desc) {
     return desc;
 }
-/** Check if a descriptor is a typed software descriptor (has a `type` field). */
-function isTypedDescriptor(desc) {
-    return ("type" in desc && typeof desc.type === "string");
-}
-const VALID_PERMISSION_TIERS = new Set([
-    "full",
-    "read-write",
-    "read-only",
-    "isolated",
-]);
-function isPermissionTier(value) {
-    return (typeof value === "string" &&
-        VALID_PERMISSION_TIERS.has(value));
-}
-function registerPermission(commandPermissions, commandName, tier) {
-    if (commandName in commandPermissions)
-        return;
-    commandPermissions[commandName] = tier;
-}
-function appendDeclaredCommand(declaredCommands, seen, commandName) {
-    if (typeof commandName !== "string" || seen.has(commandName)) {
-        return;
-    }
-    seen.add(commandName);
-    declaredCommands.push(commandName);
-}
-function collectCommandMetadata(pkg) {
-    const declaredCommands = [];
-    const seen = new Set();
-    const aliases = {};
-    if ("aliases" in pkg && pkg.aliases) {
-        for (const [aliasName, targetName] of Object.entries(pkg.aliases)) {
-            if (typeof targetName !== "string") {
-                continue;
-            }
-            aliases[aliasName] = targetName;
-            appendDeclaredCommand(declaredCommands, seen, aliasName);
-            appendDeclaredCommand(declaredCommands, seen, targetName);
-        }
-    }
-    const rawCommands = pkg.commands;
-    if (Array.isArray(rawCommands)) {
-        for (const rawCommand of rawCommands) {
-            if (typeof rawCommand !== "object" || rawCommand === null) {
-                continue;
-            }
-            const name = rawCommand.name;
-            const aliasOf = rawCommand.aliasOf;
-            appendDeclaredCommand(declaredCommands, seen, name);
-            appendDeclaredCommand(declaredCommands, seen, aliasOf);
-            if (typeof name === "string" && typeof aliasOf === "string") {
-                aliases[name] = aliasOf;
-            }
-        }
-    }
-    const permissions = pkg.permissions;
-    if (permissions) {
-        for (const commandName of permissions.full ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        for (const commandName of permissions.readWrite ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-        if (Array.isArray(permissions.readOnly)) {
-            for (const commandName of permissions.readOnly) {
-                appendDeclaredCommand(declaredCommands, seen, commandName);
-            }
-        }
-        for (const commandName of permissions.isolated ?? []) {
-            appendDeclaredCommand(declaredCommands, seen, commandName);
-        }
-    }
-    const commandDir = resolveLocalCommandDirFallback(pkg.commandDir, declaredCommands);
-    return {
-        commandDir,
-        declaredCommands,
-        aliases,
-    };
-}
-function hasUsableCommandDir(commandDir, declaredCommands) {
-    if (!existsSync(commandDir)) {
-        return false;
-    }
-    return declaredCommands.every((commandName) => existsSync(join(commandDir, commandName)));
-}
-function resolveLocalCommandDirFallback(commandDir, declaredCommands) {
-    if (declaredCommands.length === 0 ||
-        hasUsableCommandDir(commandDir, declaredCommands) ||
-        !hasUsableCommandDir(LOCAL_REGISTRY_COMMAND_DIR, declaredCommands)) {
-        return commandDir;
-    }
-    return LOCAL_REGISTRY_COMMAND_DIR;
-}
-function collectRegistryPackagePermissions(commandPermissions, pkg) {
-    const rawCommands = pkg.commands;
-    if (!Array.isArray(rawCommands))
-        return;
-    for (const rawCommand of rawCommands) {
-        if (typeof rawCommand !== "object" ||
-            rawCommand === null ||
-            !Object.hasOwn(rawCommand, "name") ||
-            !Object.hasOwn(rawCommand, "permissionTier")) {
-            continue;
-        }
-        const name = rawCommand.name;
-        const permissionTier = rawCommand
-            .permissionTier;
-        if (typeof name !== "string" || !isPermissionTier(permissionTier))
-            continue;
-        registerPermission(commandPermissions, name, permissionTier);
-    }
-}
-function collectTypedDescriptorPermissions(commandPermissions, pkg) {
-    const permissions = pkg.permissions;
-    if (!permissions)
-        return;
-    for (const commandName of permissions.full ?? []) {
-        registerPermission(commandPermissions, commandName, "full");
-    }
-    for (const commandName of permissions.readWrite ?? []) {
-        registerPermission(commandPermissions, commandName, "read-write");
-    }
-    if (Array.isArray(permissions.readOnly)) {
-        for (const commandName of permissions.readOnly) {
-            registerPermission(commandPermissions, commandName, "read-only");
-        }
-    }
-    for (const commandName of permissions.isolated ?? []) {
-        registerPermission(commandPermissions, commandName, "isolated");
-    }
-}
-/**
- * Process an array of software descriptors at boot time.
- * Collects WASM command dirs, module access roots, and agent configurations.
- *
- * Any object with a `commandDir` property (e.g., registry packages) is treated
- * as a WASM command source. Typed descriptors with `type: "agent"` or `type: "tool"`
- * are processed for module mounting and agent registration.
- */
-export function processSoftware(software) {
-    const commandDirs = [];
-    const commandPackages = [];
-    const commandPermissions = {};
-    const softwareRoots = [];
-    const seenSoftwareVmPaths = new Set();
-    const agentConfigs = new Map();
-    // Flatten nested arrays (meta-packages export arrays of sub-packages).
-    const flat = software.flat();
-    for (const pkg of flat) {
-        if (!isTypedDescriptor(pkg)) {
-            // Duck-typed: any object with commandDir is a WASM command source.
-            const commandMetadata = collectCommandMetadata(pkg);
-            commandDirs.push(commandMetadata.commandDir);
-            commandPackages.push(commandMetadata);
-            collectRegistryPackagePermissions(commandPermissions, pkg);
-            continue;
-        }
-        switch (pkg.type) {
-            case "wasm-commands": {
-                const commandMetadata = collectCommandMetadata(pkg);
-                commandDirs.push(commandMetadata.commandDir);
-                commandPackages.push(commandMetadata);
-                collectTypedDescriptorPermissions(commandPermissions, pkg);
-                break;
-            }
-            case "agent": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const ctx = createSoftwareContext(pkg.packageDir, pkg.requires);
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Compute static + dynamic env vars.
-                const staticEnv = pkg.agent.staticEnv ?? {};
-                const dynamicEnv = pkg.agent.env ? pkg.agent.env(ctx) : {};
-                const combinedEnv = { ...staticEnv, ...dynamicEnv };
-                // Register agent config.
-                const agentConfig = {
-                    acpAdapter: pkg.agent.acpAdapter,
-                    agentPackage: pkg.agent.agentPackage,
-                    declaringPackageDir: pkg.packageDir,
-                    launchArgs: pkg.agent.launchArgs,
-                    defaultEnv: Object.keys(combinedEnv).length > 0 ? combinedEnv : undefined,
-                };
-                agentConfigs.set(pkg.agent.id, agentConfig);
-                break;
-            }
-            case "tool": {
-                // Collect module roots for all required npm packages.
-                // Walks up directory tree to support flat (npm) and nested (pnpm) layouts.
-                const declaringPackageName = readPackageName(pkg.packageDir);
-                pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, pkg.packageDir, `/root/node_modules/${declaringPackageName}`);
-                for (const reqPkg of pkg.requires) {
-                    const hostDir = resolvePackageDir(pkg.packageDir, reqPkg);
-                    const vmDir = `/root/node_modules/${reqPkg}`;
-                    pushPackageSoftwareRoot(softwareRoots, seenSoftwareVmPaths, hostDir, vmDir);
-                }
-                // Tool bin registration is handled by the caller (AgentOs.create)
-                // since it requires kernel access.
-                break;
-            }
-        }
-    }
-    return {
-        commandDirs,
-        commandPackages,
-        commandPermissions,
-        softwareRoots,
-        agentConfigs,
-    };
-}

package/dist/runtime.d.ts

@@ -1,5 +1,4 @@
 export type StdioChannel = "stdout" | "stderr";
-export type TimingMitigation = "off" | "freeze";
 export type PermissionMode = "allow" | "deny";
 export type PermissionDecision = PermissionMode;
 export interface VirtualDirEntry {
@@ -10,6 +9,7 @@ export interface VirtualDirEntry {
 export interface VirtualStat {
     mode: number;
     size: number;
+    sizeExact?: bigint;
     blocks: number;
     dev: number;
     rdev: number;
@@ -20,7 +20,9 @@ export interface VirtualStat {
     ctimeMs: number;
     birthtimeMs: number;
     ino: number;
+    inoExact?: bigint;
     nlink: number;
+    nlinkExact?: bigint;
     uid: number;
     gid: number;
 }
@@ -76,7 +78,7 @@ export type NetworkPermissions = PermissionMode | RulePermissions<PatternPermiss
 export type ChildProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type ProcessPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export type EnvPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
-export type ToolPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
+export type BindingPermissions = PermissionMode | RulePermissions<PatternPermissionRule>;
 export interface ProcessInfo {
     pid: number;
     ppid: number;
@@ -86,25 +88,27 @@ export interface ProcessInfo {
     command: string;
     args: string[];
     cwd: string;
-    status: "running" | "exited";
+    status: "running" | "stopped" | "exited";
     exitCode: number | null;
     startTime: number;
     exitTime: number | null;
 }
 export interface ManagedProcess {
     pid: number;
-    writeStdin(data: Uint8Array | string): void;
-    closeStdin(): void;
-    kill(signal?: number): void;
+    writeStdin(data: Uint8Array | string): Promise<void>;
+    closeStdin(): Promise<void>;
+    kill(signal?: number): void | Promise<void>;
     wait(): Promise<number>;
     readonly exitCode: number | null;
 }
 export interface ShellHandle {
     pid: number;
-    write(data: Uint8Array | string): void;
+    /** Sidecar-owned process correlation id. */
+    processId: string;
+    write(data: Uint8Array | string): Promise<void>;
     onData: ((data: Uint8Array) => void) | null;
-    resize(cols: number, rows: number): void;
-    kill(signal?: number): void;
+    resize(cols: number, rows: number): void | Promise<void>;
+    kill(signal?: number): void | Promise<void>;
     wait(): Promise<number>;
 }
 export interface OpenShellOptions {
@@ -116,221 +120,74 @@ export interface OpenShellOptions {
     rows?: number;
     onStderr?: (data: Uint8Array) => void;
 }
-export interface ConnectTerminalOptions extends OpenShellOptions {
-    onData?: (data: Uint8Array) => void;
-}
-export interface ExecOptions {
+interface ProcessLaunchOptions {
     env?: Record<string, string>;
     cwd?: string;
-    stdin?: string | Uint8Array;
     timeout?: number;
     onStdout?: (data: Uint8Array) => void;
     onStderr?: (data: Uint8Array) => void;
+}
+export interface ExecOptions extends ProcessLaunchOptions {
+    stdin?: string | Uint8Array;
     captureStdio?: boolean;
-    filePath?: string;
-    cpuTimeLimitMs?: number;
-    timingMitigation?: TimingMitigation;
 }
 export interface ExecResult {
     exitCode: number;
     stdout: string;
     stderr: string;
 }
-export interface RunResult<T = unknown> {
-    value?: T;
-    code: number;
-    errorMessage?: string;
-}
-export interface KernelSpawnOptions extends ExecOptions {
-    stdio?: "pipe" | "inherit";
-    stdinFd?: number;
-    stdoutFd?: number;
-    stderrFd?: number;
+export interface KernelSpawnOptions extends ProcessLaunchOptions {
     streamStdin?: boolean;
 }
 export type KernelExecOptions = ExecOptions;
 export type KernelExecResult = ExecResult;
-export type StatInfo = VirtualStat;
-export type DirEntry = VirtualDirEntry;
-export type StdioEvent = {
-    channel: StdioChannel;
-    message: string;
-};
-export type StdioHook = (event: StdioEvent) => void;
 export interface Permissions {
     fs?: FsPermissions;
     network?: NetworkPermissions;
     childProcess?: ChildProcessPermissions;
     process?: ProcessPermissions;
     env?: EnvPermissions;
-    tool?: ToolPermissions;
-}
-export interface ResourceBudgets {
-    maxOutputBytes?: number;
-    maxBridgeCalls?: number;
-    maxTimers?: number;
-    maxChildProcesses?: number;
-    maxHandles?: number;
-}
-export interface ProcessConfig {
-    cwd?: string;
-    env?: Record<string, string>;
-    argv?: string[];
-    stdinIsTTY?: boolean;
-    stdoutIsTTY?: boolean;
-    stderrIsTTY?: boolean;
-}
-export interface OSConfig {
-    homedir?: string;
-    tmpdir?: string;
-}
-export interface CommandExecutor {
-    spawn(command: string, args: string[], options?: KernelSpawnOptions): ManagedProcess;
-}
-export interface NetworkAdapter {
-    fetch(url: string, options?: {
-        method?: string;
-        headers?: Record<string, string>;
-        body?: unknown;
-    }): Promise<{
-        ok: boolean;
-        status: number;
-        statusText: string;
-        headers: Record<string, string>;
-        body: string;
-        url: string;
-        redirected: boolean;
-    }>;
-    dnsLookup(hostname: string): Promise<{
-        address?: string;
-        family?: number;
-        error?: string;
-        code?: string;
-    }>;
-    httpRequest(url: string, options?: {
-        method?: string;
-        headers?: Record<string, string>;
-        body?: unknown;
-    }): Promise<{
-        status: number;
-        statusText: string;
-        headers: Record<string, string>;
-        body: string;
-        url: string;
-    }>;
-}
-export interface SystemDriver {
-    filesystem?: VirtualFileSystem;
-    network?: NetworkAdapter;
-    commandExecutor?: CommandExecutor;
-    permissions?: Permissions;
-    runtime: {
-        process: ProcessConfig;
-        os: OSConfig;
-    };
-}
-export interface RuntimeDriverOptions {
-    system: SystemDriver;
-    runtime: {
-        process: ProcessConfig;
-        os: OSConfig;
-    };
-    memoryLimit?: number;
-    cpuTimeLimitMs?: number;
-    timingMitigation?: TimingMitigation;
-    onStdio?: StdioHook;
-    payloadLimits?: {
-        base64TransferBytes?: number;
-        jsonPayloadBytes?: number;
-    };
-    resourceBudgets?: ResourceBudgets;
-}
-export interface NodeRuntimeDriver {
-    exec(code: string, options?: ExecOptions): Promise<ExecResult>;
-    run<T = unknown>(code: string, filePath?: string): Promise<RunResult<T>>;
-    dispose(): void;
-    terminate?(): Promise<void>;
-    readonly network?: Pick<NetworkAdapter, "fetch" | "dnsLookup" | "httpRequest">;
-}
-export interface NodeRuntimeDriverFactory {
-    createRuntimeDriver(options: RuntimeDriverOptions): NodeRuntimeDriver;
+    binding?: BindingPermissions;
 }
 export interface KernelInterface {
     vfs: VirtualFileSystem;
 }
+export interface KernelRecursiveDirEntry {
+    name: string;
+    path: string;
+    isDirectory: boolean;
+    isSymbolicLink: boolean;
+    size: number;
+}
 export interface Kernel extends KernelInterface {
-    mount(driver: KernelRuntimeDriver): Promise<void>;
     dispose(): Promise<void>;
     exec(command: string, options?: KernelExecOptions): Promise<KernelExecResult>;
-    spawn(command: string, args: string[], options?: KernelSpawnOptions): ManagedProcess;
-    openShell(options?: OpenShellOptions): ShellHandle;
-    connectTerminal(options?: ConnectTerminalOptions): Promise<number>;
+    spawn(command: string, args: string[], options?: KernelSpawnOptions): Promise<ManagedProcess>;
+    openShell(options?: OpenShellOptions): Promise<ShellHandle>;
     mountFs(path: string, fs: VirtualFileSystem, options?: {
         readOnly?: boolean;
-    }): void;
-    unmountFs(path: string): void;
+    }): void | Promise<void>;
+    unmountFs(path: string): void | Promise<void>;
     readFile(path: string): Promise<Uint8Array>;
     writeFile(path: string, content: string | Uint8Array): Promise<void>;
-    mkdir(path: string): Promise<void>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     readdir(path: string): Promise<string[]>;
+    readdirRecursive(path: string, options?: {
+        maxDepth?: number;
+    }): Promise<KernelRecursiveDirEntry[]>;
     stat(path: string): Promise<VirtualStat>;
     exists(path: string): Promise<boolean>;
     removeFile(path: string): Promise<void>;
     removeDir(path: string): Promise<void>;
+    removePath(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
     rename(oldPath: string, newPath: string): Promise<void>;
-    readonly commands: ReadonlyMap<string, string>;
+    movePath(oldPath: string, newPath: string): Promise<void>;
     readonly processes: ReadonlyMap<number, ProcessInfo>;
     readonly env: Record<string, string>;
     readonly cwd: string;
-    readonly socketTable: {
-        hasHostNetworkAdapter(): boolean;
-        findListener(_request: unknown): unknown | null;
-        findBoundUdp(_request: unknown): unknown | null;
-    };
-    readonly processTable: {
-        getSignalState(_pid: number): {
-            handlers: Map<number, unknown>;
-        };
-    };
-    readonly timerTable: Record<string, never>;
-    readonly zombieTimerCount: number;
-}
-export interface BindingTree {
-    [key: string]: BindingFunction | BindingTree;
-}
-export type BindingFunction = (...args: unknown[]) => unknown;
-export interface NodeDriverOptions {
-    filesystem?: VirtualFileSystem;
-    networkAdapter?: NetworkAdapter;
-    commandExecutor?: CommandExecutor;
-    permissions?: Permissions;
-    processConfig?: ProcessConfig;
-    osConfig?: OSConfig;
-}
-export interface DefaultNetworkAdapterOptions {
-    loopbackExemptPorts?: number[];
-}
-export interface NodeRuntimeOptions {
-    systemDriver?: SystemDriver;
-    runtimeDriverFactory?: NodeRuntimeDriverFactory;
-    permissions?: Partial<Permissions>;
-    memoryLimit?: number;
-    bindings?: BindingTree;
-    loopbackExemptPorts?: number[];
-}
-export type NodeRuntimeDriverFactoryOptions = Record<string, never>;
-export type NodeExecutionDriverOptions = RuntimeDriverOptions;
-export interface KernelRuntimeDriver {
-    readonly kind: "node" | "wasmvm";
-    readonly name: string;
-    readonly commands: string[];
-    readonly commandDirs?: string[];
-}
-export type DriverProcess = ManagedProcess;
-export type ProcessContext = Record<string, never>;
-export type PermissionTier = "full" | "read-write" | "read-only" | "isolated";
-export interface WasmVmRuntimeOptions {
-    wasmBinaryPath?: string;
-    commandDirs?: string[];
-    permissions?: Record<string, PermissionTier>;
 }
+export {};