@plainconceptsplatform/loop-task 2.6.0

package/dist/core/loop/chain-executor.js

@@ -0,0 +1,171 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { Writable } from "node:stream";
+import { DEFAULT_TASK_MAX_RUNS } from "../../types.js";
+import { executeCommand } from "../command/command-runner.js";
+import { t } from "../../shared/i18n/index.js";
+import { mergeCommandOutput } from "../context/context-parser.js";
+import { interpolate } from "../context/template.js";
+import { formatContextLog } from "../context/log-context.js";
+export function executeChain(options) {
+    const { chainTargetId, exitCode, task: _task, chainContext, cwd, signal, runCount, logPath, runHistory, logStream, controller, telemetryManager, loopId, loopName, runId, loopSpan } = options;
+    const nullStream = new Writable({ write(_chunk, _enc, cb) { cb(); } });
+    if (!chainTargetId) {
+        return Promise.resolve({ runHistory, lastExitCode: exitCode, lastDuration: 0 });
+    }
+    const chainGroupId = crypto.randomUUID().slice(0, 8);
+    const mainRecord = runHistory[runHistory.length - 1];
+    if (mainRecord)
+        mainRecord.chainGroupId = chainGroupId;
+    let currentTargetId = chainTargetId;
+    let prevBranch = exitCode === 0 ? "onSuccess" : "onFailure";
+    let prevExit = exitCode;
+    let totalExtraDuration = 0;
+    let finalExitCode = exitCode;
+    let hadSilentChain = false;
+    return (async () => {
+        while (currentTargetId) {
+            if (signal.aborted)
+                break;
+            const chainTask = controller.taskResolver(currentTargetId);
+            if (!chainTask)
+                break;
+            // Per-task maxRuns check for chained tasks
+            const chainTaskMaxRuns = chainTask.maxRuns ?? DEFAULT_TASK_MAX_RUNS;
+            const chainTaskRunCount = controller.getTaskRunCount(chainTask.id);
+            if (chainTaskRunCount >= chainTaskMaxRuns) {
+                // Chained task exceeded its max runs limit — fail it and continue chain
+                const chainRecord = runHistory.find(r => r.chainGroupId === chainGroupId && r.status === "running" && r.chainName === chainTask.name);
+                if (chainRecord) {
+                    chainRecord.exitCode = 1;
+                    chainRecord.duration = 0;
+                    chainRecord.logSize = 0;
+                    chainRecord.status = "completed";
+                }
+                totalExtraDuration += 0;
+                finalExitCode = 1;
+                currentTargetId = chainTask.onFailureTaskId ?? null;
+                prevBranch = "onFailure";
+                prevExit = 1;
+                continue;
+            }
+            const isSilent = chainTask.silentChain === true;
+            if (isSilent) {
+                controller.incrementSilentChainCount();
+                hadSilentChain = true;
+            }
+            if (logStream && !isSilent) {
+                logStream.write(t("loop.chainHeader", { name: chainTask.name, branch: prevBranch, prevExit }));
+            }
+            const chainStartedAt = new Date().toISOString();
+            const chainOffset = !isSilent && fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+            if (!isSilent) {
+                runHistory.push({
+                    runNumber: runCount,
+                    startedAt: chainStartedAt,
+                    exitCode: -1,
+                    duration: 0,
+                    logSize: 0,
+                    status: "running",
+                    logOffset: chainOffset,
+                    chainGroupId,
+                    chainName: chainTask.name,
+                });
+            }
+            const singleCommandFallback = {
+                command: chainTask.command,
+                commandArgs: chainTask.commandArgs,
+                commandRaw: chainTask.commandRaw,
+            };
+            const taskSteps = chainTask.steps?.length
+                ? chainTask.steps
+                : [{ commands: [singleCommandFallback] }];
+            const chainTaskHasChains = !!(chainTask.onSuccessTaskId || chainTask.onFailureTaskId);
+            const shouldCaptureStdout = chainTaskHasChains || taskSteps.length > 1 || taskSteps[0].commands.length > 1;
+            let chainExitCode = 0;
+            let chainDuration = 0;
+            const effectiveStream = isSilent ? nullStream : (logStream ?? nullStream);
+            if (!isSilent) {
+                effectiveStream.write(formatContextLog(chainContext));
+            }
+            // Telemetry: create task span for chained task
+            const telemetry = telemetryManager?.getAdapter();
+            const chainTaskSpan = (telemetry && chainTask)
+                ? telemetry.startTask({
+                    taskId: chainTask.id,
+                    taskName: chainTask.name,
+                    runId: runId ?? `chain-${chainGroupId}`,
+                    loopId: loopId ?? "chain",
+                    loopName: loopName ?? "chain",
+                }, loopSpan)
+                : undefined;
+            const chainTelemetryCtx = telemetry
+                ? {
+                    telemetry,
+                    loopSpan,
+                    taskSpan: chainTaskSpan,
+                    runId: runId ?? `chain-${chainGroupId}`,
+                    loopId: loopId ?? "chain",
+                    loopName: loopName ?? "chain",
+                    taskId: chainTask.id,
+                    taskName: chainTask.name,
+                    telemetryConfig: chainTask.telemetry,
+                }
+                : undefined;
+            for (const step of taskSteps) {
+                if (signal.aborted)
+                    break;
+                const stepResults = await Promise.allSettled(step.commands.map((cmd) => executeCommand(interpolate(cmd.command, chainContext), cmd.commandArgs.map(a => interpolate(a, chainContext)), cwd, effectiveStream, signal, runCount, shouldCaptureStdout, false, chainTelemetryCtx)));
+                if (signal.aborted)
+                    break;
+                let stepStdout = "";
+                let stepStderr = "";
+                for (const r of stepResults) {
+                    if (r.status === "fulfilled") {
+                        chainDuration += r.value.duration;
+                        if (r.value.stdout)
+                            stepStdout += (stepStdout ? "\n" : "") + r.value.stdout;
+                        if (r.value.stderr)
+                            stepStderr += (stepStderr ? "\n" : "") + r.value.stderr;
+                    }
+                }
+                if (shouldCaptureStdout && (stepStdout || stepStderr)) {
+                    mergeCommandOutput(chainContext, stepStdout, stepStderr);
+                }
+                const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
+                if (stepFailure) {
+                    const failed = stepResults.find((r) => r.status === "fulfilled" && r.value.exitCode !== 0);
+                    chainExitCode = failed ? failed.value.exitCode : 1;
+                    break;
+                }
+            }
+            const chainLogSize = !isSilent && fs.existsSync(logPath) ? fs.statSync(logPath).size - chainOffset : 0;
+            const chainRecord = runHistory.find(r => r.chainGroupId === chainGroupId && r.status === "running" && r.chainName === chainTask.name);
+            if (chainRecord) {
+                chainRecord.exitCode = chainExitCode;
+                chainRecord.duration = chainDuration;
+                chainRecord.logSize = Math.max(0, chainLogSize);
+                chainRecord.status = "completed";
+            }
+            totalExtraDuration += chainDuration;
+            finalExitCode = chainExitCode;
+            // End the chain task span
+            if (chainTaskSpan) {
+                chainTaskSpan.end(chainExitCode === 0 ? "ok" : "error");
+            }
+            // Increment per-task run counter for the chained task
+            controller.incrementTaskRunCount(chainTask.id);
+            currentTargetId = (chainExitCode === 0 ? chainTask.onSuccessTaskId : chainTask.onFailureTaskId) ?? null;
+            prevBranch = chainExitCode === 0 ? "onSuccess" : "onFailure";
+            prevExit = chainExitCode;
+        }
+        // If any silent chain task ran, remove all records for this chain group
+        // (including the main task record) — the run was uninteresting.
+        if (hadSilentChain) {
+            const filtered = runHistory.filter(r => r.chainGroupId !== chainGroupId);
+            runHistory.length = 0;
+            runHistory.push(...filtered);
+        }
+        return { runHistory, lastExitCode: finalExitCode, lastDuration: totalExtraDuration };
+    })();
+}

package/dist/core/loop/delay-utils.js

@@ -0,0 +1,65 @@
+import { sleep } from "../../shared/sleep.js";
+import { SLEEP_CHUNK_MS } from "../../shared/config/constants.js";
+export function waitForResume(ctrl) {
+    const savedStatus = ctrl._status;
+    ctrl._status = savedStatus === "idle" ? "idle" : "paused";
+    return new Promise((resolve) => {
+        ctrl.resumeResolve = resolve;
+    });
+}
+export async function waitForDelay(ctrl, ms, signal) {
+    let remaining = ms;
+    ctrl.remainingDelayMs = remaining;
+    let announced = false;
+    while (remaining > 0) {
+        if (ctrl._forceRun) {
+            ctrl._savedRemainingMs = remaining;
+            ctrl.remainingDelayMs = null;
+            ctrl.nextRunAt = null;
+            return true;
+        }
+        if (ctrl._resetSchedule) {
+            ctrl._resetSchedule = false;
+            remaining = ms;
+            ctrl.remainingDelayMs = remaining;
+            announced = false;
+        }
+        if (ctrl._paused) {
+            if (ctrl._status !== "idle") {
+                ctrl._status = "paused";
+            }
+            ctrl.emit("paused");
+            await waitForResume(ctrl);
+            announced = false;
+            if (signal.aborted) {
+                ctrl.remainingDelayMs = null;
+                return false;
+            }
+            if (ctrl._resetSchedule) {
+                ctrl._resetSchedule = false;
+                remaining = ms;
+                ctrl.remainingDelayMs = remaining;
+            }
+        }
+        if (!announced) {
+            ctrl._status = "waiting";
+            ctrl.nextRunAt = new Date(Date.now() + remaining).toISOString();
+            ctrl.emit("waiting");
+            announced = true;
+        }
+        const chunk = Math.min(remaining, SLEEP_CHUNK_MS);
+        const startedAt = Date.now();
+        try {
+            await sleep(chunk, signal);
+        }
+        catch {
+            ctrl.remainingDelayMs = null;
+            return false;
+        }
+        remaining = Math.max(0, remaining - (Date.now() - startedAt));
+        ctrl.remainingDelayMs = remaining;
+    }
+    ctrl.remainingDelayMs = null;
+    ctrl.nextRunAt = null;
+    return true;
+}

package/dist/core/loop/loop-controller.js

@@ -0,0 +1,240 @@
+import { EventEmitter } from "node:events";
+import { computePhase, alignToPhase } from "../scheduling/index.js";
+import { RotatingWriteStream } from "../logging/rotating-log-stream.js";
+import { runLoop } from "./loop-runner.js";
+export class LoopController extends EventEmitter {
+    getTaskRunCount(taskId) {
+        return this.taskRunCounts.get(taskId) ?? 0;
+    }
+    incrementTaskRunCount(taskId) {
+        const current = this.taskRunCounts.get(taskId) ?? 0;
+        this.taskRunCounts.set(taskId, current + 1);
+    }
+    resetTaskRunCounts() {
+        this.taskRunCounts.clear();
+    }
+    constructor(id, options, logPath, taskResolver, state, projectDirectory, telemetryManager) {
+        super();
+        this.runAbortController = null;
+        this._paused = false;
+        this._forceRun = false;
+        this._savedRemainingMs = null;
+        this._resetSchedule = false;
+        this._stopAfterRun = false;
+        this._maxRunsReached = false;
+        this._status = "running";
+        this.resumeResolve = null;
+        this.runCount = 0;
+        this.lastRunAt = null;
+        this.lastExitCode = null;
+        this.lastDuration = null;
+        this.nextRunAt = null;
+        this.remainingDelayMs = null;
+        this.logStream = null;
+        this.loopPromise = null;
+        this._loopActive = false;
+        this.sessionStartedAt = null;
+        this.runHistory = [];
+        this.currentRunStartOffset = 0;
+        this.skippedCount = 0;
+        this._silentChainCount = 0;
+        this._totalRunCount = 0;
+        this.taskRunCounts = new Map();
+        this.id = id;
+        this.options = options;
+        this.logPath = logPath;
+        this.taskResolver = taskResolver;
+        this.projectDirectory = projectDirectory;
+        this._telemetryManager = telemetryManager ?? null;
+        this.abortController = new AbortController();
+        this.createdAt = state?.createdAt ?? new Date().toISOString();
+        this.runCount = state?.runCount ?? 0;
+        this._maxRunsReached = state?.maxRunsReached ?? false;
+        this.sessionStartedAt = state?.sessionStartedAt ?? null;
+        this.lastRunAt = state?.lastRunAt ?? null;
+        this.lastExitCode = state?.lastExitCode ?? null;
+        this.lastDuration = state?.lastDuration ?? null;
+        this.nextRunAt = state?.nextRunAt ?? null;
+        this.remainingDelayMs = state?.remainingDelayMs ?? null;
+        this._status = state?.status ?? "running";
+        this._paused = state?.status === "paused" || state?.status === "idle";
+        this.runHistory = (state?.runHistory ?? []).map((r) => r.status === "running" ? { ...r, status: "completed" } : r).map((r) => ({ ...r, logOffset: r.logOffset ?? 0 }));
+        this.skippedCount = state?.skippedCount ?? 0;
+        this._silentChainCount = state?.silentChainCount ?? 0;
+        this._totalRunCount = state?.totalRunCount ?? this.runCount;
+    }
+    get status() {
+        return this._status;
+    }
+    get telemetryManager() {
+        return this._telemetryManager;
+    }
+    get silentChainCount() {
+        return this._silentChainCount;
+    }
+    incrementSilentChainCount() {
+        this._silentChainCount += 1;
+    }
+    start() {
+        if (this._loopActive)
+            return;
+        this._loopActive = true;
+        this.skippedCount = 0;
+        this.resetTaskRunCounts();
+        this.logStream?.end();
+        this.abortController = new AbortController();
+        this.logStream = RotatingWriteStream.create(this.logPath);
+        if (this.options.interval === 0 && !this._stopAfterRun) {
+            this._status = "idle";
+            this.nextRunAt = null;
+            this._loopActive = false;
+            this.emit("stopped");
+            return;
+        }
+        this.loopPromise = this.run().finally(() => { this._loopActive = false; });
+        if (this.sessionStartedAt === null) {
+            this.sessionStartedAt = new Date().toISOString();
+        }
+    }
+    pause(interruptCurrentRun = false) {
+        if (this._status === "running" || this._status === "waiting") {
+            this._paused = true;
+            this._status = "paused";
+            if (interruptCurrentRun && this._status === "paused") {
+                this.runAbortController?.abort();
+            }
+            this.emit("paused");
+        }
+    }
+    async stopLoop(interruptCurrentRun = false) {
+        if (this._status === "running" || this._status === "waiting" || this._status === "paused") {
+            this._paused = true;
+            this._status = "idle";
+            this.sessionStartedAt = null;
+            this.remainingDelayMs = null;
+            this.nextRunAt = null;
+            if (interruptCurrentRun) {
+                this.runAbortController?.abort();
+            }
+            this.abortController.abort();
+            if (this.resumeResolve) {
+                this.resumeResolve();
+                this.resumeResolve = null;
+            }
+            this.emit("stopped");
+            if (this.loopPromise) {
+                await this.loopPromise;
+            }
+        }
+    }
+    resume() {
+        if (this._status === "paused" && this._paused && this.resumeResolve) {
+            this._paused = false;
+            if (this.remainingDelayMs !== null) {
+                this._status = "waiting";
+                this.nextRunAt = new Date(Date.now() + this.remainingDelayMs).toISOString();
+            }
+            this.resumeResolve();
+            this.resumeResolve = null;
+            this.emit("resumed");
+        }
+    }
+    playLoop() {
+        if (this._status !== "idle")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
+            this._maxRunsReached = true;
+            return false;
+        }
+        if (this.options.interval === 0)
+            return false;
+        this.sessionStartedAt = new Date().toISOString();
+        this._resetSchedule = true;
+        this._paused = false;
+        const phase = this.options.offset !== null
+            ? this.options.offset
+            : computePhase(this.id, this.options.interval);
+        const delay = alignToPhase(Date.now(), this.options.interval, phase);
+        this.nextRunAt = new Date(Date.now() + delay).toISOString();
+        if (this.resumeResolve) {
+            this.resumeResolve();
+            this.resumeResolve = null;
+        }
+        this.start();
+        this._status = "waiting";
+        this.emit("resumed");
+        return true;
+    }
+    triggerNow() {
+        if (this._status === "running")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        const needsStart = this._status === "idle";
+        this._savedRemainingMs = this.remainingDelayMs;
+        this._forceRun = true;
+        if (needsStart) {
+            this._stopAfterRun = true;
+            this._paused = false;
+            this.start();
+            this._status = "running";
+        }
+        else {
+            if (this._paused)
+                this.resume();
+        }
+        this.emit("triggered");
+        return true;
+    }
+    async stop() {
+        this.abortController.abort();
+        if (this._paused)
+            this.resume();
+        if (this.loopPromise) {
+            await this.loopPromise;
+        }
+        this.logStream?.end();
+        this.logStream = null;
+    }
+    getMeta() {
+        return {
+            id: this.id,
+            taskId: this.options.taskId,
+            status: this._status,
+            createdAt: this.createdAt,
+            maxRunsReached: this._maxRunsReached,
+            sessionStartedAt: this.sessionStartedAt,
+            runCount: this.runCount,
+            lastRunAt: this.lastRunAt,
+            lastExitCode: this.lastExitCode,
+            lastDuration: this.lastDuration,
+            nextRunAt: this.nextRunAt,
+            remainingDelayMs: this.remainingDelayMs,
+            runHistory: this.runHistory,
+            skippedCount: this.skippedCount,
+            silentChainCount: this._silentChainCount,
+            totalRunCount: this._totalRunCount,
+        };
+    }
+    clearMaxRunsReached() {
+        this._maxRunsReached = false;
+        this._paused = false;
+        this._status = "idle";
+        this.remainingDelayMs = null;
+        this.nextRunAt = null;
+        this.runCount = 0;
+    }
+    isMaxRunsReached() {
+        return this._maxRunsReached;
+    }
+    checkLogRotation() {
+        if (this.logStream instanceof RotatingWriteStream) {
+            this.logStream.rotateIfNeeded();
+        }
+    }
+    run() {
+        return runLoop(this);
+    }
+}

package/dist/core/loop/loop-runner.js

@@ -0,0 +1,194 @@
+import { computePhase, alignToPhase } from "../scheduling/index.js";
+import { resolveEffectiveCwd } from "../command/resolve-cwd.js";
+import { executeChain } from "./chain-executor.js";
+import { executeRunImpl } from "./run-executor.js";
+import { waitForResume, waitForDelay } from "./delay-utils.js";
+import { MAX_INMEMORY_RUN_HISTORY } from "../../shared/config/constants.js";
+import { DEFAULT_TASK_MAX_RUNS } from "../../types.js";
+export async function runLoop(ctrl) {
+    const signal = ctrl.abortController.signal;
+    let isFirstRun = true;
+    try {
+        while (!signal.aborted) {
+            if (ctrl.options.maxRuns !== null && ctrl.runCount >= ctrl.options.maxRuns) {
+                ctrl._maxRunsReached = true;
+                ctrl._paused = true;
+                ctrl._status = "paused";
+                ctrl.emit("paused");
+                return;
+            }
+            if (isFirstRun && ctrl._paused) {
+                await waitForResume(ctrl);
+                if (signal.aborted)
+                    break;
+            }
+            if (isFirstRun && ctrl.nextRunAt) {
+                const delay = Math.max(0, new Date(ctrl.nextRunAt).getTime() - Date.now());
+                if (delay > 0) {
+                    const completed = await waitForDelay(ctrl, delay, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+            else if (isFirstRun && !ctrl.options.immediate) {
+                const phase = ctrl.options.offset !== null
+                    ? ctrl.options.offset
+                    : computePhase(ctrl.id, ctrl.options.interval);
+                const delay = alignToPhase(Date.now(), ctrl.options.interval, phase);
+                if (delay > 0) {
+                    ctrl.nextRunAt = new Date(Date.now() + delay).toISOString();
+                }
+                const completed = await waitForDelay(ctrl, delay, signal);
+                if (!completed)
+                    break;
+            }
+            isFirstRun = false;
+            if (ctrl._paused) {
+                await waitForResume(ctrl);
+                if (signal.aborted)
+                    break;
+            }
+            const runStartedAtMs = Date.now();
+            ctrl.resetTaskRunCounts();
+            let exitCode;
+            let totalDuration;
+            let chainContext;
+            const currentTask = ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId) : null;
+            const taskMaxRuns = currentTask?.maxRuns ?? DEFAULT_TASK_MAX_RUNS;
+            const currentTaskRunCount = ctrl.options.taskId ? ctrl.getTaskRunCount(ctrl.options.taskId) : 0;
+            if (ctrl.options.taskId && currentTaskRunCount >= taskMaxRuns) {
+                // Task exceeded its max runs limit — fail it
+                ctrl._status = "running";
+                ctrl._forceRun = false;
+                ctrl.runCount++;
+                ctrl.lastRunAt = new Date().toISOString();
+                if (ctrl.sessionStartedAt === null) {
+                    ctrl.sessionStartedAt = ctrl.lastRunAt;
+                }
+                ctrl.nextRunAt = null;
+                ctrl.emit("run:start", ctrl.runCount);
+                exitCode = 1;
+                totalDuration = 0;
+                chainContext = { ...(currentTask?.context ?? {}), ...(ctrl.options.context ?? {}) };
+                ctrl.runHistory.push({
+                    runNumber: ctrl.runCount,
+                    startedAt: ctrl.lastRunAt,
+                    exitCode,
+                    duration: totalDuration,
+                    logSize: 0,
+                    status: "completed",
+                    logOffset: ctrl.currentRunStartOffset,
+                });
+                ctrl.lastExitCode = exitCode;
+                ctrl.lastDuration = totalDuration;
+            }
+            else {
+                const result = await executeRunImpl(ctrl, signal);
+                exitCode = result.exitCode;
+                totalDuration = result.totalDuration;
+                chainContext = result.chainContext;
+                // Increment per-task run counter after successful execution
+                if (ctrl.options.taskId) {
+                    ctrl.incrementTaskRunCount(ctrl.options.taskId);
+                }
+                // Save for chain executor
+                ctrl.__lastRunId = result.runId;
+                ctrl.__lastLoopSpan = result.loopSpan;
+            }
+            const chainTargetId = exitCode === 0
+                ? (ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId)?.onSuccessTaskId : undefined)
+                : (ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId)?.onFailureTaskId : undefined);
+            if (chainTargetId && !signal.aborted) {
+                const task = ctrl.options.taskId ? ctrl.taskResolver(ctrl.options.taskId) : null;
+                const cwd = resolveEffectiveCwd(ctrl.options.cwd, ctrl.projectDirectory);
+                const lastRunId = ctrl.__lastRunId;
+                const lastLoopSpan = ctrl.__lastLoopSpan;
+                const chainResult = await executeChain({
+                    chainTargetId,
+                    exitCode,
+                    task,
+                    chainContext,
+                    cwd,
+                    signal,
+                    runCount: ctrl.runCount,
+                    logPath: ctrl.logPath,
+                    runHistory: ctrl.runHistory,
+                    logStream: ctrl.logStream,
+                    controller: ctrl,
+                    telemetryManager: ctrl.telemetryManager,
+                    loopId: ctrl.id,
+                    loopName: ctrl.options.description || ctrl.id,
+                    runId: lastRunId,
+                    loopSpan: lastLoopSpan,
+                });
+                ctrl.runHistory = chainResult.runHistory;
+                ctrl.lastExitCode = chainResult.lastExitCode;
+                ctrl.lastDuration = (ctrl.lastDuration ?? 0) + chainResult.lastDuration;
+            }
+            if (ctrl.runHistory.length > MAX_INMEMORY_RUN_HISTORY) {
+                ctrl.runHistory = ctrl.runHistory.slice(-MAX_INMEMORY_RUN_HISTORY);
+            }
+            ctrl.emit("run:end", { exitCode, duration: totalDuration });
+            if (signal.aborted)
+                break;
+            if (ctrl.options.maxRuns !== null && ctrl.runCount >= ctrl.options.maxRuns) {
+                ctrl._maxRunsReached = true;
+                ctrl._paused = true;
+                ctrl._status = "paused";
+                ctrl.remainingDelayMs = null;
+                ctrl.nextRunAt = null;
+                ctrl.emit("paused");
+                return;
+            }
+            if (ctrl._stopAfterRun) {
+                ctrl._stopAfterRun = false;
+                ctrl._paused = true;
+                ctrl._status = "idle";
+                ctrl.remainingDelayMs = null;
+                ctrl.nextRunAt = null;
+                ctrl.emit("stopped");
+                return;
+            }
+            const saved = ctrl._savedRemainingMs;
+            ctrl._savedRemainingMs = null;
+            if (saved !== null) {
+                const remaining = Math.max(0, saved - totalDuration);
+                if (remaining > 0) {
+                    const completed = await waitForDelay(ctrl, remaining, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+            else {
+                if (ctrl.options.interval === 0) {
+                    ctrl._paused = true;
+                    ctrl._status = "idle";
+                    ctrl.remainingDelayMs = null;
+                    ctrl.nextRunAt = null;
+                    ctrl.emit("stopped");
+                    return;
+                }
+                const nextSlotMs = runStartedAtMs + ctrl.options.interval;
+                const overrunMs = Date.now() - nextSlotMs;
+                if (overrunMs >= 0) {
+                    const missed = Math.floor(overrunMs / ctrl.options.interval) + 1;
+                    ctrl.skippedCount += missed;
+                    const adjustedDelay = ctrl.options.interval - (overrunMs % ctrl.options.interval);
+                    const completed = await waitForDelay(ctrl, adjustedDelay, signal);
+                    if (!completed)
+                        break;
+                }
+                else {
+                    const completed = await waitForDelay(ctrl, ctrl.options.interval, signal);
+                    if (!completed)
+                        break;
+                }
+            }
+        }
+    }
+    finally {
+        if (ctrl._status !== "idle" && ctrl._status !== "paused" && !ctrl._maxRunsReached) {
+            ctrl._status = "idle";
+        }
+    }
+}