@openclaw/plugin-inspector 0.3.24 → 0.3.26

package/src/import-loop-profile.js

@@ -1,12 +1,12 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { renderPaddedMarkdownTable, writeJsonMarkdownArtifacts } from "./artifacts.js";
+import { readBoundedJsonArtifact, renderPaddedMarkdownTable, writeJsonMarkdownArtifacts } from "./artifacts.js";
 import { resolveFromRoot } from "./path-utils.js";
-import { runProfiledProcess } from "./process-profile.js";
+import { resolveProcessLimits, runProfiledProcess } from "./process-profile.js";
 import { assertRunCount, percentile } from "./stats.js";
 
-const defaultCliPath = fileURLToPath(new URL("./cli.js", import.meta.url));
+const defaultRunnerPath = fileURLToPath(new URL("./mock-sdk-capture-runner.js", import.meta.url));
 
 export const defaultImportLoopProfileOptions = {
   entrypoint: "test/fixtures/lazy-import-plugin.mjs",
@@ -255,18 +255,49 @@ async function runCaptureSample(options) {
   const outputPath = path.join(outputDir, `${options.sampleName ?? "capture"}-${options.index}.json`);
   await mkdir(path.dirname(outputPath), { recursive: true });
 
-  const command = buildCaptureCommand({ ...options, outputPath });
+  const defaultCapture = typeof options.captureCommand !== "function" && !options.captureScript;
+  const maxOutputBytes = resolveProcessLimits({
+    ...options,
+    env: { ...process.env, ...options.env, ...options.captureEnv },
+  }, "CAPTURE").maxOutputBytes;
+  // Only the built-in route owns these sample files. An early process.exit(0)
+  // must not turn a previous capture into this run's successful result.
+  if (defaultCapture) await rm(outputPath, { force: true });
+  const command = buildCaptureCommand({ ...options, outputPath, maxOutputBytes });
   const profile = await runProfiledProcess({
     command: command.command,
     args: command.args,
     cwd: command.cwd ?? options.rootDir,
-    env: { ...process.env, ...command.env },
+    env: { ...process.env, ...options.env, ...command.env },
+    timeoutMs: options.timeoutMs,
+    maxOutputBytes: options.maxOutputBytes,
+    killGraceMs: options.killGraceMs,
+    signal: options.signal,
   });
-  const output = profile.exitCode === 0 ? await readCaptureOutput(outputPath) : null;
+  let output = null;
+  if (profile.exitCode === 0 && !profile.timedOut && !profile.cancelled) {
+    if (defaultCapture) {
+      try {
+        output = await readCaptureOutput(outputPath, maxOutputBytes);
+      } catch (error) {
+        profile.exitCode = 1;
+        profile.stderrPreview = `Invalid capture artifact: ${error.message}`;
+      }
+    } else {
+      output = await readCaptureOutput(outputPath);
+    }
+  }
+  if (options.signal?.aborted) {
+    profile.exitCode = 1;
+    profile.cancelled = true;
+    output = null;
+  }
 
   return {
     index: options.index,
     exitCode: profile.exitCode,
+    timedOut: profile.timedOut === true,
+    cancelled: profile.cancelled === true,
     status: output?.status ?? "failed",
     capturedCount: output?.captured?.length ?? 0,
     openClawLifecycle: output?.openClawLifecycle ?? null,
@@ -407,15 +438,29 @@ function buildCaptureCommand(options) {
   }
   return {
     command: process.execPath,
-    args: [defaultCliPath, "capture", options.entrypoint, "--output", options.outputPath],
+    args: [
+      "--no-warnings",
+      "--preserve-symlinks",
+      defaultRunnerPath,
+      JSON.stringify({
+        entrypoint: options.entrypoint,
+        cwd: options.rootDir,
+        outputPath: options.outputPath,
+        maxOutputBytes: options.maxOutputBytes,
+      }),
+    ],
     cwd: options.rootDir,
     env: { PLUGIN_INSPECTOR_EXECUTE_ISOLATED: "1", ...options.captureEnv },
   };
 }
 
-async function readCaptureOutput(outputPath) {
-  const { readFile } = await import("node:fs/promises");
-  return JSON.parse(await readFile(outputPath, "utf8"));
+async function readCaptureOutput(outputPath, maxOutputBytes) {
+  if (maxOutputBytes === undefined) return JSON.parse(await readFile(outputPath, "utf8"));
+  const result = await readBoundedJsonArtifact(outputPath, maxOutputBytes);
+  if (!result || typeof result.status !== "string" || !Array.isArray(result.captured)) {
+    throw new Error("expected a capture status and captured contracts");
+  }
+  return result;
 }
 
 function markdownTable(rows, headers) {

package/src/inspector.js

@@ -1,20 +1,18 @@
 import { existsSync } from "node:fs";
-import { execFile } from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
-import * as nodeModule from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { promisify } from "node:util";
 import { createCaptureApi } from "./capture-api.js";
 import { captureApiOptionsForPlugin } from "./capture-config.js";
 import { fixtureCheckoutPath, fixtureSourceRoot } from "./config.js";
 import { buildCompatibilityFixtureReport } from "./fixture-summary.js";
 import { readOpenClawTargetSurface } from "./openclaw-target.js";
 import { prepareOpenClawTarget, resolveOpenClawTargetVersion } from "./openclaw-version.js";
+import { resolveProcessLimits, startOwnedProcess } from "./process-profile.js";
 import { buildCompatibilityReport, buildReport } from "./report.js";
 import { inspectSdkDeprecations } from "./sdk-deprecation-rules.js";
+import { collectRuntimeModuleImports } from "./runtime-imports.js";
 
-const execFileAsync = promisify(execFile);
 const pluginFactoryNames = "defineBundledChannelEntry|defineChannelPluginEntry|createChatChannelPlugin|definePluginEntry";
 // Bundlers emit unbound calls as (0, sdk.factory)(...), including inline require receivers.
 const compiledFactoryCall = new RegExp(String.raw`\(\s*0\s*,\s*(?:require\s*\(\s*(?:"[^"\r\n]*"|'[^'\r\n]*')\s*\)|[$A-Z_a-z][$\w]*)(?:\s*\.\s*[$A-Z_a-z][$\w]*)*\s*\.\s*(${pluginFactoryNames})\s*\)\s*\(`, "dg");
@@ -29,6 +27,13 @@ export async function inspectFixtureSet(config, options = {}) {
 
 export async function inspectCompatibilityFixtureSet(config, options = {}) {
   const { inspections, failures } = await inspectConfiguredFixtures(config, options);
+  const reportConfig = {
+    ...config,
+    fixtures: config.fixtures.map((fixture) => ({
+      ...fixture,
+      checkoutPath: normalizeFixtureCheckoutPath(config, fixture),
+    })),
+  };
   const targetOpenClaw =
     options.targetOpenClaw ??
     (options.openclawVersion
@@ -40,7 +45,7 @@ export async function inspectCompatibilityFixtureSet(config, options = {}) {
         }));
 
   return buildCompatibilityReport({
-    config,
+    config: reportConfig,
     inspections,
     failures,
     authorFacing: options.authorFacing,
@@ -58,6 +63,11 @@ export async function inspectCompatibilityFixtureSet(config, options = {}) {
   });
 }
 
+function normalizeFixtureCheckoutPath(config, fixture) {
+  const relative = path.relative(config.rootDir ?? process.cwd(), fixtureCheckoutPath(config, fixture));
+  return (relative || ".").replaceAll("\\", "/");
+}
+
 async function inspectConfiguredFixtures(config, options = {}) {
   const inspections = [];
   const failures = [];
@@ -170,7 +180,7 @@ export function inspectSourceText(text, filePath = "source.js") {
     ...collectDetailedMatches(searchableText, new RegExp(String.raw`\b(${pluginFactoryNames})\s*\(`, "g"), filePath, "name"),
     ...collectDetailedMatches(searchableText, compiledFactoryCall, filePath, "name"),
   ];
-  const sdkImports = collectSdkImports(searchableText, filePath);
+  const sdkImports = collectSdkImports(searchableText, filePath, text);
   const sdkDeprecations = inspectSdkDeprecations(searchableText, filePath);
 
   return {
@@ -185,14 +195,23 @@ export async function captureEntrypoint(entrypoint, options = {}) {
   if (options.mockSdk === true) {
     return captureEntrypointWithMockSdk(entrypoint, options);
   }
+  if (options.isolateCapture === true) {
+    return captureEntrypointInChild(entrypoint, { ...options, mockSdk: false });
+  }
+  return invokeWithTimeout((signal) => captureInProcess(entrypoint, options, signal), options);
+}
 
+async function captureInProcess(entrypoint, options, signal) {
+  signal.throwIfAborted();
   const resolvedEntrypoint = path.resolve(options.cwd ?? process.cwd(), entrypoint);
   let module;
   try {
     module = await import(pathToFileURL(resolvedEntrypoint).href);
   } catch (error) {
+    signal.throwIfAborted();
     throw classifyCapturePhaseError(error, "entrypoint-import-error");
   }
+  signal.throwIfAborted();
   const register = findRegisterExport(module);
 
   if (!register) {
@@ -207,13 +226,17 @@ export async function captureEntrypoint(entrypoint, options = {}) {
     pluginRoot: options.pluginRoot
       ? path.resolve(options.cwd ?? process.cwd(), options.pluginRoot)
       : path.dirname(resolvedEntrypoint),
+    signal,
   });
+  signal.throwIfAborted();
   const api = createCaptureApi(apiOptions);
   try {
     await register(api);
   } catch (error) {
+    signal.throwIfAborted();
     throw classifyCapturePhaseError(error, "registration-execution-error");
   }
+  signal.throwIfAborted();
   const result = {
     status: "captured",
     entrypoint: resolvedEntrypoint,
@@ -226,60 +249,68 @@ export async function captureEntrypoint(entrypoint, options = {}) {
 }
 
 export async function captureEntrypointWithMockSdk(entrypoint, options = {}) {
+  return captureEntrypointInChild(entrypoint, { ...options, mockSdk: true });
+}
+
+async function captureEntrypointInChild(entrypoint, options) {
+  const label = options.mockSdk ? "Mock SDK" : "Real SDK";
   const runnerPath = fileURLToPath(new URL("./mock-sdk-capture-runner.js", import.meta.url));
   const payload = {
     entrypoint,
+    mockSdk: options.mockSdk,
     cwd: options.cwd ?? process.cwd(),
     pluginRoot: options.pluginRoot,
     apiOptions: options.apiOptions,
+    maxOutputBytes: options.maxOutputBytes,
   };
+  const { result } = startOwnedProcess({
+    command: process.execPath,
+    args: ["--no-warnings", ...(options.mockSdk ? ["--preserve-symlinks"] : []), runnerPath, JSON.stringify(payload)],
+    cwd: options.cwd ?? process.cwd(),
+    env: { ...process.env, ...options.env },
+    timeoutMs: options.timeoutMs,
+    killGraceMs: options.killGraceMs,
+    maxOutputBytes: options.maxOutputBytes,
+    signal: options.signal,
+  }, "CAPTURE");
+  const outcome = await result;
+  if (outcome.exitCode !== 0 || outcome.outputTruncated) {
+    const message = outcome.cancelled ? `${label} capture cancelled`
+      : outcome.outputTruncated ? `${label} capture output exceeded its byte limit`
+      : `${label} capture child failed`;
+    const { error: childError, ...details } = outcome;
+    throw classifyChildCaptureError(Object.assign(childError ?? new Error(message), details), options.mockSdk);
+  }
   try {
-    const { stdout } = await execFileAsync(
-      process.execPath,
-      ["--no-warnings", "--preserve-symlinks", runnerPath, JSON.stringify(payload)],
-      {
-        cwd: options.cwd ?? process.cwd(),
-        env: {
-          ...process.env,
-          ...(options.env ?? {}),
-        },
-        maxBuffer: 1024 * 1024 * 10,
-      },
-    );
-    return JSON.parse(stdout);
+    return JSON.parse(outcome.stdout);
   } catch (error) {
-    const captured = parseCaptureResultFromStdout(error?.stdout);
-    if (captured) {
-      return captured;
-    }
-    throw classifyMockSdkCaptureError(error);
+    throw classifyChildCaptureError(error, options.mockSdk);
   }
 }
 
-function parseCaptureResultFromStdout(stdout) {
-  if (!stdout) {
-    return null;
+export function classifyMockSdkCaptureError(error) {
+  return classifyChildCaptureError(error, true);
+}
+
+function classifyChildCaptureError(error, mockSdk) {
+  const label = mockSdk ? "Mock SDK" : "Real SDK";
+  const fallbackClass = mockSdk ? "mock-sdk-capture-error" : "capture-error";
+  if (error?.timedOut === true) {
+    return enrichCaptureError(error, {
+      message: `${label} capture timed out after ${error.timeoutMs}ms`,
+      failureClass: "capture-timeout",
+    });
   }
-  try {
-    const parsed = JSON.parse(stdout);
-    if (
-      parsed &&
-      typeof parsed === "object" &&
-      typeof parsed.status === "string" &&
-      Array.isArray(parsed.captured)
-    ) {
-      return parsed;
-    }
-  } catch {
-    return null;
+  if (error?.cancelled || error?.outputTruncated) {
+    return enrichCaptureError(error, {
+      message: error.message,
+      failureClass: fallbackClass,
+    });
   }
-  return null;
-}
 
-export function classifyMockSdkCaptureError(error) {
   const rawMessage = [error?.stderr, error?.stdout, error?.message].filter(Boolean).join("\n");
   const missingExport = rawMessage.match(/does not provide an export named ['"]([^'"]+)['"]/)?.[1];
-  if (missingExport) {
+  if (mockSdk && missingExport) {
     return enrichCaptureError(error, {
       message: `Mock SDK import failed: openclaw/plugin-sdk is missing export ${missingExport}`,
       failureClass: "missing-sdk-export",
@@ -290,9 +321,9 @@ export function classifyMockSdkCaptureError(error) {
   const missingModule =
     rawMessage.match(/Cannot find (?:package|module) ['"]([^'"]*openclaw\/plugin-sdk[^'"]*)['"]/)?.[1] ??
     rawMessage.match(/Package subpath ['"](\.\/plugin-sdk\/[^'"]+)['"]/)?.[1];
-  if (missingModule || rawMessage.includes("openclaw/plugin-sdk")) {
+  if (mockSdk && missingModule) {
     return enrichCaptureError(error, {
-      message: `Mock SDK import failed: ${missingModule ?? "openclaw/plugin-sdk module could not be resolved"}`,
+      message: `Mock SDK import failed: ${missingModule}`,
       failureClass: "missing-sdk-module",
       missingModule,
     });
@@ -301,15 +332,50 @@ export function classifyMockSdkCaptureError(error) {
   const failureClass = rawMessage.match(/\[plugin-inspector:([^\]]+)\]/)?.[1];
   if (failureClass) {
     return enrichCaptureError(error, {
-      message: firstMeaningfulErrorLine(rawMessage.replace(/\[plugin-inspector:[^\]]+\]/, "")) ?? "Mock SDK capture failed",
+      message: firstMeaningfulErrorLine(rawMessage.replace(/\[plugin-inspector:[^\]]+\]/, "")) ?? `${label} capture failed`,
       failureClass,
     });
   }
+  if (mockSdk && rawMessage.includes("openclaw/plugin-sdk")) {
+    return enrichCaptureError(error, {
+      message: "Mock SDK import failed: openclaw/plugin-sdk module could not be resolved",
+      failureClass: "missing-sdk-module",
+    });
+  }
 
   return enrichCaptureError(error, {
-    message: firstMeaningfulErrorLine(rawMessage) ?? "Mock SDK capture failed",
-    failureClass: "mock-sdk-capture-error",
+    message: firstMeaningfulErrorLine(rawMessage) ?? `${label} capture failed`,
+    failureClass: fallbackClass,
+  });
+}
+
+function invokeWithTimeout(invoke, options) {
+  const { timeoutMs } = resolveProcessLimits(options, "CAPTURE");
+  const controller = new AbortController();
+  let rejectAborted;
+  const aborted = new Promise((_, reject) => { rejectAborted = reject; });
+  const onAbort = () => rejectAborted(controller.signal.reason);
+  const onCancel = () => controller.abort(classifyCapturePhaseError(
+    new Error("In-process capture cancelled"), "capture-error",
+  ));
+  controller.signal.addEventListener("abort", onAbort, { once: true });
+  const timeoutId = setTimeout(() => controller.abort(classifyCapturePhaseError(
+    new Error(`In-process capture timed out after ${timeoutMs}ms`), "capture-timeout",
+  )), timeoutMs);
+  // Observe late settlement, but stop inspector-owned phases after the deadline.
+  // Arbitrary plugin JavaScript is only preemptable in the supervised CLI child.
+  const run = Promise.resolve().then(() => {
+    controller.signal.throwIfAborted();
+    return invoke(controller.signal);
+  });
+  const result = Promise.race([run, aborted]).finally(() => {
+    clearTimeout(timeoutId);
+    controller.signal.removeEventListener("abort", onAbort);
+    options.signal?.removeEventListener("abort", onCancel);
   });
+  options.signal?.addEventListener("abort", onCancel, { once: true });
+  if (options.signal?.aborted) onCancel();
+  return result;
 }
 
 export function classifyCapturePhaseError(error, failureClass) {
@@ -385,7 +451,7 @@ function collectDetailedMatches(text, regex, filePath, key) {
   return details;
 }
 
-function collectSdkImports(text, filePath) {
+function collectSdkImports(text, filePath, sourceText) {
   const details = [];
   for (const candidate of text.matchAll(/(?:^|;)[\t ]*(import|export)\b/gm)) {
     const keyword = candidate[1];
@@ -402,13 +468,12 @@ function collectSdkImports(text, filePath) {
     });
   }
 
-  const dynamicMatches = [...text.matchAll(/\bimport\(\s*["'`]([^"'`]*openclaw\/plugin-sdk[^"'`]*)/g)];
-  const runtimeDynamicImports = runtimeDynamicImportIndexes(text, dynamicMatches);
-  for (const [index, match] of dynamicMatches.entries()) {
-    if (!runtimeDynamicImports.has(index)) continue;
-    const line = lineForOffset(text, match.index ?? 0);
+  // Comment masking can erase executable interpolations after URL-like template text.
+  for (const { specifier, index } of collectRuntimeModuleImports(sourceText)) {
+    if (specifier !== "openclaw/plugin-sdk" && !specifier.startsWith("openclaw/plugin-sdk/")) continue;
+    const line = lineForOffset(text, index);
     details.push({
-      specifier: match[1],
+      specifier,
       file: filePath,
       line,
       ref: `${filePath}:${line}`,
@@ -475,50 +540,6 @@ function skipQuotedText(text, quoteIndex, quote) {
   return cursor;
 }
 
-function runtimeDynamicImportIndexes(text, matches) {
-  if (matches.length === 0) return new Set();
-  const markedImports = matches.map((match, index) => {
-    const specifier = match[1];
-    const specifierStart = (match.index ?? 0) + match[0].indexOf(specifier);
-    return {
-      index,
-      specifierStart,
-      specifierEnd: specifierStart + specifier.length,
-      marker: `${specifier}/__plugin_inspector_runtime_import_${index}__`,
-    };
-  });
-  let markedText = text;
-  for (const markedImport of markedImports.toReversed()) {
-    markedText =
-      markedText.slice(0, markedImport.specifierStart) +
-      markedImport.marker +
-      markedText.slice(markedImport.specifierEnd);
-  }
-
-  try {
-    const runtimeText = eraseTypeScript(markedText);
-    if (runtimeText === null) {
-      return new Set(markedImports.map((markedImport) => markedImport.index));
-    }
-    return new Set(
-      markedImports.filter((markedImport) => runtimeText.includes(markedImport.marker)).map((markedImport) => markedImport.index),
-    );
-  } catch {
-    return new Set(markedImports.map((markedImport) => markedImport.index));
-  }
-}
-
-function eraseTypeScript(text) {
-  if (typeof nodeModule.stripTypeScriptTypes === "function") {
-    return nodeModule.stripTypeScriptTypes(text, { mode: "transform" });
-  }
-  if (typeof globalThis.Bun?.Transpiler === "function") {
-    const transpiler = new globalThis.Bun.Transpiler({ loader: "ts", target: "bun" });
-    return transpiler.transformSync(text);
-  }
-  return null;
-}
-
 function isTypeOnlyStaticImportClause(clause) {
   clause = clause.trim();
   if (/^type\b/.test(clause)) {

package/src/mock-sdk-capture-runner.js

@@ -1,37 +1,56 @@
 #!/usr/bin/env node
 import { rmSync } from "node:fs";
 import { mkdtemp } from "node:fs/promises";
-import { register } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { writeArtifacts } from "./artifacts.js";
 import { createCaptureApi } from "./capture-api.js";
 import { captureApiOptionsForPlugin } from "./capture-config.js";
-import { createMockSdkPackage } from "./sdk-mock.js";
+import { createCappedCollector, resolveProcessLimits } from "./process-profile.js";
+import { createMockSdkPackage, installMockSdkLoader } from "./sdk-mock.js";
 
 const options = JSON.parse(process.argv[2] ?? "{}");
 let activeOutputCapture = null;
 
 try {
   const result = await run(options);
-  writeRunnerStdout(`${JSON.stringify(result, null, 2)}\n`);
+  const json = `${JSON.stringify(result, null, 2)}\n`;
+  const { maxOutputBytes } = resolveProcessLimits(options, options.syntheticProbes ? "PROBE" : "CAPTURE");
+  if (Buffer.byteLength(json) > maxOutputBytes) {
+    const label = options.syntheticProbes ? "Synthetic probe" : `${options.mockSdk === false ? "Real SDK" : "Mock SDK"} capture`;
+    throw new Error(`${label} result exceeded its ${maxOutputBytes}-byte limit`);
+  }
+  if (options.outputPath) {
+    await writeArtifacts([{ path: options.outputPath, content: json }]);
+  } else {
+    await writeRunnerStdout(json);
+  }
+  process.exit(0);
 } catch (error) {
   if (error.failureClass) {
-    writeRunnerStderr(`[plugin-inspector:${error.failureClass}]\n`);
+    await writeRunnerStderr(`[plugin-inspector:${error.failureClass}]\n`);
   }
-  writeRunnerStderr(`${error.stack ?? error.message}\n`);
-  process.exitCode = 1;
+  await writeRunnerStderr(`${options.outputPath ? error.message : (error.stack ?? error.message)}\n`);
+  process.exit(1);
 }
 
 async function run(options) {
   const entrypoint = path.resolve(options.cwd ?? process.cwd(), options.entrypoint);
   const pluginRoot = path.resolve(options.cwd ?? process.cwd(), options.pluginRoot ?? path.dirname(entrypoint));
+  if (options.mockSdk === false) {
+    return await captureLinkedEntrypoint(entrypoint, { ...options, pluginRoot });
+  }
   const workspace = await mkdtemp(path.join(os.tmpdir(), "plugin-inspector-mock-sdk-"));
 
   cleanupTempDirOnExit(workspace);
-  const { loaderPath } = await createMockSdkPackage(workspace, { pluginRoot });
-  register(pathToFileURL(loaderPath));
-  return await captureLinkedEntrypoint(entrypoint, { ...options, pluginRoot });
+  const mockPackage = await createMockSdkPackage(workspace, { pluginRoot });
+  const stopLoader = await installMockSdkLoader(mockPackage);
+  try {
+    return await captureLinkedEntrypoint(entrypoint, { ...options, pluginRoot });
+  } finally {
+    stopLoader();
+  }
 }
 
 function cleanupTempDirOnExit(dir) {
@@ -55,14 +74,15 @@ async function captureLinkedEntrypoint(entrypoint, options) {
 
   if (!register) {
     await drainAsyncOutput();
-    return withProcessOutput(
+    return finishCapture(
       {
         status: "no-register-export",
-        entrypoint: options.entrypoint,
-        mockSdk: true,
+        entrypoint: options.mockSdk === false ? entrypoint : options.entrypoint,
+        mockSdk: options.mockSdk !== false,
         captured: [],
       },
       outputCapture,
+      options,
     );
   }
 
@@ -80,13 +100,22 @@ async function captureLinkedEntrypoint(entrypoint, options) {
 
   const result = {
     status: "captured",
-    entrypoint: options.entrypoint,
-    mockSdk: true,
+    entrypoint: options.mockSdk === false ? entrypoint : options.entrypoint,
+    mockSdk: options.mockSdk !== false,
     captured: api.getCapturedContracts(),
   };
   if (apiOptions?.retainHandlers === true) {
     result.retained = api.getRetainedContracts();
   }
+  return finishCapture(result, outputCapture, options);
+}
+
+async function finishCapture(result, outputCapture, options) {
+  if (options.syntheticProbes) {
+    const { runCapturedSyntheticProbes } = await import("./synthetic-probes.js");
+    result = await runCapturedSyntheticProbes(result, options);
+    await drainAsyncOutput();
+  }
   return withProcessOutput(result, outputCapture);
 }
 
@@ -124,18 +153,18 @@ function findRegisterExport(module) {
 }
 
 function installProcessOutputCapture() {
-  const stdoutChunks = [];
-  const stderrChunks = [];
+  const stdout = createCappedCollector(1024 * 1024);
+  const stderr = createCappedCollector(1024 * 1024);
   const originalStdoutWrite = process.stdout.write.bind(process.stdout);
   const originalStderrWrite = process.stderr.write.bind(process.stderr);
 
   process.stdout.write = (chunk, encoding, callback) => {
-    stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+    stdout.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), typeof encoding === "string" ? encoding : "utf8"));
     invokeWriteCallback(encoding, callback);
     return true;
   };
   process.stderr.write = (chunk, encoding, callback) => {
-    stderrChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+    stderr.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), typeof encoding === "string" ? encoding : "utf8"));
     invokeWriteCallback(encoding, callback);
     return true;
   };
@@ -143,8 +172,8 @@ function installProcessOutputCapture() {
   return {
     originalStdoutWrite,
     originalStderrWrite,
-    stdout: () => stdoutChunks.join(""),
-    stderr: () => stderrChunks.join(""),
+    stdout: () => stdout.text(),
+    stderr: () => stderr.text(),
   };
 }
 
@@ -162,9 +191,19 @@ async function drainAsyncOutput() {
 }
 
 function writeRunnerStdout(text) {
-  (activeOutputCapture?.originalStdoutWrite ?? process.stdout.write.bind(process.stdout))(text);
+  const write = activeOutputCapture?.originalStdoutWrite ?? process.stdout.write.bind(process.stdout);
+  return flushWrite(write, text);
 }
 
 function writeRunnerStderr(text) {
-  (activeOutputCapture?.originalStderrWrite ?? process.stderr.write.bind(process.stderr))(text);
+  const write = activeOutputCapture?.originalStderrWrite ?? process.stderr.write.bind(process.stderr);
+  return flushWrite(write, text);
+}
+
+// The runner exits deliberately to shed plugin timers, but only after the
+// complete protocol response has reached its pipe.
+function flushWrite(write, text) {
+  return new Promise((resolve, reject) => {
+    write(text, (error) => error ? reject(error) : resolve());
+  });
 }