const TIMEOUT_KILL_GRACE_MS = 5_000;

const PROCESS_GROUP_EXIT_POLL_MS = 25;

const POST_FORCE_KILL_WAIT_MS = 1_000;

const MAX_TIMER_TIMEOUT_MS = 2_147_000_000;

/** Ordered list of supplemental boundary checks used by CI sharding. */

export const BOUNDARY_CHECKS = [

return parsed;

}

function resolveTimerTimeoutMs(valueMs) {

const value = Number(valueMs);

if (!Number.isFinite(value)) {

return MAX_TIMER_TIMEOUT_MS;

}

return Math.min(Math.max(Math.floor(value), 1), MAX_TIMER_TIMEOUT_MS);

}

/**

* Parses one N/TOTAL shard selector into zero-based index form.

*/

},

) {

return new Promise((resolve) => {

const resolvedCheckTimeoutMs = resolveTimerTimeoutMs(checkTimeoutMs);

const startedAt = performance.now();

const child = spawn(check.command, check.args, {

cwd,

const timeout = setTimeout(() => {

timedOut = true;

output.append(

`\n[boundary-check] ${check.label} timed out after ${formatDuration(checkTimeoutMs)}; terminating process group\n`,

`\n[boundary-check] ${check.label} timed out after ${formatDuration(resolvedCheckTimeoutMs)}; terminating process group\n`,

);

terminateChild(child, "SIGTERM");

forceKillTimer = setTimeout(() => {

terminateChild(child, "SIGKILL");

}, TIMEOUT_KILL_GRACE_MS);

forceKillTimer.unref?.();

}, checkTimeoutMs);

}, resolvedCheckTimeoutMs);

timeout.unref?.();

child.stdout.setEncoding("utf8");

import fs from "node:fs";

import os from "node:os";

import path from "node:path";

import { MAX_TIMER_TIMEOUT_MS } from "@openclaw/normalization-core/number-coercion";

import { describe, expect, it } from "vitest";

import {

BOUNDARY_CHECKS,

expect(result.output).toContain("timed out after 50ms");

});

it("clamps oversized check timers before scheduling", async () => {

const result = await runSingleCheck(

{

label: "slow-pass",

command: process.execPath,

args: ["-e", "setTimeout(() => process.exit(0), 25)"],

},

{

checkTimeoutMs: MAX_TIMER_TIMEOUT_MS + 1,

cwd: process.cwd(),

env: process.env,

outputMaxBytes: 4096,

},

);

expect(result.code).toBe(0);

expect(result.timedOut).toBe(false);

});

it.skipIf(process.platform === "win32")(

"waits for timed-out process groups after the wrapper exits",

async () => {