@actiondock/testing 2.2.2 → 2.4.0

package/README.md

@@ -28,14 +28,23 @@ ActionDock 2.0 确定性测试框架与测试运行时。
 - 通过 `advance(ms)` 瞬间推进模拟时间，并以确定性顺序依次唤醒挂起的计时器与延迟任务。
 - 支持时间倒流检测与高精度时间戳快照。
 
+### FakeProcessDriver 确定性测试驱动桩
+
+[FakeProcessDriver](./src/process-driver.ts) 完整实现 Core 层的 ProcessDriver 契约，是受管进程测试的核心桩：
+
+- 确定性事件模拟：提供 `emitOutput`、`emitExit`、`emitOutputClosed` 与 `emitFault` 方法，在测试中以确定性时序唤醒观察者。
+- 故障与异常注入：提供 `simulateSpawnFailure`、`simulateWriteFailure`、`simulateResizeFailure` 与 `simulateTerminateFailure`，精确验证业务层容错。
+- 历史追踪与状态断言：维护 `spawnCalls`、`writes`、`eofCalls`、`interruptCalls`、`resizeCalls`、`terminateCalls` 与 `disposeCalls` 集合，供测试后置断言。
+- 动态能力覆写：支持通过 `setCapabilities` 动态调整是否支持 PTY、resize 与 inputEOF 等特征。
+
 ### MockProcessExecutor 模拟进程执行器
 
-[MockProcessExecutor](./src/process.ts) 在沙箱中拦截并伪造所有外部系统命令与子进程调用：
+[MockProcessExecutor](./src/process.ts) 深度集成 ProcessManager 与 FakeProcessDriver，拦截并模拟外部命令与受管进程调用：
 
-- 灵活规则匹配：通过 `onCommand` 注册匹配器，支持字符串完全匹配、正则表达式匹配或自定义断言谓词函数。
-- 丰富的响应定义：支持模拟标准输出、标准错误流、非零退出码、二进制字节流以及执行耗时。
-- 异常场景复现：可直接模拟命令执行超时（`timedOut`）或取消信号阻断（`cancelled`）。
-- 调用历史追踪：精确记录每次调用的完整入参、工作目录与环境变量，提供断言追踪支持。
+- 规则灵活匹配：通过 `register` 注册匹配器，支持命令字符串精确匹配、正则表达式匹配或自定义断言谓词函数。
+- 丰富响应定义：支持模拟标准输出、标准错误流、退出状态码、二进制字节流以及执行延迟。
+- 受管进程穿透：直接暴露 `driver` 底层驱动与 `processManager` 实例，无缝承接 `run`、`start`、`acquire` 等受管操作。
+- 调用历史追踪：精确记录每次调用的命令、参数、工作目录与环境变量。
 
 ### MemoryStorage 纯内存存储
 
@@ -49,36 +58,39 @@ ActionDock 2.0 确定性测试框架与测试运行时。
 
 ## 快速使用示例
 
+### 一次性受管进程命令测试
+
 ```ts
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { defineAction } from "@actiondock/sdk";
-import { createTestRuntime, MockProcessExecutor } from "@actiondock/testing";
+import { defineAction, decodeText } from "@actiondock/sdk";
+import { createTestRuntime, FakeProcessDriver } from "@actiondock/testing";
 
 const gitBranchAction = defineAction(async (input: { remote?: boolean }, ctx) => {
-  const res = await ctx.process.exec("git", ["branch"]);
-  return { output: res.stdout.trim() };
+  const res = await ctx.process.run({
+    spec: { executable: "git", args: ["branch"], io: { mode: "pipe" } },
+    timeoutMs: 5000,
+    maxOutputBytes: 1024 * 1024,
+  });
+  return { output: decodeText(res.chunks).trim() };
 });
 
 describe("git action test", () => {
-  it("mocks process and asserts output", async () => {
-    // 初始化模拟执行器并配置预设响应
-    const processExecutor = new MockProcessExecutor();
-    processExecutor.onCommand("git", {
-      stdout: "* main\n  feature/agent\n",
-    });
+  it("使用 FakeProcessDriver 模拟输出并断言", async () => {
+    const fakeDriver = new FakeProcessDriver();
+    fakeDriver.onSpawn = (handle) => {
+      handle.emitOutput("stdout", "* main\n  feature/agent\n");
+      handle.emitExit(0);
+      handle.emitOutputClosed("natural");
+    };
 
-    // 创建测试运行时并注入执行器
     const runtime = createTestRuntime({
-      process: processExecutor,
+      platform: { processDriver: fakeDriver } as any,
     });
 
-    // 执行 Action 并断言业务数据
     const result = await runtime.run(gitBranchAction, { remote: false });
     assert.equal(result.output, "* main\n  feature/agent");
-
-    // 断言底层命令调用历史
-    assert.equal(processExecutor.getHistory().length, 1);
+    assert.equal(fakeDriver.spawnCalls.length, 1);
   });
 });
 ```

package/dist/cli.d.ts

@@ -11,6 +11,8 @@ export interface ExecCliOptions {
     input?: string | Uint8Array;
     encoding?: string;
     throwOnError?: boolean;
+    /** 输出字节总量上限，超出后终止进程并标记 truncated（与 runtime-node 执行器语义对齐） */
+    maxOutputBytes?: number;
 }
 /**
  * CLI 执行结果结构体。
@@ -22,6 +24,8 @@ export interface ExecCliResult {
     stderr: string;
     raw: Uint8Array;
     timedOut?: boolean;
+    /** 输出超过 maxOutputBytes 上限被截断时置为 true */
+    truncated?: boolean;
     durationMs: number;
 }
 /**

package/dist/cli.js

@@ -12,6 +12,7 @@ export { findExecutable };
  */
 export async function execCli(command, args = [], options = {}) {
     const startTime = performance.now();
+    const maxOutputBytes = options.maxOutputBytes ?? Infinity;
     if (options.signal?.aborted) {
         const errRes = {
             ok: false,
@@ -78,9 +79,20 @@ export async function execCli(command, args = [], options = {}) {
         }
         let settled = false;
         let timedOut = false;
+        let truncated = false;
         let spawnError;
         const stdoutChunks = [];
         const stderrChunks = [];
+        let totalOutputBytes = 0;
+        // 输出超限时终止进程：由 enforceOutputLimit 负责截断与标记
+        const terminateForLimit = () => {
+            try {
+                child.kill("SIGTERM");
+            }
+            catch {
+                // 忽略已退出状态
+            }
+        };
         let timeoutTimer;
         if (options.timeout && options.timeout > 0) {
             timeoutTimer = setTimeout(() => {
@@ -112,7 +124,12 @@ export async function execCli(command, args = [], options = {}) {
                 stderr = `Command '${command}' timed out after ${options.timeout}ms`;
             }
             const exitCode = timedOut ? -1 : (exitCodeFromClose ?? (spawnError ? -1 : 0));
-            const ok = !timedOut && exitCode === 0;
+            const ok = !timedOut && !truncated && exitCode === 0;
+            let limitMessage = "";
+            if (truncated && !stderr) {
+                limitMessage = `Command '${command}' output exceeded limit of ${maxOutputBytes} bytes`;
+                stderr = limitMessage;
+            }
             const result = {
                 ok,
                 exitCode,
@@ -120,6 +137,7 @@ export async function execCli(command, args = [], options = {}) {
                 stderr,
                 raw: rawStdout,
                 timedOut: timedOut || undefined,
+                truncated: truncated || undefined,
                 durationMs,
             };
             if (options.throwOnError && !ok) {
@@ -128,11 +146,35 @@ export async function execCli(command, args = [], options = {}) {
             }
             resolve(result);
         };
+        // 输出超限时截断已收集字节并终止进程：与 runtime-node 执行器对齐，
+        // 只保留上限内的字节（含同 chunk 内截断），丢弃超限部分
+        const enforceOutputLimit = (chunks, chunk) => {
+            const remaining = maxOutputBytes - totalOutputBytes;
+            if (remaining < chunk.length) {
+                if (remaining > 0) {
+                    chunks.push(chunk.subarray(0, remaining));
+                    totalOutputBytes += remaining;
+                }
+                else {
+                    totalOutputBytes += chunk.length;
+                }
+                truncated = true;
+                terminateForLimit();
+                return true;
+            }
+            totalOutputBytes += chunk.length;
+            chunks.push(chunk);
+            return false;
+        };
         child.stdout?.on("data", (chunk) => {
-            stdoutChunks.push(chunk);
+            if (truncated)
+                return;
+            enforceOutputLimit(stdoutChunks, chunk);
         });
         child.stderr?.on("data", (chunk) => {
-            stderrChunks.push(chunk);
+            if (truncated)
+                return;
+            enforceOutputLimit(stderrChunks, chunk);
         });
         child.on("error", (err) => {
             spawnError = err;

package/dist/clock.d.ts

@@ -38,11 +38,25 @@ export declare class FakeClock implements Clock {
     sleep(ms: number): Promise<void>;
     /**
      * 手动向前推进指定毫秒时间。
-     * 严格按时间戳递增顺序触发并完成所有到期的休眠计时器。
+     * 严格按时间戳递增顺序触发并完成所有到期的休眠计时器；
+     * 每轮先排空微任务再检查队列，确保多层 async 边界内链式注册的
+     * 已到期 sleep 在本次 advance 终点前全部触发（含链首有 await 边界的场景）。
      *
      * @param ms 推进的毫秒数
      */
     advance(ms: number): Promise<void>;
+    /**
+     * 循环排空微任务队列直至稳定（一轮排空后无新的已到期 sleep 注册），
+     * 保证链式 sleep 在本次 advance 终点前全部触发。
+     *
+     * 仅排空微任务，不等待任何宏任务（定时器、IO）：链式 sleep 依赖的
+     * async 回调链全部由微任务驱动，无需也无法跨越宏任务边界。
+     * 使用 setImmediate 兜底作为「微任务队列已排空」的观测哨兵：
+     * setImmediate 回调只能从事件循环检查点进入，它的执行必然意味着
+     * 在它之前排队的全部微任务（无论多少层 await 边界）都已完成，
+     * 以此获得不依赖拍数猜测的精确稳定性判定。
+     */
+    private drainMicrotasks;
     /**
      * 获取当前等待中的计时器数量。
      */

package/dist/clock.js

@@ -59,7 +59,9 @@ export class FakeClock {
     }
     /**
      * 手动向前推进指定毫秒时间。
-     * 严格按时间戳递增顺序触发并完成所有到期的休眠计时器。
+     * 严格按时间戳递增顺序触发并完成所有到期的休眠计时器；
+     * 每轮先排空微任务再检查队列，确保多层 async 边界内链式注册的
+     * 已到期 sleep 在本次 advance 终点前全部触发（含链首有 await 边界的场景）。
      *
      * @param ms 推进的毫秒数
      */
@@ -67,27 +69,64 @@ export class FakeClock {
         if (ms < 0) {
             throw new Error("Cannot advance clock by negative time");
         }
-        if (ms === 0) {
-            await Promise.resolve();
-            return;
-        }
         const destinationMonotonic = this.currentMonotonic + ms;
         const destinationNow = this.currentNow + ms;
-        this.advancedMs += ms;
-        while (this.pendingSleeps.length > 0) {
+        if (ms > 0) {
+            this.advancedMs += ms;
+        }
+        // 先同步处理当前已到期项，再排空微任务后复查：resolve 触发的回调链
+        // 可能在任意深度的 await 边界后注册新的到期 sleep，每轮排空后重新检查。
+        // 首轮无到期项时全程不经过 await，保持「无等待计时器时同步推进时间」契约
+        for (;;) {
             const nextSleep = this.pendingSleeps[0];
-            if (nextSleep.targetMonotonic > destinationMonotonic) {
+            if (!nextSleep || nextSleep.targetMonotonic > destinationMonotonic) {
                 break;
             }
             this.pendingSleeps.shift();
             this.currentMonotonic = nextSleep.targetMonotonic;
             this.currentNow = nextSleep.targetNow;
             nextSleep.resolve();
-            await Promise.resolve();
+            await this.drainMicrotasks();
         }
         this.currentMonotonic = destinationMonotonic;
         this.currentNow = destinationNow;
-        await Promise.resolve();
+        await this.drainMicrotasks();
+    }
+    /**
+     * 循环排空微任务队列直至稳定（一轮排空后无新的已到期 sleep 注册），
+     * 保证链式 sleep 在本次 advance 终点前全部触发。
+     *
+     * 仅排空微任务，不等待任何宏任务（定时器、IO）：链式 sleep 依赖的
+     * async 回调链全部由微任务驱动，无需也无法跨越宏任务边界。
+     * 使用 setImmediate 兜底作为「微任务队列已排空」的观测哨兵：
+     * setImmediate 回调只能从事件循环检查点进入，它的执行必然意味着
+     * 在它之前排队的全部微任务（无论多少层 await 边界）都已完成，
+     * 以此获得不依赖拍数猜测的精确稳定性判定。
+     */
+    drainMicrotasks() {
+        return new Promise((resolve) => {
+            setImmediate(() => {
+                // setImmediate 触发时本轮微任务已全部排空；若排空期间注册了新的
+                // 已到期 sleep，再排一轮直至稳定。上限保护防御异常场景下的
+                // 自续注册（正常链式回调远达不到此深度）。
+                let rounds = 0;
+                const check = () => {
+                    const pendingBefore = this.pendingSleeps.length;
+                    setImmediate(() => {
+                        if (this.pendingSleeps.length === pendingBefore) {
+                            resolve();
+                            return;
+                        }
+                        if (++rounds >= 10000) {
+                            resolve();
+                            return;
+                        }
+                        check();
+                    });
+                };
+                check();
+            });
+        });
     }
     /**
      * 获取当前等待中的计时器数量。

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./clock.js";
 export * from "./process.js";
+export * from "./process-driver.js";
 export * from "./storage.js";
 export * from "./runtime.js";
 export * from "./platform.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export * from "./clock.js";
 export * from "./process.js";
+export * from "./process-driver.js";
 export * from "./storage.js";
 export * from "./runtime.js";
 export * from "./platform.js";

package/dist/platform.d.ts

@@ -1,6 +1,7 @@
-import { type EventSink, type FileSystem, type ModuleLoader, type RuntimePlatform, type RuntimeStorage, type StorageFactory } from "@actiondock/core";
+import { type EventSink, type FileSystem, type ModuleLoader, type ProcessManager, type RuntimePlatform, type RuntimeStorage, type StorageFactory } from "@actiondock/core";
 import { FakeClock } from "./clock.js";
 import { MockProcessExecutor } from "./process.js";
+import { FakeProcessDriver } from "./process-driver.js";
 /**
  * 测试平台构建配置选项。
  */
@@ -13,6 +14,10 @@ export interface TestPlatformOptions {
     globalStorage?: RuntimeStorage;
     /** 可选注入的模拟进程执行器 */
     process?: MockProcessExecutor;
+    /** 可选注入的底层进程驱动 */
+    processDriver?: FakeProcessDriver;
+    /** 可选注入的受管进程管理器 */
+    processManager?: ProcessManager;
     /** 可选注入的执行事件接收器 */
     eventSink?: EventSink;
     /** 可选注入的文件系统抽象驱动 */

package/dist/platform.js

@@ -17,7 +17,11 @@ import { MemoryStorage } from "./storage.js";
  */
 export function createTestPlatform(options = {}) {
     const clock = options.clock ?? new FakeClock();
-    const process = options.process ?? new MockProcessExecutor();
+    const process = options.process ??
+        new MockProcessExecutor({
+            driver: options.processDriver,
+            processManager: options.processManager,
+        });
     const eventSink = options.eventSink ?? new TestEventSink();
     const files = options.files ?? new NodeFileSystem();
     const modules = options.modules ?? new DefaultModuleLoader();

package/dist/process-driver.d.ts

@@ -0,0 +1,248 @@
+import type { Capabilities, LaunchSpec } from "@actiondock/sdk";
+import type { ProcessDriver, ProcessDriverCallbacks, ProcessDriverHandle, ProcessHandle, ProcessObserver } from "@actiondock/core";
+export type { ProcessDriver, ProcessObserver, ProcessHandle };
+/**
+ * 记录的标准写入操作条目。
+ */
+export interface RecordedWrite {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 写入的二进制字节数据 */
+    data: Uint8Array;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的标准输入 EOF 调用条目。
+ */
+export interface RecordedEOF {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的中断前台作业调用条目。
+ */
+export interface RecordedInterrupt {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的调整尺寸调用条目。
+ */
+export interface RecordedResize {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 列数 */
+    cols: number;
+    /** 行数 */
+    rows: number;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的终止进程调用条目。
+ */
+export interface RecordedTerminate {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 宽限退出时限 */
+    graceMs: number;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的销毁进程调用条目。
+ */
+export interface RecordedDispose {
+    /** 目标进程句柄 */
+    handle: ProcessHandle;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 记录的进程派生启动调用条目。
+ */
+export interface RecordedSpawn {
+    /** 生成的进程句柄 */
+    handle: ProcessHandle;
+    /** 进程启动规范 */
+    spec: LaunchSpec;
+    /** 进程观察者对象 */
+    observer: ProcessObserver;
+    /** 调用发生时间戳 */
+    timestamp: number;
+}
+/**
+ * 确定性测试专用进程驱动桩。
+ * 遵循《ActionDock Managed Process 设计 v2》第 11、12 节契约：
+ * - 支持确定性模拟输出（emitOutput）
+ * - 支持确定性模拟退出（emitExit）
+ * - 支持确定性模拟输出关闭（emitOutputClosed）
+ * - 支持确定性模拟故障注入（emitFault）
+ * - 记录完整写入（writes）、EOF 调用、resize 与 terminate 操作历史
+ * - 支持模拟各阶段操作失败注入用于健壮性测试
+ */
+export declare class FakeProcessDriver implements ProcessDriver {
+    private capabilities;
+    private readonly handles;
+    /** 记录所有派生调用 */
+    readonly spawnCalls: RecordedSpawn[];
+    /** 记录所有写入调用 */
+    readonly writes: RecordedWrite[];
+    /** 记录所有 EOF 调用 */
+    readonly eofCalls: RecordedEOF[];
+    /** 记录所有前台中断调用 */
+    readonly interruptCalls: RecordedInterrupt[];
+    /** 记录所有调整尺寸调用 */
+    readonly resizeCalls: RecordedResize[];
+    /** 记录所有终止调用 */
+    readonly terminateCalls: RecordedTerminate[];
+    /** 记录所有销毁调用 */
+    readonly disposeCalls: RecordedDispose[];
+    /** 故障注入：下一次派生将抛出的异常 */
+    nextSpawnError?: Error;
+    /** 故障注入：写入时将抛出的异常 */
+    nextWriteError?: Error;
+    /** 故障注入：调整尺寸时将抛出的异常 */
+    nextResizeError?: Error;
+    /** 故障注入：终止时将抛出的异常 */
+    nextTerminateError?: Error;
+    /** 自动响应回调：在进程派生后触发 */
+    onSpawn?: (handle: ProcessHandle, spec: LaunchSpec, observer: ProcessObserver) => void;
+    constructor(capabilities?: Partial<Capabilities>);
+    /**
+     * 获取驱动能力集合。
+     */
+    getCapabilities(): Capabilities;
+    /**
+     * 覆盖驱动能力集合。
+     */
+    setCapabilities(caps: Partial<Capabilities>): void;
+    /**
+     * 派生启动新进程，支持标准与旧版重载签名。
+     */
+    spawn(spec: LaunchSpec, observer: ProcessObserver): Promise<ProcessHandle>;
+    spawn(processId: string, spec: LaunchSpec, callbacks: ProcessDriverCallbacks): Promise<ProcessDriverHandle>;
+    /**
+     * 标准接口实现派生新进程。
+     */
+    private spawnStandard;
+    /**
+     * 模拟写入数据并记录历史。
+     */
+    write(handle: ProcessHandle, data: Uint8Array): Promise<void>;
+    /**
+     * 模拟输入流关闭并记录历史。
+     */
+    inputEOF(handle: ProcessHandle): Promise<void>;
+    /**
+     * 模拟中断前台作业并记录历史。
+     */
+    interruptForeground(handle: ProcessHandle): Promise<void>;
+    /**
+     * 模拟调整终端尺寸并记录历史。
+     */
+    resize(handle: ProcessHandle, cols: number, rows: number): Promise<void>;
+    /**
+     * 模拟终止进程并记录历史。
+     *
+     * 终止语义与 MemoryProcessDriver 对齐：除非测试通过 nextTerminateError
+     * 注入故障，否则终止后进程必须退出（触发 exited 回调），否则
+     * ProcessManager.run 的超时/超限路径在 terminate 后永远收不到退出事件，
+     * 调用方会永久挂起。需要非退出语义的用例可先 setExitBehavior 或
+     * 直接使用 handle 上的确定性模拟接口自行控制退出时机。
+     */
+    terminate(handle: ProcessHandle, graceMs: number): Promise<void>;
+    terminate(processId: string, graceMs: number): Promise<void>;
+    /**
+     * 模拟销毁进程并记录历史。
+     */
+    dispose(handle: ProcessHandle): Promise<void>;
+    /**
+     * 确定性模拟向观察者发送输出。
+     */
+    emitOutput(handleOrId: ProcessHandle | string, stream: "stdout" | "stderr" | "pty", data: Uint8Array | string): void;
+    /**
+     * 确定性模拟进程退出事件。
+     */
+    emitExit(handleOrId: ProcessHandle | string, result?: {
+        code?: number | null;
+        signal?: string | null;
+    } | number): void;
+    /**
+     * 确定性模拟输出流彻底关闭事件。
+     */
+    emitOutputClosed(handleOrId: ProcessHandle | string, reason?: "natural" | "drain-timeout" | "host-lost"): void;
+    /**
+     * 确定性模拟驱动故障通知。
+     */
+    emitFault(handleOrId: ProcessHandle | string, error: Error): void;
+    /**
+     * 注入下一次 spawn 故障异常。
+     */
+    simulateSpawnFailure(error: Error): void;
+    /**
+     * 注入下一次 write 故障异常。
+     */
+    simulateWriteFailure(error: Error): void;
+    /**
+     * 注入下一次 resize 故障异常。
+     */
+    simulateResizeFailure(error: Error): void;
+    /**
+     * 注入下一次 terminate 故障异常。
+     */
+    simulateTerminateFailure(error: Error): void;
+    /**
+     * 获取最近创建的进程句柄。
+     */
+    getLastHandle(): ProcessHandle | undefined;
+    /**
+     * 查询指定句柄标识对应的句柄实例。
+     */
+    getHandle(handleOrId: ProcessHandle | string): ProcessHandle | undefined;
+    /**
+     * 查询指定句柄对应的观察者。
+     */
+    getObserver(handleOrId: ProcessHandle | string): ProcessObserver | undefined;
+    /**
+     * 获取针对指定句柄（或全部句柄）的写入字节切片列表。
+     */
+    getWrites(handleOrId?: ProcessHandle | string): Uint8Array[];
+    /**
+     * 获取针对指定句柄（或全部句柄）写入的 UTF-8 解码文本列表。
+     */
+    getWrittenStrings(handleOrId?: ProcessHandle | string): string[];
+    /**
+     * 判断指定句柄是否接收到了 EOF 输入结束通知。
+     */
+    hasInputEOF(handleOrId?: ProcessHandle | string): boolean;
+    /**
+     * 判断指定句柄是否接收到了前台作业中断通知。
+     */
+    hasInterrupted(handleOrId?: ProcessHandle | string): boolean;
+    /**
+     * 清除历史调用记录。
+     */
+    clearHistory(): void;
+    /**
+     * 重置全部句柄、模拟规则与调用历史。
+     */
+    reset(): void;
+    /**
+     * 兼容旧版基于 processId 派生新进程。
+     */
+    private spawnLegacy;
+    /**
+     * 内部解析指定句柄或标识。
+     */
+    private resolveInternal;
+}
+/**
+ * 兼容原有命名导出。
+ */
+export { FakeProcessDriver as MockProcessDriver };