@elench/testkit 0.1.64 → 0.1.66

package/lib/runner/live-run.mjs

@@ -0,0 +1,45 @@
+import { finalizeServiceResult, summarizeDbBackend } from "./results.mjs";
+import { buildLiveRunArtifact } from "./reporting.mjs";
+import { writeLiveRunArtifact } from "./artifacts.mjs";
+
+export function createLiveSnapshotWriter({
+  productDir,
+  configs,
+  trackers,
+  startedAt,
+  execution,
+  workerState,
+  selection,
+  metadata,
+  logRegistry,
+  setupRegistry,
+}) {
+  return () => {
+    const now = Date.now();
+    const partialResults = configs.map((config) => finalizeServiceResult(trackers.get(config.name), startedAt, now));
+    writeLiveRunArtifact(
+      productDir,
+      buildLiveRunArtifact({
+        productDir,
+        results: partialResults,
+        startedAt,
+        updatedAt: now,
+        execution,
+        workerCount: workerState.workerCount,
+        runtimeInstanceCount: workerState.runtimeInstanceCount,
+        runtimeStats: workerState.runtimeStats,
+        typeValues: selection.typeValues,
+        suiteSelectors: selection.suiteSelectors,
+        fileNames: selection.fileNames,
+        shard: selection.shard,
+        serviceFilter: selection.serviceFilter,
+        scenarioSeed: selection.scenarioSeed,
+        metadata,
+        summarizeDbBackend,
+        serviceLogs: logRegistry.listServiceLogs(),
+        setupLogs: logRegistry.listSetupLogs(),
+        setupOperations: setupRegistry.listOperations(),
+      })
+    );
+  };
+}

package/lib/runner/managed-processes.mjs

@@ -0,0 +1,29 @@
+import { killChildProcess } from "./processes.mjs";
+
+export function registerManagedProcess(lifecycle, subprocess, signal = "SIGINT") {
+  lifecycle.registerProcess(subprocess, () => {
+    killChildProcess(subprocess, signal);
+  });
+  if (lifecycle.isStopRequested()) {
+    interruptManagedProcess(subprocess, signal);
+  }
+}
+
+export function unregisterManagedProcess(lifecycle, subprocess) {
+  lifecycle.unregisterProcess(subprocess.pid);
+}
+
+export function registerManagedService(lifecycle, config, child, cwd, signal = "SIGTERM") {
+  lifecycle.registerService(config, child, cwd, () => {
+    killChildProcess(child, signal);
+  });
+  if (lifecycle.isStopRequested()) {
+    interruptManagedProcess(child, signal);
+  }
+}
+
+function interruptManagedProcess(subprocess, signal) {
+  const interruptSubprocess = () => killChildProcess(subprocess, signal);
+  if (subprocess.pid) interruptSubprocess();
+  else subprocess.once?.("spawn", interruptSubprocess);
+}

package/lib/runner/orchestrator.mjs

@@ -12,26 +12,13 @@ import {
   finalizeServiceResult,
   recordGraphError,
   recordTaskOutcome,
-  summarizeDbBackend,
 } from "./results.mjs";
-import { buildLiveRunArtifact, buildRunArtifact, buildStatusArtifact } from "./reporting.mjs";
-import {
-  applyKnownFailureIssueValidationToArtifacts,
-  applyKnownFailuresToArtifacts,
-  loadKnownFailuresConfig,
-} from "./triage.mjs";
+import { loadKnownFailuresConfig } from "./triage.mjs";
 import { formatError } from "./formatting.mjs";
-import {
-  shouldFailKnownFailureIssueValidation,
-  validateKnownFailureIssues,
-} from "../known-failures/github.mjs";
 import {
   loadTimings,
   resetResultArtifacts,
   saveTimings,
-  writeLiveRunArtifact,
-  writeRunArtifact,
-  writeStatusArtifact,
 } from "./artifacts.mjs";
 import { createRunLogRegistry } from "./logs.mjs";
 import { createSetupOperationRegistry } from "./setup-operations.mjs";
@@ -50,9 +37,9 @@ import {
 import { resolveExecutionConfig } from "./execution-config.mjs";
 import { createRuntimeManager } from "./runtime-manager.mjs";
 import { createWorker, runWorker } from "./worker-loop.mjs";
-import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
-import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
-import { loadHistory, saveHistory, updateHistoryFromRunArtifact } from "../history/index.mjs";
+import { ensureRequestedFilesMatch, ensureStatusWriteAllowed } from "./run-guards.mjs";
+import { createLiveSnapshotWriter } from "./live-run.mjs";
+import { finalizeRunArtifacts } from "./run-finalization.mjs";
 
 export async function runAll(configs, typeValues, suiteSelectors, opts, allConfigs = configs) {
   const configMap = new Map(allConfigs.map((config) => [config.name, config]));
@@ -75,42 +62,14 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
   );
   const reporter = opts.reporter || null;
   const logRegistry = createRunLogRegistry(productDir);
-  let workerCount = 0;
-  let runtimeInstanceCount = 0;
-  let runtimeStats = [];
+  const workerState = {
+    workerCount: 0,
+    runtimeInstanceCount: 0,
+    runtimeStats: [],
+  };
   const requestedFiles = opts.fileNames || [];
-  if (requestedFiles.length > 0) {
-    const unmatchedFiles = findUnmatchedRequestedFiles(
-      configs,
-      typeValues,
-      suiteSelectors,
-      requestedFiles,
-      collectSuites,
-      normalizePathSeparators
-    );
-    if (unmatchedFiles.length > 0) {
-      throw new Error(
-        `Requested file${unmatchedFiles.length === 1 ? "" : "s"} did not match any selected suites:\n` +
-          unmatchedFiles.map((file) => `- ${file}`).join("\n")
-      );
-    }
-  }
-  if (
-    opts.writeStatus &&
-    !opts.allowPartialStatus &&
-    !isFullRunSelection(
-      typeValues,
-      suiteSelectors,
-      requestedFiles,
-      opts.shard || null,
-      opts.serviceFilter || null
-    )
-  ) {
-    throw new Error(
-      "Refusing to overwrite testkit.status.json from a filtered run. " +
-        "Run the full suite with --write-status, or pass --allow-partial-status to opt in."
-    );
-  }
+  ensureRequestedFilesMatch(configs, typeValues, suiteSelectors, requestedFiles);
+  ensureStatusWriteAllowed(opts, typeValues, suiteSelectors, requestedFiles);
 
   const execution = resolveExecutionConfig({
     cli: opts,
@@ -126,39 +85,26 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     reporter
   );
   const trackers = buildServiceTrackers(servicePlans, startedAt);
-  const writeLiveSnapshot = () => {
-    const now = Date.now();
-    const partialResults = configs.map((config) =>
-      finalizeServiceResult(trackers.get(config.name), startedAt, now)
-    );
-    writeLiveRunArtifact(
-      productDir,
-      buildLiveRunArtifact({
-        productDir,
-        results: partialResults,
-        startedAt,
-        updatedAt: now,
-        execution,
-        workerCount,
-        runtimeInstanceCount,
-        runtimeStats,
-        typeValues,
-        suiteSelectors,
-        fileNames: requestedFiles,
-        shard: opts.shard || null,
-        serviceFilter: opts.serviceFilter || null,
-        scenarioSeed: opts.scenarioSeed || null,
-        metadata,
-        summarizeDbBackend,
-        serviceLogs: logRegistry.listServiceLogs(),
-        setupLogs: logRegistry.listSetupLogs(),
-        setupOperations: setupRegistry.listOperations(),
-      })
-    );
-  };
-  const setupRegistry = createSetupOperationRegistry({
+  let writeLiveSnapshot = () => {};
+  const setupRegistry = createSetupOperationRegistry({ logRegistry, onChange: () => writeLiveSnapshot() });
+  writeLiveSnapshot = createLiveSnapshotWriter({
+    productDir,
+    configs,
+    trackers,
+    startedAt,
+    execution,
+    workerState,
+    selection: {
+      typeValues,
+      suiteSelectors,
+      fileNames: requestedFiles,
+      shard: opts.shard || null,
+      serviceFilter: opts.serviceFilter || null,
+      scenarioSeed: opts.scenarioSeed || null,
+    },
+    metadata,
     logRegistry,
-    onChange: writeLiveSnapshot,
+    setupRegistry,
   });
   const executedPlans = servicePlans.filter((plan) => !plan.skipped);
   let exitCode = 0;
@@ -178,9 +124,9 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
       for (const task of queue) {
         task.scenarioSeed = opts.scenarioSeed || null;
       }
-      workerCount = Math.max(1, Math.min(execution.workers, queue.length));
-      runtimeInstanceCount = graphs.reduce((sum, graph) => sum + graph.instanceCount, 0);
-      const workers = Array.from({ length: workerCount }, (_unused, index) =>
+      workerState.workerCount = Math.max(1, Math.min(execution.workers, queue.length));
+      workerState.runtimeInstanceCount = graphs.reduce((sum, graph) => sum + graph.instanceCount, 0);
+      const workers = Array.from({ length: workerState.workerCount }, (_unused, index) =>
         createWorker(index + 1, productDir)
       );
       const runtimeManager = createRuntimeManager({
@@ -228,7 +174,7 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
             writeLiveSnapshot();
           }
         }
-        runtimeStats = runtimeManager.getStats();
+        workerState.runtimeStats = runtimeManager.getStats();
         writeLiveSnapshot();
       } finally {
         await runtimeManager.cleanupAll();
@@ -241,85 +187,41 @@ export async function runAll(configs, typeValues, suiteSelectors, opts, allConfi
     results = configs.map((config) =>
       finalizeServiceResult(trackers.get(config.name), startedAt, finishedAt)
     );
-    const runArtifact = buildRunArtifact({
+    const finalized = await finalizeRunArtifacts({
       productDir,
       results,
       startedAt,
       finishedAt,
       execution,
-      workerCount,
-      runtimeInstanceCount,
-      runtimeStats,
-      typeValues,
-      suiteSelectors,
-            fileNames: requestedFiles,
-            shard: opts.shard || null,
-            serviceFilter: opts.serviceFilter || null,
-            scenarioSeed: opts.scenarioSeed || null,
-            metadata,
-      summarizeDbBackend,
-      serviceLogs: logRegistry.listServiceLogs(),
-      setupLogs: logRegistry.listSetupLogs(),
-      setupOperations: setupRegistry.listOperations(),
-    });
-    const statusArtifact = opts.writeStatus
-      ? buildStatusArtifact({
-          productDir,
-          results,
-          typeValues,
-          suiteSelectors,
-      fileNames: requestedFiles,
-      shard: opts.shard || null,
-      serviceFilter: opts.serviceFilter || null,
-      scenarioSeed: opts.scenarioSeed || null,
+      workerCount: workerState.workerCount,
+      runtimeInstanceCount: workerState.runtimeInstanceCount,
+      runtimeStats: workerState.runtimeStats,
+      selection: {
+        typeValues,
+        suiteSelectors,
+        fileNames: requestedFiles,
+        shard: opts.shard || null,
+        serviceFilter: opts.serviceFilter || null,
+        scenarioSeed: opts.scenarioSeed || null,
+      },
       metadata,
-        })
-      : null;
-    const enrichedArtifacts = applyKnownFailuresToArtifacts(
-      runArtifact,
-      statusArtifact,
-      knownFailures
-    );
-    knownFailureIssueValidation = await validateKnownFailureIssues({
-      productDir,
-      document: knownFailures,
-      runArtifact: enrichedArtifacts.runArtifact,
-      statusArtifact: enrichedArtifacts.statusArtifact,
-      config: configs[0]?.testkit?.reporting?.issueValidation || null,
-      gitMetadata: metadata.git,
+      logRegistry,
+      setupRegistry,
+      knownFailures,
+      issueValidationConfig: configs[0]?.testkit?.reporting?.issueValidation || null,
+      telemetry,
+      reporter,
+      writeStatus: opts.writeStatus,
     });
-    applyKnownFailureIssueValidationToArtifacts(
-      enrichedArtifacts.runArtifact,
-      enrichedArtifacts.statusArtifact,
-      knownFailureIssueValidation
-    );
-    attachKnownFailureIssueValidation(
-      enrichedArtifacts.runArtifact,
-      enrichedArtifacts.statusArtifact,
-      knownFailureIssueValidation
-    );
-
-    writeRunArtifact(productDir, enrichedArtifacts.runArtifact);
-    if (opts.writeStatus) {
-      writeStatusArtifact(productDir, enrichedArtifacts.statusArtifact);
-    }
-    const nextHistory = updateHistoryFromRunArtifact(
-      loadHistory(productDir),
-      enrichedArtifacts.runArtifact,
-      enrichedArtifacts.runArtifact.generatedAt
-    );
-    saveHistory(productDir, nextHistory);
-
-    reporter?.runSummary?.(results, finishedAt - startedAt, knownFailureIssueValidation);
-    await reportTelemetry(telemetry, enrichedArtifacts.runArtifact, reporter);
+    knownFailureIssueValidation = finalized.knownFailureIssueValidation;
     if (results.some((result) => result.failed)) exitCode = 1;
-    if (shouldFailKnownFailureIssueValidation(knownFailureIssueValidation)) {
+    if (finalized.shouldFailIssueValidation) {
       exitCode = 1;
     }
     if (lifecycle.isStopRequested()) exitCode = Math.max(exitCode, 130);
     return {
-      runArtifact: enrichedArtifacts.runArtifact,
-      statusArtifact: enrichedArtifacts.statusArtifact,
+      runArtifact: finalized.runArtifact,
+      statusArtifact: finalized.statusArtifact,
       results,
       exitCode,
     };
@@ -386,36 +288,3 @@ function collectServicePlans(configs, configMap, typeValues, suiteSelectors, opt
     };
   });
 }
-
-async function reportTelemetry(telemetry, artifact, reporter = null) {
-  if (!telemetry?.enabled) return;
-
-  try {
-    const outcome = await uploadTelemetryArtifact(telemetry, artifact);
-    if (outcome?.ok) {
-      reporter?.telemetry?.("Telemetry: uploaded run artifact");
-      return;
-    }
-    if (outcome?.reason === "missing-token") {
-      reporter?.telemetry?.(
-        `Telemetry: skipped upload because ${telemetry.tokenEnv || "configured token env"} is not set`
-      );
-      return;
-    }
-    if (outcome?.reason && !outcome.skipped) return;
-  } catch (error) {
-    reporter?.telemetry?.(`Telemetry: upload failed (${formatError(error)})`);
-  }
-}
-
-function normalizePathSeparators(filePath) {
-  return filePath.split("\\").join("/");
-}
-
-function attachKnownFailureIssueValidation(runArtifact, statusArtifact, validation) {
-  if (!validation) return;
-  runArtifact.knownFailuresIssueValidation = validation;
-  if (statusArtifact) {
-    statusArtifact.knownFailuresIssueValidation = validation;
-  }
-}

package/lib/runner/playwright-runner.mjs

@@ -1,14 +1,14 @@
 import path from "path";
 import { execa } from "execa";
 import { parsePlaywrightJsonResults } from "../reporters/playwright.mjs";
-import { resolveServiceCwd } from "../config/index.mjs";
+import { resolveServiceCwd } from "../config/paths.mjs";
 import { formatFileTimeoutBudgetError } from "../shared/file-timeout.mjs";
 import { persistTaskOutputArtifacts } from "./artifacts.mjs";
 import { settleSubprocess } from "./default-runtime-runner.mjs";
 import { ensurePlaywrightTestConfig } from "./playwright-config.mjs";
+import { registerManagedProcess, unregisterManagedProcess } from "./managed-processes.mjs";
 import { normalizePathSeparators } from "./state.mjs";
 import { buildPlaywrightEnv } from "./template.mjs";
-import { killChildProcess } from "./processes.mjs";
 
 export async function runPlaywrightTask(targetConfig, task, lifecycle, lease, reporter = null) {
   const local = targetConfig.testkit.local;
@@ -36,21 +36,14 @@ export async function runPlaywrightTask(targetConfig, task, lifecycle, lease, re
       forceKillAfterDelay: 5_000,
     }
   );
-  lifecycle.registerProcess(subprocess, () => {
-    killChildProcess(subprocess, "SIGINT");
-  });
-  if (lifecycle.isStopRequested()) {
-    const interruptSubprocess = () => killChildProcess(subprocess, "SIGINT");
-    if (subprocess.pid) interruptSubprocess();
-    else subprocess.once?.("spawn", interruptSubprocess);
-  }
+  registerManagedProcess(lifecycle, subprocess, "SIGINT");
   reporter?.taskStarted?.(task, targetConfig);
   let result;
   let timedOut;
   try {
     ({ result, timedOut } = await settleSubprocess(subprocess, fileTimeoutSeconds));
   } finally {
-    lifecycle.unregisterProcess(subprocess.pid);
+    unregisterManagedProcess(lifecycle, subprocess);
   }
 
   const parsed = parsePlaywrightJsonResults(result.stdout || "", cwd);

package/lib/runner/run-finalization.mjs

@@ -0,0 +1,132 @@
+import { buildRunArtifact, buildStatusArtifact } from "./reporting.mjs";
+import { applyKnownFailureIssueValidationToArtifacts, applyKnownFailuresToArtifacts } from "./triage.mjs";
+import { writeRunArtifact, writeStatusArtifact } from "./artifacts.mjs";
+import { summarizeDbBackend } from "./results.mjs";
+import { formatError } from "./formatting.mjs";
+import { uploadTelemetryArtifact } from "../telemetry/index.mjs";
+import { loadHistory, saveHistory, updateHistoryFromRunArtifact } from "../history/index.mjs";
+import { shouldFailKnownFailureIssueValidation, validateKnownFailureIssues } from "../known-failures/github.mjs";
+
+export async function finalizeRunArtifacts({
+  productDir,
+  results,
+  startedAt,
+  finishedAt,
+  execution,
+  workerCount,
+  runtimeInstanceCount,
+  runtimeStats,
+  selection,
+  metadata,
+  logRegistry,
+  setupRegistry,
+  knownFailures,
+  issueValidationConfig,
+  telemetry,
+  reporter,
+  writeStatus,
+}) {
+  const runArtifact = buildRunArtifact({
+    productDir,
+    results,
+    startedAt,
+    finishedAt,
+    execution,
+    workerCount,
+    runtimeInstanceCount,
+    runtimeStats,
+    typeValues: selection.typeValues,
+    suiteSelectors: selection.suiteSelectors,
+    fileNames: selection.fileNames,
+    shard: selection.shard,
+    serviceFilter: selection.serviceFilter,
+    scenarioSeed: selection.scenarioSeed,
+    metadata,
+    summarizeDbBackend,
+    serviceLogs: logRegistry.listServiceLogs(),
+    setupLogs: logRegistry.listSetupLogs(),
+    setupOperations: setupRegistry.listOperations(),
+  });
+  const statusArtifact = writeStatus
+    ? buildStatusArtifact({
+        productDir,
+        results,
+        typeValues: selection.typeValues,
+        suiteSelectors: selection.suiteSelectors,
+        fileNames: selection.fileNames,
+        shard: selection.shard,
+        serviceFilter: selection.serviceFilter,
+        scenarioSeed: selection.scenarioSeed,
+        metadata,
+      })
+    : null;
+  const enrichedArtifacts = applyKnownFailuresToArtifacts(runArtifact, statusArtifact, knownFailures);
+  const knownFailureIssueValidation = await validateKnownFailureIssues({
+    productDir,
+    document: knownFailures,
+    runArtifact: enrichedArtifacts.runArtifact,
+    statusArtifact: enrichedArtifacts.statusArtifact,
+    config: issueValidationConfig,
+    gitMetadata: metadata.git,
+  });
+  applyKnownFailureIssueValidationToArtifacts(
+    enrichedArtifacts.runArtifact,
+    enrichedArtifacts.statusArtifact,
+    knownFailureIssueValidation
+  );
+  attachKnownFailureIssueValidation(
+    enrichedArtifacts.runArtifact,
+    enrichedArtifacts.statusArtifact,
+    knownFailureIssueValidation
+  );
+
+  writeRunArtifact(productDir, enrichedArtifacts.runArtifact);
+  if (writeStatus) {
+    writeStatusArtifact(productDir, enrichedArtifacts.statusArtifact);
+  }
+  const nextHistory = updateHistoryFromRunArtifact(
+    loadHistory(productDir),
+    enrichedArtifacts.runArtifact,
+    enrichedArtifacts.runArtifact.generatedAt
+  );
+  saveHistory(productDir, nextHistory);
+
+  reporter?.runSummary?.(results, finishedAt - startedAt, knownFailureIssueValidation);
+  await reportTelemetry(telemetry, enrichedArtifacts.runArtifact, reporter);
+
+  return {
+    runArtifact: enrichedArtifacts.runArtifact,
+    statusArtifact: enrichedArtifacts.statusArtifact,
+    knownFailureIssueValidation,
+    shouldFailIssueValidation: shouldFailKnownFailureIssueValidation(knownFailureIssueValidation),
+  };
+}
+
+async function reportTelemetry(telemetry, artifact, reporter = null) {
+  if (!telemetry?.enabled) return;
+
+  try {
+    const outcome = await uploadTelemetryArtifact(telemetry, artifact);
+    if (outcome?.ok) {
+      reporter?.telemetry?.("Telemetry: uploaded run artifact");
+      return;
+    }
+    if (outcome?.reason === "missing-token") {
+      reporter?.telemetry?.(
+        `Telemetry: skipped upload because ${telemetry.tokenEnv || "configured token env"} is not set`
+      );
+      return;
+    }
+    if (outcome?.reason && !outcome.skipped) return;
+  } catch (error) {
+    reporter?.telemetry?.(`Telemetry: upload failed (${formatError(error)})`);
+  }
+}
+
+function attachKnownFailureIssueValidation(runArtifact, statusArtifact, validation) {
+  if (!validation) return;
+  runArtifact.knownFailuresIssueValidation = validation;
+  if (statusArtifact) {
+    statusArtifact.knownFailuresIssueValidation = validation;
+  }
+}

package/lib/runner/run-guards.mjs

@@ -0,0 +1,45 @@
+import { collectSuites } from "./planning.mjs";
+import { findUnmatchedRequestedFiles, isFullRunSelection } from "./selection.mjs";
+
+export function ensureRequestedFilesMatch(configs, typeValues, suiteSelectors, requestedFiles = []) {
+  if (requestedFiles.length === 0) return;
+  const unmatchedFiles = findUnmatchedRequestedFiles(
+    configs,
+    typeValues,
+    suiteSelectors,
+    requestedFiles,
+    collectSuites,
+    normalizePathSeparators
+  );
+  if (unmatchedFiles.length === 0) return;
+
+  throw new Error(
+    `Requested file${unmatchedFiles.length === 1 ? "" : "s"} did not match any selected suites:\n` +
+      unmatchedFiles.map((file) => `- ${file}`).join("\n")
+  );
+}
+
+export function ensureStatusWriteAllowed(opts, typeValues, suiteSelectors, requestedFiles = []) {
+  if (
+    !opts.writeStatus ||
+    opts.allowPartialStatus ||
+    isFullRunSelection(
+      typeValues,
+      suiteSelectors,
+      requestedFiles,
+      opts.shard || null,
+      opts.serviceFilter || null
+    )
+  ) {
+    return;
+  }
+
+  throw new Error(
+    "Refusing to overwrite testkit.status.json from a filtered run. " +
+      "Run the full suite with --write-status, or pass --allow-partial-status to opt in."
+  );
+}
+
+function normalizePathSeparators(filePath) {
+  return filePath.split("\\").join("/");
+}

package/lib/runner/runtime-preparation.mjs

@@ -1,7 +1,7 @@
 import crypto from "crypto";
 import fs from "fs";
 import path from "path";
-import { resolveServiceCwd } from "../config/index.mjs";
+import { resolveServiceCwd } from "../config/paths.mjs";
 import { appendFileToHash, appendInputToHash } from "../database/fingerprint.mjs";
 import { announceResolvedToolchain, resolveConfiguredToolchain } from "../toolchains/index.mjs";
 import { readDatabaseUrl } from "./state-io.mjs";

package/lib/runner/services.mjs

@@ -1,9 +1,10 @@
-import { resolveServiceCwd } from "../config/index.mjs";
+import { resolveServiceCwd } from "../config/paths.mjs";
 import {
   announceResolvedToolchain,
   applyToolchainEnv,
   resolveConfiguredToolchain,
 } from "../toolchains/index.mjs";
+import { registerManagedService } from "./managed-processes.mjs";
 import { buildExecutionEnv, numericPortFromUrl } from "./template.mjs";
 import { DEFAULT_READY_TIMEOUT_MS, assertLocalServicePortsAvailable, isPortInUse, waitForReady } from "./readiness.mjs";
 import { captureOutput, killChildProcess, startDetachedCommand, stopChildProcess, sleep } from "./processes.mjs";
@@ -70,9 +71,7 @@ export async function startLocalService(config, lifecycle, options = {}) {
       },
     }),
   ];
-  lifecycle.registerService(config, child, cwd, () => {
-    killChildProcess(child, "SIGTERM");
-  });
+  registerManagedService(lifecycle, config, child, cwd, "SIGTERM");
 
   const readyTimeoutMs = config.testkit.local.readyTimeoutMs || DEFAULT_READY_TIMEOUT_MS;