@zhushanwen/subagent-core 0.2.0 → 0.4.0

package/src/orchestration/__tests__/script-generate.test.ts

@@ -0,0 +1,314 @@
+// src/orchestration/__tests__/script-generate.test.ts
+//
+// C4-core-script-pipeline（convergence W4）单元测试：generate 校验管线下沉的
+// 行为锁定。覆盖 §4.2 W4 门全部条目：
+// - 五道闸逐字文案（期望串按 pi 现版 actionGenerate 源码逻辑手工构造——
+//   pi 侧行为不变是 CA2 前提，文案改动必须同步两处）；
+// - round-trip 失败报错含 YAML 诊断与 line/col（parseResourceMetaDetailed
+//   真实调用不 mock，与 pi 测试 TC2/TC5 同原则）；
+// - 合法样本落 tmp：目录参数注入生效（真实落盘断言，非 mock fs）；
+// - 缺省目录 = pi 布局（相对 cwd resolve，pi 现行为不变）；
+// - barrel 逐名探针（红线 9）。
+// 设计权威源：docs/design/subagent-core-convergence.md §3.2 D-6。
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+import { describe, expect, it, vi } from "vitest";
+
+import type {
+  GenerateWorkflowScriptOptions,
+  GenerateWorkflowScriptResult,
+  WorkflowDirOptions,
+} from "../../index.ts";
+import * as subagentCore from "../../index.ts";
+import { parseResourceMetaDetailed } from "../../shared/meta-parser.ts";
+import { generateWorkflowScript } from "../script-generate.ts";
+
+// ============================================================
+// 样本（构造逻辑对齐 pi 侧 tool-workflow-script-generate.test.ts）
+// ============================================================
+
+const PI_META_VALID = `/* @pi-meta
+name: test-wf
+description: valid new format
+phases: [a, b]
+parameters:
+  type: object
+  properties:
+    task: { type: string }
+  required: [task]
+*/
+const agent = require("./agent");
+agent("worker", { task: $ARGS.task });
+`;
+
+const PI_META_MALFORMED = `/* @pi-meta
+name: test-wf
+description: bad
+  broken: indent
+phases: [a]
+*/
+const agent = require("./agent");
+agent("w");
+`;
+
+const PI_META_REGEX_SINGLE_BS = `/* @pi-meta
+name: test-wf
+description: regex
+phases: [A]
+parameters:
+  type: object
+  patternProperties:
+    "^batch\\d+$": { type: string }
+*/
+const agent = require("./agent");
+agent("w");
+`;
+
+const LEGACY_CONST_META = `const meta = {
+  name: "legacy-wf",
+  description: "legacy format",
+  phases: ["a"]
+};
+const agent = require("./agent");
+agent("w");
+`;
+
+const NO_META = `const agent = require("./agent");
+agent("w");
+`;
+
+const ESM_IMPORT = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+import { foo } from "bar";
+const agent = require("./agent");
+agent("w");
+`;
+
+const ESM_EXPORT_NON_META = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+const agent = require("./agent");
+export const foo = 1;
+agent("w");
+`;
+
+const NO_AGENT = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+const x = 1;
+`;
+
+const SYNTAX_ERROR = `/* @pi-meta
+name: x
+description: d
+phases: [a]
+*/
+const agent = require("./agent");
+agent("w";
+`;
+
+// ============================================================
+// 期望串（pi 现版 actionGenerate 文案逐字手工构造）
+// ============================================================
+
+/**
+ * round-trip 报错文案模板——pi 版 tool-workflow-script.ts actionGenerate
+ * 的模板逐字复制（含源码字面 `(\\d not \d)` 的历史形态：模板字符串里 `\\d`
+ * 渲染 `\d`、`\d` 渲染 `d`；两处字符级一致即运行时逐字一致）。
+ */
+function expectedRoundtripError(detailed: {
+  error: string;
+  linePos?: { line: number; col: number };
+}): string {
+  const loc = "linePos" in detailed && detailed.linePos
+    ? ` (line ${detailed.linePos.line}, col ${detailed.linePos.col})`
+    : "";
+  return `Generated /* @pi-meta */ YAML cannot be parsed${loc}: ${detailed.error}. Common causes: YAML indent errors, patternProperties regex must use double backslash (\\d not \d), or a stray star-slash inside the YAML body. Fix the meta block and retry.`;
+}
+
+/** 非.ok 分支的错误文案（窄化辅助：ok 分支直接 fail）。 */
+function errorOf(r: GenerateWorkflowScriptResult): string {
+  if (r.ok) throw new Error("expected failure result, got success");
+  return r.error;
+}
+
+function makeTmpRoot(): string {
+  return mkdtempSync(join(tmpdir(), "subagent-core-gen-"));
+}
+
+// ============================================================
+// 五道闸（文案逐字对齐 pi 现版）
+// ============================================================
+
+describe("generateWorkflowScript 校验闸（文案逐字对齐 pi 现版）", () => {
+  it("缺 name/script → 拒（防御性文案逐字）", () => {
+    expect(errorOf(generateWorkflowScript("", "x"))).toBe(
+      "generate requires 'name' and 'script' parameters",
+    );
+    expect(errorOf(generateWorkflowScript("x", ""))).toBe(
+      "generate requires 'name' and 'script' parameters",
+    );
+  });
+
+  it("ESM import → 拒（文案逐字）", () => {
+    const tmpRoot = makeTmpRoot();
+    try {
+      const r = generateWorkflowScript("esm-wf", ESM_IMPORT, { tmpDir: tmpRoot });
+      expect(errorOf(r)).toBe(
+        "Script uses ESM 'import' syntax. Workflow scripts run in a CJS Worker — use require() instead.",
+      );
+      expect(existsSync(join(tmpRoot, "esm-wf.js"))).toBe(false);
+    } finally {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("ESM export（非 meta）→ 拒（文案逐字）", () => {
+    const r = generateWorkflowScript("exp-wf", ESM_EXPORT_NON_META);
+    expect(errorOf(r)).toBe(
+      "Script uses ESM 'export' (non-meta). Use 'const meta = {...}' at top level instead.",
+    );
+  });
+
+  it("无 meta 声明 → 拒（文案逐字）", () => {
+    const r = generateWorkflowScript("nometa-wf", NO_META);
+    expect(errorOf(r)).toBe(
+      "Script must contain a meta declaration: a /* @pi-meta */ YAML block comment (preferred) or legacy const meta = { ... }. The block has the form: a block comment starting with /* @pi-meta followed by YAML (name/description/phases/parameters?/usage?), closed by */ on its own line.",
+    );
+  });
+
+  it("无 agent() 调用 → 拒（文案逐字）", () => {
+    const r = generateWorkflowScript("noagent-wf", NO_AGENT);
+    expect(errorOf(r)).toBe(
+      "Script does not contain any agent() calls. A workflow must call agent() at least once.",
+    );
+  });
+
+  it("语法错误 → 拒（前缀逐字 + V8 诊断非空）", () => {
+    const r = generateWorkflowScript("synerr-wf", SYNTAX_ERROR);
+    const err = errorOf(r);
+    expect(err.startsWith("Syntax error in script: ")).toBe(true);
+    expect(err.length > "Syntax error in script: ".length).toBe(true);
+  });
+
+  it("malformed @pi-meta YAML → round-trip 拒，报错含 line/col + 未落盘", () => {
+    const tmpRoot = makeTmpRoot();
+    try {
+      const r = generateWorkflowScript("bad-wf", PI_META_MALFORMED, { tmpDir: tmpRoot });
+      const err = errorOf(r);
+      // 行列信息保留（ERR4：LLM 自纠正依赖）
+      expect(err).toMatch(/ \(line \d+, col \d+\)/);
+      // 期望串 = 同一 parser 实测值 + pi 源码模板手工展开 → 逐字一致
+      const detailed = parseResourceMetaDetailed(PI_META_MALFORMED, "workflow");
+      expect(detailed.ok).toBe(false);
+      if (!detailed.ok) {
+        expect(detailed.linePos).toBeDefined();
+        expect(err).toBe(expectedRoundtripError(detailed));
+      }
+      expect(existsSync(join(tmpRoot, "bad-wf.js"))).toBe(false);
+    } finally {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("patternProperties 单反斜杠正则 → round-trip 拒（LLM 高频错，含行列）", () => {
+    const r = generateWorkflowScript("regex-wf", PI_META_REGEX_SINGLE_BS);
+    const err = errorOf(r);
+    expect(err).toMatch(/ \(line \d+, col \d+\)/);
+    const detailed = parseResourceMetaDetailed(PI_META_REGEX_SINGLE_BS, "workflow");
+    expect(detailed.ok).toBe(false);
+    if (!detailed.ok) {
+      expect(err).toBe(expectedRoundtripError(detailed));
+    }
+  });
+});
+
+// ============================================================
+// 合法样本落 tmp（目录参数注入生效）
+// ============================================================
+
+describe("generateWorkflowScript 合法样本落 tmp", () => {
+  it("注入 tmpDir：真实落盘指定目录，内容逐字节一致", () => {
+    const tmpRoot = makeTmpRoot();
+    try {
+      const r = generateWorkflowScript("my-wf", PI_META_VALID, { tmpDir: tmpRoot });
+      expect(r.ok).toBe(true);
+      if (!r.ok) throw new Error(r.error);
+      expect(r.path).toBe(resolve(tmpRoot, "my-wf.js"));
+      expect(existsSync(r.path)).toBe(true);
+      expect(readFileSync(r.path, "utf-8")).toBe(PI_META_VALID);
+    } finally {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("legacy const meta（过渡期）→ 过闸落盘（无 @pi-meta 跳过 round-trip）", () => {
+    const tmpRoot = makeTmpRoot();
+    try {
+      const r = generateWorkflowScript("legacy-wf", LEGACY_CONST_META, { tmpDir: tmpRoot });
+      expect(r.ok).toBe(true);
+      if (!r.ok) throw new Error(r.error);
+      expect(existsSync(r.path)).toBe(true);
+    } finally {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("缺省 tmpDir = pi 布局 <cwd>/.pi/workflows/.tmp（pi 现行为不变）", () => {
+    const fakeCwd = mkdtempSync(join(tmpdir(), "subagent-core-cwd-"));
+    const cwdSpy = vi.spyOn(process, "cwd").mockReturnValue(fakeCwd);
+    try {
+      const r = generateWorkflowScript("def-wf", PI_META_VALID);
+      expect(r.ok).toBe(true);
+      if (!r.ok) throw new Error(r.error);
+      expect(r.path).toBe(join(fakeCwd, ".pi", "workflows", ".tmp", "def-wf.js"));
+      expect(existsSync(r.path)).toBe(true);
+    } finally {
+      cwdSpy.mockRestore();
+      rmSync(fakeCwd, { recursive: true, force: true });
+    }
+  });
+});
+
+// ============================================================
+// barrel 逐名探针（红线 9：新增导出必须进 barrel，逐名列出）
+// ============================================================
+
+describe("barrel exports probe", () => {
+  it("值导出逐名可达（typeof function）", () => {
+    const valueExports = [
+      "generateWorkflowScript",
+      "saveWorkflow",
+      "deleteWorkflow",
+    ] as const;
+    const barrel = subagentCore as Record<string, unknown>;
+    for (const name of valueExports) {
+      expect(typeof barrel[name], `barrel 缺值导出: ${name}`).toBe("function");
+    }
+  });
+
+  it("缺省目录常量经 barrel 可达（值 = pi 布局）", () => {
+    const barrel = subagentCore as Record<string, unknown>;
+    expect(barrel["DEFAULT_WORKFLOW_TMP_DIR"]).toBe(".pi/workflows/.tmp");
+    expect(barrel["DEFAULT_WORKFLOW_SAVED_DIR"]).toBe(".pi/workflows");
+  });
+
+  it("类型导出经 barrel 可引用（typecheck 即探针）", () => {
+    const genOpts: GenerateWorkflowScriptOptions = { tmpDir: "/tmp/x" };
+    const dirOpts: WorkflowDirOptions = { tmpDir: "/tmp/x", savedDir: "/tmp/y" };
+    let result: GenerateWorkflowScriptResult = { ok: true, path: "/p" };
+    result = { ok: false, error: "e" };
+    expect(genOpts.tmpDir).toBe("/tmp/x");
+    expect(dirOpts.savedDir).toBe("/tmp/y");
+    expect(result.ok).toBe(false);
+  });
+});

package/src/orchestration/__tests__/worker-pending-timeout-abort.test.ts

@@ -0,0 +1,275 @@
+/**
+ * [OR-3] worker 侧 pending per-call timeoutMs + abort 广播 测试（真实 Worker 线程，P-T3）。
+ *
+ * 覆盖（unbounded-wait-audit §4.1 OR-3 / §7.2 T3③ / §7.3 P-T3）：
+ * - agent() 传 timeoutMs：主线程不回话 → pending 以错误 resolve（不 reject、不放大成
+ *   脚本 error）+ 超时 warn 记入 _workerLogs——消息层自己的超时，旧实现零超时永挂
+ * - returnMeta 模式超时 resolve {value:"", error}
+ * - 主线程不传 timeoutMs（缺省不限）：pending 不挂 timer（行为不变）
+ * - abort 广播：await 中的 agent() 以 WorkflowAbortedError reject（脚本 catch 可感知
+ *   取消）→ 脚本自然收尾 → worker 自然退出（exit 0）
+ * - P-T3：abort 广播与 worker 自然退出交错不产 unhandledRejection——广播后立即
+ *   terminate 的竞态、fire-and-forget 后 return 的自然退出，均不产生主线程
+ *   unhandledRejection 与 worker 'error' 事件
+ */
+import { Worker } from "node:worker_threads";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { buildWorkerScript } from "../worker-script-builder.ts";
+
+// ── 判别联合（对齐 worker-script-builder-runtime.test.ts 的守卫形态） ──
+
+interface ReturnMsg {
+  type: "return";
+  result: unknown;
+  workerLogs?: Array<{ level: string; message: string }>;
+}
+interface ErrorMsg {
+  type: "error";
+  error: string;
+  workerLogs?: Array<{ level: string; message: string }>;
+}
+
+function isReturn(m: unknown): m is ReturnMsg {
+  return typeof m === "object" && m !== null && (m as { type?: unknown }).type === "return";
+}
+function isError(m: unknown): m is ErrorMsg {
+  return typeof m === "object" && m !== null && (m as { type?: unknown }).type === "error";
+}
+function isAgentCall(m: unknown): m is { type: "agent-call"; callId: number } {
+  return typeof m === "object" && m !== null && (m as { type?: unknown }).type === "agent-call";
+}
+
+// ── harness：主线程「不回话」的可控 Worker 运行器 ──────────────
+
+interface RunResult {
+  returnValue?: unknown;
+  errorMessage?: string;
+  /** return/error 消息带回的 workerLogs（超时 warn 通路）。 */
+  workerLogs: Array<{ level: string; message: string }>;
+  exitCode?: number;
+  workerError?: string;
+  /** 收到的 agent-call 消息数（确认脚本确实发起了调用）。 */
+  agentCallCount: number;
+}
+
+interface RunOptions {
+  /** 收到 agent-call 后的主线程动作（默认：不回话——pending 留在 worker 侧）。 */
+  onAgentCall?: (msg: { callId: number; opts: Record<string, unknown> }, worker: Worker) => void;
+  /** 显式 finish（供 abort 竞态场景手工收尾）。 */
+  timeoutMs?: number;
+}
+
+const createdWorkers: Worker[] = [];
+
+afterEach(() => {
+  for (const w of createdWorkers.splice(0)) {
+    w.terminate().catch(() => {});
+  }
+});
+
+function runWorker(userScript: string, opts: RunOptions = {}): Promise<RunResult> {
+  const timeoutMs = opts.timeoutMs ?? (process.env.CI ? 5000 : 2000);
+  return new Promise((resolve) => {
+    const worker = new Worker(buildWorkerScript(userScript), {
+      eval: true,
+      workerData: {
+        scriptPath: "test.js",
+        args: {},
+        workspace: process.cwd(),
+        budget: { maxTokens: 0, usedTokens: 0, usedCost: 0 },
+      },
+    });
+    createdWorkers.push(worker);
+
+    const result: RunResult = { workerLogs: [], agentCallCount: 0 };
+    let settled = false;
+    const finish = (): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(graceTimer);
+      resolve(result);
+    };
+    // 兜底：永不 settle 时 terminate + 以当前观察收尾
+    const timer = setTimeout(() => {
+      worker.terminate().catch(() => {});
+      finish();
+    }, timeoutMs);
+    // 收到终态消息后的宽限窗：给潜在 worker 'error' 事件一个到达机会，
+    // 然后收尾（parentPort 挂着 message listener 时 worker 线程不自然退出，
+    // 与生产一致由 terminate 回收——故不依赖 exit 事件断言）。
+    let graceTimer: ReturnType<typeof setTimeout>;
+
+    worker.on("message", (raw: unknown) => {
+      if (isAgentCall(raw)) {
+        result.agentCallCount += 1;
+        opts.onAgentCall?.(raw as { callId: number; opts: Record<string, unknown> }, worker);
+        return;
+      }
+      if (isReturn(raw)) {
+        result.returnValue = raw.result;
+        result.workerLogs = raw.workerLogs ?? [];
+        graceTimer = setTimeout(finish, 150);
+        return;
+      }
+      if (isError(raw)) {
+        result.errorMessage = raw.error;
+        result.workerLogs = raw.workerLogs ?? [];
+        graceTimer = setTimeout(finish, 150);
+      }
+    });
+    worker.on("error", (err: Error) => {
+      result.workerError = err.message;
+    });
+    worker.on("exit", (code: number) => {
+      result.exitCode = code;
+      finish();
+    });
+  });
+}
+
+/** 收集本测试进程的 unhandledRejection（P-T3 断言）。 */
+function trackUnhandledRejections(): { reasons: unknown[]; dispose: () => void } {
+  const reasons: unknown[] = [];
+  const handler = (reason: unknown): void => {
+    reasons.push(reason);
+  };
+  process.on("unhandledRejection", handler);
+  return { reasons, dispose: () => process.off("unhandledRejection", handler) };
+}
+
+// ── [OR-3] per-call timeoutMs（消息层自己的超时） ─────────────
+
+describe("[OR-3] agent() pending per-call timeoutMs", () => {
+  it("主线程不回话 + timeoutMs=50 → pending 以错误 resolve（[B-5] 单值错误消息字符串）", async () => {
+    const script = `
+      const r = await agent("never answered", { timeoutMs: 50 });
+      return { got: r };
+    `;
+    const res = await runWorker(script);
+
+    // 脚本正常 return（超时未放大成脚本 error → 不触发 rebuild 矩阵）
+    expect(res.errorMessage).toBeUndefined();
+    expect(res.workerError).toBeUndefined();
+    expect(res.agentCallCount).toBe(1);
+    // [B-5] 非 returnMeta 超时 resolve 单值字符串（对齐 agent-result 失败路径
+    // resolve _value = parsedOutput ?? content 的形态）——字符串消费型脚本
+    // （r.trim() 类）不再 TypeError
+    const got = (res.returnValue as { got: string }).got;
+    expect(typeof got).toBe("string");
+    expect(got).toContain("timed out after 50ms");
+    expect(got).toContain("no agent-result received");
+    // 超时 warn 记入 _workerLogs（诊断可见）
+    expect(res.workerLogs.some((l) => l.level === "warn" && l.message.includes("timed out after 50ms"))).toBe(true);
+  });
+
+  it("returnMeta 模式超时（对象分支透传 returnMeta）→ resolve {value:\"\", error}", async () => {
+    const script = `
+      const r = await agent({ prompt: "never answered", timeoutMs: 50, returnMeta: true });
+      return r;
+    `;
+    const res = await runWorker(script);
+
+    expect(res.errorMessage).toBeUndefined();
+    expect(res.returnValue).toEqual({ value: "", error: expect.stringContaining("timed out after 50ms") });
+  });
+
+  it("[B-5] 字符串消费型脚本（r.trim()）在超时路径不 TypeError（resolve 单值字符串）", async () => {
+    // 旧实现超时 resolve {content:"", error} 对象 → r.trim() 抛 TypeError →
+    // 脚本 error → 放大成 rebuild；修复后 resolve 字符串，脚本按普通失败文本消费
+    const script = `
+      const r = await agent("never answered", { timeoutMs: 40 });
+      return { trimmed: r.trim().length > 0 };
+    `;
+    const res = await runWorker(script);
+
+    expect(res.errorMessage).toBeUndefined();
+    expect(res.workerError).toBeUndefined();
+    expect(res.returnValue).toEqual({ trimmed: true });
+  });
+
+  it("string+secondArg 分支：timeoutMs 透传到 agent-call 消息 opts（此前该分支丢弃该字段）", async () => {
+    let seenOpts: Record<string, unknown> | undefined;
+    const script = `await agent("with timeout", { timeoutMs: 1234, label: "probe" }); return "unreachable";`;
+    await runWorker(script, {
+      onAgentCall: (msg, worker) => {
+        seenOpts = msg.opts;
+        // 回发结果让脚本收尾（透传断言与挂起行为解耦）
+        worker.postMessage({ type: "agent-result", callId: msg.callId, result: { content: "ok" }, cached: false });
+      },
+    });
+
+    expect(seenOpts?.timeoutMs).toBe(1234);
+    expect(seenOpts?.prompt).toBe("with timeout");
+  });
+});
+
+// ── [OR-3] abort 广播（worker 侧接收） ───────────────────────
+
+describe("[OR-3] abort 广播接收（P-T3：交错不产 unhandledRejection）", () => {
+  it("await 中的 agent() 收到 abort → WorkflowAbortedError → 脚本 catch 后自然 return → exit 0", async () => {
+    const script = `
+      try {
+        await agent("will be aborted");
+        return "should not reach";
+      } catch (e) {
+        return { caught: e.name, reason: e.reason };
+      }
+    `;
+    const res = await runWorker(script, {
+      onAgentCall: (msg, worker) => {
+        worker.postMessage({ type: "abort", reason: "run aborted by user" });
+      },
+    });
+
+    expect(res.workerError).toBeUndefined();
+    expect(res.errorMessage).toBeUndefined();
+    expect(res.returnValue).toEqual({ caught: "WorkflowAbortedError", reason: "run aborted by user" });
+  });
+
+  it("广播后立即 terminate（竞态）：无 worker error、无 unhandledRejection", async () => {
+    const tracked = trackUnhandledRejections();
+    try {
+      const script = `return await agent("race with terminate");`;
+      const res = await runWorker(script, {
+        onAgentCall: (msg, worker) => {
+          // 广播与 terminate 同 tick 发出——模拟 abortRun 的广播→transition(terminate) 竞态
+          worker.postMessage({ type: "abort", reason: "race" });
+          void worker.terminate();
+        },
+      });
+      // 无论脚本是否来得及收尾：主线程侧无 error 事件、进程无 unhandledRejection
+      expect(res.workerError).toBeUndefined();
+      // 给潜在异步 unhandledRejection 一个窗口
+      await new Promise((r) => { setTimeout(r, 20); });
+      expect(tracked.reasons).toEqual([]);
+    } finally {
+      tracked.dispose();
+    }
+  });
+
+  it("fire-and-forget agent() 后脚本 return：无 worker error（超时/abort 通路外的孤儿 pending 不产 rejection）", async () => {
+    const script = `
+      agent("fire and forget");
+      return "returned early";
+    `;
+    const res = await runWorker(script, { timeoutMs: 400 });
+
+    expect(res.returnValue).toBe("returned early");
+    expect(res.workerError).toBeUndefined();
+  });
+
+  it("fire-and-forget + timeoutMs：超时 resolve（非 reject）→ 无 worker error 事件", async () => {
+    const script = `
+      agent("orphan with timeout", { timeoutMs: 40 });
+      return "returned before timeout";
+    `;
+    const res = await runWorker(script, { timeoutMs: 600 });
+
+    // 超时以 resolve 收口（容错策略）——即使无人消费该 promise 也不产 rejection
+    expect(res.returnValue).toBe("returned before timeout");
+    expect(res.workerError).toBeUndefined();
+  });
+});