let pendingRestartTimer: ReturnType<typeof setTimeout> | null = null;

let pendingRestartDueAt = 0;

let pendingRestartReason: string | undefined;

let pendingRestartEmitHooks: RestartEmitHooks | undefined;

const activeDeferralPolls = new Set<ReturnType<typeof setInterval>>();

function hasUnconsumedRestartSignal(): boolean {

pendingRestartTimer = null;

pendingRestartDueAt = 0;

pendingRestartReason = undefined;

pendingRestartEmitHooks = undefined;

}

function clearActiveDeferralPolls(): void {

afterEmitRejected?: () => Promise<void>;

};

function updatePendingRestartEmitHooks(hooks?: RestartEmitHooks): void {

if (hooks) {

pendingRestartEmitHooks = hooks;

}

}

async function emitPreparedGatewayRestart(hooks?: RestartEmitHooks): Promise<void> {

try {

await hooks?.beforeEmit?.();

restartLog.warn(

`restart request coalesced (already scheduled) reason=${reason ?? "unspecified"} pendingReason=${pendingRestartReason ?? "unspecified"} delayMs=${remainingMs} ${formatRestartAudit(opts?.audit)}`,

);

updatePendingRestartEmitHooks(opts?.emitHooks);

return {

ok: true,

pid: process.pid,

pendingRestartDueAt = requestedDueAt;

pendingRestartReason = reason;

pendingRestartEmitHooks = opts?.emitHooks;

pendingRestartTimer = setTimeout(

() => {

pendingRestartTimer = null;

pendingRestartDueAt = 0;

pendingRestartReason = undefined;

const emitHooks = pendingRestartEmitHooks;

pendingRestartEmitHooks = undefined;

const pendingCheck = preRestartCheck;

if (!pendingCheck) {

void emitPreparedGatewayRestart(opts?.emitHooks);

void emitPreparedGatewayRestart(emitHooks);

return;

}

const cfg = getRuntimeConfig();

deferGatewayRestartUntilIdle({

getPendingCount: pendingCheck,

maxWaitMs: cfg.gateway?.reload?.deferralTimeoutMs,

emitHooks: opts?.emitHooks,

emitHooks,

});

},

Math.max(0, requestedDueAt - nowMs),