--runs <n> Measured process samples per case (default: ${DEFAULT_RUNS})

--warmup <n> Warmup process samples per case (default: ${DEFAULT_WARMUP})

--restarts <n> In-process restarts per process sample (default: ${DEFAULT_RESTARTS})

--timeout-ms <ms> Per-process timeout (default: ${DEFAULT_TIMEOUT_MS})

--timeout-ms <ms> Timeout for initial startup and each restart (default: ${DEFAULT_TIMEOUT_MS})

--post-ready-delay-ms <ms> Resource snapshot delay after next ready (default: ${DEFAULT_POST_READY_DELAY_MS})

--output <path> Write machine-readable JSON to a file

--json Emit machine-readable JSON

return predicate();

}

function resolvePhaseDeadlineAt(startedAt: number, timeoutMs: number): number {

return startedAt + timeoutMs;

}

async function runGatewaySample(options: {

benchCase: GatewayBenchCase;

entry: string;

const configPath = writeConfig(root, options.benchCase);

const env = sanitizedEnv(root, configPath, options.benchCase);

const sampleStartAt = performance.now();

const deadlineAt = sampleStartAt + options.timeoutMs;

const initialDeadlineAt = resolvePhaseDeadlineAt(sampleStartAt, options.timeoutMs);

const initialStartupTrace: Record<string, number> = {};

const events: BenchmarkEvent[] = [{ ms: 0, type: "process.spawn.start" }];

const output: string[] = [];

let failureCode: GatewayRestartFailureCode | null = null;

const initialHealthz = await waitForProbeReady({

deadlineAt,

deadlineAt: initialDeadlineAt,

isDone: () => childExited,

path: "/healthz",

port,

const initialReadyz =

failureCode === null

? await waitForProbeReady({

deadlineAt,

deadlineAt: initialDeadlineAt,

isDone: () => childExited,

path: "/readyz",

port,

flushOutputLineBuffers(outputBuffers, onLine, performance.now() - sampleStartAt);

await waitForIterationCondition(

() => hasInitialReadyLogs({ initialGatewayReadyLogMs, initialHttpListenLogMs }),

deadlineAt,

initialDeadlineAt,

);

flushOutputLineBuffers(outputBuffers, onLine, performance.now() - sampleStartAt);

if (!hasInitialReadyLogs({ initialGatewayReadyLogMs, initialHttpListenLogMs })) {

const iterations: RestartIteration[] = [];

if (failureCode === null) {

for (let index = 1; index <= options.restarts; index += 1) {

if (performance.now() >= deadlineAt || childExited) {

if (childExited) {

failureCode = resolveRestartDeadlineFailure(childExited);

break;

}

}

const signalSentAt = performance.now();

iteration.signalSentMs = signalSentAt - sampleStartAt;

const iterationDeadlineAt = resolvePhaseDeadlineAt(signalSentAt, options.timeoutMs);

events.push({ iteration: index, ms: iteration.signalSentMs, type: "restart-signal-sent" });

const healthzPromise = waitForRestartProbe({

deadlineAt,

deadlineAt: iterationDeadlineAt,

events,

isDone: () => hasRestartReadySignal(iteration),

isProcessDone: () => childExited,

signalSentAt,

});

const readyzPromise = waitForRestartProbe({

deadlineAt,

deadlineAt: iterationDeadlineAt,

events,

isDone: () => hasRestartReadySignal(iteration),

isProcessDone: () => childExited,

iteration.healthz = healthz;

iteration.readyz = readyz;

iteration.resourceSnapshots.push(snapshotResources(child, sampleStartAt, "after-next-ready"));

await waitForIterationCondition(() => hasRestartReadySignal(iteration), deadlineAt);

if (options.postReadyDelayMs > 0 && performance.now() < deadlineAt) {

await waitForIterationCondition(() => hasRestartReadySignal(iteration), iterationDeadlineAt);

if (options.postReadyDelayMs > 0 && performance.now() < iterationDeadlineAt) {

await delay(

Math.min(options.postReadyDelayMs, Math.max(0, deadlineAt - performance.now())),

Math.min(options.postReadyDelayMs, Math.max(0, iterationDeadlineAt - performance.now())),

);

}

iteration.resourceSnapshots.push(

parsePositiveInt,

resolveRestartDeadlineFailure,

resolveEntry,

resolvePhaseDeadlineAt,

sanitizedEnv,

shouldFailBenchmark,

summarizeCase,