@cronwatch/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1317 @@
+'use strict';
+
+var croner = require('croner');
+
+// src/duration.ts
+var UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5,
+  w: 6048e5
+};
+function parseDuration(value, label = "duration") {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) throw new Error(`${label} must be a non-negative number of milliseconds`);
+    return value;
+  }
+  const text = value.trim().toLowerCase();
+  if (text === "") throw new Error(`${label} is empty`);
+  const re = /(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)/g;
+  let total = 0;
+  let consumed = "";
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    total += parseFloat(match[1]) * UNIT_MS[match[2]];
+    consumed += match[0];
+  }
+  if (consumed.replace(/\s+/g, "") !== text.replace(/\s+/g, "")) {
+    throw new Error(`${label} "${value}" is not a duration like "15m", "1h30m" or "90s"`);
+  }
+  return Math.round(total);
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms)) return "?";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const parts = [];
+  let rest = Math.round(ms / 1e3);
+  const units = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+  for (const [unit, size] of units) {
+    if (rest >= size) {
+      const n = Math.floor(rest / size);
+      rest -= n * size;
+      parts.push(`${n}${unit}`);
+    }
+    if (parts.length === 2) break;
+  }
+  return parts.join(" ") || "0s";
+}
+function formatRelative(at, now) {
+  const diff = at - now;
+  const abs = Math.abs(diff);
+  const text = abs < 5e3 ? "now" : formatDuration(abs);
+  if (abs < 5e3) return text;
+  return diff < 0 ? `${text} ago` : `in ${text}`;
+}
+var cache = /* @__PURE__ */ new Map();
+function parseSchedule(schedule, timezone) {
+  const key = `${timezone ?? ""}|${schedule}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const text = schedule.trim();
+  const every = /^every\s+(.+)$/i.exec(text);
+  let parsed;
+  if (every) {
+    const everyMs = parseDuration(every[1], "schedule interval");
+    if (everyMs < 1e3) throw new Error(`schedule "${schedule}" is shorter than one second`);
+    parsed = { kind: "interval", source: text, everyMs };
+  } else {
+    let cron;
+    try {
+      cron = new croner.Cron(text, timezone ? { timezone } : {});
+    } catch (error) {
+      throw new Error(`schedule "${schedule}" is not a cron expression or "every <duration>": ${error.message}`);
+    }
+    parsed = { kind: "cron", source: text, cron };
+  }
+  cache.set(key, parsed);
+  return parsed;
+}
+function nextFire(parsed, from, lastRunAt) {
+  if (parsed.kind === "interval") {
+    const base = lastRunAt ?? from;
+    return base + parsed.everyMs;
+  }
+  const next = parsed.cron.nextRun(new Date(from));
+  return next ? next.getTime() : null;
+}
+function previousFire(parsed, now) {
+  if (parsed.kind !== "cron") throw new Error("previousFire is for cron schedules");
+  const cron = parsed.cron;
+  const fireAtOrBefore = (from) => {
+    const next = cron.nextRun(new Date(from - 1));
+    if (!next) return null;
+    const t = next.getTime();
+    return t <= now ? t : null;
+  };
+  const YEAR = 366 * 864e5;
+  let step = 6e4;
+  let lo = null;
+  while (step <= YEAR) {
+    if (fireAtOrBefore(now - step) !== null) {
+      lo = now - step;
+      break;
+    }
+    step *= 2;
+  }
+  if (lo === null) return null;
+  let hi = now;
+  while (hi - lo > 1) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (fireAtOrBefore(mid) !== null) lo = mid;
+    else hi = mid;
+  }
+  return fireAtOrBefore(lo);
+}
+function expectation(parsed, now, lastRunAt, registeredAt, graceMs2) {
+  if (parsed.kind === "interval") {
+    const dueAt = (lastRunAt ?? registeredAt) + parsed.everyMs;
+    return { dueAt, deadline: dueAt + graceMs2 };
+  }
+  const prev = previousFire(parsed, now);
+  if (prev === null || prev < registeredAt) return null;
+  return { dueAt: prev, deadline: prev + graceMs2 };
+}
+function runCovers(startedAt, dueAt) {
+  return startedAt >= dueAt - 6e4;
+}
+
+// src/stats.ts
+function percentile(values, p) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(p / 100 * sorted.length) - 1));
+  return sorted[index];
+}
+function median(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+
+// src/evaluate.ts
+var DEFAULT_GRACE_MS = 10 * 6e4;
+var DEFAULT_TIMEOUT_MS = 60 * 6e4;
+var SLOW_FLOOR_MS = 1e4;
+var BASELINE_MIN_RUNS = 5;
+var BASELINE_WINDOW = 20;
+function emptyState(job) {
+  return { job, open: {}, consecutiveFailures: 0, silencedUntil: null, lastAlertAt: null };
+}
+function cloneState(state) {
+  return { ...state, open: { ...state.open } };
+}
+function openCondition(state, condition, now) {
+  if (state.open[condition] !== void 0) return false;
+  state.open[condition] = now;
+  return true;
+}
+function closeCondition(state, condition) {
+  if (state.open[condition] === void 0) return false;
+  delete state.open[condition];
+  return true;
+}
+function openConditions(state) {
+  return Object.keys(state.open);
+}
+function graceMs(def) {
+  return def.grace === void 0 ? DEFAULT_GRACE_MS : parseDuration(def.grace, "grace");
+}
+function timeoutMs(def) {
+  return def.timeout === void 0 ? DEFAULT_TIMEOUT_MS : parseDuration(def.timeout, "timeout");
+}
+function slowThreshold(def, history) {
+  if (def.maxDuration !== void 0) {
+    return { thresholdMs: parseDuration(def.maxDuration, "maxDuration"), basis: "maxDuration" };
+  }
+  const durations = history.filter((r) => r.status === "ok" && r.durationMs !== null).slice(0, BASELINE_WINDOW).map((r) => r.durationMs);
+  if (durations.length < BASELINE_MIN_RUNS) return null;
+  const p95 = percentile(durations, 95);
+  return { thresholdMs: Math.max(2 * p95, SLOW_FLOOR_MS), basis: `twice the p95 of the last ${durations.length} runs (${formatDuration(p95)})` };
+}
+function budgetBreaches(def, run, history) {
+  const breaches = [];
+  for (const [metric, value] of Object.entries(run.metrics)) {
+    const ceiling = def.budget?.[metric];
+    if (ceiling !== void 0) {
+      if (value > ceiling) breaches.push({ metric, value, limit: ceiling, basis: "budget" });
+      continue;
+    }
+    const past = history.filter((r) => r.status === "ok" && typeof r.metrics[metric] === "number").slice(0, BASELINE_WINDOW).map((r) => r.metrics[metric]);
+    if (past.length < BASELINE_MIN_RUNS) continue;
+    const usual = median(past);
+    if (usual > 0 && value > 3 * usual) {
+      breaches.push({ metric, value, limit: 3 * usual, basis: `three times the usual ${formatNumber(usual)}` });
+    }
+  }
+  return breaches;
+}
+function formatNumber(n) {
+  if (Number.isInteger(n)) return n.toLocaleString("en-US");
+  return n.toLocaleString("en-US", { maximumFractionDigits: 4 });
+}
+function onRunStart(state) {
+  const next = cloneState(state);
+  const openBefore = openConditions(next);
+  closeCondition(next, "missed");
+  closeCondition(next, "stuck");
+  return { state: next, openBefore };
+}
+function onRunFinish(def, run, state, history, openBefore, now) {
+  const next = cloneState(state);
+  const alerts = [];
+  if (run.status === "ok") {
+    next.consecutiveFailures = 0;
+    closeCondition(next, "failed");
+    closeCondition(next, "missed");
+    closeCondition(next, "stuck");
+    const slow = slowThreshold(def, history);
+    if (slow && run.durationMs !== null && run.durationMs > slow.thresholdMs) {
+      if (openCondition(next, "slow", now)) {
+        alerts.push({ type: "slow", run, details: { durationMs: run.durationMs, thresholdMs: slow.thresholdMs, basis: slow.basis } });
+      }
+    } else {
+      closeCondition(next, "slow");
+    }
+    const breaches = budgetBreaches(def, run, history);
+    if (breaches.length > 0) {
+      if (openCondition(next, "over_budget", now)) {
+        alerts.push({ type: "over_budget", run, details: { breaches } });
+      }
+    } else {
+      closeCondition(next, "over_budget");
+    }
+    const wasOpen = /* @__PURE__ */ new Set([...openBefore, ...openConditions(state)]);
+    if (wasOpen.size > 0 && openConditions(next).length === 0) {
+      alerts.push({ type: "recovered", run, details: { after: [...wasOpen] } });
+    }
+    return { state: next, alerts };
+  }
+  next.consecutiveFailures += 1;
+  closeCondition(next, "missed");
+  const threshold = Math.max(1, def.failuresBeforeAlert ?? 1);
+  const condition = run.status === "timeout" ? "stuck" : "failed";
+  if (next.consecutiveFailures >= threshold) {
+    if (openCondition(next, condition, now)) {
+      alerts.push({ type: condition, run, details: { consecutiveFailures: next.consecutiveFailures, threshold } });
+    }
+  }
+  return { state: next, alerts };
+}
+function onCheck(def, stored, lastRun, state, now) {
+  const next = cloneState(state);
+  const alerts = [];
+  if (!def.schedule) return { state: next, alerts, nextExpectedAt: null, dueAt: null };
+  const parsed = parseSchedule(def.schedule, def.timezone);
+  const grace = graceMs(def);
+  const exp = expectation(parsed, now, lastRun?.startedAt ?? null, stored.createdAt, grace);
+  let nextExpectedAt = null;
+  if (parsed.kind === "interval") {
+    nextExpectedAt = (lastRun?.startedAt ?? stored.createdAt) + parsed.everyMs;
+  } else {
+    const upcoming = parsed.cron.nextRun(new Date(now));
+    nextExpectedAt = upcoming ? upcoming.getTime() : null;
+  }
+  if (!exp) return { state: next, alerts, nextExpectedAt, dueAt: null };
+  const covered = parsed.kind === "cron" && lastRun !== null && runCovers(lastRun.startedAt, exp.dueAt);
+  if (covered) {
+    closeCondition(next, "missed");
+  } else if (now > exp.deadline) {
+    if (openCondition(next, "missed", now)) {
+      alerts.push({
+        type: "missed",
+        run: lastRun,
+        details: { dueAt: exp.dueAt, deadline: exp.deadline, graceMs: grace, lastRunAt: lastRun?.startedAt ?? null }
+      });
+    }
+  }
+  return { state: next, alerts, nextExpectedAt, dueAt: exp.dueAt };
+}
+function isStuck(def, run, now) {
+  return run.status === "running" && now - run.startedAt > timeoutMs(def);
+}
+function muteOpens(previous, next) {
+  const muted = cloneState(next);
+  for (const condition of openConditions(muted)) {
+    if (previous.open[condition] === void 0) delete muted.open[condition];
+  }
+  return muted;
+}
+function isSilenced(state, now) {
+  return state.silencedUntil !== null && state.silencedUntil > now;
+}
+
+// src/format.ts
+function when(at, now) {
+  if (at === null || at === void 0) return "never";
+  return `${new Date(at).toISOString().replace("T", " ").slice(0, 19)} UTC (${formatRelative(at, now)})`;
+}
+function firstLines(text, n) {
+  if (!text) return "";
+  return text.split("\n").slice(0, n).join("\n");
+}
+function tail(text, n) {
+  if (!text) return "";
+  const lines = text.trimEnd().split("\n");
+  return lines.slice(Math.max(0, lines.length - n)).join("\n");
+}
+function composeAlert(draft, def, now) {
+  const name = def.name;
+  const run = draft.run;
+  const d = draft.details;
+  let title;
+  const lines = [];
+  switch (draft.type) {
+    case "missed": {
+      title = `${name} missed its scheduled run`;
+      lines.push(`Due ${when(d.dueAt, now)}, and no run had started by ${when(d.deadline, now)} (grace ${formatDuration(d.graceMs)}).`);
+      lines.push(`Schedule: ${def.schedule}${def.timezone ? ` (${def.timezone})` : ""}.`);
+      lines.push(`Last run: ${run ? `${run.status} ${when(run.startedAt, now)}` : "never"}.`);
+      break;
+    }
+    case "failed": {
+      title = `${name} failed`;
+      const n = d.consecutiveFailures;
+      if (n > 1) lines.push(`${n} consecutive failures.`);
+      if (run) {
+        lines.push(`Started ${when(run.startedAt, now)}${run.durationMs !== null ? `, ran ${formatDuration(run.durationMs)}` : ""}.`);
+        if (run.error) lines.push(`Error: ${firstLines(run.error, 4)}`);
+        const out = tail(run.output, 8);
+        if (out) lines.push(`Output (tail):
+${out}`);
+      }
+      break;
+    }
+    case "stuck": {
+      title = `${name} is stuck`;
+      if (run) {
+        lines.push(`Started ${when(run.startedAt, now)} and never reported finishing. Marked as timed out after ${formatDuration(run.durationMs ?? now - run.startedAt)}.`);
+        const out = tail(run.output, 8);
+        if (out) lines.push(`Output so far (tail):
+${out}`);
+      }
+      lines.push(`If the process was killed mid-run (a serverless timeout, a deploy), this is what that looks like.`);
+      break;
+    }
+    case "slow": {
+      title = `${name} was slow`;
+      lines.push(`Took ${formatDuration(d.durationMs)}; the limit is ${formatDuration(d.thresholdMs)} (${d.basis}).`);
+      if (run) lines.push(`Started ${when(run.startedAt, now)}.`);
+      break;
+    }
+    case "over_budget": {
+      title = `${name} went over budget`;
+      for (const b of d.breaches) {
+        lines.push(`${b.metric}: ${formatNumber(b.value)}, limit ${formatNumber(b.limit)} (${b.basis}).`);
+      }
+      if (run) lines.push(`Started ${when(run.startedAt, now)}.`);
+      break;
+    }
+    case "recovered": {
+      title = `${name} recovered`;
+      const after = d.after.map((c) => c.replace("_", " ")).join(", ");
+      lines.push(`A run ${run ? when(run.startedAt, now) : "just now"} succeeded${after ? ` after: ${after}` : ""}.`);
+      if (run?.durationMs !== null && run?.durationMs !== void 0) lines.push(`Ran ${formatDuration(run.durationMs)}.`);
+      break;
+    }
+  }
+  return {
+    type: draft.type,
+    job: name,
+    definition: def,
+    run,
+    title,
+    message: lines.join("\n"),
+    details: d,
+    at: now
+  };
+}
+
+// src/http.ts
+function json(body, status = 200, headers = {}) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", ...headers }
+  });
+}
+
+// src/output.ts
+var OUTPUT_CAP = 16 * 1024;
+function capOutput(text) {
+  if (text.length <= OUTPUT_CAP) return text;
+  return "[earlier output trimmed]\n" + text.slice(text.length - OUTPUT_CAP);
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    const stack = error.stack ? `
+${error.stack.split("\n").slice(1, 6).join("\n")}` : "";
+    return `${error.name}: ${error.message}${stack}`;
+  }
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+// src/job.ts
+function stringify(part) {
+  if (typeof part === "string") return part;
+  if (part instanceof Error) return `${part.name}: ${part.message}`;
+  try {
+    return JSON.stringify(part);
+  } catch {
+    return String(part);
+  }
+}
+function createRecorder(run) {
+  const lines = [];
+  let size = 0;
+  const metrics = {};
+  const controller = new AbortController();
+  const context = {
+    name: run.job,
+    runId: run.id,
+    startedAt: run.startedAt,
+    signal: controller.signal,
+    log(...parts) {
+      const line = parts.map(stringify).join(" ");
+      lines.push(line);
+      size += line.length + 1;
+      while (size > 64 * 1024 && lines.length > 1) {
+        size -= lines.shift().length + 1;
+      }
+    },
+    metric(name, value) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`metric "${name}" must be a finite number`);
+      }
+      metrics[name] = value;
+    },
+    metrics(values) {
+      for (const [k, v] of Object.entries(values)) context.metric(k, v);
+    }
+  };
+  return {
+    context,
+    output: () => lines.length === 0 ? null : capOutput(lines.join("\n")),
+    metrics: () => ({ ...metrics }),
+    abort: () => controller.abort()
+  };
+}
+
+// src/serialize.ts
+function toStored(def) {
+  const { expect, ...rest } = def;
+  const stored = { ...rest };
+  if (expect !== void 0) {
+    stored.expect = typeof expect === "string" ? `contains ${JSON.stringify(expect)}` : expect instanceof RegExp ? `matches ${expect.toString()}` : "custom function";
+  }
+  return stored;
+}
+function checkExpectation(expect, output) {
+  if (expect === void 0) return null;
+  const text = output ?? "";
+  if (typeof expect === "string") {
+    return text.includes(expect) ? null : `Output did not contain ${JSON.stringify(expect)}`;
+  }
+  if (expect instanceof RegExp) {
+    return expect.test(text) ? null : `Output did not match ${expect.toString()}`;
+  }
+  let ok = false;
+  try {
+    ok = expect(text);
+  } catch (error) {
+    return `Output check threw: ${error.message}`;
+  }
+  return ok ? null : "Output did not pass the expect() check";
+}
+
+// src/routes/html.ts
+function escapeHtml(value) {
+  return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+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}}
+*{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}
+.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}}
+`;
+function layout(title, body, options = {}) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="robots" content="noindex,nofollow">
+${options.refresh ? `<meta http-equiv="refresh" content="${options.refresh}">` : ""}
+<title>${h(title)}</title>
+<style>${CSS}</style>
+</head>
+<body><main>${body}</main></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 runPill(run) {
+  const cls = run.status === "ok" ? "ok" : run.status === "running" ? "info" : "bad";
+  return `<span class="pill ${cls}">${h(run.status)}</span>`;
+}
+function sparkline(runs) {
+  const points = [...runs].reverse().filter((r) => r.durationMs !== null).slice(-20);
+  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>`;
+}
+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 rows = jobs.map((job) => {
+    const last = job.lastRun;
+    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="hide-sm">${sparkline(runsByJob.get(job.name) ?? [])}</td>
+</tr>`;
+  }).join("\n");
+  const body = `
+<header>
+  <h1><a href="${h(base)}/">CronWatch</a></h1>
+  <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>
+  </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) {
+  const d = job.definition;
+  const okRate = `${Math.round(job.stats.okRate * 100)}%`;
+  const runRows = runs.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>` : ""
+    ].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>
+<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>` : ""}`;
+  }).join("\n");
+  const silenced = job.silencedUntil !== null && job.silencedUntil > 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>`}
+    <form class="inline" method="post" action="${h(base)}/jobs/${encodeURIComponent(job.name)}/forget" onsubmit="return confirm('Remove this job and its runs from the store?')"><button type="submit">Forget</button></form>
+  </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 ${job.stats.runs}</div><div class="v">${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>` : ""}
+  ${d.failuresBeforeAlert && d.failuresBeforeAlert > 1 ? `<dt>Alert after</dt><dd>${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>${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>`);
+}
+
+// src/routes/index.ts
+var COOKIE = "cronwatch_token";
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function readCookie(request, name) {
+  const header = request.headers.get("cookie");
+  if (!header) return null;
+  for (const part of header.split(";")) {
+    const [k, ...rest] = part.trim().split("=");
+    if (k === name) return decodeURIComponent(rest.join("="));
+  }
+  return null;
+}
+function stripBase(pathname, base) {
+  let path = pathname.startsWith(base) ? pathname.slice(base.length) : pathname;
+  if (path === "") path = "/";
+  if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+  return path;
+}
+async function readBody(request) {
+  const type = request.headers.get("content-type") ?? "";
+  try {
+    if (type.includes("application/json")) {
+      const data = await request.json();
+      return typeof data === "object" && data !== null ? Object.fromEntries(Object.entries(data).map(([k, v]) => [k, String(v)])) : {};
+    }
+    if (type.includes("application/x-www-form-urlencoded") || type.includes("multipart/form-data")) {
+      const form = await request.formData();
+      const out = {};
+      for (const [k, v] of form.entries()) out[k] = String(v);
+      return out;
+    }
+  } catch {
+    return {};
+  }
+  return {};
+}
+function createRoutes(cw, options = {}) {
+  const token = options.token === void 0 ? process.env.CRONWATCH_TOKEN ?? null : options.token;
+  const base = (options.basePath ?? "/cronwatch").replace(/\/+$/, "");
+  const production = process.env.NODE_ENV === "production";
+  const handler = async (request) => {
+    const url = new URL(request.url);
+    const path = stripBase(url.pathname, base);
+    const wantsHtml = !path.startsWith("/api");
+    const method = request.method.toUpperCase();
+    if (!token && production) {
+      return wantsHtml ? html(messagePage("CronWatch routes are locked", "Set CRONWATCH_TOKEN (or pass token to cw.routes()) to use them in production.", base), 503) : json({ ok: false, error: "CRONWATCH_TOKEN is not set" }, 503);
+    }
+    if (token) {
+      const bearer = request.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? null;
+      const query = url.searchParams.get("token");
+      const cookie = readCookie(request, COOKIE);
+      const presented = bearer ?? query ?? cookie;
+      const isCheck = path === "/api/check";
+      const cronSecretOk = isCheck && bearer !== null && cw.cronSecret !== null && constantTimeEqual(bearer, cw.cronSecret);
+      if (!cronSecretOk && (presented === null || !constantTimeEqual(presented, token))) {
+        return wantsHtml ? html(messagePage("Sign in", `Open this page with ?token=<your CRONWATCH_TOKEN> once and it will stay signed in.`, base), 401) : json({ ok: false, error: "Unauthorized" }, 401);
+      }
+      if (query !== null && wantsHtml && method === "GET") {
+        url.searchParams.delete("token");
+        const secure = url.protocol === "https:" ? "; Secure" : "";
+        return new Response(null, {
+          status: 303,
+          headers: {
+            location: url.pathname + (url.search || ""),
+            "set-cookie": `${COOKIE}=${encodeURIComponent(token)}; Path=${base || "/"}; HttpOnly; SameSite=Lax; Max-Age=${60 * 60 * 24 * 30}${secure}`
+          }
+        });
+      }
+    }
+    const redirectBack = () => {
+      const referer = request.headers.get("referer") ?? "";
+      const location = referer.startsWith(url.origin + "/") ? referer : `${base}/`;
+      return new Response(null, { status: 303, headers: { location } });
+    };
+    const jobName = (segment) => segment ? decodeURIComponent(segment) : "";
+    const parts = path.split("/").filter(Boolean);
+    if (method === "GET" && path === "/") {
+      const jobs = await cw.jobs();
+      const runsByJob = /* @__PURE__ */ new Map();
+      for (const job of jobs) runsByJob.set(job.name, await cw.runs(job.name, 20));
+      return html(dashboardPage(jobs, runsByJob, cw.now(), base));
+    }
+    if (method === "GET" && parts[0] === "jobs" && parts.length === 2) {
+      const job = await cw.jobSummary(jobName(parts[1]));
+      if (!job) return html(messagePage("No such job", `${jobName(parts[1])} is not in the store.`, base), 404);
+      return html(jobPage(job, await cw.runs(job.name, 50), cw.now(), base));
+    }
+    if (method === "POST" && path === "/check") {
+      await cw.check();
+      return redirectBack();
+    }
+    if (method === "POST" && parts[0] === "jobs" && parts.length === 3) {
+      const name = jobName(parts[1]);
+      const body = await readBody(request);
+      if (parts[2] === "silence") await cw.silence(name, safeDuration(body.for, "1h"));
+      else if (parts[2] === "unsilence") await cw.unsilence(name);
+      else if (parts[2] === "forget") {
+        await cw.forget(name);
+        return new Response(null, { status: 303, headers: { location: `${base}/` } });
+      } else return html(messagePage("Not found", path, base), 404);
+      return redirectBack();
+    }
+    if (parts[0] === "api") {
+      const rest = parts.slice(1);
+      if (method === "GET" && rest[0] === "jobs" && rest.length === 1) {
+        return json({ ok: true, jobs: await cw.jobs() });
+      }
+      if (rest[0] === "jobs" && rest.length === 2) {
+        const name = jobName(rest[1]);
+        if (method === "GET") {
+          const job = await cw.jobSummary(name);
+          if (!job) return json({ ok: false, error: "No such job" }, 404);
+          const limit = Number(url.searchParams.get("runs") ?? 20);
+          return json({ ok: true, job, runs: await cw.runs(name, Number.isFinite(limit) ? limit : 20) });
+        }
+        if (method === "DELETE") {
+          await cw.forget(name);
+          return json({ ok: true });
+        }
+      }
+      if (method === "POST" && rest[0] === "jobs" && rest.length === 3) {
+        const name = jobName(rest[1]);
+        if (!await cw.jobSummary(name)) return json({ ok: false, error: "No such job" }, 404);
+        const body = await readBody(request);
+        if (rest[2] === "silence") return json({ ok: true, state: await cw.silence(name, safeDuration(body.for ?? url.searchParams.get("for"), "1h")) });
+        if (rest[2] === "unsilence") return json({ ok: true, state: await cw.unsilence(name) });
+      }
+      if ((method === "GET" || method === "POST") && rest[0] === "check" && rest.length === 1) {
+        const result = await cw.check();
+        return json({ ok: true, ...result });
+      }
+      if (method === "GET" && rest[0] === "runs" && rest.length === 2) {
+        const run = await cw.getRun(rest[1]);
+        return run ? json({ ok: true, run }) : json({ ok: false, error: "No such run" }, 404);
+      }
+      return json({ ok: false, error: "Not found" }, 404);
+    }
+    return html(messagePage("Not found", path, base), 404);
+  };
+  return { handler, GET: handler, POST: handler, DELETE: handler };
+}
+function safeDuration(value, fallback) {
+  if (!value) return fallback;
+  try {
+    parseDuration(value);
+    return value;
+  } catch {
+    return fallback;
+  }
+}
+function html(body, status = 200) {
+  return new Response(body, {
+    status,
+    headers: { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "x-robots-tag": "noindex" }
+  });
+}
+
+// src/stores/memory.ts
+function memory() {
+  const jobs = /* @__PURE__ */ new Map();
+  const runs = /* @__PURE__ */ new Map();
+  const order = /* @__PURE__ */ new Map();
+  const states = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const clone = (v) => JSON.parse(JSON.stringify(v));
+  return {
+    async upsertJob(definition, now) {
+      const existing = jobs.get(definition.name);
+      jobs.set(definition.name, {
+        name: definition.name,
+        definition: clone(definition),
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      });
+    },
+    async getJob(name) {
+      const j = jobs.get(name);
+      return j ? clone(j) : null;
+    },
+    async listJobs() {
+      return [...jobs.values()].map(clone).sort((a, b) => a.name.localeCompare(b.name));
+    },
+    async deleteJob(name) {
+      jobs.delete(name);
+      states.delete(name);
+      for (const [id, run] of runs) if (run.job === name) {
+        runs.delete(id);
+        order.delete(id);
+      }
+    },
+    async insertRun(run) {
+      runs.set(run.id, clone(run));
+      order.set(run.id, ++seq);
+    },
+    async updateRun(run) {
+      runs.set(run.id, clone(run));
+    },
+    async getRun(id) {
+      const r = runs.get(id);
+      return r ? clone(r) : null;
+    },
+    async listRuns(job, limit) {
+      return [...runs.values()].filter((r) => r.job === job).sort((a, b) => b.startedAt - a.startedAt || order.get(b.id) - order.get(a.id)).slice(0, limit).map(clone);
+    },
+    async lastRun(job) {
+      const list = await this.listRuns(job, 1);
+      return list[0] ?? null;
+    },
+    async runningRuns() {
+      return [...runs.values()].filter((r) => r.status === "running").map(clone);
+    },
+    async getState(job) {
+      const s = states.get(job);
+      return s ? clone(s) : null;
+    },
+    async setState(state) {
+      states.set(state.job, clone(state));
+    },
+    async prune(before) {
+      let n = 0;
+      for (const [id, run] of runs) {
+        if (run.status !== "running" && run.startedAt < before) {
+          runs.delete(id);
+          order.delete(id);
+          n++;
+        }
+      }
+      return n;
+    }
+  };
+}
+
+// src/client.ts
+var NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/;
+var TRIAGE_TIMEOUT_MS = 25e3;
+var PRUNE_INTERVAL_MS = 60 * 6e4;
+function constantTimeEqual2(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+var CronWatch = class {
+  store;
+  alerts;
+  triage;
+  cronSecret;
+  retentionMs;
+  now;
+  onError;
+  defaults;
+  definitions = /* @__PURE__ */ new Map();
+  synced = /* @__PURE__ */ new Set();
+  ready = null;
+  checking = null;
+  lastPruneAt = 0;
+  timer = null;
+  usingDefaultStore = false;
+  constructor(options = {}) {
+    this.store = options.store ?? (this.usingDefaultStore = true, memory());
+    this.alerts = options.alerts ?? [consoleChannel()];
+    this.triage = options.triage;
+    this.cronSecret = options.cronSecret === void 0 ? process.env.CRON_SECRET ?? null : options.cronSecret;
+    this.retentionMs = parseDuration(options.retention ?? "30d", "retention");
+    this.defaults = options.defaults ?? {};
+    this.now = options.now ?? (() => Date.now());
+    this.onError = options.onError ?? ((error, where) => console.error(`[cronwatch] ${where}:`, error));
+  }
+  /** Declare a job. Call it once, at module level, and keep the handle. */
+  job(name, options = {}) {
+    if (!NAME_RE.test(name)) {
+      throw new Error(`job name "${name}" must be 1 to 120 characters of letters, digits, ".", "_", ":" or "-"`);
+    }
+    const definition = { ...this.defaults, ...options, name };
+    if (definition.schedule) parseSchedule(definition.schedule, definition.timezone);
+    if (definition.grace !== void 0) parseDuration(definition.grace, "grace");
+    if (definition.timeout !== void 0) parseDuration(definition.timeout, "timeout");
+    if (definition.maxDuration !== void 0) parseDuration(definition.maxDuration, "maxDuration");
+    this.definitions.set(name, definition);
+    this.synced.delete(name);
+    return this.handle(definition);
+  }
+  run(name, optionsOrFn, maybeFn) {
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    const options = typeof optionsOrFn === "function" ? void 0 : optionsOrFn;
+    const handle = options || !this.definitions.has(name) ? this.job(name, options) : this.handle(this.definitions.get(name));
+    return handle.run(fn);
+  }
+  /** The definitions declared in this process. */
+  definedJobs() {
+    return [...this.definitions.values()];
+  }
+  handle(definition) {
+    const self = this;
+    return {
+      name: definition.name,
+      definition,
+      async run(fn, options) {
+        const outcome = await self.execute(definition, fn, options?.trigger ?? "run");
+        if (outcome.threw) throw outcome.error;
+        return outcome.result;
+      },
+      handler(fn, options) {
+        const secret = options?.secret === void 0 ? self.cronSecret : options.secret;
+        return async (request) => {
+          if (secret) {
+            const header = request.headers.get("authorization") ?? "";
+            if (!constantTimeEqual2(header, `Bearer ${secret}`)) {
+              return json({ ok: false, error: "Unauthorized" }, 401);
+            }
+          }
+          const outcome = await self.execute(definition, (job) => fn(job, request), "handler");
+          if (outcome.result instanceof Response) return outcome.result;
+          const body = {
+            ok: outcome.run.status === "ok",
+            job: definition.name,
+            run: outcome.run.id,
+            status: outcome.run.status,
+            durationMs: outcome.run.durationMs,
+            ...outcome.run.error ? { error: outcome.run.error.split("\n")[0] } : {}
+          };
+          return json(body, outcome.run.status === "ok" ? 200 : 500);
+        };
+      }
+    };
+  }
+  async ensureReady() {
+    if (!this.ready) {
+      this.ready = (async () => {
+        if (this.store.init) await this.store.init();
+        if (this.usingDefaultStore && process.env.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.");
+        }
+      })();
+    }
+    await this.ready;
+  }
+  async sync(definition) {
+    await this.ensureReady();
+    if (this.synced.has(definition.name)) return;
+    await this.store.upsertJob(toStored(definition), this.now());
+    this.synced.add(definition.name);
+  }
+  /** Runs a function as a recorded run. Never throws for the job's own error; see `threw`. */
+  async execute(definition, fn, trigger) {
+    await this.sync(definition);
+    const startedAt = this.now();
+    const run = {
+      id: crypto.randomUUID(),
+      job: definition.name,
+      status: "running",
+      startedAt,
+      finishedAt: null,
+      durationMs: null,
+      error: null,
+      output: null,
+      metrics: {},
+      trigger
+    };
+    await this.store.insertRun(run);
+    const before = await this.store.getState(definition.name) ?? emptyState(definition.name);
+    const started = onRunStart(before);
+    if (openConditions(started.state).length !== openConditions(before).length) {
+      await this.store.setState(started.state);
+    }
+    const recorder = createRecorder(run);
+    const timer = setTimeout(() => recorder.abort(), timeoutMs(definition));
+    if (typeof timer === "object" && "unref" in timer) timer.unref();
+    let result;
+    let error;
+    let threw = false;
+    try {
+      result = await fn(recorder.context);
+    } catch (e) {
+      error = e;
+      threw = true;
+    } finally {
+      clearTimeout(timer);
+    }
+    const finishedAt = this.now();
+    run.finishedAt = finishedAt;
+    run.durationMs = Math.max(0, finishedAt - startedAt);
+    run.metrics = recorder.metrics();
+    run.output = recorder.output() ?? (typeof result === "string" ? result : null);
+    if (threw) {
+      run.status = "failed";
+      run.error = errorMessage(error);
+    } else if (result instanceof Response && result.status >= 400) {
+      run.status = "failed";
+      run.error = `HTTP ${result.status}${result.statusText ? ` ${result.statusText}` : ""}`;
+    } else {
+      const unmet = checkExpectation(definition.expect, run.output);
+      if (unmet) {
+        run.status = "failed";
+        run.error = unmet;
+      } else {
+        run.status = "ok";
+      }
+    }
+    await this.store.updateRun(run);
+    try {
+      const history = (await this.store.listRuns(definition.name, BASELINE_WINDOW + 5)).filter((r) => r.id !== run.id);
+      const state = await this.store.getState(definition.name) ?? emptyState(definition.name);
+      const evaluation = onRunFinish(definition, run, state, history, started.openBefore, finishedAt);
+      await this.settle(state, evaluation, toStored(definition), finishedAt);
+    } catch (e) {
+      this.onError(e, `evaluating ${definition.name}`);
+    }
+    return { run, result, error, threw };
+  }
+  /**
+   * Look for missed and stuck runs across every job, send alerts, and prune
+   * old runs. Call it from an interval (start()), a cron hitting the mounted
+   * routes, or by hand. Concurrent calls share one check.
+   */
+  check() {
+    if (!this.checking) {
+      this.checking = this.runCheck().finally(() => {
+        this.checking = null;
+      });
+    }
+    return this.checking;
+  }
+  async runCheck() {
+    await this.ensureReady();
+    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()) {
+      const stored = await this.store.getJob(run.job);
+      const declared = this.definitions.get(run.job);
+      const definition = declared ? toStored(declared) : stored?.definition;
+      if (!definition || !isStuck(definition, run, now)) continue;
+      run.status = "timeout";
+      run.finishedAt = now;
+      run.durationMs = now - run.startedAt;
+      run.error = `Still running after ${Math.round(timeoutMs(definition) / 6e4)} minutes; marked as timed out`;
+      await this.store.updateRun(run);
+      const history = (await this.store.listRuns(run.job, BASELINE_WINDOW + 5)).filter((r) => r.id !== run.id);
+      const state = await this.store.getState(run.job) ?? emptyState(run.job);
+      const evaluation = onRunFinish(definition, run, state, history, [], now);
+      alerts.push(...await this.settle(state, evaluation, definition, now));
+    }
+    const jobs = [];
+    for (const stored of await this.store.listJobs()) {
+      const definition = stored.definition;
+      const lastRun = await this.store.lastRun(stored.name);
+      const state = await this.store.getState(stored.name) ?? emptyState(stored.name);
+      const evaluation = onCheck(definition, stored, lastRun, state, now);
+      alerts.push(...await this.settle(state, evaluation, definition, now));
+      jobs.push(await this.summarize(stored, lastRun, evaluation.state, evaluation.nextExpectedAt, now));
+    }
+    let pruned = 0;
+    if (now - this.lastPruneAt > PRUNE_INTERVAL_MS) {
+      this.lastPruneAt = now;
+      try {
+        pruned = await this.store.prune(now - this.retentionMs);
+      } catch (e) {
+        this.onError(e, "pruning");
+      }
+    }
+    return { checkedAt: now, jobs, alerts, pruned };
+  }
+  /** Every job the store knows about, with its health. Does not send alerts. */
+  async jobs() {
+    await this.ensureReady();
+    for (const definition of this.definitions.values()) await this.sync(definition);
+    const now = this.now();
+    const out = [];
+    for (const stored of await this.store.listJobs()) {
+      const lastRun = await this.store.lastRun(stored.name);
+      const state = await this.store.getState(stored.name) ?? emptyState(stored.name);
+      const { nextExpectedAt } = onCheck(stored.definition, stored, lastRun, state, now);
+      out.push(await this.summarize(stored, lastRun, state, nextExpectedAt, now));
+    }
+    return out;
+  }
+  async jobSummary(name) {
+    await this.ensureReady();
+    const definition = this.definitions.get(name);
+    if (definition) await this.sync(definition);
+    const stored = await this.store.getJob(name);
+    if (!stored) return null;
+    const now = this.now();
+    const lastRun = await this.store.lastRun(name);
+    const state = await this.store.getState(name) ?? emptyState(name);
+    const { nextExpectedAt } = onCheck(stored.definition, stored, lastRun, state, now);
+    return this.summarize(stored, lastRun, state, nextExpectedAt, now);
+  }
+  async runs(name, limit = 50) {
+    await this.ensureReady();
+    return this.store.listRuns(name, Math.min(500, Math.max(1, limit)));
+  }
+  async getRun(id) {
+    await this.ensureReady();
+    return this.store.getRun(id);
+  }
+  /** Stop alerts for a job for a while. State keeps updating underneath. */
+  async silence(name, duration) {
+    await this.ensureReady();
+    const state = await this.store.getState(name) ?? emptyState(name);
+    state.silencedUntil = this.now() + parseDuration(duration, "silence duration");
+    await this.store.setState(state);
+    return state;
+  }
+  async unsilence(name) {
+    await this.ensureReady();
+    const state = await this.store.getState(name) ?? emptyState(name);
+    state.silencedUntil = null;
+    await this.store.setState(state);
+    return state;
+  }
+  /** Remove a job and its runs from the store. A job still declared in code comes back on its next run. */
+  async forget(name) {
+    await this.ensureReady();
+    this.definitions.delete(name);
+    this.synced.delete(name);
+    await this.store.deleteJob(name);
+  }
+  /** The dashboard and JSON API as fetch-style handlers. See createRoutes(). */
+  routes(options) {
+    return createRoutes(this, options);
+  }
+  /** Check on an interval, for long-running servers. Default every minute. */
+  start(every = "1m") {
+    if (this.timer) return;
+    const ms = Math.max(5e3, parseDuration(every, "check interval"));
+    const tick = () => this.check().catch((e) => this.onError(e, "check"));
+    this.timer = setInterval(tick, ms);
+    if (typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
+    setTimeout(tick, 1e3).unref?.();
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+  async close() {
+    this.stop();
+    if (this.store.close) await this.store.close();
+  }
+  async summarize(stored, lastRun, state, nextExpectedAt, now) {
+    const recent = await this.store.listRuns(stored.name, BASELINE_WINDOW);
+    const finished = recent.filter((r) => r.status !== "running");
+    const okDurations = recent.filter((r) => r.status === "ok" && r.durationMs !== null).map((r) => r.durationMs);
+    const open = openConditions(state);
+    let health;
+    if (state.silencedUntil !== null && state.silencedUntil > now) health = "silenced";
+    else if (open.includes("stuck") || lastRun && isStuck(stored.definition, lastRun, now)) health = "stuck";
+    else if (open.includes("failed") || lastRun?.status === "failed" || lastRun?.status === "timeout") health = "failing";
+    else if (open.includes("missed")) health = "late";
+    else if (!lastRun) health = "never_ran";
+    else health = "healthy";
+    return {
+      name: stored.name,
+      definition: stored.definition,
+      health,
+      open,
+      lastRun,
+      nextExpectedAt,
+      consecutiveFailures: state.consecutiveFailures,
+      silencedUntil: state.silencedUntil,
+      stats: {
+        runs: finished.length,
+        okRate: finished.length === 0 ? 1 : finished.filter((r) => r.status === "ok").length / finished.length,
+        p50Ms: percentile(okDurations, 50),
+        p95Ms: percentile(okDurations, 95)
+      }
+    };
+  }
+  /** Save an evaluation's state, honouring silence, and send its alerts. */
+  async settle(previous, evaluation, definition, now) {
+    if (isSilenced(previous, now)) {
+      evaluation.state = muteOpens(previous, evaluation.state);
+      evaluation.alerts = [];
+    }
+    if (JSON.stringify(evaluation.state) !== JSON.stringify(previous)) await this.store.setState(evaluation.state);
+    return this.dispatch(evaluation.alerts, definition, evaluation.state, now);
+  }
+  async dispatch(drafts, definition, state, now) {
+    if (drafts.length === 0) return [];
+    const sent = [];
+    for (const draft of drafts) {
+      const alert = composeAlert(draft, definition, now);
+      if (this.triage && alert.type !== "recovered") {
+        try {
+          const recentRuns = await this.store.listRuns(alert.job, 5);
+          const diagnosis = await withTimeout(this.triage({ alert, recentRuns }), TRIAGE_TIMEOUT_MS);
+          if (diagnosis) alert.triage = diagnosis;
+        } catch (e) {
+          this.onError(e, `triage for ${alert.job}`);
+        }
+      }
+      for (const channel of this.alerts) {
+        try {
+          await channel.send(alert);
+        } catch (e) {
+          this.onError(e, `alert channel ${channel.name}`);
+        }
+      }
+      sent.push(alert);
+    }
+    state.lastAlertAt = now;
+    await this.store.setState(state);
+    return sent;
+  }
+};
+function withTimeout(promise, ms) {
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`timed out after ${ms}ms`)), ms);
+    promise.then((v) => {
+      clearTimeout(t);
+      resolve(v);
+    }, (e) => {
+      clearTimeout(t);
+      reject(e);
+    });
+  });
+}
+function consoleChannel() {
+  return {
+    name: "console",
+    async send(alert) {
+      const line = `[cronwatch] ${alert.title}
+${alert.message}${alert.triage ? `
+Triage: ${alert.triage}` : ""}`;
+      if (alert.type === "recovered") console.info(line);
+      else console.error(line);
+    }
+  };
+}
+function custom(name, send) {
+  return { name, send: async (alert) => {
+    await send(alert);
+  } };
+}
+
+// src/index.ts
+function cronwatch(options = {}) {
+  return new CronWatch(options);
+}
+
+exports.CronWatch = CronWatch;
+exports.composeAlert = composeAlert;
+exports.consoleChannel = consoleChannel;
+exports.createRoutes = createRoutes;
+exports.cronwatch = cronwatch;
+exports.custom = custom;
+exports.formatDuration = formatDuration;
+exports.formatRelative = formatRelative;
+exports.json = json;
+exports.memory = memory;
+exports.nextFire = nextFire;
+exports.parseDuration = parseDuration;
+exports.parseSchedule = parseSchedule;
+exports.previousFire = previousFire;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map