@rebasepro/server 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/{cron-routes-Bc-SB0Se.js → cron-routes-OD6BstUj.js}

@@ -3,10 +3,10 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
-import { r as isAlreadyExecutingSkip } from "./cron-scheduler-CYQgco86.js";
+import { r as isAlreadyExecutingSkip } from "./cron-scheduler-idtLPoN-.js";
 import { r as logger } from "./logger-D-S-hO5e.js";
+import { a as resolveListLimitParam } from "./query-parser-4WkMoA_K.js";
 import { r as errorHandler, t as ApiError } from "./errors-D6_y86c5.js";
-import { a as resolveListLimitParam } from "./query-parser-BgiKJKvc.js";
 import { Hono } from "hono";
 //#region src/cron/cron-routes.ts
 var cron_routes_exports = /* @__PURE__ */ __exportAll({ createCronRoutes: () => createCronRoutes });
@@ -18,12 +18,24 @@ function actorOf(c) {
 	return apiKey ? `api-key:${apiKey.id}` : void 0;
 }
 /**
+* The manual trigger's `?async` switch. Absent means synchronous, as it always
+* was; anything other than a plain yes or no is refused rather than read as
+* one, so `?async=yes-please` does not quietly hold the request open.
+*/
+function readAsyncFlag(raw) {
+	if (raw === void 0) return false;
+	const value = raw.trim().toLowerCase();
+	if (value === "1" || value === "true") return true;
+	if (value === "" || value === "0" || value === "false") return false;
+	throw ApiError.badRequest(`?async must be 1, true, 0 or false — got "${raw}"`);
+}
+/**
 * Create admin REST routes for managing cron jobs.
 *
 * Routes:
 *   GET    /          → list all cron jobs
 *   GET    /:id       → get a single job's status
-*   POST   /:id/trigger → manually trigger a job
+*   POST   /:id/trigger → manually trigger a job (`?async=1`: 202 once it has started)
 *   GET    /:id/logs  → get execution logs for a job
 *   PUT    /:id       → update job (enable/disable, or `null` to follow the code)
 *
@@ -56,7 +68,18 @@ function createCronRoutes(scheduler, skipped = 0) {
 	});
 	router.post("/:id/trigger", async (c) => {
 		const id = c.req.param("id");
+		const asyncRun = readAsyncFlag(c.req.query("async"));
 		if (!scheduler.getJob(id)) throw ApiError.notFound(`Cron job "${id}" not found`);
+		if (asyncRun) {
+			const outcome = await scheduler.startJob(id);
+			if (!outcome) throw ApiError.notFound(`Cron job "${id}" not found`);
+			if (!outcome.started) throw ApiError.conflict(`Cron job "${id}" is already executing — try again when that run has finished`, "CRON_JOB_ALREADY_EXECUTING", { log: outcome.log });
+			return c.json({
+				accepted: true,
+				startedAt: outcome.startedAt,
+				job: await scheduler.fetchJob(id)
+			}, 202);
+		}
 		const log = await scheduler.triggerJob(id);
 		if (log && isAlreadyExecutingSkip(log)) throw ApiError.conflict(`Cron job "${id}" is already executing — try again when that run has finished`, "CRON_JOB_ALREADY_EXECUTING", { log });
 		return c.json({
@@ -93,4 +116,4 @@ function createCronRoutes(scheduler, skipped = 0) {
 //#endregion
 export { cron_routes_exports as n, createCronRoutes as t };
 
-//# sourceMappingURL=cron-routes-Bc-SB0Se.js.map
+//# sourceMappingURL=cron-routes-OD6BstUj.js.map

package/dist/cron-routes-OD6BstUj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-routes-OD6BstUj.js","names":[],"sources":["../src/cron/cron-routes.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport type { Context } from \"hono\";\nimport type { HonoEnv } from \"../api/types\";\nimport { isAlreadyExecutingSkip, type CronScheduler } from \"./cron-scheduler\";\nimport { ApiError, errorHandler } from \"../api/errors\";\nimport { resolveListLimitParam } from \"../api/rest/query-parser\";\nimport { logger } from \"../utils/logger.js\";\n\n/** Who made a change, as `cron_job_state.updated_by` records it. */\nfunction actorOf(c: Context<HonoEnv>): string | undefined {\n    const user = c.get(\"user\");\n    if (typeof user === \"object\" && user !== null && typeof user.uid === \"string\") return user.uid;\n    const apiKey = c.get(\"apiKey\");\n    return apiKey ? `api-key:${apiKey.id}` : undefined;\n}\n\n/**\n * The manual trigger's `?async` switch. Absent means synchronous, as it always\n * was; anything other than a plain yes or no is refused rather than read as\n * one, so `?async=yes-please` does not quietly hold the request open.\n */\nfunction readAsyncFlag(raw: string | undefined): boolean {\n    if (raw === undefined) return false;\n    const value = raw.trim().toLowerCase();\n    if (value === \"1\" || value === \"true\") return true;\n    if (value === \"\" || value === \"0\" || value === \"false\") return false;\n    throw ApiError.badRequest(`?async must be 1, true, 0 or false — got \"${raw}\"`);\n}\n\n/**\n * Create admin REST routes for managing cron jobs.\n *\n * Routes:\n *   GET    /          → list all cron jobs\n *   GET    /:id       → get a single job's status\n *   POST   /:id/trigger → manually trigger a job (`?async=1`: 202 once it has started)\n *   GET    /:id/logs  → get execution logs for a job\n *   PUT    /:id       → update job (enable/disable, or `null` to follow the code)\n *\n * Every answer about a job's state is read from the store, not from this\n * process's memory: the process serving these routes is often not the one\n * running the jobs (the `api` role never starts its scheduler), and is only\n * ever one replica of several.\n */\nexport function createCronRoutes(scheduler: CronScheduler, skipped = 0): Hono<HonoEnv> {\n    const router = new Hono<HonoEnv>();\n    // Hono's onError does NOT propagate from parent to child routers, so this\n    // child router registers its own handler to format thrown ApiErrors.\n    router.onError(errorHandler);\n\n    // List all jobs\n    router.get(\"/\", async (c) => {\n        const jobs = await scheduler.fetchJobs();\n        // A file that failed to load is not a job, so it appears nowhere in\n        // this list — and \"my job is missing\" and \"my job is not scheduled\"\n        // look identical from here. Say how many were dropped, as the\n        // functions listing does, so the Studio panel and anyone with curl can\n        // see it without boot-log access.\n        //\n        // Two ways to be dropped, counted together and reported apart. A file\n        // the loader could not read has only a count: the failure happened\n        // before there was a job to name. A schedule the scheduler refused has a\n        // name and a reason — most often \"Expected 5 fields, got 6\", from an\n        // expression copied out of a tool that supports seconds — and quoting it\n        // here turns a job that silently never fires into a one-line fix.\n        const rejected = scheduler.listRejectedJobs();\n        const total = skipped + rejected.length;\n        return c.json({\n            jobs,\n            ...(total > 0 && {\n                skipped: total,\n                ...(rejected.length > 0 && { rejected }),\n                note: [\n                    skipped > 0 ? `${skipped} cron file(s) failed to load` : undefined,\n                    // Not \"an invalid schedule\": a job is also refused for an\n                    // unknown timezone or a timeout that is not a positive\n                    // number, and `rejected` says which.\n                    rejected.length > 0 ? `${rejected.length} job(s) were refused` : undefined\n                ].filter(Boolean).join(\" and \") +\n                    \" — NOT scheduled. \" +\n                    (rejected.length > 0\n                        ? \"See `rejected` for the reason; \"\n                        : \"\") +\n                    \"the server log has the rest.\"\n            })\n        });\n    });\n\n    // Get single job\n    router.get(\"/:id\", async (c) => {\n        const id = c.req.param(\"id\");\n        const job = await scheduler.fetchJob(id);\n        if (!job) {\n            throw ApiError.notFound(`Cron job \"${id}\" not found`);\n        }\n        return c.json({ job });\n    });\n\n    // Trigger a job manually\n    router.post(\"/:id/trigger\", async (c) => {\n        const id = c.req.param(\"id\");\n        const asyncRun = readAsyncFlag(c.req.query(\"async\"));\n        const job = scheduler.getJob(id);\n        if (!job) {\n            throw ApiError.notFound(`Cron job \"${id}\" not found`);\n        }\n\n        // `?async=1`: answer once the run has started rather than when it\n        // ends. A long job's synchronous answer is cut by any proxy with a\n        // shorter timeout than the job (60 s is common) while the run carries\n        // on; this one is not. The outcome is in `GET /:id/logs`, as the entry\n        // with `manual: true` and this `startedAt`.\n        if (asyncRun) {\n            const outcome = await scheduler.startJob(id);\n            if (!outcome) throw ApiError.notFound(`Cron job \"${id}\" not found`);\n            if (!outcome.started) {\n                throw ApiError.conflict(\n                    `Cron job \"${id}\" is already executing — try again when that run has finished`,\n                    \"CRON_JOB_ALREADY_EXECUTING\",\n                    { log: outcome.log }\n                );\n            }\n            return c.json({\n                accepted: true,\n                startedAt: outcome.startedAt,\n                job: await scheduler.fetchJob(id)\n            }, 202);\n        }\n\n        const log = await scheduler.triggerJob(id);\n        // Nothing ran, so this is not a success: the job is executing already —\n        // on this process, or on whichever one holds its run lease (the worker,\n        // seen from the api role). The skip is in the run history either way;\n        // `details.log` carries it, and its line names the process.\n        if (log && isAlreadyExecutingSkip(log)) {\n            throw ApiError.conflict(\n                `Cron job \"${id}\" is already executing — try again when that run has finished`,\n                \"CRON_JOB_ALREADY_EXECUTING\",\n                { log }\n            );\n        }\n        return c.json({ log,\njob: await scheduler.fetchJob(id) });\n    });\n\n    // Get job logs\n    router.get(\"/:id/logs\", async (c) => {\n        const id = c.req.param(\"id\");\n        // Validated, not `parseInt`-ed. `?limit=abc` used to reach the store as\n        // `NaN`, where Postgres refused `LIMIT NaN`, the store swallowed the\n        // error and returned `[]` — a 200 with an empty list, which reads as\n        // \"this job has never run\". The data plane answers 400 for the same\n        // input; so does this now.\n        const limit = resolveListLimitParam(c.req.query(\"limit\") ?? null, { defaultLimit: 50 });\n\n        const job = scheduler.getJob(id);\n        if (!job) {\n            throw ApiError.notFound(`Cron job \"${id}\" not found`);\n        }\n\n        const logs = await scheduler.getJobLogsFromDb(id, limit).catch((err: unknown) => {\n            // Not an empty 200: Studio shows that as \"No executions yet\".\n            logger.error(`[cron] Could not read the run history of \"${id}\"`, { error: err });\n            throw ApiError.serviceUnavailable(\n                `The run history of cron job \"${id}\" could not be read. The server log has the reason.`\n            );\n        });\n        return c.json({ logs });\n    });\n\n    // Enable/disable a job — for every process, and across redeploys\n    router.put(\"/:id\", async (c) => {\n        const id = c.req.param(\"id\");\n        const body: unknown = await c.req.json().catch(() => ({}));\n        const enabled = typeof body === \"object\" && body !== null && \"enabled\" in body ? body.enabled : undefined;\n\n        if (typeof enabled !== \"boolean\" && enabled !== null) {\n            throw ApiError.badRequest(\n                \"Missing 'enabled' in body: true or false to override the job's code, or null to follow it again\"\n            );\n        }\n\n        if (!scheduler.getJob(id)) {\n            throw ApiError.notFound(`Cron job \"${id}\" not found`);\n        }\n\n        try {\n            await scheduler.persistJobEnabled(id, enabled, actorOf(c));\n        } catch (err) {\n            logger.error(`[cron] Could not save the enabled state of \"${id}\"`, { error: err });\n            throw ApiError.serviceUnavailable(\n                `The change to cron job \"${id}\" could not be saved, so no process was changed. ` +\n                \"The server log has the reason.\"\n            );\n        }\n\n        return c.json({ job: await scheduler.fetchJob(id) });\n    });\n\n    return router;\n}\n"],"mappings":"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"}

package/dist/{cron-scheduler-CYQgco86.js → cron-scheduler-idtLPoN-.js}

@@ -3,7 +3,7 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
-import "./src-CatHFUym.js";
+import "./src-D5Y3N-S4.js";
 import { a as redactSensitiveText, r as logger, s as stringifyForLog } from "./logger-D-S-hO5e.js";
 import { randomUUID } from "node:crypto";
 import { hostname } from "node:os";
@@ -149,6 +149,8 @@ function buildScaleToZeroWarning(jobs, env = process.env) {
 //#region src/cron/cron-scheduler.ts
 var cron_scheduler_exports = /* @__PURE__ */ __exportAll({
 	CronScheduler: () => CronScheduler,
+	MAX_CAPTURED_LOG_BYTES: () => MAX_CAPTURED_LOG_BYTES,
+	MAX_CAPTURED_LOG_LINES: () => 500,
 	findMostRecentSlot: () => findMostRecentSlot,
 	isAlreadyExecutingSkip: () => isAlreadyExecutingSkip,
 	isValidTimeZone: () => isValidTimeZone,
@@ -295,6 +297,7 @@ function wallClockIn(candidate, zone) {
 			timeZone: zone,
 			hourCycle: "h23",
 			weekday: "short",
+			year: "numeric",
 			month: "numeric",
 			day: "numeric",
 			hour: "numeric",
@@ -305,6 +308,7 @@ function wallClockIn(candidate, zone) {
 	const parts = {};
 	for (const part of formatter.formatToParts(candidate)) parts[part.type] = part.value;
 	return {
+		year: Number(parts.year),
 		minute: Number(parts.minute),
 		hour: Number(parts.hour),
 		dom: Number(parts.day),
@@ -313,21 +317,69 @@ function wallClockIn(candidate, zone) {
 	};
 }
 /**
-* Whether a minute-precision instant matches every field of the expression.
-*
-* Read in `zone` when one is named, else in the process's own zone — which is
-* whatever the host is set to, UTC in nearly every container. A schedule that
-* names its zone means the same wall-clock hour on every host it runs on.
+* The wall clock an instant reads in `zone` when one is named, else in the
+* process's own zone — which is whatever the host is set to, UTC in nearly
+* every container. A schedule that names its zone means the same wall-clock
+* hour on every host it runs on.
 */
-function matchesCronFields(candidate, fields, zone) {
-	const wall = zone ? wallClockIn(candidate, zone) : {
+function wallClockOf(instantMs, zone) {
+	const candidate = new Date(instantMs);
+	if (zone) return wallClockIn(candidate, zone);
+	return {
+		year: candidate.getFullYear(),
 		minute: candidate.getMinutes(),
 		hour: candidate.getHours(),
 		dom: candidate.getDate(),
 		month: candidate.getMonth() + 1,
 		dow: candidate.getDay()
 	};
-	return fields.months.includes(wall.month) && fields.doms.includes(wall.dom) && fields.dows.includes(wall.dow) && fields.hours.includes(wall.hour) && fields.minutes.includes(wall.minute);
+}
+/**
+* The zone's offset from UTC at an instant: its wall clock read back as UTC,
+* minus the instant. Two instants with the same offset have wall clocks
+* exactly as far apart as the instants themselves.
+*/
+function offsetAt(instantMs, wall) {
+	return Date.UTC(wall.year, wall.month - 1, wall.dom, wall.hour, wall.minute) - instantMs;
+}
+/** Whether a wall-clock day — month, day of month, weekday — can hold a slot. */
+function dayMatches(wall, fields) {
+	return fields.months.includes(wall.month) && fields.doms.includes(wall.dom) && fields.dows.includes(wall.dow);
+}
+/** Whether a wall-clock minute matches every field of the expression. */
+function wallMatches(wall, fields) {
+	return dayMatches(wall, fields) && fields.hours.includes(wall.hour) && fields.minutes.includes(wall.minute);
+}
+var MINUTES_PER_DAY = 1440;
+/**
+* How many wall-clock minutes from a non-matching `wall` to the first later
+* wall minute that could match. Never past the next wall midnight, so the
+* minutes in between share `wall`'s day and every one of them is a miss.
+*/
+function wallMinutesToNextCandidate(wall, fields) {
+	const minuteOfDay = wall.hour * 60 + wall.minute;
+	if (!dayMatches(wall, fields)) return MINUTES_PER_DAY - minuteOfDay;
+	if (!fields.hours.includes(wall.hour)) {
+		const nextHour = fields.hours.find((hour) => hour > wall.hour);
+		return nextHour === void 0 ? MINUTES_PER_DAY - minuteOfDay : nextHour * 60 - minuteOfDay;
+	}
+	const nextMinute = fields.minutes.find((minute) => minute > wall.minute);
+	return nextMinute === void 0 ? 60 - wall.minute : nextMinute - wall.minute;
+}
+/**
+* The mirror of {@link wallMinutesToNextCandidate}: how many wall-clock
+* minutes back from a non-matching `wall` to the latest earlier wall minute
+* that could match. Never before 23:59 of the previous wall day.
+*/
+function wallMinutesToPreviousCandidate(wall, fields) {
+	const minuteOfDay = wall.hour * 60 + wall.minute;
+	if (!dayMatches(wall, fields)) return minuteOfDay + 1;
+	if (!fields.hours.includes(wall.hour)) {
+		const previousHour = [...fields.hours].reverse().find((hour) => hour < wall.hour);
+		return previousHour === void 0 ? minuteOfDay + 1 : minuteOfDay - (previousHour * 60 + 59);
+	}
+	const previousMinute = [...fields.minutes].reverse().find((minute) => minute < wall.minute);
+	return previousMinute === void 0 ? wall.minute + 1 : wall.minute - previousMinute;
 }
 /**
 * How far forward to look for the next matching slot.
@@ -339,27 +391,86 @@ function matchesCronFields(candidate, fields, zone) {
 var MAX_SLOT_SEARCH_MINUTES = 2105280;
 var MINUTE_MS = 6e4;
 /**
+* The first real minute in `[startMs, endMs)`, stepping in `direction`, whose
+* wall clock matches `fields` — the same answer as testing every minute in
+* turn, without testing every minute.
+*
+* The search moves through *real* minutes and only reads the wall clock, never
+* steps it: across a daylight-saving change a wall-clock minute is not a real
+* one. Falling back, a wall-clock step from 02:59 summer time lands on 03:00
+* winter time and skips the repeated hour; inside it, the "next" minute can be
+* an hour in the past. That is why this used to test one real minute at a
+* time — and a yearly job named in a zone cost half a million `Intl` calls,
+* blocking the event loop for a third of a second on every re-arm, and two
+* seconds for 29 February.
+*
+* Now it hops. From a miss, {@link wallMinutesToNextCandidate} says how many
+* wall minutes cannot match (the rest of a day that is the wrong date, the
+* rest of an hour that is the wrong hour, the minutes before the next listed
+* one). While the zone's offset holds, that many wall minutes are exactly
+* that many real minutes, so the hop is taken when the offset at both ends is
+* the same. When it differs, a transition lies inside the hop: the search
+* bisects for the first minute on the new offset and resumes there — every
+* minute before it is on the old offset, so its wall clock is inside the
+* stretch already known to miss. A hop is at most a day, and the one thing
+* this assumes is that no zone changes its offset and changes it back within
+* a single day, which none in the tz database does. Each day costs one
+* wall-clock read, plus about a dozen for each transition crossed.
+*
+* `direction: -1` walks back from `startMs` to `endMs` (inclusive) with the
+* mirror of the same hop, for {@link findMostRecentSlot}.
+*/
+function searchSlot(fields, startMs, endMs, direction, zone) {
+	const inWindow = (instantMs) => direction === 1 ? instantMs < endMs : instantMs >= endMs;
+	let current = startMs;
+	let wall = wallClockOf(current, zone);
+	while (inWindow(current)) {
+		if (wallMatches(wall, fields)) return current;
+		const skip = direction === 1 ? wallMinutesToNextCandidate(wall, fields) : wallMinutesToPreviousCandidate(wall, fields);
+		const target = current + direction * skip * MINUTE_MS;
+		const targetWall = wallClockOf(target, zone);
+		const offset = offsetAt(current, wall);
+		if (skip === 1 || offsetAt(target, targetWall) === offset) {
+			current = target;
+			wall = targetWall;
+			continue;
+		}
+		let held = current;
+		let changed = target;
+		let changedWall = targetWall;
+		while (Math.abs(changed - held) > MINUTE_MS) {
+			const middle = held + direction * Math.floor(Math.abs(changed - held) / MINUTE_MS / 2) * MINUTE_MS;
+			const middleWall = wallClockOf(middle, zone);
+			if (offsetAt(middle, middleWall) === offset) held = middle;
+			else {
+				changed = middle;
+				changedWall = middleWall;
+			}
+		}
+		current = changed;
+		wall = changedWall;
+	}
+}
+/**
 * Calculate the next Date after `after` that matches the cron expression.
 * Throws on invalid expressions.
 */
 function parseCronExpression(expression, after, timezone) {
 	const fields = parseCronFields(expression);
-	const candidate = new Date(after);
-	candidate.setUTCSeconds(0, 0);
-	candidate.setTime(candidate.getTime() + MINUTE_MS);
-	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES; i++) {
-		if (matchesCronFields(candidate, fields, timezone)) return candidate;
-		candidate.setTime(candidate.getTime() + MINUTE_MS);
-	}
+	const start = new Date(after);
+	start.setUTCSeconds(0, 0);
+	const startMs = start.getTime() + MINUTE_MS;
+	const slot = searchSlot(fields, startMs, startMs + MAX_SLOT_SEARCH_MINUTES * MINUTE_MS, 1, timezone);
+	if (slot !== void 0) return new Date(slot);
 	throw new Error(`Cron expression "${expression}" has no matching time within ${Math.round(MAX_SLOT_SEARCH_MINUTES / 525960)} years of ${after.toISOString()}. Check the day-of-month and month fields — a date such as 31 February never occurs.`);
 }
 /**
 * The latest slot matching `expression` within the inclusive window
 * `[from, to]`, or `undefined` when the expression has no slot in it.
 *
-* Walks backwards a minute at a time from `to`, so the first hit is already
-* the answer — in the common case (a job that ran normally moments ago) that
-* is a handful of iterations, not a scan of the whole window.
+* Walks backwards from `to`, so the first hit is already the answer — in the
+* common case (a job that ran normally moments ago) that is a handful of
+* steps, not a scan of the whole window.
 *
 * `to`'s own minute is included: an instance booting at 06:00:30 has *not* run
 * the 06:00 slot — `parseCronExpression` already skipped past it to tomorrow —
@@ -371,14 +482,46 @@ function parseCronExpression(expression, after, timezone) {
 */
 function findMostRecentSlot(expression, from, to, timezone) {
 	const fields = parseCronFields(expression);
-	const candidate = new Date(to);
-	candidate.setUTCSeconds(0, 0);
-	for (let i = 0; i < MAX_SLOT_SEARCH_MINUTES && candidate.getTime() >= from.getTime(); i++) {
-		if (matchesCronFields(candidate, fields, timezone)) return candidate;
-		candidate.setTime(candidate.getTime() - MINUTE_MS);
-	}
+	const start = new Date(to);
+	start.setUTCSeconds(0, 0);
+	const startMs = start.getTime();
+	const slot = searchSlot(fields, startMs, Math.max(from.getTime(), startMs - (MAX_SLOT_SEARCH_MINUTES - 1) * MINUTE_MS), -1, timezone);
+	return slot === void 0 ? void 0 : new Date(slot);
 }
 var MAX_LOGS_PER_JOB = 50;
+var MAX_CAPTURED_LOG_BYTES = 64 * 1024;
+/**
+* A run's `ctx.log` capture, capped at {@link MAX_CAPTURED_LOG_LINES} and
+* {@link MAX_CAPTURED_LOG_BYTES}. The kept lines are the first ones: once one
+* line is dropped, every later one is too, so the history reads as a prefix of
+* the run's output and never as lines with gaps between them.
+*/
+function createLogCapture(firstLine) {
+	const lines = [];
+	let bytes = 0;
+	let dropped = 0;
+	let closed = false;
+	const capture = {
+		add(line) {
+			if (closed) return;
+			const size = Buffer.byteLength(line, "utf8");
+			if (dropped === 0 && lines.length < 500 && bytes + size <= 65536) {
+				lines.push(line);
+				bytes += size;
+				return;
+			}
+			dropped++;
+		},
+		/** The lines kept, and the line that says what was not. Later `add`s are ignored. */
+		close() {
+			if (!closed && dropped > 0) lines.push(`… ${dropped} more line${dropped === 1 ? "" : "s"} not kept — see the server log`);
+			closed = true;
+			return lines;
+		}
+	};
+	if (firstLine !== void 0) capture.add(firstLine);
+	return capture;
+}
 /**
 * Minimum milliseconds between scheduled executions of the same job.
 * Prevents tight re-execution loops caused by jitter or clock drift.
@@ -410,6 +553,12 @@ function setLongTimeout(callback, delayMs) {
 /** A run's timeout when its definition names none. */
 var DEFAULT_TIMEOUT_SECONDS = 300;
 /**
+* How often a started scheduler deletes slot claims and run history past
+* retention. Both accrue one row per job per fire, so a scheduler that lives
+* for months needs to prune while it runs, not only when it next boots.
+*/
+var CLAIM_SWEEP_INTERVAL_MS = 60 * 6e4;
+/**
 * How long a run lease outlasts the run's own timeout.
 *
 * The lease is timed on the database's clock from the moment it is taken, the
@@ -469,6 +618,10 @@ var CronScheduler = class {
 	* ever clear the lease that run took.
 	*/
 	instanceLabel = `${hostname()}:${process.pid}`;
+	/** The hourly claim- and log-retention sweep, while the scheduler is started with a store. */
+	claimSweepTimer;
+	sweepingClaims = false;
+	sweepingLogs = false;
 	/**
 	* Set the server singleton to make it available to cron job handlers.
 	*
@@ -559,8 +712,48 @@ var CronScheduler = class {
 		if (!this.store) logger.warn("[cron] No cron store attached — runs are uncoordinated; with multiple app instances every instance will execute every job");
 		this.warnIfScaleToZero();
 		this.catchUpMissedSlots();
+		if (this.store?.sweepClaims || this.store?.sweepLogs) {
+			const sweep = () => {
+				this.sweepClaims();
+				this.sweepLogs();
+			};
+			sweep();
+			this.claimSweepTimer = setInterval(sweep, CLAIM_SWEEP_INTERVAL_MS);
+			this.claimSweepTimer.unref?.();
+		}
 		logger.info(`⏰ Cron scheduler started with ${this.jobs.size} job(s)`);
 	}
+	/** Delete slot claims past retention. Failures are logged; the next hour tries again. */
+	async sweepClaims() {
+		const store = this.store;
+		if (!store?.sweepClaims || this.sweepingClaims) return;
+		this.sweepingClaims = true;
+		try {
+			await store.sweepClaims();
+		} catch (err) {
+			logger.warn("[cron] The claim retention sweep failed; it runs again within the hour", { error: err });
+		} finally {
+			this.sweepingClaims = false;
+		}
+	}
+	/**
+	* Delete run history past retention, and count the runs not counted yet.
+	* Failures are logged; the next hour tries again, from where this one
+	* stopped — each batch it finished is committed.
+	*/
+	async sweepLogs() {
+		const store = this.store;
+		if (!store?.sweepLogs || this.sweepingLogs) return;
+		this.sweepingLogs = true;
+		try {
+			const { counted } = await store.sweepLogs();
+			if (counted > 0) logger.info(`[cron] Counted ${counted} earlier run(s) into the jobs' run totals`);
+		} catch (err) {
+			logger.warn("[cron] The run history sweep failed; it runs again within the hour", { error: err });
+		} finally {
+			this.sweepingLogs = false;
+		}
+	}
 	/**
 	* Stop the scheduler: clear every timer, then wait for the runs executing
 	* right now — for at most `timeoutMs` when given.
@@ -576,6 +769,10 @@ var CronScheduler = class {
 	async stop(timeoutMs) {
 		this.started = false;
 		for (const [id] of this.jobs) this.stopJob(id);
+		if (this.claimSweepTimer) {
+			clearInterval(this.claimSweepTimer);
+			this.claimSweepTimer = void 0;
+		}
 		if (this.inFlight.size === 0) return;
 		const settled = Promise.allSettled([...this.inFlight]).then(() => true);
 		if (timeoutMs === void 0) {
@@ -747,6 +944,46 @@ var CronScheduler = class {
 		return this.executeJob(job, true);
 	}
 	/**
+	* Start a job now and answer as soon as the run has begun, not when it
+	* ends — the manual trigger's `?async=1`.
+	*
+	* The synchronous {@link triggerJob} holds its HTTP request open for the
+	* whole run, and a proxy in front of the server (many stop at 60 s) cuts
+	* a long job's answer while the run carries on. This resolves once the
+	* run lease is held and the handler is about to be called, so a run that
+	* cannot start — already executing here or on the lease holder — is still
+	* answered as the skip it is. The run itself is tracked like any other:
+	* `stop()` waits for it, and its outcome lands in the run history, where
+	* the entry carries `manual: true` and the `startedAt` returned here.
+	*
+	* Returns `undefined` if the job doesn't exist.
+	*/
+	async startJob(id) {
+		const job = this.jobs.get(id);
+		if (!job) return void 0;
+		if (job.executing) {
+			logger.warn(`[cron] Skipping manual trigger of "${id}" — already executing`);
+			return {
+				started: false,
+				log: this.recordSkip(job, "already_executing", true)
+			};
+		}
+		let onStart;
+		const begun = new Promise((resolve) => {
+			onStart = resolve;
+		});
+		const run = this.executeJob(job, true, void 0, onStart);
+		const first = await Promise.race([begun.then((startedAt) => ({ startedAt })), run.then((log) => ({ log }))]);
+		if ("startedAt" in first) return {
+			started: true,
+			startedAt: first.startedAt
+		};
+		return {
+			started: false,
+			log: first.log
+		};
+	}
+	/**
 	* Record a run that did not happen because the previous one had not
 	* finished.
 	*
@@ -899,7 +1136,7 @@ var CronScheduler = class {
 		if (!this.started) {
 			const now = /* @__PURE__ */ new Date();
 			for (const job of jobs) try {
-				viewOf(job.id).nextRunAt = parseCronExpression(job.definition.schedule, now, job.definition.timezone);
+				viewOf(job.id).nextRunAt = this.listedNextRun(job, now);
 			} catch {}
 		}
 		if (store?.fetchRunSummaries && ids.length > 0) try {
@@ -911,6 +1148,34 @@ var CronScheduler = class {
 		return views;
 	}
 	/**
+	* The next slot of `job` after `now`, for a listing on a process whose
+	* scheduler is not started — the `api` role, which Studio's Cron panel
+	* polls every 15 seconds.
+	*
+	* Cached on the job. The key is the job's schedule and zone (a re-register
+	* replaces the job, and with it the cache); the entry holds while
+	* `computedAt <= now < slot`. That is the same answer, not an
+	* approximation: the search found no matching minute between
+	* `computedAt`'s next minute and `slot`, so from any later instant before
+	* `slot` it lands on `slot` again. A clock that moves back, or reaching the
+	* slot, recomputes. The cache holds a pure function of the schedule, so
+	* there is nothing user- or role-scoped in it.
+	*/
+	listedNextRun(job, now) {
+		const { schedule, timezone } = job.definition;
+		const nowMs = now.getTime();
+		const cached = job.listedSlot;
+		if (cached && cached.schedule === schedule && cached.timezone === timezone && cached.computedAt <= nowMs && nowMs < cached.slot.getTime()) return cached.slot;
+		const slot = parseCronExpression(schedule, now, timezone);
+		job.listedSlot = {
+			schedule,
+			timezone,
+			computedAt: nowMs,
+			slot
+		};
+		return slot;
+	}
+	/**
 	* Warn once at start when the process looks like it is running on a
 	* platform that freezes or evicts instances between requests, where the
 	* in-process timers this scheduler relies on never fire.
@@ -1064,10 +1329,10 @@ var CronScheduler = class {
 	* - Persists to store (non-blocking) if available
 	* - Always restores state even on catastrophic errors
 	*/
-	executeJob(job, manual, seedLog) {
+	executeJob(job, manual, seedLog, onStart) {
 		const abort = new AbortController();
 		this.runControllers.add(abort);
-		const run = this.runJob(job, manual, abort, seedLog);
+		const run = this.runJob(job, manual, abort, seedLog, onStart);
 		this.track(run);
 		return run.finally(() => {
 			this.runControllers.delete(abort);
@@ -1081,7 +1346,7 @@ var CronScheduler = class {
 		};
 		work.then(release, release);
 	}
-	async runJob(job, manual, abort, seedLog) {
+	async runJob(job, manual, abort, seedLog, onStart) {
 		if (job.executing) return this.recordSkip(job, "already_executing", manual);
 		job.executing = true;
 		const lease = await this.acquireLease(job);
@@ -1091,14 +1356,14 @@ var CronScheduler = class {
 			return this.recordSkip(job, "already_executing", manual, lease.holder ?? "another process");
 		}
 		const startedAt = /* @__PURE__ */ new Date();
-		const capturedLogs = seedLog ? [seedLog] : [];
+		const capturedLogs = createLogCapture(seedLog || void 0);
 		const ctx = {
 			jobId: job.id,
 			scheduledAt: startedAt,
 			signal: abort.signal,
 			log: (...args) => {
 				const line = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-				capturedLogs.push(line);
+				capturedLogs.add(line);
 				logger.info(args.map((a) => typeof a === "string" ? a : stringifyForLog(a)).join(" "), { cron: job.id });
 			},
 			rebase: this.client
@@ -1106,6 +1371,7 @@ var CronScheduler = class {
 		job.state = "running";
 		job.lastRunAt = startedAt;
 		job.totalRuns++;
+		onStart?.(startedAt.toISOString());
 		let success = true;
 		let error;
 		let result;
@@ -1144,7 +1410,7 @@ var CronScheduler = class {
 			success,
 			error,
 			result: result !== void 0 ? result : void 0,
-			logs: capturedLogs,
+			logs: capturedLogs.close(),
 			manual
 		};
 		job.logs.push(logEntry);
@@ -1188,4 +1454,4 @@ var CronScheduler = class {
 //#endregion
 export { parseEnvBoolean as a, validateCronExpression as i, cron_scheduler_exports as n, isAlreadyExecutingSkip as r, CronScheduler as t };
 
-//# sourceMappingURL=cron-scheduler-CYQgco86.js.map
+//# sourceMappingURL=cron-scheduler-idtLPoN-.js.map