@cronvello/sdk 0.1.4 → 0.2.1

package/dist/dev.js

@@ -0,0 +1,1173 @@
+import http from 'http';
+
+// src/internal/cron-schedule.ts
+var MACRO_EXPANSIONS = {
+  "@yearly": "0 0 1 1 *",
+  "@annually": "0 0 1 1 *",
+  "@monthly": "0 0 1 * *",
+  "@weekly": "0 0 * * 0",
+  "@daily": "0 0 * * *",
+  "@midnight": "0 0 * * *",
+  "@hourly": "0 * * * *"
+};
+var MONTH_NAMES = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+var DOW_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+var SECOND_SPEC = { min: 0, max: 59, nameOffset: 0, label: "second" };
+var MINUTE_SPEC = { min: 0, max: 59, nameOffset: 0, label: "minute" };
+var HOUR_SPEC = { min: 0, max: 23, nameOffset: 0, label: "hour" };
+var DOM_SPEC = { min: 1, max: 31, nameOffset: 0, label: "day-of-month" };
+var MONTH_SPEC = { min: 1, max: 12, names: MONTH_NAMES, nameOffset: 1, label: "month" };
+var DOW_SPEC = { min: 0, max: 7, names: DOW_NAMES, nameOffset: 0, fold: (v) => v % 7, label: "day-of-week" };
+function parseCron(expr) {
+  if (typeof expr !== "string" || !expr.trim()) throw new Error("cron expression is empty");
+  let trimmed = expr.trim();
+  if (trimmed.startsWith("@")) {
+    const macro = trimmed.toLowerCase();
+    if (macro === "@reboot") {
+      return {
+        seconds: /* @__PURE__ */ new Set([0]),
+        minutes: /* @__PURE__ */ new Set(),
+        hours: /* @__PURE__ */ new Set(),
+        daysOfMonth: /* @__PURE__ */ new Set(),
+        months: /* @__PURE__ */ new Set(),
+        daysOfWeek: /* @__PURE__ */ new Set(),
+        domRestricted: false,
+        dowRestricted: false,
+        reboot: true
+      };
+    }
+    const expanded = MACRO_EXPANSIONS[macro];
+    if (!expanded) throw new Error(`unknown cron macro "${trimmed}" (try @daily, @hourly, \u2026)`);
+    trimmed = expanded;
+  }
+  const parts = trimmed.split(/\s+/);
+  if (parts.length !== 5 && parts.length !== 6) {
+    throw new Error(`expected 5 fields (min hour dom month dow) or 6 with seconds, got ${parts.length}: "${trimmed}"`);
+  }
+  const hasSeconds = parts.length === 6;
+  const [secRaw, minRaw, hourRaw, domRaw, monthRaw, dowRaw] = hasSeconds ? parts : ["0", ...parts];
+  return {
+    seconds: expandField(secRaw, SECOND_SPEC),
+    minutes: expandField(minRaw, MINUTE_SPEC),
+    hours: expandField(hourRaw, HOUR_SPEC),
+    daysOfMonth: expandField(domRaw, DOM_SPEC),
+    months: expandField(monthRaw, MONTH_SPEC),
+    daysOfWeek: expandField(dowRaw, DOW_SPEC),
+    domRestricted: isRestricted(domRaw),
+    dowRestricted: isRestricted(dowRaw),
+    reboot: false
+  };
+}
+function isRestricted(field) {
+  const f = field.trim();
+  return f !== "*" && f !== "?";
+}
+function expandField(raw, spec) {
+  const set = /* @__PURE__ */ new Set();
+  for (const term of raw.split(",")) {
+    if (term === "") throw new Error(`empty term in ${spec.label} field "${raw}"`);
+    let base = term;
+    let step = 1;
+    const slash = term.indexOf("/");
+    if (slash >= 0) {
+      base = term.slice(0, slash);
+      const stepStr = term.slice(slash + 1);
+      if (!/^\d+$/.test(stepStr) || Number(stepStr) === 0) {
+        throw new Error(`invalid step "${stepStr}" in ${spec.label} field "${raw}"`);
+      }
+      step = Number(stepStr);
+    }
+    let lo;
+    let hi;
+    if (base === "*" || base === "?") {
+      lo = spec.min;
+      hi = spec.max;
+    } else {
+      const dash = base.indexOf("-");
+      if (dash > 0) {
+        lo = resolveValue(base.slice(0, dash), spec);
+        hi = resolveValue(base.slice(dash + 1), spec);
+      } else {
+        lo = resolveValue(base, spec);
+        hi = step > 1 ? spec.max : lo;
+      }
+    }
+    if (lo === null || hi === null) {
+      throw new Error(`value out of range in ${spec.label} field "${raw}" (${spec.min}-${spec.max})`);
+    }
+    if (lo > hi) throw new Error(`range start ${lo} is greater than end ${hi} in ${spec.label} field "${raw}"`);
+    for (let v = lo; v <= hi; v += step) set.add(spec.fold ? spec.fold(v) : v);
+  }
+  return set;
+}
+function resolveValue(token, spec) {
+  const t = token.trim();
+  if (/^\d+$/.test(t)) {
+    const n = Number(t);
+    return n >= spec.min && n <= spec.max ? n : null;
+  }
+  if (spec.names) {
+    const idx = spec.names.indexOf(t.toLowerCase());
+    if (idx >= 0) return idx + spec.nameOffset;
+  }
+  return null;
+}
+var SEARCH_HORIZON_YEARS = 5;
+function nextOccurrence(expr, opts = {}) {
+  const parsed = typeof expr === "string" ? parseCron(expr) : expr;
+  if (parsed.reboot) throw new Error("@reboot has no scheduled next occurrence (the engine fires it once at start)");
+  const tz = opts.timeZone ?? "UTC";
+  const fromMs = opts.from === void 0 ? Date.now() : typeof opts.from === "number" ? opts.from : opts.from.getTime();
+  const cursor = Math.floor(fromMs / 1e3) * 1e3 + 1e3;
+  const p = getZonedParts(cursor, tz);
+  const startYear = p.y;
+  const hourArr = sorted(parsed.hours);
+  const minuteArr = sorted(parsed.minutes);
+  const secondArr = sorted(parsed.seconds);
+  let guard = 0;
+  while (guard++ < 1e6) {
+    if (p.y > startYear + SEARCH_HORIZON_YEARS) return null;
+    if (!parsed.months.has(p.mo)) {
+      bumpMonth(p);
+      continue;
+    }
+    if (p.d > daysInMonth(p.y, p.mo)) {
+      bumpMonth(p);
+      continue;
+    }
+    if (!dayMatches(parsed, p.y, p.mo, p.d)) {
+      bumpDay(p);
+      continue;
+    }
+    const nh = firstAtLeast(hourArr, p.h);
+    if (nh === null) {
+      bumpDay(p);
+      continue;
+    }
+    if (nh !== p.h) {
+      p.h = nh;
+      p.mi = 0;
+      p.s = 0;
+    }
+    const nmi = firstAtLeast(minuteArr, p.mi);
+    if (nmi === null) {
+      p.h += 1;
+      p.mi = 0;
+      p.s = 0;
+      continue;
+    }
+    if (nmi !== p.mi) {
+      p.mi = nmi;
+      p.s = 0;
+    }
+    const ns = firstAtLeast(secondArr, p.s);
+    if (ns === null) {
+      p.mi += 1;
+      p.s = 0;
+      continue;
+    }
+    p.s = ns;
+    const epoch = zonedWallToEpoch(p, tz);
+    if (epoch <= fromMs) {
+      p.s += 1;
+      continue;
+    }
+    return new Date(epoch);
+  }
+  throw new Error(`nextOccurrence: search exceeded its iteration bound for "${typeof expr === "string" ? expr : "(parsed)"}"`);
+}
+function dayMatches(parsed, y, mo, d) {
+  const domOk = parsed.daysOfMonth.has(d);
+  const dowOk = parsed.daysOfWeek.has(weekdayOf(y, mo, d));
+  if (parsed.domRestricted && parsed.dowRestricted) return domOk || dowOk;
+  if (parsed.domRestricted) return domOk;
+  if (parsed.dowRestricted) return dowOk;
+  return true;
+}
+function bumpMonth(p) {
+  p.mo += 1;
+  if (p.mo > 12) {
+    p.mo = 1;
+    p.y += 1;
+  }
+  p.d = 1;
+  p.h = 0;
+  p.mi = 0;
+  p.s = 0;
+}
+function bumpDay(p) {
+  p.d += 1;
+  p.h = 0;
+  p.mi = 0;
+  p.s = 0;
+}
+function sorted(set) {
+  return [...set].sort((a, b) => a - b);
+}
+function firstAtLeast(arr, v) {
+  for (const x of arr) if (x >= v) return x;
+  return null;
+}
+function daysInMonth(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function weekdayOf(year, month, day) {
+  return new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+}
+var FORMATTER_CACHE = /* @__PURE__ */ new Map();
+function formatterFor(timeZone) {
+  let fmt = FORMATTER_CACHE.get(timeZone);
+  if (!fmt) {
+    fmt = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+    FORMATTER_CACHE.set(timeZone, fmt);
+  }
+  return fmt;
+}
+function getZonedParts(epochMs, timeZone) {
+  const parts = formatterFor(timeZone).formatToParts(new Date(epochMs));
+  const m = {};
+  for (const part of parts) if (part.type !== "literal") m[part.type] = part.value;
+  let h = Number(m["hour"]);
+  if (h === 24) h = 0;
+  return { y: Number(m["year"]), mo: Number(m["month"]), d: Number(m["day"]), h, mi: Number(m["minute"]), s: Number(m["second"]) };
+}
+function offsetAt(epochMs, timeZone) {
+  const p = getZonedParts(epochMs, timeZone);
+  const asNaive = Date.UTC(p.y, p.mo - 1, p.d, p.h, p.mi, p.s);
+  return asNaive - epochMs;
+}
+function zonedWallToEpoch(p, timeZone) {
+  const asUTC = Date.UTC(p.y, p.mo - 1, p.d, p.h, p.mi, p.s);
+  const o1 = offsetAt(asUTC, timeZone);
+  let epoch = asUTC - o1;
+  const o2 = offsetAt(epoch, timeZone);
+  if (o2 !== o1) epoch = asUTC - o2;
+  return epoch;
+}
+function previewSchedule(expr, opts = {}) {
+  const parsed = parseCron(expr);
+  const timeZone = opts.timeZone ?? localTimeZone();
+  const count = Math.min(Math.max(Math.trunc(opts.count ?? 5), 1), 100);
+  const out = [];
+  let from = opts.from === void 0 ? Date.now() : typeof opts.from === "number" ? opts.from : opts.from.getTime();
+  for (let i = 0; i < count; i++) {
+    const next = nextOccurrence(parsed, { from, timeZone });
+    if (!next) break;
+    out.push(next);
+    from = next.getTime();
+  }
+  return out;
+}
+function upcomingFires(jobs, opts = {}) {
+  const from = opts.from === void 0 ? Date.now() : typeof opts.from === "number" ? opts.from : opts.from.getTime();
+  const withinMs = opts.withinMs ?? 60 * 60 * 1e3;
+  const maxPerJob = Math.max(1, opts.maxPerJob ?? 50);
+  const horizon = from + withinMs;
+  const fires = [];
+  for (const job of jobs) {
+    let parsed;
+    try {
+      parsed = parseCron(job.schedule);
+    } catch {
+      continue;
+    }
+    if (parsed.reboot) continue;
+    let cursor = from;
+    for (let i = 0; i < maxPerJob; i++) {
+      const next = nextOccurrence(parsed, { from: cursor, timeZone: job.timeZone });
+      if (!next || next.getTime() > horizon) break;
+      fires.push({ key: job.key, time: next, schedule: job.schedule, timeZone: job.timeZone });
+      cursor = next.getTime();
+    }
+  }
+  fires.sort((a, b) => a.time.getTime() - b.time.getTime());
+  return fires;
+}
+function localTimeZone() {
+  try {
+    return new Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+// src/dev/engine.ts
+var DEFAULT_HISTORY_LIMIT = 100;
+var MAX_TIMER_MS = 2 ** 31 - 1;
+function defaultBackoff(attempt) {
+  return Math.min(3e4, 500 * 2 ** (attempt - 1));
+}
+var realClock = {
+  now: () => Date.now(),
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (handle) => clearTimeout(handle)
+};
+var RunTimeoutError = class extends Error {
+  constructor(key, ms) {
+    super(`job '${key}' timed out after ${ms}ms`);
+    this.name = "RunTimeoutError";
+  }
+};
+function createLocalEngine(jobs, runner, options = {}) {
+  return new LocalEngine(jobs, runner, options);
+}
+var LocalEngine = class {
+  clock;
+  /** Every event listener. The constructor's `onEvent` is registered as one of them. */
+  listeners = /* @__PURE__ */ new Set();
+  /** Run after the engine has drained, e.g. to close a dashboard server. */
+  closeHooks = [];
+  historyLimit;
+  backoff;
+  runner;
+  states;
+  history = [];
+  inFlight = /* @__PURE__ */ new Set();
+  started = false;
+  stopped = false;
+  signalCleanup = null;
+  constructor(jobs, runner, options = {}) {
+    this.clock = options.clock ?? realClock;
+    if (options.onEvent) this.listeners.add(options.onEvent);
+    this.historyLimit = Math.max(1, options.historyLimit ?? DEFAULT_HISTORY_LIMIT);
+    this.backoff = options.backoff ?? defaultBackoff;
+    this.runner = runner;
+    this.states = jobs.map((job) => ({
+      job,
+      nextFire: null,
+      timer: null,
+      running: false,
+      isReboot: job.schedule.trim().toLowerCase() === "@reboot"
+    }));
+    if (options.installSignalHandlers) this.installSignalHandlers();
+  }
+  /**
+   * Subscribe to every lifecycle event (in addition to the constructor's `onEvent`). Returns an
+   * unsubscribe function. Used by the local dashboard to fan events out to many SSE clients without
+   * disturbing the scheduler. A listener that throws is isolated — it can't break the loop.
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Register a hook to run once, after {@link stop} has drained in-flight runs — e.g. to close a
+   * dashboard server so `engine.stop()` tears everything down together. Hooks are awaited.
+   */
+  onStop(hook) {
+    this.closeHooks.push(hook);
+    return this;
+  }
+  /** Deliver an event to every listener, isolating each so one bad listener can't stall the loop. */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /** Begin scheduling. Idempotent — a second call is a no-op. */
+  start() {
+    if (this.started) return this;
+    this.started = true;
+    this.stopped = false;
+    this.emit({ type: "engine-start", jobs: this.states.length, at: this.clock.now() });
+    for (const state of this.states) {
+      if (state.isReboot) {
+        this.launch(state);
+      } else {
+        this.scheduleNext(state);
+      }
+    }
+    return this;
+  }
+  /**
+   * Stop scheduling and wait for in-flight runs to settle. After this resolves no further handlers
+   * will start. Safe to call from a signal handler.
+   */
+  async stop() {
+    if (this.stopped) {
+      await Promise.allSettled([...this.inFlight]);
+      return;
+    }
+    this.stopped = true;
+    for (const state of this.states) {
+      if (state.timer !== null) {
+        this.clock.clearTimeout(state.timer);
+        state.timer = null;
+      }
+    }
+    this.signalCleanup?.();
+    this.signalCleanup = null;
+    await Promise.allSettled([...this.inFlight]);
+    this.emit({ type: "engine-stop", at: this.clock.now() });
+    for (const hook of this.closeHooks.splice(0)) {
+      try {
+        await hook();
+      } catch {
+      }
+    }
+  }
+  /** The run history, newest first (a copy — safe to keep). */
+  runs() {
+    return [...this.history].reverse();
+  }
+  /** History entries for one job, newest first. */
+  runsFor(key) {
+    return this.runs().filter((r) => r.key === key);
+  }
+  /** Current scheduling state of every job, for the dev table. */
+  snapshot() {
+    return this.states.map((s) => ({
+      key: s.job.key,
+      schedule: s.job.schedule,
+      timeZone: s.job.timeZone,
+      ...s.job.description !== void 0 ? { description: s.job.description } : {},
+      nextFire: s.nextFire !== null ? new Date(s.nextFire) : null,
+      running: s.running
+    }));
+  }
+  /** The jobs this engine manages (read-only view). */
+  jobs() {
+    return this.states.map((s) => s.job);
+  }
+  /** Number of runs currently in flight. */
+  get activeRuns() {
+    return this.inFlight.size;
+  }
+  // ── Scheduling ─────────────────────────────────────────────────────────────
+  scheduleNext(state) {
+    if (this.stopped) return;
+    const now = this.clock.now();
+    let next;
+    try {
+      next = nextOccurrence(state.job.schedule, { from: now, timeZone: state.job.timeZone });
+    } catch {
+      state.nextFire = null;
+      return;
+    }
+    if (!next) {
+      state.nextFire = null;
+      return;
+    }
+    state.nextFire = next.getTime();
+    const delay = Math.max(0, Math.min(state.nextFire - now, MAX_TIMER_MS));
+    state.timer = this.clock.setTimeout(() => this.onDue(state), delay);
+    this.emit({ type: "scheduled", key: state.job.key, at: state.nextFire });
+  }
+  onDue(state) {
+    state.timer = null;
+    if (this.stopped) return;
+    const now = this.clock.now();
+    if (state.nextFire !== null && now < state.nextFire) {
+      const delay = Math.max(0, Math.min(state.nextFire - now, MAX_TIMER_MS));
+      state.timer = this.clock.setTimeout(() => this.onDue(state), delay);
+      return;
+    }
+    if (state.running && !state.job.allowConcurrentRuns) {
+      this.emit({ type: "skipped", key: state.job.key, reason: "overlap", at: now });
+      this.record({
+        key: state.job.key,
+        source: "local",
+        startedAt: now,
+        finishedAt: now,
+        durationMs: 0,
+        status: "skipped",
+        attempts: 0
+      });
+    } else {
+      this.launch(state);
+    }
+    this.scheduleNext(state);
+  }
+  /**
+   * Run a job once, right now, by key — the local equivalent of "run now" in the cloud. Goes through
+   * the exact same execution path as a scheduled fire (overlap protection, timeout, retry/backoff,
+   * history + events), so a manual run shows up in the feed just like any other. Resolves with the
+   * resulting {@link RunRecord}. Throws for an unknown key or after the engine has stopped.
+   */
+  async trigger(key) {
+    if (this.stopped) throw new Error("cannot trigger a job on a stopped engine");
+    const state = this.states.find((s) => s.job.key === key);
+    if (!state) throw new Error(`unknown job '${key}'`);
+    if (state.running && !state.job.allowConcurrentRuns) {
+      const now = this.clock.now();
+      const skipped = { key, source: "local", startedAt: now, finishedAt: now, durationMs: 0, status: "skipped", attempts: 0 };
+      this.emit({ type: "skipped", key, reason: "overlap", at: now });
+      this.record(skipped);
+      return skipped;
+    }
+    return this.launch(state);
+  }
+  /**
+   * The run history as newline-delimited JSON (NDJSON), oldest run first — one record per line, the
+   * natural shape for piping to a file or another tool. No trailing newline.
+   */
+  toNdjson() {
+    return this.history.map((r) => JSON.stringify(r)).join("\n");
+  }
+  /** Start an execution and track it so {@link stop} can await it. Resolves with the run's record. */
+  launch(state) {
+    const promise = this.execute(state);
+    const tracked = promise.finally(() => {
+      this.inFlight.delete(tracked);
+    });
+    this.inFlight.add(tracked);
+    return tracked;
+  }
+  // ── Execution with timeout + retry/backoff ──────────────────────────────────
+  async execute(state) {
+    const job = state.job;
+    state.running = true;
+    const startedAt = this.clock.now();
+    const maxRetries = Math.max(0, job.maxRetries ?? 0);
+    let attempt = 0;
+    let status = "error";
+    let error;
+    let result;
+    while (!this.stopped) {
+      attempt++;
+      this.emit({ type: "fire", key: job.key, attempt, at: this.clock.now() });
+      try {
+        result = await this.runOnce(job);
+        status = "success";
+        this.emit({ type: "success", key: job.key, durationMs: this.clock.now() - startedAt, attempts: attempt, result, at: this.clock.now() });
+        error = void 0;
+        break;
+      } catch (err) {
+        const timedOut = err instanceof RunTimeoutError;
+        status = timedOut ? "timed_out" : "error";
+        error = err instanceof Error ? err.message : String(err);
+        const willRetry = attempt <= maxRetries && !this.stopped;
+        const at = this.clock.now();
+        if (timedOut) {
+          this.emit({ type: "timeout", key: job.key, durationMs: at - startedAt, attempt, willRetry, at });
+        } else {
+          this.emit({ type: "error", key: job.key, durationMs: at - startedAt, attempt, willRetry, error, at });
+        }
+        if (!willRetry) break;
+        const delayMs = this.backoff(attempt);
+        this.emit({ type: "retry", key: job.key, attempt: attempt + 1, delayMs, at });
+        await this.sleep(delayMs);
+      }
+    }
+    const finishedAt = this.clock.now();
+    const record = {
+      key: job.key,
+      source: "local",
+      startedAt,
+      finishedAt,
+      durationMs: finishedAt - startedAt,
+      status,
+      attempts: attempt,
+      ...error !== void 0 ? { error } : {},
+      ...status === "success" ? { result } : {}
+    };
+    this.record(record);
+    state.running = false;
+    return record;
+  }
+  /** A single attempt: run the handler, racing it against the per-job timeout. */
+  runOnce(job) {
+    const controller = new AbortController();
+    const handlerPromise = this.runner(job.key, controller.signal);
+    const timeoutMs = job.timeoutMs;
+    if (!timeoutMs || timeoutMs <= 0) return handlerPromise;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = this.clock.setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        controller.abort();
+        reject(new RunTimeoutError(job.key, timeoutMs));
+      }, timeoutMs);
+      handlerPromise.then(
+        (value) => {
+          if (settled) return;
+          settled = true;
+          this.clock.clearTimeout(timer);
+          resolve(value);
+        },
+        (err) => {
+          if (settled) return;
+          settled = true;
+          this.clock.clearTimeout(timer);
+          reject(err);
+        }
+      );
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve) => this.clock.setTimeout(resolve, ms));
+  }
+  record(record) {
+    this.history.push(record);
+    if (this.history.length > this.historyLimit) this.history.shift();
+  }
+  installSignalHandlers() {
+    const handler = () => {
+      void this.stop().then(() => process.exit(0));
+    };
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+    this.signalCleanup = () => {
+      process.removeListener("SIGINT", handler);
+      process.removeListener("SIGTERM", handler);
+    };
+  }
+};
+
+// src/dev/dashboard-assets.ts
+var DASHBOARD_HTML = `<!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" />
+<title>Cronvello \u2014 local dashboard</title>
+<style>
+  :root {
+    --indigo: #4F46E5;
+    --indigo-soft: #6366F1;
+    --teal: #14B8A6;
+    --green: #10B981;
+    --amber: #F59E0B;
+    --red: #EF4444;
+    --bg: #f8fafc;
+    --panel: #ffffff;
+    --panel-2: #f1f5f9;
+    --border: #e2e8f0;
+    --text: #0f172a;
+    --muted: #64748b;
+    --shadow: 0 1px 3px rgba(15, 23, 42, 0.08), 0 1px 2px rgba(15, 23, 42, 0.04);
+  }
+  [data-theme="dark"] {
+    --bg: #0b1120;
+    --panel: #111827;
+    --panel-2: #0f172a;
+    --border: #1f2937;
+    --text: #e5e7eb;
+    --muted: #94a3b8;
+    --shadow: 0 1px 3px rgba(0, 0, 0, 0.5), 0 1px 2px rgba(0, 0, 0, 0.4);
+  }
+  /* Dark-mode-first: follow the OS preference unless the user has explicitly chosen light. */
+  @media (prefers-color-scheme: dark) {
+    :root:not([data-theme="light"]) {
+      --bg: #0b1120;
+      --panel: #111827;
+      --panel-2: #0f172a;
+      --border: #1f2937;
+      --text: #e5e7eb;
+      --muted: #94a3b8;
+      --shadow: 0 1px 3px rgba(0, 0, 0, 0.5), 0 1px 2px rgba(0, 0, 0, 0.4);
+    }
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; padding: 0; }
+  body {
+    background: var(--bg);
+    color: var(--text);
+    font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Inter, Roboto, sans-serif;
+    font-size: 14px;
+    line-height: 1.5;
+  }
+  code, .mono { font-family: ui-monospace, "SF Mono", "JetBrains Mono", Menlo, Consolas, monospace; }
+  header {
+    display: flex; align-items: center; gap: 12px;
+    padding: 14px 20px;
+    border-bottom: 1px solid var(--border);
+    background: var(--panel);
+    position: sticky; top: 0; z-index: 10;
+  }
+  .logo {
+    width: 28px; height: 28px; border-radius: 8px;
+    display: grid; place-items: center;
+    background: linear-gradient(135deg, var(--indigo), var(--teal));
+    color: #fff; font-size: 17px; font-weight: 700;
+  }
+  .brand { font-weight: 700; letter-spacing: -0.01em; }
+  .brand small { color: var(--muted); font-weight: 500; margin-left: 6px; }
+  .spacer { flex: 1; }
+  .pill {
+    display: inline-flex; align-items: center; gap: 6px;
+    padding: 4px 10px; border-radius: 999px;
+    font-size: 12px; font-weight: 600;
+    border: 1px solid var(--border); background: var(--panel-2); color: var(--muted);
+  }
+  .dot { width: 8px; height: 8px; border-radius: 50%; background: var(--muted); }
+  .pill.live .dot { background: var(--green); box-shadow: 0 0 0 0 rgba(16,185,129,0.5); animation: pulse 1.8s infinite; }
+  .pill.down .dot { background: var(--red); }
+  @keyframes pulse { 0% { box-shadow: 0 0 0 0 rgba(16,185,129,0.5); } 70% { box-shadow: 0 0 0 6px rgba(16,185,129,0); } 100% { box-shadow: 0 0 0 0 rgba(16,185,129,0); } }
+  button {
+    font: inherit; cursor: pointer; color: var(--text);
+    background: var(--panel-2); border: 1px solid var(--border);
+    border-radius: 8px; padding: 6px 12px;
+  }
+  button:hover { border-color: var(--indigo-soft); }
+  button.primary { background: var(--indigo); color: #fff; border-color: var(--indigo); }
+  button.primary:hover { background: var(--indigo-soft); }
+  .layout { display: grid; grid-template-columns: 1.4fr 1fr; gap: 16px; padding: 16px 20px; align-items: start; }
+  @media (max-width: 860px) { .layout { grid-template-columns: 1fr; } }
+  .card { background: var(--panel); border: 1px solid var(--border); border-radius: 12px; box-shadow: var(--shadow); overflow: hidden; }
+  .card > h2 { margin: 0; padding: 12px 16px; font-size: 13px; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted); border-bottom: 1px solid var(--border); }
+  table { width: 100%; border-collapse: collapse; }
+  th, td { text-align: left; padding: 10px 16px; border-bottom: 1px solid var(--border); vertical-align: middle; }
+  th { font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted); font-weight: 600; }
+  tr:last-child td { border-bottom: none; }
+  tbody tr { cursor: pointer; }
+  tbody tr:hover { background: var(--panel-2); }
+  .jobkey { font-weight: 600; }
+  .jobdesc { color: var(--muted); font-size: 12px; }
+  .count { font-variant-numeric: tabular-nums; }
+  .badge { display: inline-block; padding: 2px 8px; border-radius: 999px; font-size: 11px; font-weight: 700; }
+  .badge.success { background: rgba(16,185,129,0.15); color: var(--green); }
+  .badge.error, .badge.timed_out { background: rgba(239,68,68,0.15); color: var(--red); }
+  .badge.skipped { background: rgba(100,116,139,0.18); color: var(--muted); }
+  .badge.running { background: rgba(79,70,229,0.15); color: var(--indigo-soft); }
+  .badge.none { background: var(--panel-2); color: var(--muted); }
+  .feed { max-height: 70vh; overflow-y: auto; }
+  .ev { display: flex; gap: 10px; padding: 8px 16px; border-bottom: 1px solid var(--border); font-size: 13px; }
+  .ev .glyph { width: 16px; text-align: center; flex: none; }
+  .ev .body { flex: 1; min-width: 0; }
+  .ev .when { color: var(--muted); font-size: 11px; font-variant-numeric: tabular-nums; }
+  .ev.success .glyph { color: var(--green); }
+  .ev.error .glyph, .ev.timeout .glyph { color: var(--red); }
+  .ev.retry .glyph { color: var(--amber); }
+  .ev.fire .glyph { color: var(--indigo-soft); }
+  .ev.skipped .glyph, .ev.scheduled .glyph, .ev.engine .glyph { color: var(--muted); }
+  .empty { padding: 24px 16px; color: var(--muted); text-align: center; }
+  footer { padding: 12px 20px 28px; color: var(--muted); font-size: 12px; }
+  .overlay { position: fixed; inset: 0; background: rgba(15,23,42,0.45); display: none; align-items: stretch; justify-content: flex-end; z-index: 30; }
+  .overlay.open { display: flex; }
+  .drawer { width: min(520px, 92vw); background: var(--panel); border-left: 1px solid var(--border); height: 100%; overflow-y: auto; box-shadow: var(--shadow); }
+  .drawer header { background: var(--panel); }
+  .drawer .pad { padding: 16px; }
+  .kv { display: flex; gap: 8px; margin: 4px 0; }
+  .kv span:first-child { color: var(--muted); min-width: 90px; }
+  .section-title { font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted); margin: 18px 0 8px; }
+  ul.plain { list-style: none; margin: 0; padding: 0; }
+  ul.plain li { padding: 6px 0; border-bottom: 1px solid var(--border); display: flex; justify-content: space-between; gap: 8px; }
+</style>
+</head>
+<body>
+<header>
+  <div class="logo">&#8635;</div>
+  <div class="brand">Cronvello <small>local dashboard</small></div>
+  <div class="spacer"></div>
+  <span id="conn" class="pill"><span class="dot"></span><span id="conn-text">connecting&hellip;</span></span>
+  <button id="theme-btn" title="Toggle theme">&#9788;</button>
+</header>
+
+<div class="layout">
+  <section class="card">
+    <h2>Jobs &mdash; next fire &amp; last status</h2>
+    <table>
+      <thead><tr><th>Job</th><th>Schedule</th><th>Timezone</th><th>Next fire</th><th>Last</th></tr></thead>
+      <tbody id="jobs"><tr><td colspan="5" class="empty">Loading jobs&hellip;</td></tr></tbody>
+    </table>
+  </section>
+
+  <section class="card">
+    <h2>Live run feed</h2>
+    <div id="feed" class="feed"><div class="empty">Waiting for runs&hellip;</div></div>
+  </section>
+</div>
+
+<footer>Local &middot; no account &middot; no cloud &middot; no external network. The engine on this machine is the only source of truth.</footer>
+
+<div id="overlay" class="overlay">
+  <div class="drawer">
+    <header>
+      <div class="brand" id="drawer-title">Job</div>
+      <div class="spacer"></div>
+      <button id="drawer-close">Close</button>
+    </header>
+    <div class="pad" id="drawer-body"></div>
+  </div>
+</div>
+
+<script>
+(function () {
+  "use strict";
+  var MAX_FEED = 200;
+  var jobsByKey = {};
+
+  function el(id) { return document.getElementById(id); }
+  function esc(s) {
+    return String(s == null ? "" : s).replace(/[&<>"']/g, function (c) {
+      return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
+    });
+  }
+  function pad(n) { return n < 10 ? "0" + n : "" + n; }
+  function clockTime(ms) {
+    var d = new Date(ms);
+    return pad(d.getHours()) + ":" + pad(d.getMinutes()) + ":" + pad(d.getSeconds());
+  }
+  function fmtDuration(ms) {
+    if (ms == null) return "";
+    if (ms < 1000) return ms + "ms";
+    return (ms / 1000).toFixed(ms < 10000 ? 2 : 1) + "s";
+  }
+  function countdown(iso) {
+    if (!iso) return "&mdash;";
+    var diff = new Date(iso).getTime() - Date.now();
+    if (diff <= 0) return "due now";
+    var s = Math.floor(diff / 1000);
+    var d = Math.floor(s / 86400); s -= d * 86400;
+    var h = Math.floor(s / 3600); s -= h * 3600;
+    var m = Math.floor(s / 60); s -= m * 60;
+    var out = "in ";
+    if (d) out += d + "d ";
+    if (d || h) out += h + "h ";
+    if (d || h || m) out += m + "m ";
+    out += s + "s";
+    return out;
+  }
+
+  // \u2500\u2500 Theme \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  function applyTheme(t) {
+    if (t === "dark" || t === "light") document.documentElement.setAttribute("data-theme", t);
+    else document.documentElement.removeAttribute("data-theme");
+  }
+  function resolvedTheme() {
+    var t = document.documentElement.getAttribute("data-theme");
+    if (t) return t;
+    return window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  }
+  try { applyTheme(localStorage.getItem("cronvello-theme")); } catch (e) {}
+  el("theme-btn").addEventListener("click", function () {
+    var next = resolvedTheme() === "dark" ? "light" : "dark";
+    applyTheme(next);
+    try { localStorage.setItem("cronvello-theme", next); } catch (e) {}
+  });
+
+  // \u2500\u2500 Jobs table \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  function statusBadge(s) {
+    if (!s) return '<span class="badge none">&mdash;</span>';
+    return '<span class="badge ' + esc(s) + '">' + esc(s) + "</span>";
+  }
+  function renderJobs(jobs) {
+    jobsByKey = {};
+    if (!jobs.length) { el("jobs").innerHTML = '<tr><td colspan="5" class="empty">No jobs registered.</td></tr>'; return; }
+    var rows = "";
+    for (var i = 0; i < jobs.length; i++) {
+      var j = jobs[i];
+      jobsByKey[j.key] = j;
+      var last = j.running ? "running" : (j.lastStatus || "");
+      rows +=
+        '<tr data-key="' + esc(j.key) + '">' +
+        "<td><div class=\\"jobkey\\">" + esc(j.key) + "</div>" + (j.description ? '<div class="jobdesc">' + esc(j.description) + "</div>" : "") + "</td>" +
+        '<td><code>' + esc(j.schedule) + "</code></td>" +
+        "<td>" + esc(j.timeZone) + "</td>" +
+        '<td class="count" data-next="' + esc(j.nextFire || "") + '">' + countdown(j.nextFire) + "</td>" +
+        "<td>" + (j.running ? '<span class="badge running">running</span>' : statusBadge(j.lastStatus)) + "</td>" +
+        "</tr>";
+    }
+    el("jobs").innerHTML = rows;
+    var trs = el("jobs").querySelectorAll("tr[data-key]");
+    for (var k = 0; k < trs.length; k++) {
+      trs[k].addEventListener("click", function () { openDrawer(this.getAttribute("data-key")); });
+    }
+  }
+  function tickCountdowns() {
+    var cells = el("jobs").querySelectorAll("td[data-next]");
+    for (var i = 0; i < cells.length; i++) {
+      var iso = cells[i].getAttribute("data-next");
+      cells[i].innerHTML = iso ? countdown(iso) : "&mdash;";
+    }
+  }
+
+  function loadJobs() {
+    return fetch("/api/jobs").then(function (r) { return r.json(); }).then(function (jobs) {
+      // Fold in each job's last run so the table can show a status without a per-row fetch.
+      return fetch("/api/runs").then(function (r) { return r.json(); }).then(function (runs) {
+        var lastByKey = {};
+        for (var i = 0; i < runs.length; i++) { if (!lastByKey[runs[i].key]) lastByKey[runs[i].key] = runs[i]; }
+        for (var j = 0; j < jobs.length; j++) {
+          var lr = lastByKey[jobs[j].key];
+          jobs[j].lastStatus = lr ? lr.status : "";
+        }
+        renderJobs(jobs);
+      });
+    }).catch(function () {});
+  }
+
+  // \u2500\u2500 Live feed \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  var glyphs = { fire: "&#9655;", success: "&#10003;", error: "&#10007;", timeout: "&#9203;", retry: "&#8635;", skipped: "&#8866;", scheduled: "&#128337;", "engine-start": "&#9889;", "engine-stop": "&#9632;" };
+  function describe(ev) {
+    switch (ev.type) {
+      case "fire": return "<strong>" + esc(ev.key) + "</strong> fired" + (ev.attempt > 1 ? " (attempt " + ev.attempt + ")" : "");
+      case "success": return "<strong>" + esc(ev.key) + "</strong> succeeded in " + fmtDuration(ev.durationMs) + (ev.attempts > 1 ? " after " + ev.attempts + " attempts" : "");
+      case "error": return "<strong>" + esc(ev.key) + "</strong> errored: " + esc(ev.error) + (ev.willRetry ? " \u2014 will retry" : "");
+      case "timeout": return "<strong>" + esc(ev.key) + "</strong> timed out after " + fmtDuration(ev.durationMs) + (ev.willRetry ? " \u2014 will retry" : "");
+      case "retry": return "<strong>" + esc(ev.key) + "</strong> retrying (attempt " + ev.attempt + ") in " + fmtDuration(ev.delayMs);
+      case "skipped": return "<strong>" + esc(ev.key) + "</strong> skipped (overlap)";
+      case "scheduled": return "<strong>" + esc(ev.key) + "</strong> scheduled";
+      case "engine-start": return "Engine started \u2014 " + ev.jobs + " job(s)";
+      case "engine-stop": return "Engine stopped";
+      default: return esc(ev.type);
+    }
+  }
+  function feedClass(type) {
+    if (type === "engine-start" || type === "engine-stop" || type === "scheduled") return "engine";
+    return type;
+  }
+  function pushEvent(ev) {
+    var feed = el("feed");
+    if (feed.firstChild && feed.firstChild.className === "empty") feed.innerHTML = "";
+    var div = document.createElement("div");
+    div.className = "ev " + feedClass(ev.type);
+    div.innerHTML =
+      '<div class="glyph">' + (glyphs[ev.type] || "&#8226;") + "</div>" +
+      '<div class="body">' + describe(ev) + "</div>" +
+      '<div class="when">' + clockTime(ev.at || Date.now()) + "</div>";
+    feed.insertBefore(div, feed.firstChild);
+    while (feed.childNodes.length > MAX_FEED) feed.removeChild(feed.lastChild);
+
+    // A terminal event changes a job's last status / running flag \u2014 refresh the table.
+    if (ev.type === "success" || ev.type === "error" || ev.type === "timeout" || ev.type === "skipped" || ev.type === "scheduled") {
+      loadJobs();
+    }
+  }
+
+  function setConn(state) {
+    var pill = el("conn"), text = el("conn-text");
+    pill.className = "pill " + state;
+    text.textContent = state === "live" ? "live" : (state === "down" ? "disconnected" : "connecting\u2026");
+  }
+
+  function connect() {
+    setConn("connecting");
+    var src = new EventSource("/api/events");
+    src.onopen = function () { setConn("live"); };
+    src.onmessage = function (m) {
+      try { pushEvent(JSON.parse(m.data)); } catch (e) {}
+    };
+    src.onerror = function () { setConn("down"); };
+  }
+
+  // \u2500\u2500 Job drawer \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  function openDrawer(key) {
+    var job = jobsByKey[key];
+    if (!job) return;
+    el("drawer-title").textContent = key;
+    el("drawer-body").innerHTML = '<div class="empty">Loading&hellip;</div>';
+    el("overlay").classList.add("open");
+
+    Promise.all([
+      fetch("/api/preview/" + encodeURIComponent(key) + "?n=5").then(function (r) { return r.json(); }).catch(function () { return []; }),
+      fetch("/api/runs/" + encodeURIComponent(key)).then(function (r) { return r.json(); }).catch(function () { return []; })
+    ]).then(function (res) {
+      var fires = res[0] || [], runs = res[1] || [];
+      var html =
+        '<div class="kv"><span>Schedule</span><code>' + esc(job.schedule) + "</code></div>" +
+        '<div class="kv"><span>Timezone</span><span>' + esc(job.timeZone) + "</span></div>" +
+        (job.description ? '<div class="kv"><span>Description</span><span>' + esc(job.description) + "</span></div>" : "") +
+        '<div style="margin-top:14px"><button class="primary" id="run-now">Run now</button></div>' +
+        '<div class="section-title">Next fire times</div>';
+      if (fires.length) {
+        html += '<ul class="plain">';
+        for (var i = 0; i < fires.length; i++) html += "<li><span>" + esc(new Date(fires[i]).toLocaleString()) + "</span><span class=\\"count\\">" + countdown(fires[i]) + "</span></li>";
+        html += "</ul>";
+      } else { html += '<div class="empty">No upcoming fires.</div>'; }
+
+      html += '<div class="section-title">Recent runs</div>';
+      if (runs.length) {
+        html += '<ul class="plain">';
+        for (var j = 0; j < runs.length && j < 20; j++) {
+          var run = runs[j];
+          html += "<li><span>" + statusBadge(run.status) + " <span class=\\"when\\">" + esc(new Date(run.startedAt).toLocaleString()) + "</span></span><span>" + fmtDuration(run.durationMs) + "</span></li>";
+        }
+        html += "</ul>";
+      } else { html += '<div class="empty">No runs yet.</div>'; }
+
+      el("drawer-body").innerHTML = html;
+      el("run-now").addEventListener("click", function () { runNow(key, this); });
+    });
+  }
+  function closeDrawer() { el("overlay").classList.remove("open"); }
+  el("drawer-close").addEventListener("click", closeDrawer);
+  el("overlay").addEventListener("click", function (e) { if (e.target === el("overlay")) closeDrawer(); });
+
+  function runNow(key, btn) {
+    btn.disabled = true; btn.textContent = "Running\u2026";
+    fetch("/api/trigger/" + encodeURIComponent(key), { method: "POST", headers: { "content-type": "application/json" } })
+      .then(function (r) { return r.json(); })
+      .then(function () { btn.textContent = "Ran \u2713"; setTimeout(function () { openDrawer(key); }, 600); loadJobs(); })
+      .catch(function () { btn.disabled = false; btn.textContent = "Run now"; });
+  }
+
+  // \u2500\u2500 Boot \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  loadJobs();
+  connect();
+  setInterval(tickCountdowns, 1000);
+  setInterval(loadJobs, 15000);
+})();
+</script>
+</body>
+</html>`;
+
+// src/dev/dashboard.ts
+var DEFAULT_PORT = 4747;
+var DEFAULT_HOST = "127.0.0.1";
+var HEARTBEAT_MS = 15e3;
+var MAX_PREVIEW = 50;
+function startDashboard(engine, options = {}) {
+  const host = options.host ?? DEFAULT_HOST;
+  const port = options.port ?? DEFAULT_PORT;
+  const sseClients = /* @__PURE__ */ new Set();
+  const server = http.createServer((req, res) => handleRequest(engine, sseClients, req, res));
+  return new Promise((resolve, reject) => {
+    const onError = (err) => {
+      server.removeListener("error", onError);
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Cronvello dashboard: port ${port} on ${host} is already in use \u2014 pass a different --port.`));
+      } else {
+        reject(err);
+      }
+    };
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.removeListener("error", onError);
+      const actualPort = server.address().port;
+      const shown = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+      const url = `http://${shown}:${actualPort}`;
+      let closed = false;
+      const close = () => {
+        if (closed) return Promise.resolve();
+        closed = true;
+        for (const client of sseClients) client.end();
+        sseClients.clear();
+        return new Promise((res2) => {
+          server.closeAllConnections?.();
+          server.close(() => res2());
+        });
+      };
+      resolve({ url, port: actualPort, close });
+    });
+  });
+}
+function handleRequest(engine, sseClients, req, res) {
+  const url = new URL(req.url ?? "/", "http://localhost");
+  const path = url.pathname;
+  const method = req.method ?? "GET";
+  if (method === "GET" && path === "/") {
+    return sendHtml(res, DASHBOARD_HTML);
+  }
+  if (method === "GET" && path === "/api/events") {
+    return openEventStream(engine, sseClients, req, res);
+  }
+  if (method === "GET" && path === "/api/health") {
+    return sendJson(res, 200, { ok: true, jobs: engine.jobs().length, activeRuns: engine.activeRuns });
+  }
+  if (method === "GET" && path === "/api/runs.ndjson") {
+    res.writeHead(200, { "content-type": "application/x-ndjson; charset=utf-8", "cache-control": "no-store" });
+    const body = engine.toNdjson();
+    return void res.end(body.length ? body + "\n" : "");
+  }
+  if (method === "GET" && path === "/api/runs") {
+    const key = url.searchParams.get("key");
+    return sendJson(res, 200, key ? engine.runsFor(key) : engine.runs());
+  }
+  if (method === "GET" && path.startsWith("/api/runs/")) {
+    return sendJson(res, 200, engine.runsFor(decodeKey(path, "/api/runs/")));
+  }
+  if (method === "GET" && path.startsWith("/api/preview/")) {
+    const key = decodeKey(path, "/api/preview/");
+    const job = engine.snapshot().find((j) => j.key === key);
+    if (!job) return sendJson(res, 404, { error: `unknown job '${key}'` });
+    const n = clampCount(url.searchParams.get("n"));
+    try {
+      const fires = previewSchedule(job.schedule, { timeZone: job.timeZone, count: n });
+      return sendJson(res, 200, fires.map((d) => d.toISOString()));
+    } catch {
+      return sendJson(res, 200, []);
+    }
+  }
+  if (method === "GET" && path === "/api/jobs") {
+    const jobs = engine.snapshot().map((j) => ({
+      key: j.key,
+      schedule: j.schedule,
+      timeZone: j.timeZone,
+      description: j.description,
+      nextFire: j.nextFire ? j.nextFire.toISOString() : null,
+      running: j.running
+    }));
+    return sendJson(res, 200, jobs);
+  }
+  if (method === "POST" && path.startsWith("/api/trigger/")) {
+    if (!isSameOrigin(req)) return sendJson(res, 403, { error: "cross-origin request rejected" });
+    const key = decodeKey(path, "/api/trigger/");
+    return void engine.trigger(key).then((record) => sendJson(res, 200, record)).catch((err) => {
+      const status = /unknown job/.test(err.message) ? 404 : 400;
+      sendJson(res, status, { error: err.message });
+    });
+  }
+  sendJson(res, 404, { error: "not found" });
+}
+function openEventStream(engine, sseClients, req, res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-store",
+    connection: "keep-alive",
+    "x-accel-buffering": "no"
+  });
+  res.write(": connected\n\n");
+  sseClients.add(res);
+  const unsubscribe = engine.subscribe((event) => {
+    res.write(`data: ${JSON.stringify(event)}
+
+`);
+  });
+  const heartbeat = setInterval(() => res.write(": ping\n\n"), HEARTBEAT_MS);
+  if (typeof heartbeat.unref === "function") heartbeat.unref();
+  const cleanup = () => {
+    clearInterval(heartbeat);
+    unsubscribe();
+    sseClients.delete(res);
+  };
+  res.on("close", cleanup);
+  req.on("close", cleanup);
+}
+function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  res.end(payload);
+}
+function sendHtml(res, html) {
+  res.writeHead(200, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+  res.end(html);
+}
+function decodeKey(path, prefix) {
+  return decodeURIComponent(path.slice(prefix.length));
+}
+function clampCount(raw) {
+  const n = raw ? Number.parseInt(raw, 10) : 5;
+  if (!Number.isFinite(n) || n < 1) return 5;
+  return Math.min(n, MAX_PREVIEW);
+}
+function isSameOrigin(req) {
+  const origin = req.headers.origin;
+  if (!origin) return true;
+  try {
+    return new URL(origin).host === req.headers.host;
+  } catch {
+    return false;
+  }
+}
+
+export { LocalEngine, createLocalEngine, localTimeZone, nextOccurrence, parseCron, previewSchedule, startDashboard, upcomingFires };
+//# sourceMappingURL=dev.js.map
+//# sourceMappingURL=dev.js.map