@cronwatch/sdk 0.3.1 → 0.5.0

package/dist/index.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var croner = require('croner');
-var crypto$1 = require('crypto');
 
 // src/duration.ts
 var UNIT_MS = {
@@ -55,6 +54,16 @@ function formatRelative(at, now) {
   if (abs < 5e3) return text;
   return diff < 0 ? `${text} ago` : `in ${text}`;
 }
+
+// src/env.ts
+function readEnv(name) {
+  return typeof process === "undefined" || !process.env ? void 0 : process.env[name];
+}
+function isDevelopment() {
+  if (typeof process === "undefined" || !process.env) return false;
+  const mode = process.env.NODE_ENV;
+  return mode === "development" || mode === "test";
+}
 var cache = /* @__PURE__ */ new Map();
 var crons = /* @__PURE__ */ new WeakMap();
 var EARLY_SLACK_MS = 6e4;
@@ -95,6 +104,28 @@ function fireAfter(parsed, from) {
   }
   return null;
 }
+function firesBetween(parsed, from, to, limit) {
+  const cron = crons.get(parsed);
+  if (!cron) throw new Error(`schedule "${parsed.source}" was not made by parseSchedule`);
+  const out = [];
+  let probe = from;
+  let last = from;
+  for (let guard = 0; guard < 1e3; guard++) {
+    const batch = cron.nextRuns(Math.min(limit + 1 - out.length, 24), new Date(probe));
+    if (batch.length === 0) return out;
+    for (const date of batch) {
+      const t = date.getTime();
+      if (t <= last) continue;
+      if (t > to) return out;
+      out.push(t);
+      last = t;
+      if (out.length > limit) return null;
+    }
+    const end = batch[batch.length - 1].getTime();
+    probe = end > probe ? end : probe + 36e5;
+  }
+  return out;
+}
 function nextFire(parsed, from, lastRunAt) {
   if (parsed.kind === "interval") {
     const base = lastRunAt ?? from;
@@ -307,7 +338,15 @@ function onRunFinish(def, run, state, history, now) {
 function onCheck(def, stored, lastRun, state, now) {
   const next = cloneState(state);
   const alerts = [];
-  if (!def.schedule) return { state: next, alerts, nextExpectedAt: null, dueAt: null };
+  if (!def.schedule) {
+    const since = next.open.missed;
+    if (since !== void 0) {
+      delete next.open.missed;
+      next.pendingRecovery = (next.pendingRecovery ?? []).filter((c) => c !== "missed");
+      alerts.push({ type: "recovered", run: lastRun, details: { after: ["missed"], reason: "unscheduled", since } });
+    }
+    return { state: next, alerts, nextExpectedAt: null, dueAt: null };
+  }
   const parsed = parseSchedule(def.schedule, def.timezone);
   const grace = graceMs(def);
   const lastRunAt = lastRun?.startedAt ?? null;
@@ -457,6 +496,12 @@ ${out}`);
       break;
     }
     case "recovered": {
+      if (draft.details.reason === "unscheduled") {
+        title = `${name} is no longer scheduled`;
+        const since = draft.details.since;
+        lines.push(`${since === void 0 ? "" : `Missed since ${when(since, now)}. `}It has no schedule now, so nothing is due; the missed alert is closed.`);
+        break;
+      }
       title = `${name} recovered`;
       const after = draft.details.after.map((c) => c.replace("_", " ")).join(", ");
       lines.push(`A run ${run ? when(run.startedAt, now) : "just now"} succeeded${after ? ` after: ${after}` : ""}.`);
@@ -642,191 +687,796 @@ function checkExpectation(expect, output) {
   return ok ? null : "Output did not pass the expect() check";
 }
 
-// src/routes/html.ts
+// src/routes/escape.ts
 function escapeHtml(value) {
   return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+
+// src/routes/icons.ts
+var ICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40"><rect width="40" height="40" rx="10" fill="#141417"/><rect x="0.5" y="0.5" width="39" height="39" rx="9.5" fill="none" stroke="#2a2a2f"/><circle cx="20" cy="20" r="10.5" fill="none" stroke="#f3f3f1" stroke-width="2"/><path d="M20 12.5V20h6" fill="none" stroke="#f3f3f1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+var MASKABLE_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 40"><rect width="40" height="40" fill="#141417"/><circle cx="20" cy="20" r="10.5" fill="none" stroke="#f3f3f1" stroke-width="2"/><path d="M20 12.5V20h6" fill="none" stroke="#f3f3f1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+var ICON_192_PNG = "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";
+var ICON_512_PNG = "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";
+var MASKABLE_512_PNG = "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";
+var APPLE_TOUCH_ICON_PNG = "iVBORw0KGgoAAAANSUhEUgAAALQAAAC0CAMAAAAKE/YAAAAAM1BMVEUUFBciIiU+PkBaWlt2dnaRkZKfn5+tra27u7tMTE7X19bz8/FoaGnl5eMwMDKEhITJycgc8OlvAAAFSklEQVR42u2caZPjKAyGOZ042XXm///LSVXaB9fW7vYYfGTawiJO1+j91IcNj4UQAoMZI5FIJBKJRCKRSCQSiUQikUgkEolEIpG+izh+iZ9ijIVPvTd0baRclhic0+17QvOrqfzT/4pBP8K7QUulvrzGWvdG0A0328oJOtwxLISA7IXf+OzcB/ZXfzw01wJUhgwsHO0eqvbge0Rrj4SuTybrPt23h7nHLayZWVh3Cp0IIfRa9UyteIPnl/4YSzfD8on1w1/n8aF5iOuyQVx1PwBaXuZmdvbyDKT5UPMnFB/u5dDqNGPo3O+7pJDn2QW9fTG0rmYBwc1dt2bzzsblLNQM5qXQlZ6a/eeij3rPhFj+eWpcM7wwekyZzbJPaR4YC57NPaavJ71XcvcyS0+YQ7+sWNSfP7RLP5cnvtfWcq8/m96v5Xy/AvLyn8GmlUrmXwI9iRv9al/6+xfJeW0McUGluUhGHgB/zJS5y4patkt+Ocny0M0ludlnjg/OJ/VeGnBbQ29Ien94eJapVpzH7gh/cqilbzIZA7OZGfNdrFneykLXiQ/bHcyM+bSkuih00gm7nasCbbdaLD60igGu3z2zdjEcGlUOmsdmNJbtlo0mqHkxaDV6cTAMQWbMDL0qBd3E4btHWS0K0UGqphB07HkGaanImZXCUaETQ58Zks5ZpgZAx76i7ljQd5WTJAOgx6ZcTkjy9VMsiseEjgvPqGvNbZxBFoAeG1I4TGgn4LnbZmg+ltmhvo4I42iuODr0NdqGocqtVIEFbWICjwsd02mDDj0GacuQZRdVYEHHtaELNvRYoK+Rocem03ds6LuG+sdW6DGIPhi6HtD1DDC0x4f2haA5B8el7boua8GBHq+/40PfBTBpgkIbVkCmMLQvAe2B0AoIXQOXZp+swwzt6mpKIWhg4vFs+BSnIaykH4XcAyuXVtVqTl0GusLyY1Wv5DW40AW04/GPg2bvBj0gXbMPOsCq2rA3wrYr/KEM9MaUd/iK2qZPXwOhFRB6YyIWevHbjjZM3npJWxZ6c5xuARG91WXdQxSNBoWgdQloXRjaN/jMjS8EHV4xRwy40DEREwVd2rFC0CXniNjQcW0C3akbA+3lW6Hb8cIPbOixQNEiQ8f8QGFDK3AKtRl6bDqJ3BXj/lqNDh1DncSFlgwcTTdDhzFvO6OeI+DjWzkb0KHjxNqjmlr6r2bue6AdNKfepphLuwLQsZ/4Gx7zzWekYgDo6HIWbYBpLAMmS8BQ0MeLB6w3XCEW2RaxdOLLGqkvSs1yOgqk9sTUEuUdF4/Rcyi0dYIxG1e/UWYwOq7Vg4wAa+e4aydni+gi6YgTdtgWP1giYaOBT7vdOtm0qmHeBqw6eZWj1D6/rhMPs7CigClbmySmale6J9KSgKve4OTnnGyQ3bHZNNkgy1yXnRhu1IWPQxc/ZUe++pzaHHq6CJ5mynSrWJc3NO4sAx4DQro5XmVFPpUyZ2xazQhcPr1JcTA1r9IF1SHDw3KirU83dknlA9A10jpNzivgrCHCpdRc8ev2ntSE/cdcih2DepbzH3gMirnpjf68xUe4uk473YsPnB17tC877fG+CtM5iJbPj1c3rqrktDFEmz39yc8f3OKEmzy5H1ou5o+N1D/cIil0PH/Ktmvh5bbavsL42rX/xuKhlq3Qq16j9uwM/pZHsP/Aw+7/xTHodoLB7t0WvHvdNhgJGiEGaQ7/FsL/8eHFn8r4lh8lwVq2Dc5WVj1veGHkh8Xa4v6Hf2gnrjIU/6QRiUQikUgkEolEIpFIJBKJRCKRSCQSifR99A+QQLqujpJ2+QAAAABJRU5ErkJggg==";
+
+// src/routes/pwa.ts
+var BACKGROUND_COLOR = "#f4f4f5";
+var THEME_COLOR = "#ffffff";
+var THEME_COLOR_DARK = "#111113";
+function manifest(base) {
+  const icon = (name, sizes, type, purpose) => ({ src: `${base}/icons/${name}`, sizes, type, purpose });
+  return JSON.stringify({
+    id: `${base}/`,
+    name: "CronWatch",
+    short_name: "CronWatch",
+    description: "The scheduled jobs of this app: their health, their last day and their runs.",
+    start_url: `${base}/`,
+    scope: `${base}/`,
+    display: "standalone",
+    background_color: BACKGROUND_COLOR,
+    theme_color: THEME_COLOR,
+    icons: [
+      icon("icon.svg", "any", "image/svg+xml", "any"),
+      icon("maskable.svg", "any", "image/svg+xml", "maskable"),
+      icon("icon-192.png", "192x192", "image/png", "any"),
+      icon("icon-512.png", "512x512", "image/png", "any"),
+      icon("maskable-512.png", "512x512", "image/png", "maskable")
+    ]
+  });
+}
+var APP_JS = `"use strict";
+(function () {
+  var script = document.currentScript;
+  if (!script || !("serviceWorker" in navigator)) return;
+  var base = new URL("./", script.src);
+  navigator.serviceWorker.register(new URL("sw.js", base).href, { scope: base.pathname }).catch(function () {});
+})();
+`;
+var SW_JS = `"use strict";
+var VERSION = "cronwatch-shell-1";
+var SCOPE = self.registration.scope;
+var CACHE = VERSION + " " + SCOPE;
+var SHELL = ["offline", "manifest.webmanifest", "app.js", "icons/icon.svg", "icons/maskable.svg", "icons/icon-192.png", "icons/icon-512.png", "icons/maskable-512.png", "icons/apple-touch-icon.png"].map(function (path) {
+  return new URL(path, SCOPE).href;
+});
+var OFFLINE = SHELL[0];
+
+self.addEventListener("install", function (event) {
+  event.waitUntil(caches.open(CACHE).then(function (cache) {
+    return cache.addAll(SHELL.map(function (url) { return new Request(url, { credentials: "omit", cache: "reload" }); }));
+  }).then(function () { return self.skipWaiting(); }));
+});
+
+self.addEventListener("activate", function (event) {
+  event.waitUntil(caches.keys().then(function (keys) {
+    return Promise.all(keys.filter(function (key) {
+      return key !== CACHE && key.indexOf("cronwatch-shell-") === 0 && key.slice(key.indexOf(" ") + 1) === SCOPE;
+    }).map(function (key) { return caches.delete(key); }));
+  }).then(function () { return self.clients.claim(); }));
+});
+
+self.addEventListener("fetch", function (event) {
+  var request = event.request;
+  if (request.method !== "GET") return;
+  var url = new URL(request.url);
+  url.search = "";
+  if (SHELL.indexOf(url.href) !== -1 && url.href !== OFFLINE) {
+    event.respondWith(caches.open(CACHE).then(function (cache) {
+      return cache.match(url.href).then(function (hit) { return hit || fetch(request); });
+    }));
+    return;
+  }
+  if (request.mode !== "navigate") return;
+  event.respondWith(fetch(request).catch(function () {
+    return caches.open(CACHE).then(function (cache) { return cache.match(OFFLINE); }).then(function (page) {
+      return page || new Response("You are offline.", { status: 503, headers: { "content-type": "text/plain; charset=utf-8" } });
+    });
+  }));
+});
+`;
+var YEAR = "public, max-age=31536000, immutable";
+var REVALIDATE = "no-cache";
+function decode(base64) {
+  const bytes = atob(base64);
+  const out = new Uint8Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) out[i] = bytes.charCodeAt(i);
+  return out;
+}
+var ICONS = {
+  "/icons/icon.svg": () => ({ type: "image/svg+xml", body: ICON_SVG, cache: YEAR }),
+  "/icons/maskable.svg": () => ({ type: "image/svg+xml", body: MASKABLE_SVG, cache: YEAR }),
+  "/icons/icon-192.png": () => ({ type: "image/png", body: decode(ICON_192_PNG), cache: YEAR }),
+  "/icons/icon-512.png": () => ({ type: "image/png", body: decode(ICON_512_PNG), cache: YEAR }),
+  "/icons/maskable-512.png": () => ({ type: "image/png", body: decode(MASKABLE_512_PNG), cache: YEAR }),
+  "/icons/apple-touch-icon.png": () => ({ type: "image/png", body: decode(APPLE_TOUCH_ICON_PNG), cache: YEAR })
+};
+function staticAsset(path, base) {
+  if (path === "/manifest.webmanifest") return { type: "application/manifest+json", body: manifest(base), cache: REVALIDATE };
+  if (path === "/app.js") return { type: "text/javascript; charset=utf-8", body: APP_JS, cache: REVALIDATE };
+  if (path === "/sw.js") return { type: "text/javascript; charset=utf-8", body: SW_JS, cache: REVALIDATE, worker: true };
+  return Object.hasOwn(ICONS, path) ? ICONS[path]() : null;
+}
+
+// src/routes/timeline.ts
+var HOUR = 36e5;
+var DAY = 24 * HOUR;
+var BOARD_BEHIND_MS = DAY;
+var BOARD_AHEAD_MS = 3 * HOUR;
+var BOARD_LANES = 30;
+var BOARD_RUNS = 200;
+var WEEK_DAYS = 7;
+var W = 1e3;
+var MAX_TICKS = 330;
+var MAX_BOXES = 8;
+var MIN_BOX = 10;
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+var WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+function clock(t) {
+  return new Date(t).toISOString().slice(11, 16);
+}
+function dayLabel(t) {
+  const d = new Date(t);
+  return `${WEEKDAYS[d.getUTCDay()]} ${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]}`;
+}
+function when2(t, now) {
+  if (Math.floor(t / DAY) === Math.floor(now / DAY)) return clock(t);
+  const d = new Date(t);
+  return `${d.getUTCDate()} ${MONTHS[d.getUTCMonth()]} ${clock(t)}`;
+}
+function parsedSchedule(job) {
+  if (!job.definition.schedule) return null;
+  try {
+    return parseSchedule(job.definition.schedule, job.definition.timezone);
+  } catch {
+    return null;
+  }
+}
+function safely(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function dueTimes(job, parsed, runs, from, to) {
+  if (!parsed) return { times: [], dense: false };
+  if (parsed.kind === "interval") {
+    const every = parsed.everyMs;
+    if ((to - from) / every > MAX_TICKS) return { times: [], dense: true };
+    const starts = runs.map((r) => r.startedAt).sort((a, b) => a - b);
+    const times2 = /* @__PURE__ */ new Set();
+    for (const start of starts) {
+      const t2 = start + every;
+      if (t2 >= from && t2 <= to) times2.add(t2);
+    }
+    let t = starts.length ? starts[starts.length - 1] + every : job.nextExpectedAt;
+    if (t !== null) {
+      if (t < from) t += Math.ceil((from - t) / every) * every;
+      for (; t <= to; t += every) times2.add(t);
+    }
+    return { times: [...times2].sort((a, b) => a - b), dense: false };
+  }
+  const times = safely(() => firesBetween(parsed, from - 1, to, MAX_TICKS), []);
+  return times === null ? { times: [], dense: true } : { times, dense: false };
+}
+function missedAt(job, parsed, times, now) {
+  if (!parsed || !job.open.includes("missed")) return null;
+  const grace = safely(() => graceMs(job.definition), 0);
+  const last = job.lastRun?.startedAt ?? null;
+  if (last !== null) return safely(() => expectation(parsed, last, last, grace)?.dueAt ?? null, null);
+  const past = times.filter((t) => t + grace < now);
+  return past.length ? past[past.length - 1] : null;
+}
+function toneOf(run, job, now) {
+  if (run.status === "running") return safely(() => isStuck(job.definition, run, now), false) ? "stuck" : "running";
+  if (run.status === "failed") return "bad";
+  if (run.status === "timeout") return "timeout";
+  const latest = job.lastRun?.id === run.id;
+  return latest && (job.open.includes("over_budget") || job.open.includes("slow")) ? "warn" : "ok";
+}
+function timeoutText(job) {
+  return safely(() => formatDuration(timeoutMs(job.definition)), "configured");
+}
+function describeRun(run, tone, job, now) {
+  const at = `${when2(run.startedAt, now)} UTC`;
+  if (tone === "running") return `running since ${at}, ${formatDuration(now - run.startedAt)} so far`;
+  if (tone === "stuck") return `running since ${at}, past its ${timeoutText(job)} timeout`;
+  const took = run.durationMs !== null ? `, took ${formatDuration(run.durationMs)}` : "";
+  const extra = tone === "warn" ? job.open.includes("over_budget") ? ", over budget" : ", slow" : "";
+  return `${run.status} at ${at}${took}${extra}`;
+}
+function overCeilings(job) {
+  const metrics = job.lastRun?.metrics ?? {};
+  return Object.entries(job.definition.budget ?? {}).filter(([k, limit]) => (metrics[k] ?? -Infinity) > limit).map(([k]) => k);
+}
+function laneNote(job, missed, now) {
+  const last = job.lastRun;
+  if (job.silencedUntil !== null && job.silencedUntil > now) return `silenced until ${when2(job.silencedUntil, now)}`;
+  if (job.open.includes("missed")) return missed !== null ? `due ${when2(missed, now)}, nothing ran` : "overdue, nothing ran";
+  if (last?.status === "running") {
+    const stuck = safely(() => isStuck(job.definition, last, now), false);
+    return stuck ? `running since ${when2(last.startedAt, now)}, past its ${timeoutText(job)} timeout` : `running since ${when2(last.startedAt, now)}`;
+  }
+  if (last?.status === "failed") return `failed at ${when2(last.startedAt, now)}${job.consecutiveFailures > 1 ? `, ${job.consecutiveFailures} in a row` : ""}`;
+  if (last?.status === "timeout") return `timed out at ${when2(last.startedAt, now)}`;
+  if (job.open.includes("stuck")) return "stuck";
+  if (job.open.includes("over_budget") && last) {
+    const over = overCeilings(job);
+    return `went over budget${over.length ? ` on ${over.join(" and ")}` : ""} at ${when2(last.startedAt, now)}`;
+  }
+  if (job.open.includes("slow") && last?.durationMs != null) return `slow: took ${formatDuration(last.durationMs)}`;
+  if (job.open.includes("failed")) return "failing";
+  if (!last && job.nextExpectedAt !== null) return `no runs yet, first due ${when2(job.nextExpectedAt, now)}`;
+  return null;
+}
+var f = (n) => n.toFixed(1);
+var delay = (x, base = 80, perUnit = 0.75) => `--d:${Math.round(base + Math.max(0, x) * perUnit)}ms`;
+function lane(input, span, options) {
+  const { job } = input;
+  const { from, to, now } = span;
+  const x = (t) => Math.min(W, Math.max(0, (t - from) / (to - from) * W));
+  const parsed = parsedSchedule(job);
+  const due = dueTimes(job, parsed, input.runs, from, to);
+  const missed = missedAt(job, parsed, due.times, now);
+  const grace = safely(() => graceMs(job.definition), 0);
+  const name = options.label;
+  const busy = [];
+  let s = `<svg class="marks" viewBox="0 0 ${W} 24" preserveAspectRatio="none" aria-hidden="true" focusable="false">`;
+  if (options.nowInLane && now > from && now < to) s += `<rect class="ahead" x="${f(x(now))}" y="0" width="${f(W - x(now))}" height="24"/>`;
+  s += `<line class="base" x1="0" y1="12" x2="${W}" y2="12"/>`;
+  const inSpan = input.runs.filter((r) => r.startedAt <= to && (r.finishedAt ?? now) >= from).sort((a, b) => a.startedAt - b.startedAt);
+  if (!input.complete) {
+    const oldest = Math.min(...input.runs.map((r) => r.startedAt));
+    if (Number.isFinite(oldest) && oldest > from) {
+      s += `<rect class="unloaded" x="0" y="4" width="${f(x(oldest))}" height="16"><title>${escapeHtml(`${name}: runs before ${when2(oldest, now)} UTC are not loaded here`)}</title></rect>`;
+    }
+  }
+  if (due.dense) {
+    s += `<line class="cadence" x1="0" y1="12" x2="${W}" y2="12"><title>${escapeHtml(`${name}: due ${job.definition.schedule ?? ""}, too often to mark each time`)}</title></line>`;
+  }
+  for (const t of due.times) {
+    const tx = x(t);
+    s += `<line class="tick${t > now ? " ahead" : ""}" x1="${f(tx)}" y1="6" x2="${f(tx)}" y2="18" style="${delay(tx, 0, 0.45)}"/>`;
+  }
+  if (missed !== null && missed <= to) {
+    const slots = due.dense ? [] : due.times.filter((t) => t >= missed && t + grace < now);
+    if (!slots.includes(missed) && missed >= from) slots.unshift(missed);
+    const title = escapeHtml(`${name}: due ${when2(missed, now)} UTC, nothing started${slots.length > 1 ? ` (${slots.length} slots in this span)` : ""}`);
+    if (due.dense || slots.length > MAX_BOXES) {
+      const x1 = x(Math.max(missed, from)), x2 = Math.max(x(now), x1 + MIN_BOX);
+      s += `<rect class="missed" x="${f(x1)}" y="5" width="${f(x2 - x1)}" height="14" style="${delay(x1)}"><title>${title}</title></rect>`;
+      busy.push([x1, x2]);
+    } else {
+      for (const t of slots) {
+        if (t < from) continue;
+        const x1 = x(t), width = Math.max(x(t + grace) - x1, MIN_BOX);
+        s += `<rect class="missed" x="${f(x1)}" y="5" width="${f(width)}" height="14" style="${delay(x1)}"><title>${title}</title></rect>`;
+        busy.push([x1, x1 + width]);
+      }
+    }
+  }
+  for (const run of inSpan) {
+    const tone = toneOf(run, job, now);
+    const x1 = x(run.startedAt), x2 = Math.max(x(run.finishedAt ?? now), x1 + 0.5);
+    s += `<rect class="run ${tone}" x="${f(x1)}" y="5" width="${f(x2 - x1)}" height="14" style="${delay(x1)}"><title>${escapeHtml(`${name}: ${describeRun(run, tone, job, now)}`)}</title></rect>`;
+    busy.push([x1, x2]);
+  }
+  if (options.nowInLane && now > from && now < to) s += `<line class="nowline" x1="${f(x(now))}" y1="0" x2="${f(x(now))}" y2="24"/>`;
+  s += `</svg>`;
+  const text = laneNote(job, missed, now);
+  let note = "";
+  if (text) {
+    const nowX = x(now);
+    const lo = busy.length ? Math.min(...busy.map((b) => b[0])) : nowX;
+    const hi = busy.length ? Math.max(...busy.map((b) => b[1])) : nowX;
+    const right = W - hi >= lo;
+    const room = right ? W - hi : lo;
+    if (room > 90) {
+      const edge = right ? hi + 14 : lo - 14;
+      const place = right ? `left:${f(edge / 10)}%` : `right:${f(100 - edge / 10)}%`;
+      note = `<span class="note${right ? "" : " before"}" style="${place};max-width:${f((room - 18) / 10)}%">${escapeHtml(text)}</span>`;
+    }
+  }
+  return { svg: s, note, words: words(job, inSpan, due, missed, span, text) };
+}
+function words(job, runs, due, missed, span, note) {
+  const parts = [];
+  if (due.dense) parts.push(`due ${job.definition.schedule}`);
+  else if (job.definition.schedule) {
+    const n = due.times.filter((t) => t <= span.now).length;
+    parts.push(`due ${n === 0 ? "no times" : n === 1 ? "once" : `${n} times`} so far`);
+  }
+  const ok = runs.filter((r) => r.status === "ok").length;
+  parts.push(`${runs.length} ${runs.length === 1 ? "run" : "runs"} recorded${!runs.length ? "" : ok === runs.length ? ok === 1 ? ", ok" : ", all ok" : ok ? `, ${ok} ok` : ""}`);
+  for (const r of runs.filter((r2) => r2.status === "failed" || r2.status === "timeout").slice(-5)) {
+    parts.push(`${r.status} at ${when2(r.startedAt, span.now)} UTC after ${formatDuration(r.durationMs ?? 0)}`);
+  }
+  if (missed !== null) parts.push(`due at ${when2(missed, span.now)} UTC and nothing started`);
+  if (note && !/^(due |failed at|timed out)/.test(note)) parts.push(note);
+  return parts.join("; ");
+}
+function hours(span, step, nowLabel) {
+  const x = (t) => (t - span.from) / (span.to - span.from) * W;
+  const nowX = x(span.now);
+  let lines = "", labels = "";
+  for (let t = Math.ceil(span.from / step) * step; t <= span.to; t += step) {
+    const gx = x(t);
+    lines += `<i class="gl" style="left:${f(gx / 10)}%"></i>`;
+    const nearNow = nowLabel && Math.abs(gx - nowX) < 70;
+    if (gx < 25 || gx > W - 25 || nearNow) continue;
+    const minor = Math.round(t / HOUR) % 6 !== 0;
+    const near = nowLabel && Math.abs(gx - nowX) < 170;
+    const cls = [minor && "minor", near && "near"].filter(Boolean).join(" ");
+    labels += `<span class="${cls}" style="left:${f(gx / 10)}%">${clock(t)}</span>`;
+  }
+  if (nowLabel && span.now >= span.from && span.now <= span.to) labels += `<span class="nowlabel" style="left:${f(nowX / 10)}%">now ${clock(span.now)}</span>`;
+  return { lines, labels };
+}
+function legend() {
+  const key = (inner) => `<svg class="key" viewBox="0 0 16 12" aria-hidden="true" focusable="false">${inner}</svg>`;
+  const box = (cls) => key(`<rect class="${cls}" x="2" y="1" width="12" height="10"/>`);
+  const items = [
+    [key(`<line class="tick" x1="8" y1="1" x2="8" y2="11"/>`), "due"],
+    [box("run ok"), "ran"],
+    [box("run bad"), "failed"],
+    [box("run timeout"), "timed out"],
+    [box("run warn"), "over budget or slow"],
+    [box("run running"), "running"],
+    [box("missed"), "missed"]
+  ];
+  return `<p class="legend" aria-hidden="true">${items.map(([k, label]) => `<span>${k}${label}</span>`).join("")}</p>`;
+}
+function stateClass(job) {
+  return { healthy: "ok", late: "warn", failing: "bad", stuck: "bad", silenced: "muted", never_ran: "muted" }[job.health];
+}
+function dayTimeline(lanes, span, base, total) {
+  const grid = hours(span, 3 * HOUR, true);
+  const nowX = (span.now - span.from) / (span.to - span.from) * 100;
+  const rows = lanes.map((input) => {
+    const { job } = input;
+    const parts = lane(input, span, { nowInLane: false, label: job.name });
+    return {
+      html: `<li class="lane"><div class="who"><i class="sq ${stateClass(job)}" aria-hidden="true"></i><a class="name" href="${escapeHtml(base)}/jobs/${encodeURIComponent(job.name)}">${escapeHtml(job.name)}</a><span class="sched">${escapeHtml(job.definition.schedule ?? "no schedule")}</span></div><div class="track">${parts.svg}${parts.note}</div></li>`,
+      words: `<li>${escapeHtml(`${job.name} (${job.definition.schedule ?? "no schedule"}): ${parts.words}.`)}</li>`
+    };
+  });
+  const more = total > lanes.length ? `<p class="more">Showing the first ${lanes.length} of ${total} jobs here; the table below lists them all.</p>` : "";
+  return `<figure class="timeline day">
+<div class="axis" aria-hidden="true"><span></span><div class="hours">${grid.labels}</div></div>
+<div class="field">
+<div class="under" aria-hidden="true"><span></span><div>${grid.lines}<i class="future" style="left:${f(nowX)}%"></i></div></div>
+<ol class="lanes">${rows.map((r) => r.html).join("")}</ol>
+<div class="over" aria-hidden="true"><span></span><div><i class="now" style="left:${f(nowX)}%"></i></div></div>
+</div>
+${legend()}${more}
+<ul class="vh">${rows.map((r) => r.words).join("")}</ul>
+</figure>`;
+}
+function weekTimeline(job, runs, complete, now) {
+  const today = Math.floor(now / DAY) * DAY;
+  const oldest = runs.length ? Math.min(...runs.map((r) => r.startedAt)) : null;
+  const first = { from: today, to: today + DAY, now };
+  const grid = hours(first, 3 * HOUR, false);
+  const rows = [];
+  for (let i = 0; i < WEEK_DAYS; i++) {
+    const from = today - i * DAY;
+    const span = { from, to: from + DAY, now };
+    const dayRuns = runs.filter((r) => r.startedAt < span.to && (r.finishedAt ?? now) >= from);
+    const known = complete || oldest !== null && oldest <= from;
+    const label = i === 0 ? "today" : dayLabel(from);
+    const parts = lane({ job, runs, complete: known }, span, { nowInLane: i === 0, label: `${job.name}, ${label}` });
+    const count = `${dayRuns.length} ${dayRuns.length === 1 ? "run" : "runs"}`;
+    rows.push({
+      html: `<li class="lane${i === 0 ? " today" : ""}"><div class="who"><span class="name">${escapeHtml(i === 0 ? `Today, ${dayLabel(from).slice(4)}` : dayLabel(from))}</span><span class="sched">${escapeHtml(count)}</span></div><div class="track">${parts.svg}${i === 0 ? parts.note : ""}</div></li>`,
+      words: `<li>${escapeHtml(`${i === 0 ? "Today" : dayLabel(from)}: ${parts.words}.`)}</li>`
+    });
+  }
+  return `<figure class="timeline week">
+<div class="axis" aria-hidden="true"><span></span><div class="hours">${grid.labels}</div></div>
+<div class="field">
+<div class="under" aria-hidden="true"><span></span><div>${grid.lines}</div></div>
+<ol class="lanes">${rows.map((r) => r.html).join("")}</ol>
+</div>
+${legend()}
+<ul class="vh">${rows.map((r) => r.words).join("")}</ul>
+</figure>`;
+}
+function weekRunsLimit(job, now) {
+  const parsed = parsedSchedule(job);
+  if (!parsed) return 50;
+  const from = Math.floor(now / DAY) * DAY - (WEEK_DAYS - 1) * DAY;
+  const span = now + DAY - from;
+  const expected = parsed.kind === "interval" ? span / parsed.everyMs : (() => {
+    const due = dueTimes(job, parsed, [], now - DAY, now);
+    return due.dense ? Infinity : due.times.length * span / DAY;
+  })();
+  return Math.min(500, Math.max(50, Math.ceil(expected * 1.2) + 10));
+}
+
+// src/routes/html.ts
 var h = escapeHtml;
 var CSS = `
-:root{--bg:#fbfbf9;--fg:#1b1b18;--muted:#6b6b64;--line:#e6e5df;--card:#fff;--ok:#1f8a4c;--warn:#b7791f;--bad:#c62828;--info:#2b5fb3;--pill:#f1f0ea;--mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;--sans:-apple-system,BlinkMacSystemFont,"Segoe UI",Inter,Roboto,sans-serif}
-@media(prefers-color-scheme:dark){:root{--bg:#121311;--fg:#ecece6;--muted:#9a9a91;--line:#2a2b27;--card:#1a1b18;--pill:#24251f}}
+:root{color-scheme:light dark;--paper:#f4f4f5;--sheet:#fff;--sunk:#fafafa;--rule:#e4e4e7;--rule-2:#d4d4d8;--tick:#909098;--ink:#000;--body:#18181b;--muted:#71717a;--ok:#15803d;--warn:#a16207;--bad:#b91c1c;--serif:"Newsreader",ui-serif,Georgia,Cambria,"Times New Roman",serif;--mono:"IBM Plex Mono",ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;--who:200px}
+@media(prefers-color-scheme:dark){:root{--paper:#09090b;--sheet:#111113;--sunk:#18181b;--rule:#27272a;--rule-2:#3f3f46;--tick:#66666f;--ink:#fff;--body:#e4e4e7;--muted:#a1a1aa;--ok:#4ade80;--warn:#fbbf24;--bad:#f87171}}
 *{box-sizing:border-box}html{-webkit-text-size-adjust:100%}
-body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.5 var(--sans)}
-a{color:inherit}main{max-width:1080px;margin:0 auto;padding:24px 16px 64px}
-header{display:flex;align-items:baseline;justify-content:space-between;gap:16px;flex-wrap:wrap;margin-bottom:20px}
-header h1{font-size:18px;margin:0;letter-spacing:-.01em}header h1 a{text-decoration:none}
-header .meta{color:var(--muted);font-size:13px}
-.card{background:var(--card);border:1px solid var(--line);border-radius:10px;overflow:hidden}
-table{width:100%;border-collapse:collapse;font-size:14px}
-th{text-align:left;font-weight:600;color:var(--muted);font-size:12px;text-transform:uppercase;letter-spacing:.04em;padding:10px 12px;border-bottom:1px solid var(--line);white-space:nowrap}
-td{padding:10px 12px;border-bottom:1px solid var(--line);vertical-align:top}
-tr:last-child td{border-bottom:0}
-.name{font-weight:600;white-space:nowrap}.name a{text-decoration:none}.name a:hover{text-decoration:underline}
-.mono{font-family:var(--mono);font-size:13px}.muted{color:var(--muted)}.nowrap{white-space:nowrap}
-.pill{display:inline-flex;align-items:center;gap:6px;padding:2px 9px;border-radius:999px;background:var(--pill);font-size:12px;font-weight:600;white-space:nowrap}
-.pill::before{content:"";width:7px;height:7px;border-radius:50%;background:currentColor}
-.ok{color:var(--ok)}.warn{color:var(--warn)}.bad{color:var(--bad)}.info{color:var(--info)}.mutedpill{color:var(--muted)}
-.spark{display:block}
-form.inline{display:inline}
-button,select{font:inherit;font-size:13px;padding:5px 10px;border:1px solid var(--line);border-radius:7px;background:var(--card);color:var(--fg);cursor:pointer}
-button:hover{border-color:var(--muted)}
-.actions{display:flex;gap:8px;align-items:center;flex-wrap:wrap}
-.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin:0 0 20px}
-.stat{padding:12px 14px}.stat .k{font-size:12px;color:var(--muted);text-transform:uppercase;letter-spacing:.04em}.stat .v{font-size:20px;font-weight:600;margin-top:2px}
-pre{margin:0;padding:10px 12px;background:var(--pill);border-radius:8px;font:12.5px/1.45 var(--mono);white-space:pre-wrap;word-break:break-word;max-height:320px;overflow:auto}
-details summary{cursor:pointer;color:var(--muted);font-size:13px}details{margin-top:6px}
-details.confirm{margin:0}details.confirm summary{list-style:none;display:inline-block;font-size:13px;padding:5px 10px;border:1px solid var(--line);border-radius:7px;background:var(--card);color:var(--fg)}
-details.confirm summary::-webkit-details-marker{display:none}details.confirm[open] summary{border-color:var(--muted)}details.confirm form{margin-left:8px;font-size:13px}
-.empty{padding:40px 16px;text-align:center;color:var(--muted)}
-dl{display:grid;grid-template-columns:max-content 1fr;gap:6px 16px;margin:0;padding:14px 16px;font-size:14px}dt{color:var(--muted)}dd{margin:0}
-footer{margin-top:28px;color:var(--muted);font-size:12px}
-@media(max-width:720px){.hide-sm{display:none}main{padding:16px 16px 48px}}
+body{margin:0;background:var(--paper);color:var(--ink);font:400 16px/1.55 var(--serif);-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}
+a{color:inherit;text-decoration:underline;text-decoration-thickness:1px;text-underline-offset:.16em;text-decoration-color:var(--rule-2)}a:hover{text-decoration-color:currentColor}
+:focus-visible{outline:2px solid var(--ink);outline-offset:2px}
+code,pre,.mono{font-family:var(--mono)}
+.vh{position:absolute!important;width:1px;height:1px;margin:-1px;padding:0;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0}
+.sheet{max-width:1180px;min-height:100vh;margin:0 auto;background:var(--sheet);border-inline:1px solid var(--rule);padding:0 clamp(16px,4vw,48px)}
+.top{display:flex;align-items:center;justify-content:space-between;gap:12px 20px;flex-wrap:wrap;padding:18px 0 17px;border-bottom:1px solid var(--rule)}
+.brand{display:flex;align-items:center;gap:10px;margin:0;font:600 18px/1.2 var(--serif);letter-spacing:-.01em;min-width:0}
+.brand a{display:inline-flex;align-items:center;gap:10px;text-decoration:none}.brand svg{width:24px;height:24px;flex:none;color:var(--ink)}
+.brand .crumb{font:500 15px/1.2 var(--mono);color:var(--body);overflow-wrap:anywhere}.brand .slash{color:var(--rule-2);font-weight:400}
+.actions{display:flex;align-items:center;gap:10px;flex-wrap:wrap}
+.meta{font:400 12px/1.4 var(--mono);color:var(--muted)}
+button,select,details.confirm>summary{font:500 12.5px/1 var(--mono);color:var(--ink);background:var(--sheet);border:1px solid var(--rule-2);border-radius:3px;padding:8px 11px;cursor:pointer}
+select{padding:7px 8px}
+button:hover,select:hover,details.confirm>summary:hover{border-color:var(--muted)}
+button.primary{background:var(--ink);border-color:var(--ink);color:var(--sheet)}button.primary:hover{opacity:.86}
+form.inline{display:inline-flex;align-items:center;gap:6px;margin:0}
+details.confirm{display:inline-flex;align-items:center;gap:8px;margin:0}details.confirm>summary{list-style:none;display:inline-block}
+details.confirm>summary::-webkit-details-marker{display:none}details.confirm[open]>summary{border-color:var(--muted)}
+details.confirm form{margin-left:8px;font-size:14px;color:var(--muted)}
+.sec{display:grid;grid-template-columns:150px minmax(0,1fr);gap:10px 40px;padding:30px 0;border-top:1px solid var(--rule)}
+.top+main>.sec:first-child{border-top:0}
+.sec>h2{margin:0;font:500 11px/1.5 var(--mono);letter-spacing:.12em;text-transform:uppercase;color:var(--muted);padding-top:5px}
+.sec>.wide{grid-column:1/-1;min-width:0}
+.lede{margin:0;color:var(--muted);font-size:16px;max-width:64ch;text-wrap:pretty}
+.headline{margin:0;font:400 clamp(24px,3.2vw,32px)/1.2 var(--serif);letter-spacing:-.01em;text-wrap:balance}
+.headline b{font-weight:600}
+.state{font:500 12.5px/1.4 var(--mono);white-space:nowrap}.state+.state::before{content:" \\00b7  ";color:var(--muted);font-weight:400}
+.ok{color:var(--ok)}.warn{color:var(--warn)}.bad{color:var(--bad)}.muted{color:var(--muted)}.info{color:var(--ink)}
+.sq{display:inline-block;width:8px;height:8px;border-radius:1.5px;background:currentColor;margin-right:7px;vertical-align:1px;flex:none}
+.sq.muted{background:none;box-shadow:inset 0 0 0 1.5px var(--tick)}
+.figures{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:0;margin:22px 0 0;border-top:1px solid var(--rule)}
+.figures>div{display:flex;flex-direction:column-reverse;justify-content:flex-end;gap:4px;padding:14px 16px 2px 0}
+.figures dt{font:500 11px/1.4 var(--mono);letter-spacing:.08em;text-transform:uppercase;color:var(--muted);display:flex;align-items:center}
+.figures dd{margin:0;font:400 30px/1.1 var(--serif);font-variant-numeric:tabular-nums;color:var(--ink)}
+.figures dd small{font-size:17px;color:var(--muted)}
+.figures .zero dd{color:var(--rule-2)}
+.figures .bad dd{color:var(--bad)}.figures .warn dd{color:var(--warn)}
+.stateline{margin:12px 0 0;display:flex;flex-wrap:wrap;align-items:baseline;gap:4px 12px}
+.stateline .why{font-style:italic;color:var(--muted)}
+.jobname{margin:0;font:500 clamp(22px,3vw,28px)/1.2 var(--mono);letter-spacing:-.01em;overflow-wrap:anywhere}
+.desc{margin:6px 0 0;color:var(--body);max-width:64ch}
+.intro .actions{margin-top:18px}
+table{width:100%;border-collapse:collapse}
+th{text-align:left;font:500 10.5px/1.2 var(--mono);letter-spacing:.08em;text-transform:uppercase;color:var(--muted);padding:0 14px 10px 0;border-bottom:1px solid var(--rule);white-space:nowrap}
+td{padding:12px 14px 12px 0;border-bottom:1px solid var(--rule);vertical-align:top;font:400 12.5px/1.5 var(--mono);color:var(--body)}
+tbody tr:last-child td{border-bottom:0}
+td.job{font-family:var(--serif);font-size:15px;min-width:180px}
+td.job .name{font:500 13.5px/1.5 var(--mono);color:var(--ink)}
+td.job .desc{display:block;margin:2px 0 0;font-size:14px;color:var(--muted);line-height:1.4}
+td .tz,td .sub{display:block;color:var(--muted);font-size:11.5px}
+.nowrap{white-space:nowrap}
+.spark{display:block;overflow:visible}.spark rect{fill:var(--tick)}.spark rect.bad{fill:var(--bad)}.spark rect.warn{fill:var(--warn)}.spark rect.running{fill:none;stroke:var(--ink);stroke-width:1}
+.runs td{padding-top:11px;padding-bottom:11px}.runs tr.has-detail td{border-bottom:0;padding-bottom:4px}.runs tr.detail td{padding-top:0}
+.metrics{display:flex;flex-wrap:wrap;gap:2px 14px}.metrics .k{color:var(--muted)}
+pre{margin:6px 0 0;padding:12px 14px;background:var(--sunk);border:1px solid var(--rule);border-radius:3px;font:400 12.5px/1.55 var(--mono);color:var(--body);white-space:pre-wrap;overflow-wrap:anywhere;max-height:340px;overflow:auto}
+details.out{margin-top:4px}details.out>summary{cursor:pointer;font:400 12px/1.6 var(--mono);color:var(--muted)}details.out>summary:hover{color:var(--ink)}
+details.out.error>summary{color:var(--bad)}
+dl.def{display:grid;grid-template-columns:max-content minmax(0,1fr);gap:8px 28px;margin:0}
+dl.def dt{font:500 11px/1.9 var(--mono);letter-spacing:.08em;text-transform:uppercase;color:var(--muted)}
+dl.def dd{margin:0;font:400 13.5px/1.7 var(--mono);color:var(--body);overflow-wrap:anywhere}dl.def dd.prose{font:400 16px/1.55 var(--serif)}
+.empty{padding:28px 0 8px;color:var(--muted);max-width:60ch}
+.empty code{font-size:.86em;color:var(--ink)}
+.message{padding:clamp(56px,12vh,120px) 0;text-align:center}
+.message h1{margin:0;font:400 clamp(28px,4vw,40px)/1.15 var(--serif);letter-spacing:-.015em}
+.message p{margin:14px auto 0;max-width:52ch;color:var(--muted);text-wrap:pretty}
+.signin{display:flex;flex-wrap:wrap;align-items:center;justify-content:center;gap:8px;margin:28px auto 0;max-width:420px}
+.signin label{font:500 11px/1.4 var(--mono);letter-spacing:.08em;text-transform:uppercase;color:var(--muted)}
+.signin input{flex:1 1 180px;min-width:0;font:400 16px/1.2 var(--mono);color:var(--ink);background:var(--sheet);border:1px solid var(--rule-2);border-radius:3px;padding:8px 10px}
+footer{display:flex;flex-wrap:wrap;gap:6px 18px;padding:20px 0 40px;border-top:1px solid var(--rule);font:400 12px/1.5 var(--mono);color:var(--muted)}
+.timeline{margin:18px 0 0}
+.timeline .axis,.timeline .under,.timeline .over,.timeline .lane{display:grid;grid-template-columns:var(--who) minmax(0,1fr)}
+.timeline .hours{position:relative;height:22px;font:400 11px/1 var(--mono);color:var(--muted);letter-spacing:.04em}
+.timeline .hours span{position:absolute;top:2px;transform:translateX(-50%);white-space:nowrap}
+.timeline .hours .nowlabel{color:var(--ink);font-weight:500;animation:cw-fade .5s 1s both}
+.timeline .field{position:relative}
+.timeline .under,.timeline .over{position:absolute;inset:0;pointer-events:none}
+.timeline .under>div,.timeline .over>div{position:relative}
+.timeline .gl{position:absolute;top:0;bottom:0;width:1px;background:var(--rule)}
+.timeline .future{position:absolute;top:0;bottom:0;right:0;background:var(--sunk)}
+.timeline .now{position:absolute;top:-6px;bottom:0;width:1.5px;margin-left:-.75px;background:var(--ink);transform-origin:top;animation:cw-drop .6s .85s cubic-bezier(.2,.8,.2,1) both}
+.timeline .lanes{position:relative;list-style:none;margin:0;padding:0;border-top:1px solid var(--rule);border-bottom:1px solid var(--rule)}
+.timeline .lane{align-items:center;min-height:40px}
+.timeline .who{display:grid;grid-template-columns:auto minmax(0,1fr);align-items:center;column-gap:0;padding:6px 14px 6px 0;min-width:0}
+.timeline .who .sched{grid-column:2}
+.timeline.week .who{display:flex;align-items:baseline;gap:10px}
+.timeline .who .name{font:500 13px/1.35 var(--mono);color:var(--ink);overflow-wrap:anywhere}
+.timeline .who .sched{font:400 11px/1.35 var(--mono);color:var(--muted);white-space:nowrap}
+.timeline .track{position:relative;height:24px}
+.timeline .marks{display:block;width:100%;height:24px;overflow:visible}
+.timeline .note{position:absolute;top:50%;transform:translateY(-50%);font:italic 400 14px/1.2 var(--serif);color:var(--muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding:0 3px;text-shadow:0 0 3px var(--sheet),0 0 3px var(--sheet),0 0 6px var(--sheet);animation:cw-fade .6s 1.1s both}
+.timeline .note.before{text-align:right}
+.timeline .legend{display:flex;flex-wrap:wrap;gap:6px 18px;margin:14px 0 0;padding-left:var(--who);font:400 11.5px/1.4 var(--mono);color:var(--muted)}
+.timeline .legend span{display:inline-flex;align-items:center;gap:7px}
+.timeline .more{margin:10px 0 0;padding-left:var(--who);font-size:14px;color:var(--muted);font-style:italic}
+.key{width:16px;height:12px;overflow:visible}
+.marks *{vector-effect:non-scaling-stroke}
+svg .base{stroke:var(--rule);stroke-width:1}
+svg .tick{stroke:var(--tick);stroke-width:1.5}svg .tick.ahead{stroke-dasharray:2 2;opacity:.75}
+svg .cadence{stroke:var(--tick);stroke-width:2;stroke-dasharray:1 3}
+svg .run{stroke-width:2;stroke-linejoin:round}
+svg .run.ok{fill:var(--ok);stroke:var(--ok)}
+svg .run.bad{fill:var(--bad);stroke:var(--bad)}
+svg .run.timeout{fill:var(--bad);fill-opacity:.28;stroke:var(--bad);stroke-width:1.5}
+svg .run.warn{fill:var(--warn);stroke:var(--warn)}
+svg .run.running{fill:none;stroke:var(--ink);stroke-width:1.5}
+svg .run.stuck{fill:var(--bad);fill-opacity:.12;stroke:var(--bad);stroke-width:1.5}
+svg .missed{fill:none;stroke:var(--bad);stroke-width:1.5;stroke-dasharray:3 2.5}
+svg .unloaded{fill:var(--sunk)}
+svg .ahead{fill:var(--sunk)}
+svg .nowline{stroke:var(--ink);stroke-width:1.5}
+.marks .tick{animation:cw-fade .4s var(--d,0ms) both}
+.marks .run,.marks .missed{transform-box:fill-box;transform-origin:0 50%;animation:cw-grow .55s cubic-bezier(.2,.8,.2,1) var(--d,0ms) both}
+.marks .missed,.marks .run.running,.marks .run.stuck{animation:cw-grow .55s cubic-bezier(.2,.8,.2,1) var(--d,0ms) both,cw-breathe 2.6s ease-in-out calc(var(--d,0ms) + .6s) infinite alternate}
+.figures>div{animation:cw-rise .5s cubic-bezier(.2,.8,.2,1) both}
+.figures>div:nth-child(2){animation-delay:40ms}.figures>div:nth-child(3){animation-delay:80ms}.figures>div:nth-child(4){animation-delay:120ms}.figures>div:nth-child(5){animation-delay:160ms}.figures>div:nth-child(6){animation-delay:200ms}
+@keyframes cw-fade{from{opacity:0}}
+@keyframes cw-grow{from{opacity:0;transform:scaleX(0)}}
+@keyframes cw-drop{from{opacity:0;transform:scaleY(0)}}
+@keyframes cw-rise{from{opacity:0;transform:translateY(4px)}}
+@keyframes cw-breathe{to{opacity:.38}}
+body{padding:0 env(safe-area-inset-right) 0 env(safe-area-inset-left)}
+footer{padding-bottom:calc(40px + env(safe-area-inset-bottom))}
+@media(display-mode:standalone){
+.top{position:sticky;top:0;z-index:2;background:var(--sheet);padding-top:calc(14px + env(safe-area-inset-top));padding-bottom:13px;-webkit-user-select:none;user-select:none}
+.message{padding-top:clamp(40px,8vh,80px)}
+}
+@media(prefers-reduced-motion:reduce){*,*::before,*::after{animation:none!important;transition:none!important}}
+@media(max-width:760px){
+.sec{grid-template-columns:minmax(0,1fr);gap:10px;padding:24px 0}
+.hide-sm{display:none}
+:root{--who:0px}
+.timeline .lane{grid-template-columns:minmax(0,1fr);padding:6px 0 8px}
+.timeline .who{padding:0 0 4px}
+.timeline .who .name{background:var(--sheet);padding-right:4px}
+.timeline .hours .minor,.timeline .hours .near{display:none}
+.timeline .note{font-size:13px}
+td.job{min-width:0}
+table.board thead{display:none}
+table.board tr{display:grid;grid-template-columns:minmax(0,1fr) auto;column-gap:14px;padding:12px 0;border-bottom:1px solid var(--rule)}
+table.board tbody tr:last-child{border-bottom:0}
+table.board td{border:0;padding:0}
+table.board td.last{grid-column:1/-1;margin-top:4px;white-space:normal}
+table.board td.last .sub{display:inline;margin-left:8px}
+.runs td.nowrap{white-space:normal}
+dl.def{grid-template-columns:minmax(0,1fr);gap:0}dl.def dd{margin-bottom:10px}
+}
 `;
-function layout(title, body, options = {}) {
+var MARK = `<svg viewBox="0 0 40 40" aria-hidden="true" focusable="false"><rect x="1" y="1" width="38" height="38" rx="9.5" fill="none" stroke="currentColor" stroke-opacity=".22" stroke-width="1.5"/><circle cx="20" cy="20" r="10.5" fill="none" stroke="currentColor" stroke-width="2"/><path d="M20 12.5V20h6" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>`;
+function layout(title, body, base, options = {}) {
+  const b = h(base);
   return `<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover">
 <meta name="robots" content="noindex,nofollow">
+<meta name="color-scheme" content="light dark">
 ${options.refresh ? `<meta http-equiv="refresh" content="${options.refresh}">` : ""}
 <title>${h(title)}</title>
+<meta name="theme-color" content="${THEME_COLOR}" media="(prefers-color-scheme: light)">
+<meta name="theme-color" content="${THEME_COLOR_DARK}" media="(prefers-color-scheme: dark)">
+<meta name="mobile-web-app-capable" content="yes">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="apple-mobile-web-app-title" content="CronWatch">
+<meta name="apple-mobile-web-app-status-bar-style" content="default">
+<link rel="manifest" href="${b}/manifest.webmanifest">
+<link rel="icon" href="${b}/icons/icon.svg" type="image/svg+xml">
+<link rel="apple-touch-icon" href="${b}/icons/apple-touch-icon.png">
+<script src="${b}/app.js" defer></script>
 <style>${CSS}</style>
 </head>
-<body><main>${body}</main></body>
+<body><div class="sheet">${body}</div></body>
 </html>`;
 }
-function healthPill(job) {
-  const map = {
-    healthy: ["ok", "healthy"],
-    late: ["warn", "late"],
-    failing: ["bad", "failing"],
-    stuck: ["bad", "stuck"],
-    silenced: ["mutedpill", "silenced"],
-    never_ran: ["info", "never ran"]
-  };
-  const [cls, label] = map[job.health];
-  const extras = job.open.filter((c) => !["missed", "failed", "stuck"].includes(c)).map((c) => c.replace("_", " "));
-  return `<span class="pill ${cls}">${label}</span>${extras.length ? ` <span class="pill warn">${h(extras.join(", "))}</span>` : ""}`;
+function brand(base, crumb) {
+  const home = `<a href="${h(base)}/">${MARK}<span>CronWatch</span></a>`;
+  return crumb === void 0 ? `<p class="brand">${home}</p>` : `<p class="brand">${home}<span class="slash" aria-hidden="true">/</span><span class="crumb">${h(crumb)}</span></p>`;
+}
+var HEALTH = {
+  failing: ["bad", "failing"],
+  stuck: ["bad", "stuck"],
+  late: ["warn", "late"],
+  healthy: ["ok", "healthy"],
+  silenced: ["muted", "silenced"],
+  never_ran: ["muted", "never ran"]
+};
+function healthState(job) {
+  const [cls, label] = HEALTH[job.health];
+  const extras = job.open.filter((c) => !["missed", "failed", "stuck"].includes(c)).map((c) => `<span class="state warn">${h(c.replace("_", " "))}</span>`).join("");
+  return `<span class="state ${cls}"><i class="sq ${cls}" aria-hidden="true"></i>${label}</span>${extras}`;
 }
-function runPill(run) {
+function runState(run) {
   const cls = run.status === "ok" ? "ok" : run.status === "running" ? "info" : "bad";
-  return `<span class="pill ${cls}">${h(run.status)}</span>`;
+  return `<span class="state ${cls}">${h(run.status)}</span>`;
 }
 function sparkline(runs) {
-  const points = [...runs].reverse().filter((r) => r.durationMs !== null).slice(-20);
+  const points = [...runs].slice(0, 20).reverse();
   if (points.length < 2) return "";
-  const w = 96, hgt = 22;
-  const max = Math.max(...points.map((r) => r.durationMs), 1);
-  const step = w / (points.length - 1);
-  const path = points.map((r, i) => `${i === 0 ? "M" : "L"}${(i * step).toFixed(1)},${(hgt - 2 - r.durationMs / max * (hgt - 4)).toFixed(1)}`).join(" ");
-  const dots = points.map((r, i) => r.status === "ok" ? "" : `<circle cx="${(i * step).toFixed(1)}" cy="${(hgt - 2 - r.durationMs / max * (hgt - 4)).toFixed(1)}" r="2.2" fill="var(--bad)"/>`).join("");
-  return `<svg class="spark" width="${w}" height="${hgt}" viewBox="0 0 ${w} ${hgt}" aria-hidden="true"><path d="${path}" fill="none" stroke="var(--muted)" stroke-width="1.5"/>${dots}</svg>`;
+  const bar = 4, gap = 1.5, hgt = 22;
+  const max = Math.max(...points.map((r) => r.durationMs ?? 0), 1);
+  const bars = points.map((r, i) => {
+    const x = (i * (bar + gap)).toFixed(1);
+    if (r.status === "running") return `<rect class="running" x="${x}" y="${hgt - 6.5}" width="${bar - 1}" height="6"/>`;
+    const tall = Math.max(r.status === "ok" ? 2 : 6, (r.durationMs ?? 0) / max * hgt);
+    const cls = r.status === "ok" ? "" : ` class="bad"`;
+    return `<rect${cls} x="${x}" y="${(hgt - tall).toFixed(1)}" width="${bar}" height="${tall.toFixed(1)}" rx=".5"/>`;
+  }).join("");
+  const w = points.length * (bar + gap) - gap;
+  return `<svg class="spark" width="${w.toFixed(1)}" height="${hgt}" viewBox="0 0 ${w.toFixed(1)} ${hgt}" aria-hidden="true" focusable="false">${bars}</svg>`;
 }
 function stamp(at, now) {
   if (at === null) return `<span class="muted">never</span>`;
-  const iso = new Date(at).toISOString().replace("T", " ").slice(0, 19);
-  return `<span class="nowrap" title="${iso} UTC">${h(formatRelative(at, now))}</span>`;
-}
-function dashboardPage(jobs, runsByJob, now, base, checkedAt) {
+  const iso = new Date(at).toISOString();
+  return `<time class="nowrap" datetime="${iso}" title="${iso.replace("T", " ").slice(0, 19)} UTC">${h(formatRelative(at, now))}</time>`;
+}
+function healthFigures(jobs) {
+  return `<dl class="figures">${Object.keys(HEALTH).map((health) => {
+    const [cls, label] = HEALTH[health];
+    const n = jobs.filter((j) => j.health === health).length;
+    return `<div class="${n === 0 ? "zero" : cls}"><dt><i class="sq ${cls}" aria-hidden="true"></i>${label}</dt><dd>${n}</dd></div>`;
+  }).join("")}</dl>`;
+}
+function dashboardPage(jobs, runsByJob, now, base, checkedAt, lanes = jobs.slice(0, BOARD_LANES).map((job) => ({ job, runs: runsByJob.get(job.name) ?? [], complete: true }))) {
+  const attention = jobs.filter((j) => j.health !== "healthy").length;
+  const headline = jobs.length === 0 ? "No jobs yet." : attention === 0 ? `${jobs.length === 1 ? "The one job is" : `All ${jobs.length} jobs are`} healthy.` : `${jobs.length} job${jobs.length === 1 ? "" : "s"}, <b>${attention} needing attention</b>.`;
   const rows = jobs.map((job) => {
     const last = job.lastRun;
+    const d = job.definition;
     return `<tr>
-<td class="name"><a href="${h(base)}/jobs/${encodeURIComponent(job.name)}">${h(job.name)}</a>${job.definition.description ? `<div class="muted" style="font-weight:400;font-size:13px;white-space:normal">${h(job.definition.description)}</div>` : ""}</td>
-<td>${healthPill(job)}</td>
-<td class="mono nowrap">${h(job.definition.schedule ?? "")}<span class="muted">${job.definition.schedule ? "" : "no schedule"}</span></td>
-<td class="nowrap">${last ? `${runPill(last)} ${stamp(last.startedAt, now)}${last.durationMs !== null ? ` <span class="muted">${h(formatDuration(last.durationMs))}</span>` : ""}` : `<span class="muted">never</span>`}</td>
-<td class="nowrap hide-sm">${stamp(job.nextExpectedAt, now)}</td>
+<td class="job"><a class="name" href="${h(base)}/jobs/${encodeURIComponent(job.name)}">${h(job.name)}</a>${d.description ? `<span class="desc">${h(d.description)}</span>` : ""}</td>
+<td class="health">${healthState(job)}</td>
+<td class="nowrap hide-sm">${d.schedule ? `${h(d.schedule)}${d.timezone ? `<span class="tz">${h(d.timezone)}</span>` : ""}` : `<span class="muted">no schedule</span>`}</td>
+<td class="nowrap last">${last ? `${runState(last)} ${stamp(last.startedAt, now)}${last.durationMs !== null ? `<span class="sub">took ${h(formatDuration(last.durationMs))}</span>` : ""}` : `<span class="muted">never</span>`}</td>
+<td class="nowrap hide-sm">${job.nextExpectedAt !== null ? `${job.nextExpectedAt < now ? `<span class="state warn">overdue</span> ` : ""}${stamp(job.nextExpectedAt, now)}<span class="sub">${h(when2(job.nextExpectedAt, now))} UTC</span>` : `<span class="muted">not scheduled</span>`}</td>
 <td class="hide-sm">${sparkline(runsByJob.get(job.name) ?? [])}</td>
 </tr>`;
   }).join("\n");
+  const span = { from: now - BOARD_BEHIND_MS, to: now + BOARD_AHEAD_MS, now };
   const body = `
-<header>
-  <h1><a href="${h(base)}/">CronWatch</a></h1>
+<header class="top">
+  ${brand(base)}
   <div class="actions">
-    <span class="meta">${jobs.length} job${jobs.length === 1 ? "" : "s"}${""}</span>
-    <form class="inline" method="post" action="${h(base)}/check"><button type="submit">Run check now</button></form>
+    <span class="meta">${h(clock(now))} UTC${""}</span>
+    <form class="inline" method="post" action="${h(base)}/check"><button class="primary" type="submit">Run check now</button></form>
   </div>
 </header>
-<div class="card">
-${jobs.length === 0 ? `<div class="empty">No jobs yet. Declare one with <code class="mono">cw.job("name", { schedule: "0 2 * * *" })</code> and run it once.</div>` : `<table>
-<thead><tr><th>Job</th><th>Health</th><th>Schedule</th><th>Last run</th><th class="hide-sm">Next due</th><th class="hide-sm">Durations</th></tr></thead>
-<tbody>${rows}</tbody></table>`}
-</div>
-<footer>Refreshes every minute. <a href="${h(base)}/api/jobs">JSON</a></footer>`;
-  return layout("CronWatch", body, { refresh: 60 });
-}
-function jobPage(job, runs, now, base) {
+<main>
+<section class="sec" aria-label="Health">
+  <h2>Health</h2>
+  <div>
+    <p class="headline">${headline}</p>
+    ${jobs.length ? healthFigures(jobs) : `<p class="empty">Declare one with <code>cw.job("name", { schedule: "0 2 * * *" })</code> and run it once, and it shows up here.</p>`}
+  </div>
+</section>
+${jobs.length ? `<section class="sec" aria-label="Last 24 hours">
+  <h2>Last 24 hours</h2>
+  <p class="lede">One lane per job. Faint ticks mark when it was due, bars the runs it recorded, as long as they took. A dashed box is a slot nothing ran in. Times are UTC.</p>
+  <div class="wide">${dayTimeline(lanes, span, base, jobs.length)}</div>
+</section>
+<section class="sec" aria-label="Jobs">
+  <h2>Jobs</h2>
+  <p class="lede">Every job in the store. Open one for its week, its runs and their output.</p>
+  <div class="wide"><table class="board">
+<thead><tr><th>Job</th><th>Health</th><th class="hide-sm">Schedule</th><th>Last run</th><th class="hide-sm">Next due</th><th class="hide-sm">Recent runs</th></tr></thead>
+<tbody>${rows}</tbody></table></div>
+</section>` : ""}
+</main>
+<footer><span>Refreshes every minute. Times are UTC.</span><a href="${h(base)}/api/jobs">JSON</a></footer>`;
+  return layout("CronWatch", body, base, { refresh: 60 });
+}
+function jobPage(job, runs, now, base, complete = true) {
   const d = job.definition;
   const okRate = `${Math.round(job.stats.okRate * 100)}%`;
-  const runRows = runs.map((run) => {
+  const listed = runs.slice(0, 50);
+  const runRows = listed.map((run) => {
     const detail = [
-      run.error ? `<details open><summary>error</summary><pre>${h(run.error)}</pre></details>` : "",
-      run.output ? `<details${run.status === "ok" ? "" : " open"}><summary>output</summary><pre>${h(run.output)}</pre></details>` : ""
+      run.error ? `<details class="out error" open><summary>error</summary><pre>${h(run.error)}</pre></details>` : "",
+      run.output ? `<details class="out"${run.status === "ok" ? "" : " open"}><summary>output</summary><pre>${h(run.output)}</pre></details>` : ""
     ].join("");
-    const metrics = Object.entries(run.metrics).map(([k, v]) => `<span class="pill mutedpill">${h(k)} ${h(Number.isInteger(v) ? v : v.toFixed(4))}</span>`).join(" ");
-    return `<tr>
-<td class="nowrap">${runPill(run)}</td>
-<td class="nowrap">${stamp(run.startedAt, now)}</td>
+    const metrics = Object.entries(run.metrics).map(([k, v]) => `<span><span class="k">${h(k)}</span> ${h(Number.isInteger(v) ? v : v.toFixed(4))}</span>`).join("");
+    return `<tr${detail ? ` class="has-detail"` : ""}>
+<td class="nowrap">${runState(run)}</td>
+<td class="nowrap">${h(when2(run.startedAt, now))} <span class="muted">UTC</span><span class="sub">${stamp(run.startedAt, now)}</span></td>
 <td class="nowrap">${run.durationMs !== null ? h(formatDuration(run.durationMs)) : `<span class="muted">running</span>`}</td>
-<td class="hide-sm">${metrics}</td>
-<td class="mono hide-sm muted">${h(run.trigger)}</td>
-</tr>${detail ? `<tr><td colspan="5" style="padding-top:0">${detail}</td></tr>` : ""}`;
+<td class="hide-sm">${metrics ? `<span class="metrics">${metrics}</span>` : ""}</td>
+<td class="hide-sm muted">${h(run.trigger)}</td>
+</tr>${detail ? `<tr class="detail"><td colspan="5">${detail}</td></tr>` : ""}`;
   }).join("\n");
   const silenced = job.silencedUntil !== null && job.silencedUntil > now;
+  const path = `${h(base)}/jobs/${encodeURIComponent(job.name)}`;
+  const parsed = parsedSchedule(job);
+  const why = laneNote(job, missedAt(job, parsed, [], now), now);
   const body = `
-<header>
-  <h1><a href="${h(base)}/">CronWatch</a> <span class="muted">/</span> ${h(job.name)}</h1>
-  <div class="actions">
-    ${healthPill(job)}
-    ${silenced ? `<form class="inline" method="post" action="${h(base)}/jobs/${encodeURIComponent(job.name)}/unsilence"><button type="submit">Unsilence (until ${h(formatRelative(job.silencedUntil, now))})</button></form>` : `<form class="inline" method="post" action="${h(base)}/jobs/${encodeURIComponent(job.name)}/silence"><select name="for"><option value="1h">1 hour</option><option value="4h">4 hours</option><option value="1d">1 day</option><option value="7d">1 week</option></select> <button type="submit">Silence</button></form>`}
-    <details class="confirm"><summary>Forget</summary><form class="inline" method="post" action="${h(base)}/jobs/${encodeURIComponent(job.name)}/forget"><span class="muted">Remove this job and its runs from the store?</span> <button type="submit">Forget</button></form></details>
-  </div>
+<header class="top">
+  ${brand(base, job.name)}
+  <div class="actions"><span class="meta">${h(clock(now))} UTC</span></div>
 </header>
-<div class="grid">
-  <div class="card stat"><div class="k">Last run</div><div class="v">${job.lastRun ? h(formatRelative(job.lastRun.startedAt, now)) : "never"}</div></div>
-  <div class="card stat"><div class="k">Next due</div><div class="v">${job.nextExpectedAt ? h(formatRelative(job.nextExpectedAt, now)) : "no schedule"}</div></div>
-  <div class="card stat"><div class="k">Success, last ${h(job.stats.runs)}</div><div class="v">${h(okRate)}</div></div>
-  <div class="card stat"><div class="k">p50 / p95</div><div class="v">${job.stats.p50Ms !== null ? h(formatDuration(job.stats.p50Ms)) : "?"} <span class="muted">/</span> ${job.stats.p95Ms !== null ? h(formatDuration(job.stats.p95Ms)) : "?"}</div></div>
-</div>
-<div class="card" style="margin-bottom:20px">
-<dl>
-  <dt>Schedule</dt><dd class="mono">${d.schedule ? h(d.schedule) + (d.timezone ? ` <span class="muted">${h(d.timezone)}</span>` : "") : `<span class="muted">none</span>`}</dd>
-  <dt>Grace</dt><dd class="mono">${h(d.grace ?? "10m")}</dd>
-  <dt>Timeout</dt><dd class="mono">${h(d.timeout ?? "1h")}</dd>
-  ${d.maxDuration ? `<dt>Max duration</dt><dd class="mono">${h(d.maxDuration)}</dd>` : ""}
-  ${d.budget ? `<dt>Budget</dt><dd class="mono">${h(Object.entries(d.budget).map(([k, v]) => `${k} \u2264 ${v}`).join(", "))}</dd>` : ""}
-  ${d.expect ? `<dt>Expect</dt><dd class="mono">${h(d.expect)}</dd>` : ""}
+<main>
+<section class="sec intro" aria-label="Job">
+  <h2>Job</h2>
+  <div>
+    <h1 class="jobname">${h(job.name)}</h1>
+    ${d.description ? `<p class="desc">${h(d.description)}</p>` : ""}
+    <p class="stateline">${healthState(job)}${why ? `<span class="why">${h(why)}</span>` : ""}</p>
+    <div class="actions">
+      ${silenced ? `<form class="inline" method="post" action="${path}/unsilence"><button type="submit">Unsilence (until ${h(formatRelative(job.silencedUntil, now))})</button></form>` : `<form class="inline" method="post" action="${path}/silence"><select name="for" aria-label="Silence for"><option value="1h">1 hour</option><option value="4h">4 hours</option><option value="1d">1 day</option><option value="7d">1 week</option></select><button type="submit">Silence</button></form>`}
+      <details class="confirm"><summary>Forget</summary><form class="inline" method="post" action="${path}/forget"><span>Remove this job and its runs from the store?</span> <button type="submit">Forget</button></form></details>
+    </div>
+    <dl class="figures">
+      <div><dt>Last run</dt><dd>${job.lastRun ? h(formatRelative(job.lastRun.startedAt, now)) : "never"}</dd></div>
+      <div><dt>Next due</dt><dd>${job.nextExpectedAt !== null ? h(formatRelative(job.nextExpectedAt, now)) : `<small>no schedule</small>`}</dd></div>
+      <div><dt>Success, last ${h(job.stats.runs)}</dt><dd>${h(okRate)}</dd></div>
+      <div><dt>p50 / p95</dt><dd>${job.stats.p50Ms !== null ? h(formatDuration(job.stats.p50Ms)) : "?"} <small>/ ${job.stats.p95Ms !== null ? h(formatDuration(job.stats.p95Ms)) : "?"}</small></dd></div>
+    </dl>
+  </div>
+</section>
+<section class="sec" aria-label="Last 7 days">
+  <h2>Last 7 days</h2>
+  <p class="lede">A lane per UTC day, today first. Faint ticks mark when the job was due, bars its runs, as long as they took.</p>
+  <div class="wide">${weekTimeline(job, runs, complete, now)}</div>
+</section>
+<section class="sec" aria-label="Runs">
+  <h2>Runs</h2>
+  ${listed.length === 0 ? `<p class="lede">No runs yet.</p>` : `<p class="lede">The newest ${listed.length === 1 ? "run" : `${listed.length} runs`}, with any error and output.</p>
+  <div class="wide"><table class="runs">
+<thead><tr><th>Status</th><th>Started</th><th>Took</th><th class="hide-sm">Metrics</th><th class="hide-sm">Trigger</th></tr></thead>
+<tbody>${runRows}</tbody></table></div>`}
+</section>
+<section class="sec" aria-label="Definition">
+  <h2>Definition</h2>
+  <dl class="def">
+  <dt>Schedule</dt><dd>${d.schedule ? h(d.schedule) + (d.timezone ? ` <span class="muted">${h(d.timezone)}</span>` : "") : `<span class="muted">none</span>`}</dd>
+  <dt>Grace</dt><dd>${h(d.grace ?? "10m")}</dd>
+  <dt>Timeout</dt><dd>${h(d.timeout ?? "1h")}</dd>
+  ${d.maxDuration ? `<dt>Max duration</dt><dd>${h(d.maxDuration)}</dd>` : ""}
+  ${d.budget ? `<dt>Budget</dt><dd>${h(Object.entries(d.budget).map(([k, v]) => `${k} \u2264 ${v}`).join(", "))}</dd>` : ""}
+  ${d.expect ? `<dt>Expect</dt><dd>${h(d.expect)}</dd>` : ""}
   ${d.failuresBeforeAlert && d.failuresBeforeAlert > 1 ? `<dt>Alert after</dt><dd>${h(d.failuresBeforeAlert)} consecutive failures</dd>` : ""}
-  ${d.description ? `<dt>Description</dt><dd>${h(d.description)}</dd>` : ""}
-  ${d.tags?.length ? `<dt>Tags</dt><dd>${d.tags.map((t) => `<span class="pill mutedpill">${h(t)}</span>`).join(" ")}</dd>` : ""}
-  ${job.open.length ? `<dt>Open</dt><dd>${job.open.map((c) => `<span class="pill warn">${h(c.replace("_", " "))}</span>`).join(" ")}</dd>` : ""}
-  ${job.consecutiveFailures > 0 ? `<dt>Consecutive failures</dt><dd>${h(job.consecutiveFailures)}</dd>` : ""}
-</dl>
-</div>
-<div class="card">
-${runs.length === 0 ? `<div class="empty">No runs yet.</div>` : `<table>
-<thead><tr><th>Status</th><th>Started</th><th>Duration</th><th class="hide-sm">Metrics</th><th class="hide-sm">Trigger</th></tr></thead>
-<tbody>${runRows}</tbody></table>`}
-</div>
-<footer><a href="${h(base)}/api/jobs/${encodeURIComponent(job.name)}">JSON</a></footer>`;
-  return layout(`${job.name}: CronWatch`, body, { refresh: 60 });
-}
-function messagePage(title, message, base) {
-  return layout(title, `<header><h1><a href="${h(base)}/">CronWatch</a></h1></header><div class="card"><div class="empty"><strong>${h(title)}</strong><br>${h(message)}</div></div>`);
+  ${d.tags?.length ? `<dt>Tags</dt><dd>${d.tags.map((t) => h(t)).join(", ")}</dd>` : ""}
+  ${job.open.length ? `<dt>Open</dt><dd>${job.open.map((c) => `<span class="state ${c === "failed" || c === "stuck" ? "bad" : "warn"}">${h(c.replace("_", " "))}</span>`).join("")}</dd>` : ""}
+  ${job.consecutiveFailures > 0 ? `<dt>Failures in a row</dt><dd>${h(job.consecutiveFailures)}</dd>` : ""}
+  </dl>
+</section>
+</main>
+<footer><span>Refreshes every minute. Times are UTC.</span><a href="${h(base)}/api/jobs/${encodeURIComponent(job.name)}">JSON</a></footer>`;
+  return layout(`${job.name}: CronWatch`, body, base, { refresh: 60 });
+}
+function messagePage(title, message, base, signIn = false) {
+  const form = signIn ? `<form class="signin" method="get" action="${h(base)}/"><label for="token">Token</label><input id="token" name="token" type="password" autocomplete="current-password" autocapitalize="off" spellcheck="false" required><button class="primary" type="submit">Sign in</button></form>` : "";
+  return layout(title, `<header class="top">${brand(base)}</header><main class="message"><h1>${h(title)}</h1><p>${h(message)}</p>${form}</main>`, base);
 }
 
 // src/routes/index.ts
 var COOKIE = "cronwatch_token";
-function cookieValue(token) {
-  return crypto$1.createHash("sha256").update(`cronwatch-cookie:${token}`).digest("hex");
+async function cookieValue(token) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`cronwatch-cookie:${token}`));
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 var DEFAULT_RUNS = 20;
 var MAX_RUNS = 500;
-var CSP = "default-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none'; base-uri 'none'";
+var BOARD_PAGE_RUNS = 20;
+async function boardLanes(cw, entries, now) {
+  const from = now - BOARD_BEHIND_MS;
+  return Promise.all(entries.slice(0, BOARD_LANES).map(async ({ job, runs }) => {
+    const short = runs.length >= BOARD_PAGE_RUNS && runs[runs.length - 1].startedAt > from;
+    if (!short) return { job, runs, complete: true };
+    const deeper = await cw.runs(job.name, BOARD_RUNS);
+    return { job, runs: deeper, complete: deeper.length < BOARD_RUNS };
+  }));
+}
+var CSP = "default-src 'none'; script-src 'self'; style-src 'unsafe-inline'; img-src 'self' data:; manifest-src 'self'; worker-src 'self'; form-action 'self'; frame-ancestors 'none'; base-uri 'none'";
+var ASSET_CSP = "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'";
 var SECURITY_HEADERS = { "x-content-type-options": "nosniff", "referrer-policy": "same-origin", "x-robots-tag": "noindex" };
 function developmentToken() {
-  return crypto$1.randomBytes(32).toString("base64url");
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 function developmentSignInLine(origin, base, token) {
   return `[cronwatch] CRONWATCH_TOKEN is not set, so this development server made a token for the dashboard. Sign in: ${origin}${base}/?token=${token}`;
@@ -847,6 +1497,34 @@ function readCookie(request, name) {
   }
   return null;
 }
+function firstValue(value) {
+  const first = value?.split(",")[0]?.trim();
+  return first ? first : null;
+}
+function configuredOrigin(value) {
+  if (value === void 0 || value === "") return null;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`routes: origin must be an absolute URL such as "https://app.example.com", got ${JSON.stringify(value)}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`routes: origin must be http or https, got ${JSON.stringify(value)}`);
+  return url.origin;
+}
+function forwardedOrigin(request, url) {
+  const proto = firstValue(request.headers.get("x-forwarded-proto"))?.toLowerCase() ?? null;
+  const host = firstValue(request.headers.get("x-forwarded-host"));
+  if (proto === null && host === null) return url.origin;
+  if (proto !== null && proto !== "http" && proto !== "https") return url.origin;
+  try {
+    const built = new URL(`${proto ?? url.protocol.slice(0, -1)}://${host ?? url.host}`);
+    if (built.pathname !== "/" || built.username || built.password || built.search || built.hash) return url.origin;
+    return built.origin;
+  } catch {
+    return url.origin;
+  }
+}
 function stripBase(pathname, base) {
   let path = pathname.startsWith(base) ? pathname.slice(base.length) : pathname;
   if (path === "") path = "/";
@@ -871,9 +1549,9 @@ async function readBody(request) {
   }
   return {};
 }
-function crossSite(request, url) {
+function crossSite(request, publicOrigin) {
   const origin = request.headers.get("origin");
-  if (origin !== null && origin !== url.origin) return true;
+  if (origin !== null && origin !== publicOrigin) return true;
   const site = request.headers.get("sec-fetch-site");
   return site !== null && site !== "same-origin" && site !== "none";
 }
@@ -890,48 +1568,61 @@ function runsLimit(value) {
 }
 function createRoutes(cw, options = {}) {
   const optedOut = options.token === null;
-  const configured = optedOut ? null : options.token || process.env.CRONWATCH_TOKEN || null;
+  const configured = optedOut ? null : options.token || readEnv("CRONWATCH_TOKEN") || null;
   const base = (options.basePath ?? "/cronwatch").replace(/\/+$/, "");
-  const developing = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+  const developing = isDevelopment();
+  const fixedOrigin = configuredOrigin(options.origin);
+  const trustProxy = options.trustProxy === true;
+  const originOf = (request, url) => fixedOrigin ?? (trustProxy ? forwardedOrigin(request, url) : url.origin);
   const generated = !configured && !optedOut && developing;
   const token = generated ? developmentToken() : configured;
   let announced = false;
+  let cookie = null;
+  const expectedCookie = (value) => cookie ??= cookieValue(value);
   const serve = async (request, url, path, wantsHtml) => {
     const method = request.method.toUpperCase();
+    const publicOrigin = originOf(request, url);
     if (generated && !announced) {
       announced = true;
-      console.info(developmentSignInLine(url.origin, base, token));
+      console.info(developmentSignInLine(publicOrigin, base, token));
+    }
+    if (method === "GET" || method === "HEAD") {
+      if (path === "/offline") {
+        return html(messagePage("You are offline", "CronWatch shows live data from your app, so it needs a connection.", base), 200, "no-cache");
+      }
+      const asset = staticAsset(path, base);
+      if (asset) return shell(asset, base);
     }
     if (!token && !optedOut) {
       return wantsHtml ? html(messagePage("CronWatch routes are locked", "Set CRONWATCH_TOKEN (or pass token to cw.routes()), or pass token: null to serve them open behind your own auth.", base), 503) : api({ ok: false, error: "CRONWATCH_TOKEN is not set" }, 503);
     }
-    if (method !== "GET" && method !== "HEAD" && crossSite(request, url)) {
+    if (method !== "GET" && method !== "HEAD" && crossSite(request, publicOrigin)) {
       return wantsHtml ? html(messagePage("Cross-site request refused", "Changes can only be made from the dashboard itself.", base), 403) : api({ ok: false, error: "Cross-site request refused" }, 403);
     }
     const bearer = request.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? null;
     if (token) {
       const query = wantsHtml && method === "GET" ? url.searchParams.get("token") : null;
-      const cookie = readCookie(request, COOKIE);
+      const sent = readCookie(request, COOKIE);
       const isCheck = path === "/api/check";
       const cronSecretOk = isCheck && bearer !== null && cw.cronSecret !== null && constantTimeEqual(bearer, cw.cronSecret);
-      const tokenOk = bearer !== null ? constantTimeEqual(bearer, token) : query !== null ? constantTimeEqual(query, token) : cookie !== null && constantTimeEqual(cookie, cookieValue(token));
+      const tokenOk = bearer !== null ? constantTimeEqual(bearer, token) : query !== null ? constantTimeEqual(query, token) : sent !== null && constantTimeEqual(sent, await expectedCookie(token));
       if (!cronSecretOk && !tokenOk) {
         if (generated) {
-          return wantsHtml ? html(messagePage("Sign in", "CRONWATCH_TOKEN is not set, so this development server made a token. The sign-in link is in the server log: open it once and this browser stays signed in.", base), 401) : api({ ok: false, error: "Unauthorized: CRONWATCH_TOKEN is not set, so this development server made a token; it is in the server log" }, 401);
+          return wantsHtml ? html(messagePage("Sign in", "CRONWATCH_TOKEN is not set, so this development server made a token. The sign-in link is in the server log: open it once and this browser stays signed in.", base, true), 401) : api({ ok: false, error: "Unauthorized: CRONWATCH_TOKEN is not set, so this development server made a token; it is in the server log" }, 401);
         }
-        return wantsHtml ? html(messagePage("Sign in", `Open this page with ?token=<your CRONWATCH_TOKEN> once and it will stay signed in.`, base), 401) : api({ ok: false, error: "Unauthorized" }, 401);
+        return wantsHtml ? html(messagePage("Sign in", `Open this page with ?token=<your CRONWATCH_TOKEN> once and it will stay signed in.`, base, true), 401) : api({ ok: false, error: "Unauthorized" }, 401);
       }
       if (query !== null) {
         url.searchParams.delete("token");
-        const secure = url.protocol === "https:" ? "; Secure" : "";
+        const secure = publicOrigin.startsWith("https:") ? "; Secure" : "";
         return redirect(url.pathname + (url.search || ""), {
-          "set-cookie": `${COOKIE}=${cookieValue(token)}; Path=${base || "/"}; HttpOnly; SameSite=Lax; Max-Age=${60 * 60 * 24 * 30}${secure}`
+          "set-cookie": `${COOKIE}=${await expectedCookie(token)}; Path=${base || "/"}; HttpOnly; SameSite=Lax; Max-Age=${60 * 60 * 24 * 30}${secure}`
         });
       }
     }
     const redirectBack = () => {
       const referer = request.headers.get("referer") ?? "";
-      return redirect(referer.startsWith(url.origin + "/") ? referer : `${base}/`);
+      return redirect(referer.startsWith(publicOrigin + "/") ? referer : `${base}/`);
     };
     const decoded = path.split("/").filter(Boolean).map(safeDecode);
     if (decoded.some((part) => part === null)) {
@@ -939,14 +1630,18 @@ function createRoutes(cw, options = {}) {
     }
     const parts = decoded;
     if (method === "GET" && path === "/") {
-      const entries = await cw.jobsWithRuns(20);
+      const entries = await cw.jobsWithRuns(BOARD_PAGE_RUNS);
+      const now = cw.now();
       const runsByJob = new Map(entries.map((entry) => [entry.job.name, entry.runs]));
-      return html(dashboardPage(entries.map((entry) => entry.job), runsByJob, cw.now(), base));
+      return html(dashboardPage(entries.map((entry) => entry.job), runsByJob, now, base, null, await boardLanes(cw, entries, now)));
     }
     if (method === "GET" && parts[0] === "jobs" && parts.length === 2) {
       const job = await cw.jobSummary(parts[1]);
       if (!job) return html(messagePage("No such job", `${parts[1]} is not in the store.`, base), 404);
-      return html(jobPage(job, await cw.runs(job.name, 50), cw.now(), base));
+      const now = cw.now();
+      const limit = weekRunsLimit(job, now);
+      const runs = await cw.runs(job.name, limit);
+      return html(jobPage(job, runs, now, base, runs.length < limit));
     }
     if (method === "POST" && path === "/check") {
       await cw.check();
@@ -1044,12 +1739,18 @@ function api(body, status = 200, headers = {}) {
 function redirect(location, headers = {}) {
   return new Response(null, { status: 303, headers: { location, "cache-control": "no-store", ...SECURITY_HEADERS, ...headers } });
 }
-function html(body, status = 200) {
+function shell(asset, base) {
+  const headers = { "content-type": asset.type, "cache-control": asset.cache, ...SECURITY_HEADERS };
+  if (asset.type === "image/svg+xml") headers["content-security-policy"] = ASSET_CSP;
+  if (asset.worker) headers["service-worker-allowed"] = `${base}/`;
+  return new Response(asset.body, { status: 200, headers });
+}
+function html(body, status = 200, cache2 = "no-store") {
   return new Response(body, {
     status,
     headers: {
       "content-type": "text/html; charset=utf-8",
-      "cache-control": "no-store",
+      "cache-control": cache2,
       "content-security-policy": CSP,
       "x-frame-options": "DENY",
       ...SECURITY_HEADERS
@@ -1092,6 +1793,7 @@ function memory() {
       }
     },
     async insertRun(run) {
+      if (runs.has(run.id)) throw new Error(`run ${run.id} already exists`);
       runs.set(run.id, clone(run));
       order.set(run.id, ++seq);
     },
@@ -1101,6 +1803,13 @@ function memory() {
       const { status, finishedAt, durationMs, error, output, metrics } = clone(run);
       runs.set(run.id, { ...existing, status, finishedAt, durationMs, error, output, metrics });
     },
+    async updateRunIf(run, fromStatuses) {
+      const existing = runs.get(run.id);
+      if (!existing || !fromStatuses.includes(existing.status)) return false;
+      const { status, finishedAt, durationMs, error, output, metrics } = clone(run);
+      runs.set(run.id, { ...existing, status, finishedAt, durationMs, error, output, metrics });
+      return true;
+    },
     async getRun(id) {
       const r = runs.get(id);
       return r ? clone(r) : null;
@@ -1196,6 +1905,7 @@ var CronWatch = class {
   store;
   alerts;
   triage;
+  sources;
   /** The secret handler() requests must carry, or null when none is set. */
   cronSecret;
   retentionMs;
@@ -1211,6 +1921,8 @@ var CronWatch = class {
   synced = /* @__PURE__ */ new Set();
   /** The tail of each job's queue of state updates. See serial(). */
   queues = /* @__PURE__ */ new Map();
+  /** start() calls with an id still in flight, so two at once in this process record one run. */
+  starting = /* @__PURE__ */ new Map();
   ready = null;
   checking = null;
   lastPruneAt = 0;
@@ -1223,7 +1935,8 @@ var CronWatch = class {
     this.store = options.store ?? (this.usingDefaultStore = true, memory());
     this.alerts = options.alerts ?? [consoleChannel()];
     this.triage = options.triage;
-    const secret = options.cronSecret === void 0 ? process.env.CRON_SECRET : options.cronSecret;
+    this.sources = options.sources ?? [];
+    const secret = options.cronSecret === void 0 ? readEnv("CRON_SECRET") : options.cronSecret;
     this.cronSecret = secret ? secret : null;
     this.secretOptOut = options.cronSecret === null;
     this.retentionMs = parseDuration(options.retention ?? "30d", "retention");
@@ -1267,6 +1980,12 @@ var CronWatch = class {
   definedJobs() {
     return [...this.definitions.values()];
   }
+  /** A handle on a run started elsewhere, as job(name).resume(runId). The job must be declared in this process. */
+  resumeRun(name, runId) {
+    const definition = this.definitions.get(name);
+    if (!definition) return Promise.reject(new Error(`resumeRun: job "${name}" is not declared; call job() first`));
+    return this.resumeHandle(definition, runId);
+  }
   handle(definition) {
     const self = this;
     return {
@@ -1305,6 +2024,12 @@ var CronWatch = class {
           };
           return json(body, outcome.run.status === "ok" ? 200 : 500);
         };
+      },
+      start(options) {
+        return self.startRun(definition, options ?? {});
+      },
+      resume(runId) {
+        return self.resumeHandle(definition, runId);
       }
     };
   }
@@ -1324,7 +2049,7 @@ var CronWatch = class {
     if (!this.ready) {
       this.ready = (async () => {
         if (this.store.init) await this.store.init();
-        if (this.usingDefaultStore && process.env.NODE_ENV === "production") {
+        if (this.usingDefaultStore && readEnv("NODE_ENV") === "production") {
           console.warn("[cronwatch] using the in-memory store: runs and state are lost on restart. Pass a store from @cronwatch/sdk/sqlite or @cronwatch/sdk/postgres.");
         }
       })().catch((error) => {
@@ -1441,6 +2166,21 @@ var CronWatch = class {
     run.durationMs = Math.max(0, finishedAt - startedAt);
     run.metrics = recorder.metrics();
     run.output = recorder.output() ?? (typeof result === "string" ? capOutput(result) : null);
+    this.conclude(definition, run, result, error, threw, recorder.expectText() ?? (typeof result === "string" ? result : null));
+    await started;
+    try {
+      const ignored = await this.recordFinish(definition, run, recorded, finishedAt);
+      if (ignored) this.report(new Error(`run ${run.id} of ${name} ${ignored}; ignored`), `finishing ${name}`);
+    } catch (e) {
+      this.onError(e, `recording ${name}`);
+    }
+    return { run, result, error, threw };
+  }
+  /**
+   * Sets a finished run's status and error from how it ended, then redacts
+   * its output and error. Shared by execute() and RunHandle.finish().
+   */
+  conclude(definition, run, result, error, threw, expectText) {
     if (threw) {
       run.status = "failed";
       run.error = errorMessage(error);
@@ -1448,7 +2188,6 @@ var CronWatch = class {
       run.status = "failed";
       run.error = `HTTP ${result.status}${result.statusText ? ` ${result.statusText}` : ""}`;
     } else {
-      const expectText = recorder.expectText() ?? (typeof result === "string" ? result : null);
       const unmet = checkExpectation(definition.expect, expectText);
       if (unmet) {
         run.status = "failed";
@@ -1459,44 +2198,336 @@ var CronWatch = class {
     }
     if (run.output !== null) run.output = stripNul(this.redact(run.output));
     if (run.error !== null) run.error = stripNul(this.redact(run.error));
-    await started;
+  }
+  /**
+   * Writes a finished run and evaluates it. `recorded` says whether its
+   * start was written; if not, it is inserted now. Returns why nothing was
+   * recorded (another process finished the run first, say), or null. Throws
+   * when the store does, so a handle can be finished again. Shared by
+   * execute() and RunHandle.finish().
+   */
+  async recordFinish(definition, run, recorded, finishedAt) {
     if (!recorded) {
+      await this.sync(definition);
       try {
-        await this.sync(definition);
         await this.store.insertRun(run);
-        recorded = true;
+        await this.finishRun(toStored(definition), run, finishedAt);
+        return null;
       } catch (e) {
-        this.onError(e, `recording ${name}`);
+        const stored = await this.store.getRun(run.id).catch(() => null);
+        if (!stored) throw e;
+        if (stored.job !== run.job) return `belongs to job "${stored.job}"`;
       }
-      if (recorded) await this.finishRun(toStored(definition), run, finishedAt, false);
-    } else if (await this.markedTimedOut(run)) {
+    }
+    const claim = await this.claimFinish(run);
+    if ("ignored" in claim) return claim.ignored;
+    if (!claim.lateAfterTimeout || run.status === "ok") await this.finishRun(toStored(definition), run, finishedAt);
+    return null;
+  }
+  /** A conditional write (Store.updateRunIf), or for a store without one, a read then a plain write. */
+  async writeRunIf(run, fromStatuses) {
+    if (typeof this.store.updateRunIf === "function") return this.store.updateRunIf(run, fromStatuses);
+    const stored = await this.store.getRun(run.id);
+    if (!stored || !fromStatuses.includes(stored.status)) return false;
+    await this.store.updateRun(run);
+    return true;
+  }
+  /**
+   * Writes a finished run over its stored row, only while that row is still
+   * running, or else still marked timeout by a check. Only the process whose
+   * write lands goes on to evaluate the run; for the others it returns why
+   * nothing was written. `lateAfterTimeout` means a check already counted
+   * the run as a stuck failure: a late failure must not count twice, while
+   * a late success still closes stuck and recovers. Throws when the store does.
+   */
+  async claimFinish(run) {
+    if (await this.writeRunIf(run, ["running"])) return { lateAfterTimeout: false };
+    if (await this.writeRunIf(run, ["timeout"])) return { lateAfterTimeout: true };
+    const stored = await this.store.getRun(run.id);
+    return { ignored: stored ? `was already finished as ${stored.status}` : "was not found" };
+  }
+  /** job.start(): records a running run and returns a handle to finish it. See JobHandle.start. */
+  async startRun(definition, options) {
+    const id = options.id;
+    if (id === void 0) return this.recordStart(definition, options.trigger);
+    checkRunId(definition.name, id, "start");
+    const key = `${definition.name}
+${id}`;
+    const inFlight = this.starting.get(key);
+    if (inFlight) return inFlight;
+    const started = this.recordStart(definition, options.trigger, id).finally(() => {
+      if (this.starting.get(key) === started) this.starting.delete(key);
+    });
+    this.starting.set(key, started);
+    return started;
+  }
+  /**
+   * The start of execute() without the function: the run is inserted and
+   * missed and stuck close (onRunStart). A store that fails is reported and
+   * the handle inserts the finished run instead, as execute() does.
+   */
+  async recordStart(definition, trigger = "start", id) {
+    const name = definition.name;
+    if (id !== void 0) {
+      let stored = null;
       try {
-        await this.store.updateRun(run);
+        await this.ensureReady();
+        stored = await this.store.getRun(id);
       } catch (e) {
         this.onError(e, `recording ${name}`);
       }
-    } else {
-      await this.finishRun(toStored(definition), run, finishedAt, true);
+      if (stored) return this.existingHandle(definition, stored);
     }
-    return { run, result, error, threw };
+    const run = {
+      id: id ?? crypto.randomUUID(),
+      job: name,
+      status: "running",
+      startedAt: this.now(),
+      finishedAt: null,
+      durationMs: null,
+      error: null,
+      output: null,
+      metrics: {},
+      trigger
+    };
+    let recorded = false;
+    try {
+      await this.sync(definition);
+      await this.store.insertRun({ ...run });
+      recorded = true;
+    } catch (e) {
+      const stored = id === void 0 ? null : await this.store.getRun(id).catch(() => null);
+      if (stored) return this.existingHandle(definition, stored);
+      this.onError(e, `recording ${name}`);
+    }
+    if (recorded) {
+      await this.updateState(name, (before) => ({ state: onRunStart(before), result: void 0 })).catch((e) => this.onError(e, `starting ${name}`));
+    }
+    return this.runHandle(definition, run.id, run, recorded, null);
   }
-  /** Whether a check already marked this run as timed out, for a failure that finished late. */
-  async markedTimedOut(run) {
-    if (run.status === "ok") return false;
+  /** job.resume() and cw.resumeRun(). A store that cannot be read is reported, and finish() reads it again. */
+  async resumeHandle(definition, runId) {
+    checkRunId(definition.name, runId, "resume");
+    let stored;
     try {
-      return (await this.store.getRun(run.id))?.status === "timeout";
-    } catch {
-      return false;
+      await this.ensureReady();
+      stored = await this.store.getRun(runId);
+    } catch (e) {
+      this.onError(e, `resuming ${definition.name}`);
+      return this.runHandle(definition, runId, null, true, null);
+    }
+    if (!stored) return this.runHandle(definition, runId, null, true, "was not found");
+    return this.existingHandle(definition, stored);
+  }
+  /** A handle on a stored run. One still running, or marked timeout by a check, can be finished. */
+  existingHandle(definition, stored) {
+    if (stored.job !== definition.name) {
+      throw new Error(`run "${stored.id}" belongs to job "${stored.job}", not "${definition.name}"`);
+    }
+    const finished = stored.status === "ok" || stored.status === "failed";
+    return this.runHandle(definition, stored.id, stored, true, finished ? `already finished as ${stored.status}` : null);
+  }
+  /**
+   * The handle itself. `base` is the run as last known here, `recorded`
+   * whether its start is in the store, and `inactive` why finish() has
+   * nothing to do, or null. Lines and metrics wait in the handle until
+   * flush() or finish() merges them onto a fresh read of the stored run.
+   */
+  runHandle(definition, id, base, recorded, inactive) {
+    const self = this;
+    const name = definition.name;
+    const fresh = () => createRecorder({ id, job: name, startedAt: base?.startedAt ?? 0 });
+    let recorder = fresh();
+    let finished = inactive !== null;
+    let finishCalled = false;
+    let head = null;
+    let queue = Promise.resolve();
+    const inTurn = (fn) => {
+      const result = queue.then(fn);
+      queue = result.catch(() => {
+      });
+      return result;
+    };
+    const ignored = (why) => self.report(new Error(`run ${id} of ${name} ${why}; ignored`), `finishing ${name}`);
+    const finish = (outcome) => {
+      if (finishCalled) {
+        ignored("was already finished by this handle");
+        return Promise.resolve(null);
+      }
+      finishCalled = true;
+      const wasInactive = finished;
+      finished = true;
+      const retryable = (error) => {
+        finishCalled = false;
+        finished = false;
+        self.report(error, `finishing ${name}`);
+        return null;
+      };
+      return inTurn(async () => {
+        if (wasInactive) {
+          ignored(inactive);
+          return null;
+        }
+        let from = base;
+        if (recorded) {
+          try {
+            from = await self.store.getRun(id) ?? base;
+          } catch (e) {
+            return retryable(e);
+          }
+        }
+        if (!from) {
+          ignored("was not found");
+          return null;
+        }
+        if (from.job !== name) {
+          ignored(`belongs to job "${from.job}"`);
+          return null;
+        }
+        if (from.status === "ok" || from.status === "failed") {
+          ignored(`was already finished as ${from.status}`);
+          return null;
+        }
+        const failed = typeof outcome === "object" && outcome !== null && "error" in outcome;
+        const result = typeof outcome === "string" ? outcome : failed ? void 0 : outcome?.result;
+        const error = failed ? outcome.error : void 0;
+        const finishedAt = self.now();
+        const added = recorder.output() ?? (typeof result === "string" ? capOutput(result) : null);
+        const run = {
+          ...from,
+          status: "running",
+          finishedAt,
+          durationMs: Math.max(0, finishedAt - from.startedAt),
+          error: null,
+          output: joinOutput(from.output, added),
+          metrics: { ...from.metrics, ...recorder.metrics() }
+        };
+        const expectText = joinLines(head, joinLines(from.output, recorder.expectText() ?? (typeof result === "string" ? result : null)));
+        self.conclude(definition, run, result, error, failed, expectText);
+        let why;
+        try {
+          why = await self.recordFinish(definition, run, recorded, finishedAt);
+        } catch (e) {
+          return retryable(e);
+        }
+        if (why) {
+          ignored(why);
+          return null;
+        }
+        return run;
+      });
+    };
+    return {
+      id,
+      job: name,
+      startedAt: base?.startedAt ?? null,
+      get active() {
+        return !finished;
+      },
+      log: (...parts) => recorder.context.log(...parts),
+      metric: (metric, value) => recorder.context.metric(metric, value),
+      metrics: (values) => recorder.context.metrics(values),
+      flush: () => inTurn(async () => {
+        if (finished || !recorded) return;
+        const lines = recorder.output();
+        const metrics = recorder.metrics();
+        if (lines === null && Object.keys(metrics).length === 0) return;
+        const taken = recorder;
+        recorder = fresh();
+        const putBack = () => {
+          const later = recorder;
+          recorder = fresh();
+          for (const text of [taken.expectText(), later.expectText()]) if (text !== null) recorder.context.log(text);
+          recorder.context.metrics({ ...taken.metrics(), ...later.metrics() });
+        };
+        try {
+          const stored = await self.store.getRun(id);
+          if (!stored || stored.status !== "running") return putBack();
+          if (stored.job !== name) {
+            putBack();
+            self.report(new Error(`run ${id} of ${name} belongs to job "${stored.job}"; ignored`), `flushing ${name}`);
+            return;
+          }
+          const output = lines === null ? stored.output : joinOutput(stored.output, stripNul(self.redact(lines)));
+          if (!await self.writeRunIf({ ...stored, output, metrics: { ...stored.metrics, ...metrics } }, ["running"])) return putBack();
+          const text = taken.expectText();
+          if (text !== null && (head === null || head.length < OUTPUT_CAP)) head = (joinLines(head, text) ?? "").slice(0, OUTPUT_CAP);
+        } catch (e) {
+          putBack();
+          self.report(e, `flushing ${name}`);
+        }
+      }),
+      finish,
+      fail: (error) => finish({ error })
+    };
+  }
+  /**
+   * Record a run that happened outside this process, for a Source. Its job
+   * must be declared with job() first. Runs are keyed by id: a new one is
+   * inserted, a stored one still running (or marked timeout by a check) is
+   * finished when this one is not running, and anything else is left alone,
+   * so recording the same run twice changes nothing. Finishing is
+   * conditional (see Store.updateRunIf): when two processes record the same
+   * finish, only the one whose write lands evaluates it, and the other
+   * reports it as already finished. A stored run of another job is left
+   * alone and reported. A finished run is judged as if it had been wrapped
+   * here (expect, failures, duration, budgets) and its output and error are
+   * redacted the same way; one finishing after a check marked it timeout is
+   * judged only when it succeeded, as RunHandle.finish() does. Returns the
+   * alerts it sent.
+   */
+  async recordRun(input, options = {}) {
+    const declared = this.definitions.get(input.job);
+    if (!declared) throw new Error(`recordRun: job "${input.job}" is not declared; call job() first`);
+    await this.sync(declared);
+    const run = { ...input, metrics: { ...input.metrics } };
+    if (run.status === "ok") {
+      const unmet = checkExpectation(declared.expect, run.output);
+      if (unmet) {
+        run.status = "failed";
+        run.error = unmet;
+      }
+    }
+    if (run.output !== null) run.output = stripNul(this.redact(capOutput(run.output)));
+    if (run.error !== null) run.error = stripNul(this.redact(capOutput(run.error)));
+    const evaluate = options.evaluate !== false;
+    const definition = toStored(declared);
+    const stored = await this.store.getRun(run.id);
+    if (stored) return this.recordOver(definition, stored, run, evaluate);
+    try {
+      await this.store.insertRun(run);
+    } catch (e) {
+      const again = await this.store.getRun(run.id).catch(() => null);
+      if (again) return this.recordOver(definition, again, run, evaluate);
+      throw e;
+    }
+    if (!evaluate) return [];
+    await this.updateState(run.job, (before) => ({ state: onRunStart(before), result: void 0 }));
+    if (run.status === "running") return [];
+    return this.finishRun(definition, run, this.now());
+  }
+  /** recordRun() for a run already stored. */
+  async recordOver(definition, stored, run, evaluate) {
+    if (stored.job !== run.job) {
+      this.report(new Error(`run ${run.id} of ${run.job} belongs to job "${stored.job}"; ignored`), `recording ${run.job}`);
+      return [];
+    }
+    if (stored.status !== "running" && stored.status !== "timeout" || run.status === "running") return [];
+    const claim = await this.claimFinish(run);
+    if ("ignored" in claim) {
+      this.report(new Error(`run ${run.id} of ${run.job} ${claim.ignored}; ignored`), `recording ${run.job}`);
+      return [];
     }
+    if (!evaluate || claim.lateAfterTimeout && run.status !== "ok") return [];
+    return this.finishRun(definition, run, this.now());
   }
   /**
-   * Record a finished run (ok, failed, or timed out by a check), evaluate it
-   * against the job's state and send what that produces. Never throws.
+   * Evaluate a finished run (ok, failed, or timed out by a check), already
+   * written, against the job's state and send what that produces. Never throws.
    */
-  async finishRun(definition, run, now, write) {
+  async finishRun(definition, run, now) {
     let drafts;
     try {
-      if (write) await this.store.updateRun(run);
       let history = null;
       ({ result: drafts } = await this.updateState(run.job, async (previous) => {
         history ??= await this.history(run);
@@ -1537,9 +2568,16 @@ var CronWatch = class {
   }
   async runCheck() {
     await this.ensureReady();
+    const alerts = [];
+    for (const source of this.sources) {
+      try {
+        alerts.push(...await source.sync(this) ?? []);
+      } catch (e) {
+        this.onError(e, `source ${source.name}`);
+      }
+    }
     for (const definition of this.definitions.values()) await this.sync(definition);
     const now = this.now();
-    const alerts = [];
     for (const run of await this.store.runningRuns()) {
       try {
         const declared = this.definitions.get(run.job);
@@ -1550,7 +2588,8 @@ var CronWatch = class {
         run.finishedAt = now;
         run.durationMs = now - run.startedAt;
         run.error = `Still running after ${formatDuration(timeout)}; marked as timed out`;
-        alerts.push(...await this.finishRun(definition, run, now, true));
+        if (!await this.writeRunIf(run, ["running"])) continue;
+        alerts.push(...await this.finishRun(definition, run, now));
       } catch (e) {
         this.onError(e, `checking ${run.job}`);
       }
@@ -1668,7 +2707,11 @@ var CronWatch = class {
   routes(options) {
     return createRoutes(this, options);
   }
-  /** Check on an interval, for long-running servers. Default every minute. */
+  /**
+   * Check on an interval, for long-running servers. Default every minute.
+   * Not for serverless functions or Cloudflare Workers, where nothing runs
+   * between requests: call check() from a cron there instead.
+   */
   start(every = "1m") {
     if (this.timer) return;
     const ms = Math.max(5e3, parseDuration(every, "check interval"));
@@ -1777,7 +2820,7 @@ var CronWatch = class {
     const results = await Promise.all(
       this.alerts.map(async (channel) => {
         try {
-          await withTimeout(channel.send(alert), CHANNEL_TIMEOUT_MS);
+          await withTimeout(channel.send(alert, { onError: (e) => this.report(e, `alert channel ${channel.name}`) }), CHANNEL_TIMEOUT_MS);
           return true;
         } catch (e) {
           this.onError(e, `alert channel ${channel.name}`);
@@ -1801,8 +2844,24 @@ var CronWatch = class {
     }
   }
 };
-function isDevelopment() {
-  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+var RESERVED_RUN_ID_PREFIX = "pgcron:";
+function checkRunId(job, id, method) {
+  if (typeof id !== "string" || id.length === 0 || id.length > 200) {
+    throw new Error(`job "${job}": ${method}() needs a run id of 1 to 200 characters (got ${typeof id === "string" ? `${id.length} characters` : typeof id})`);
+  }
+  if (id.startsWith(RESERVED_RUN_ID_PREFIX)) {
+    throw new Error(`job "${job}": ${method}() cannot take a run id starting with "${RESERVED_RUN_ID_PREFIX}", which the pg_cron source uses for its runs`);
+  }
+}
+function joinLines(before, after) {
+  if (before === null || before === "") return after;
+  if (after === null) return before;
+  return `${before}
+${after}`;
+}
+function joinOutput(before, after) {
+  const joined = joinLines(before, after);
+  return joined === null ? null : capOutput(joined);
 }
 function clampLimit(limit, fallback, min) {
   const n = typeof limit === "number" && Number.isFinite(limit) ? Math.trunc(limit) : fallback;