@svgrid/enterprise 2.5.2 → 2.6.0

package/src/scheduler-resource-tree.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { buildResourceRows, visibleResourceIds, type SchedulerResourceGroup } from './scheduler-resource-tree'
-
-type Res = { id: string; title?: string; group?: string }
-const groupOf = (r: Res) => r.group
-
-const groups: SchedulerResourceGroup[] = [
-  { id: 'clinic', title: 'Clinic' },
-  { id: 'cardio', title: 'Cardiology', parentId: 'clinic' },
-  { id: 'derm', title: 'Dermatology', parentId: 'clinic' },
-]
-const resources: Res[] = [
-  { id: 'dr-a', title: 'Dr A', group: 'cardio' },
-  { id: 'dr-b', title: 'Dr B', group: 'cardio' },
-  { id: 'dr-c', title: 'Dr C', group: 'derm' },
-]
-
-describe('buildResourceRows', () => {
-  it('nests groups and interleaves resources in tree order', () => {
-    const rows = buildResourceRows(resources, groups, groupOf)
-    expect(rows.map((r) => `${r.kind}:${r.id}@${r.depth}`)).toEqual([
-      'group:clinic@0',
-      'group:cardio@1',
-      'resource:dr-a@2',
-      'resource:dr-b@2',
-      'group:derm@1',
-      'resource:dr-c@2',
-    ])
-  })
-
-  it('computes childResourceIds (roll-up) for each group subtree', () => {
-    const rows = buildResourceRows(resources, groups, groupOf)
-    const byId = Object.fromEntries(rows.filter((r) => r.kind === 'group').map((r) => [r.id, r.childResourceIds]))
-    expect(byId.clinic).toEqual(['dr-a', 'dr-b', 'dr-c'])
-    expect(byId.cardio).toEqual(['dr-a', 'dr-b'])
-    expect(byId.derm).toEqual(['dr-c'])
-  })
-
-  it('collapsing a group hides its subtree but keeps the header', () => {
-    const rows = buildResourceRows(resources, groups, groupOf, new Set(['cardio']))
-    expect(rows.map((r) => `${r.kind}:${r.id}`)).toEqual([
-      'group:clinic',
-      'group:cardio', // header stays
-      // dr-a, dr-b hidden
-      'group:derm',
-      'resource:dr-c',
-    ])
-    expect(rows.find((r) => r.id === 'cardio')?.collapsed).toBe(true)
-  })
-
-  it('collapsing an ancestor hides all descendants', () => {
-    const rows = buildResourceRows(resources, groups, groupOf, new Set(['clinic']))
-    expect(rows.map((r) => r.id)).toEqual(['clinic'])
-  })
-
-  it('puts ungrouped / unknown-group resources in a trailing section (no header)', () => {
-    const res: Res[] = [{ id: 'x', group: 'cardio' }, { id: 'y' }, { id: 'z', group: 'nope' }]
-    const rows = buildResourceRows(res, groups, groupOf)
-    const last2 = rows.slice(-2).map((r) => `${r.kind}:${r.id}@${r.depth}`)
-    expect(last2).toEqual(['resource:y@0', 'resource:z@0'])
-  })
-
-  it('treats a group with an unknown parent as a root', () => {
-    const g: SchedulerResourceGroup[] = [{ id: 'a', title: 'A', parentId: 'ghost' }]
-    const rows = buildResourceRows([{ id: 'r', group: 'a' }], g, groupOf)
-    expect(rows[0]).toMatchObject({ kind: 'group', id: 'a', depth: 0 })
-  })
-
-  it('does not loop on a cyclic parent chain', () => {
-    const g: SchedulerResourceGroup[] = [
-      { id: 'a', title: 'A', parentId: 'b' },
-      { id: 'b', title: 'B', parentId: 'a' },
-    ]
-    const rows = buildResourceRows([{ id: 'r', group: 'a' }], g, groupOf)
-    // Should terminate; both groups appear at most once.
-    expect(rows.filter((r) => r.id === 'a').length).toBeLessThanOrEqual(1)
-    expect(rows.filter((r) => r.id === 'b').length).toBeLessThanOrEqual(1)
-  })
-
-  it('visibleResourceIds returns leaf resources in order', () => {
-    const rows = buildResourceRows(resources, groups, groupOf)
-    expect(visibleResourceIds(rows)).toEqual(['dr-a', 'dr-b', 'dr-c'])
-  })
-})

package/src/scheduler-resource-tree.ts

@@ -1,107 +0,0 @@
-/**
- * scheduler-resource-tree - the pure core behind Scheduler Pro *grouped / tree
- * resources*. No Svelte, no DOM. Resources are flat in the base grid; this builds
- * a hierarchy of collapsible GROUP header rows (departments -> teams -> people)
- * interleaved with the resource rows, so the timeline gutter can render a tree.
- *
- * Groups nest via `parentId`; each resource is mapped to a group by a `groupOf`
- * accessor. Resources whose group is unknown / unset fall into a trailing
- * "ungrouped" section (rendered without a header). Collapsing a group drops its
- * whole subtree from the output (the header stays).
- */
-
-/** A group node in the resource tree. `parentId` nests it under another group. */
-export type SchedulerResourceGroup = {
-  id: string
-  title: string
-  parentId?: string
-  color?: string
-}
-
-/** One rendered row: a group header, or a leaf resource. */
-export type ResourceRow<R = unknown> = {
-  kind: 'group' | 'resource'
-  id: string
-  title: string
-  /** Indent depth (0 = top level). */
-  depth: number
-  color?: string
-  /** Present for `kind: 'resource'`. */
-  resource?: R
-  /** Present for `kind: 'group'`: whether it is collapsed. */
-  collapsed?: boolean
-  /** Present for `kind: 'group'`: every leaf resource id in its subtree (for roll-ups). */
-  childResourceIds?: string[]
-}
-
-type MinResource = { id: string; title?: string; color?: string }
-
-/**
- * Build the ordered tree rows. `groups` define the hierarchy; `groupOf(resource)`
- * returns the group id a resource belongs to (or undefined = ungrouped). `collapsed`
- * is the set of collapsed group ids. Order: for each group, its child groups
- * (recursively) then its direct resources; ungrouped resources trail at the end.
- */
-export function buildResourceRows<R extends MinResource>(
-  resources: ReadonlyArray<R>,
-  groups: ReadonlyArray<SchedulerResourceGroup>,
-  groupOf: (r: R) => string | undefined,
-  collapsed: ReadonlySet<string> = new Set(),
-): ResourceRow<R>[] {
-  const groupById = new Map<string, SchedulerResourceGroup>()
-  for (const g of groups) if (g && g.id) groupById.set(g.id, g)
-
-  // parentId -> child groups (root groups keyed under '' ). A parentId that is not
-  // a known group is treated as a root.
-  const childGroups = new Map<string, SchedulerResourceGroup[]>()
-  for (const g of groupById.values()) {
-    const p = g.parentId && groupById.has(g.parentId) ? g.parentId : ''
-    ;(childGroups.get(p) ?? childGroups.set(p, []).get(p)!).push(g)
-  }
-
-  // group id -> resources ('' = ungrouped / unknown group).
-  const resByGroup = new Map<string, R[]>()
-  for (const r of resources) {
-    const gid = groupOf(r)
-    const key = gid && groupById.has(gid) ? gid : ''
-    ;(resByGroup.get(key) ?? resByGroup.set(key, []).get(key)!).push(r)
-  }
-
-  // Every leaf resource id under a group's subtree (recursive), for roll-ups.
-  const leafSeen = new Set<string>()
-  const leafIds = (gid: string): string[] => {
-    if (leafSeen.has(gid)) return [] // cycle guard
-    leafSeen.add(gid)
-    const ids: string[] = []
-    for (const r of resByGroup.get(gid) ?? []) ids.push(r.id)
-    for (const cg of childGroups.get(gid) ?? []) ids.push(...leafIds(cg.id))
-    leafSeen.delete(gid)
-    return ids
-  }
-
-  const out: ResourceRow<R>[] = []
-  const walked = new Set<string>()
-  const walk = (g: SchedulerResourceGroup, depth: number): void => {
-    if (walked.has(g.id)) return // cycle guard
-    walked.add(g.id)
-    const isCollapsed = collapsed.has(g.id)
-    out.push({ kind: 'group', id: g.id, title: g.title, depth, color: g.color, collapsed: isCollapsed, childResourceIds: leafIds(g.id) })
-    if (isCollapsed) return
-    for (const cg of childGroups.get(g.id) ?? []) walk(cg, depth + 1)
-    for (const r of resByGroup.get(g.id) ?? []) {
-      out.push({ kind: 'resource', id: r.id, title: r.title ?? r.id, depth: depth + 1, color: r.color, resource: r })
-    }
-  }
-
-  for (const g of childGroups.get('') ?? []) walk(g, 0)
-  // Ungrouped resources trail at the end (no header).
-  for (const r of resByGroup.get('') ?? []) {
-    out.push({ kind: 'resource', id: r.id, title: r.title ?? r.id, depth: 0, color: r.color, resource: r })
-  }
-  return out
-}
-
-/** The leaf resource ids actually visible (resource rows only) in tree order. */
-export function visibleResourceIds<R extends MinResource>(rows: ReadonlyArray<ResourceRow<R>>): string[] {
-  return rows.filter((r) => r.kind === 'resource').map((r) => r.id)
-}

package/src/scheduler-slots.test.ts

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { availableSlots, mergeIntervals, subtractIntervals, type Interval } from './scheduler-slots'
-
-const D = (h: number, m = 0) => new Date(2026, 0, 5, h, m, 0, 0)
-const iv = (sh: number, sm: number, eh: number, em: number): Interval => ({ start: D(sh, sm), end: D(eh, em) })
-const hhmm = (d: Date) => `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`
-const show = (slots: { start: Date; end: Date }[]) => slots.map((s) => `${hhmm(s.start)}-${hhmm(s.end)}`)
-
-describe('mergeIntervals', () => {
-  it('merges overlapping and touching intervals', () => {
-    expect(show(mergeIntervals([iv(9, 0, 10, 0), iv(9, 30, 11, 0), iv(11, 0, 12, 0)]))).toEqual(['09:00-12:00'])
-  })
-})
-
-describe('subtractIntervals', () => {
-  it('cuts occupied blocks out of a base window', () => {
-    const free = subtractIntervals(iv(9, 0, 17, 0), [iv(12, 0, 13, 0)])
-    expect(show(free)).toEqual(['09:00-12:00', '13:00-17:00'])
-  })
-})
-
-describe('availableSlots', () => {
-  it('fills an empty working window with back-to-back slots', () => {
-    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [], durationMin: 60 })
-    expect(show(slots)).toEqual(['09:00-10:00', '10:00-11:00', '11:00-12:00'])
-  })
-
-  it('removes slots that hit a busy booking', () => {
-    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [iv(10, 0, 11, 0)], durationMin: 60 })
-    expect(show(slots)).toEqual(['09:00-10:00', '11:00-12:00'])
-  })
-
-  it('buffers widen what a booking blocks', () => {
-    // busy 10:00-11:00 with a 15-min buffer blocks 09:45-11:15, so the 09:00 slot
-    // (ends 10:00 > 09:45) is gone and only 11:15+ is free (no 60-min slot fits before 12:00).
-    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [iv(10, 0, 11, 0)], durationMin: 60, bufferBeforeMin: 15, bufferAfterMin: 15 })
-    expect(show(slots)).toEqual([]) // 09:00-09:45 too short for 60m; 11:15-12:00 too short
-  })
-
-  it('honours a smaller step (overlapping start times)', () => {
-    const slots = availableSlots({ working: [iv(9, 0, 10, 30)], busy: [], durationMin: 60, stepMin: 30 })
-    expect(show(slots)).toEqual(['09:00-10:00', '09:30-10:30'])
-  })
-
-  it('drops slots before minStart (lead time)', () => {
-    const slots = availableSlots({ working: [iv(9, 0, 12, 0)], busy: [], durationMin: 60, minStart: D(10, 0) })
-    expect(show(slots)).toEqual(['10:00-11:00', '11:00-12:00'])
-  })
-
-  it('returns nothing when the duration cannot fit', () => {
-    expect(availableSlots({ working: [iv(9, 0, 9, 45)], busy: [], durationMin: 60 })).toEqual([])
-  })
-})

package/src/scheduler-slots.ts

@@ -1,94 +0,0 @@
-/**
- * scheduler-slots - the pure core behind Scheduler Pro's *bookable slots /
- * find-a-time* (Calendly-style). No Svelte, no DOM. Given a resource's working
- * windows and its busy intervals, it produces the open, bookable slots of a fixed
- * duration - subtracting busy time (widened by buffers) and anything before a
- * minimum start (now + lead). Deterministic: the caller supplies all dates.
- */
-
-export type Interval = { start: Date; end: Date }
-export type Slot = { start: Date; end: Date }
-
-const MS_MIN = 60_000
-
-/** Merge overlapping / touching intervals into a sorted, disjoint list. */
-export function mergeIntervals(intervals: ReadonlyArray<Interval>): Interval[] {
-  const sorted = [...intervals]
-    .filter((i) => i.end.getTime() > i.start.getTime())
-    .sort((a, b) => a.start.getTime() - b.start.getTime())
-  const out: Interval[] = []
-  for (const iv of sorted) {
-    const last = out[out.length - 1]
-    if (last && iv.start.getTime() <= last.end.getTime()) {
-      if (iv.end.getTime() > last.end.getTime()) last.end = iv.end
-    } else out.push({ start: iv.start, end: iv.end })
-  }
-  return out
-}
-
-/** The parts of `[base]` not covered by any of the (merged) `occupied` intervals. */
-export function subtractIntervals(base: Interval, occupied: ReadonlyArray<Interval>): Interval[] {
-  const occ = mergeIntervals(occupied)
-  const out: Interval[] = []
-  let cursor = base.start.getTime()
-  const end = base.end.getTime()
-  for (const o of occ) {
-    const os = o.start.getTime()
-    const oe = o.end.getTime()
-    if (oe <= cursor || os >= end) continue // outside base
-    if (os > cursor) out.push({ start: new Date(cursor), end: new Date(Math.min(os, end)) })
-    cursor = Math.max(cursor, oe)
-    if (cursor >= end) break
-  }
-  if (cursor < end) out.push({ start: new Date(cursor), end: new Date(end) })
-  return out
-}
-
-export type SlotOptions = {
-  working: ReadonlyArray<Interval>
-  busy: ReadonlyArray<Interval>
-  durationMin: number
-  /** Slot start granularity (minutes). Default = `durationMin` (back-to-back slots). */
-  stepMin?: number
-  /** Clear minutes required before / after a busy booking (widens what it blocks). */
-  bufferBeforeMin?: number
-  bufferAfterMin?: number
-  /** Earliest allowed slot start (e.g. now + lead time). Slots before it are dropped. */
-  minStart?: Date
-}
-
-/**
- * The bookable slots. For each working window, subtract busy time (each busy
- * interval widened by the buffers) and anything before `minStart`, then step
- * through the remaining free space emitting `durationMin` slots every `stepMin`.
- */
-export function availableSlots(opts: SlotOptions): Slot[] {
-  const durMs = Math.max(1, opts.durationMin) * MS_MIN
-  const stepMs = Math.max(1, opts.stepMin ?? opts.durationMin) * MS_MIN
-  const bufB = (opts.bufferBeforeMin ?? 0) * MS_MIN
-  const bufA = (opts.bufferAfterMin ?? 0) * MS_MIN
-  const floor = opts.minStart ? opts.minStart.getTime() : -Infinity
-
-  const occupied: Interval[] = opts.busy.map((b) => ({
-    start: new Date(b.start.getTime() - bufB),
-    end: new Date(b.end.getTime() + bufA),
-  }))
-
-  const out: Slot[] = []
-  for (const w of mergeIntervals(opts.working)) {
-    // Clip the window to `minStart` before subtracting busy.
-    const wStart = Math.max(w.start.getTime(), floor)
-    if (wStart >= w.end.getTime()) continue
-    const free = subtractIntervals({ start: new Date(wStart), end: w.end }, occupied)
-    for (const gap of free) {
-      let s = gap.start.getTime()
-      const gEnd = gap.end.getTime()
-      let guard = 0
-      while (s + durMs <= gEnd && guard++ < 5000) {
-        out.push({ start: new Date(s), end: new Date(s + durMs) })
-        s += stepMs
-      }
-    }
-  }
-  return out
-}

package/src/scheduler-summary.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { busyMinutesReducer, columnSummaries, sumReducer } from './scheduler-summary'
-
-type Row = { id: string; amount: number }
-type Ev = { row: Row; start: Date; end: Date }
-const D = (h: number) => new Date(2026, 0, 5, h, 0, 0, 0)
-const ev = (id: string, s: number, e: number, amount: number): Ev => ({ row: { id, amount }, start: D(s), end: D(e) })
-
-const opts = { startOf: (e: Ev) => e.start, endOf: (e: Ev) => e.end, rowOf: (e: Ev) => e.row }
-const cols = [
-  { start: D(9), end: D(10) },
-  { start: D(10), end: D(11) },
-  { start: D(11), end: D(12) },
-]
-
-describe('columnSummaries', () => {
-  it('counts events overlapping each column', () => {
-    const events = [ev('a', 9, 11, 5), ev('b', 10, 12, 3)] // a in cols 0,1; b in cols 1,2
-    expect(columnSummaries(events, cols, 'count', opts)).toEqual([1, 2, 1])
-  })
-
-  it('sums a numeric field per column', () => {
-    const events = [ev('a', 9, 11, 5), ev('b', 10, 12, 3)]
-    expect(columnSummaries(events, cols, sumReducer<Row>('amount'), opts)).toEqual([5, 8, 3])
-  })
-
-  it('yields 0 for empty columns', () => {
-    expect(columnSummaries([], cols, 'count', opts)).toEqual([0, 0, 0])
-    expect(columnSummaries([], cols, sumReducer<Row>('amount'), opts)).toEqual([0, 0, 0])
-  })
-
-  it('clips events to the column for a busy-minutes reducer', () => {
-    const events = [ev('a', 9, 12, 0)] // spans all three hours
-    // Each column is 1h; the event contributes 60 clipped minutes to each.
-    expect(columnSummaries(events, cols, busyMinutesReducer<Row>(), opts)).toEqual([60, 60, 60])
-  })
-
-  it('passes column-clipped items to a custom reducer', () => {
-    const events = [ev('a', 9, 12, 0)]
-    const seen: number[] = []
-    columnSummaries(events, cols, (items) => {
-      seen.push(items.length ? (items[0]!.end.getTime() - items[0]!.start.getTime()) / 60000 : 0)
-      return items.length
-    }, opts)
-    expect(seen).toEqual([60, 60, 60]) // clipped to each 1h column
-  })
-})

package/src/scheduler-summary.ts

@@ -1,81 +0,0 @@
-/**
- * scheduler-summary - the pure core behind Scheduler Pro's *per-time-column
- * summary* strip (counts / sums / a custom roll-up aligned to the timeline axis).
- * No Svelte, no DOM. Each event is clipped to the column it falls in before the
- * reducer runs, so duration-based reducers (busy minutes) are per-column.
- */
-
-const MS_MIN = 60_000
-
-/** One event clipped to a column: its row plus the clipped [start, end). */
-export type SummaryItem<TData> = { row: TData; start: Date; end: Date }
-
-/**
- * How a column's overlapping events roll up to one cell value:
- *   - `'count'`  - number of events touching the column
- *   - `{ sum }`  - sum of a numeric row field over those events
- *   - function   - custom, receives the column-clipped items
- */
-export type ColumnReducer<TData> =
-  | 'count'
-  | { sum: keyof TData & string }
-  | ((items: SummaryItem<TData>[]) => string | number)
-
-export type SummaryOptions<E, TData> = {
-  startOf: (e: E) => Date
-  endOf: (e: E) => Date
-  rowOf: (e: E) => TData
-}
-
-function overlaps(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
-  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime()
-}
-
-/**
- * One summary value per column. For each column, collect the events overlapping
- * it, clip each to the column bounds, then apply `reducer`. Empty columns yield
- * `0` for `count` / `sum` and `reducer([])` for the function form.
- */
-export function columnSummaries<E, TData>(
-  events: ReadonlyArray<E>,
-  columns: ReadonlyArray<{ start: Date; end: Date }>,
-  reducer: ColumnReducer<TData>,
-  opts: SummaryOptions<E, TData>,
-): Array<string | number> {
-  return columns.map((col) => {
-    const items: SummaryItem<TData>[] = []
-    for (const e of events) {
-      const s = opts.startOf(e)
-      const en = opts.endOf(e)
-      if (!overlaps(s, en, col.start, col.end)) continue
-      items.push({
-        row: opts.rowOf(e),
-        start: new Date(Math.max(s.getTime(), col.start.getTime())),
-        end: new Date(Math.min(en.getTime(), col.end.getTime())),
-      })
-    }
-    if (reducer === 'count') return items.length
-    if (typeof reducer === 'function') return reducer(items)
-    // { sum: field }
-    const field = reducer.sum
-    let total = 0
-    for (const it of items) {
-      const v = (it.row as Record<string, unknown>)[field as string]
-      if (typeof v === 'number' && Number.isFinite(v)) total += v
-    }
-    return total
-  })
-}
-
-/** Built-in reducer: sum a numeric row field. */
-export function sumReducer<TData>(field: keyof TData & string): ColumnReducer<TData> {
-  return { sum: field }
-}
-
-/** Built-in reducer: count events. */
-export const countReducer = 'count' as const
-
-/** Built-in reducer: total column-clipped busy minutes across the column's events. */
-export function busyMinutesReducer<TData>(): (items: SummaryItem<TData>[]) => number {
-  return (items) => items.reduce((sum, it) => sum + (it.end.getTime() - it.start.getTime()) / MS_MIN, 0)
-}

package/src/scheduling.test.ts

@@ -1,194 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  parseCron,
-  cronMatches,
-  isScheduleDue,
-  nextRun,
-  createScheduler,
-  CRON_PRESETS,
-  type Schedule,
-} from './scheduling'
-
-// A fixed reference instant: Monday 2026-07-27, 17:30 local time.
-// (2026-07-27 is a Monday; getDay() === 1.)
-const MON_1730 = new Date(2026, 6, 27, 17, 30, 0)
-
-describe('parseCron', () => {
-  it('rejects the wrong field count', () => {
-    expect(() => parseCron('* * * *')).toThrow(/5 fields/)
-    expect(() => parseCron('0 9 * * * *')).toThrow(/5 fields/)
-  })
-
-  it('rejects an unparseable step', () => {
-    expect(() => parseCron('*/0 * * * *')).toThrow(/step/)
-  })
-})
-
-describe('cronMatches', () => {
-  it('matches an exact minute/hour', () => {
-    expect(cronMatches('30 17 * * *', MON_1730)).toBe(true)
-    expect(cronMatches('31 17 * * *', MON_1730)).toBe(false)
-    expect(cronMatches('30 16 * * *', MON_1730)).toBe(false)
-  })
-
-  it('matches weekday ranges (1-5 = Mon-Fri)', () => {
-    expect(cronMatches('30 17 * * 1-5', MON_1730)).toBe(true)
-    const sun = new Date(2026, 6, 26, 17, 30) // Sunday
-    expect(cronMatches('30 17 * * 1-5', sun)).toBe(false)
-  })
-
-  it('accepts 7 as an alias for Sunday', () => {
-    const sun = new Date(2026, 6, 26, 9, 0)
-    expect(cronMatches('0 9 * * 7', sun)).toBe(true)
-    expect(cronMatches('0 9 * * 0', sun)).toBe(true)
-  })
-
-  it('honors step values (*/15)', () => {
-    expect(cronMatches('*/15 * * * *', new Date(2026, 6, 27, 10, 0))).toBe(true)
-    expect(cronMatches('*/15 * * * *', new Date(2026, 6, 27, 10, 15))).toBe(true)
-    expect(cronMatches('*/15 * * * *', new Date(2026, 6, 27, 10, 7))).toBe(false)
-  })
-
-  it('honors lists (0,30)', () => {
-    expect(cronMatches('0,30 * * * *', new Date(2026, 6, 27, 10, 0))).toBe(true)
-    expect(cronMatches('0,30 * * * *', new Date(2026, 6, 27, 10, 30))).toBe(true)
-    expect(cronMatches('0,30 * * * *', new Date(2026, 6, 27, 10, 15))).toBe(false)
-  })
-
-  it('uses UNION semantics when both day-of-month and day-of-week are set', () => {
-    // Fires on the 1st OR on any Monday. 2026-07-27 is a Monday (not the 1st).
-    expect(cronMatches('0 9 1 * 1', new Date(2026, 6, 27, 9, 0))).toBe(true)
-    // 2026-07-15 is a Wednesday and not the 1st -> neither matches.
-    expect(cronMatches('0 9 1 * 1', new Date(2026, 6, 15, 9, 0))).toBe(false)
-    // The 1st of the month, a Wednesday -> dom matches.
-    expect(cronMatches('0 9 1 * 1', new Date(2026, 6, 1, 9, 0))).toBe(true)
-  })
-
-  it('every preset parses and matches at least one time this year', () => {
-    for (const p of CRON_PRESETS) {
-      expect(() => parseCron(p.cron)).not.toThrow()
-      expect(nextRun({ id: p.label, cron: p.cron }, MON_1730)).toBeInstanceOf(Date)
-    }
-  })
-})
-
-describe('isScheduleDue', () => {
-  it('is false when disabled', () => {
-    expect(isScheduleDue({ id: 'a', cron: '30 17 * * *', enabled: false }, MON_1730)).toBe(false)
-  })
-
-  it('fires a one-off in its exact minute only', () => {
-    const s: Schedule = { id: 'once', runAt: MON_1730.toISOString() }
-    expect(isScheduleDue(s, MON_1730)).toBe(true)
-    expect(isScheduleDue(s, new Date(2026, 6, 27, 17, 31))).toBe(false)
-  })
-
-  it('prefers runAt over cron when both are present', () => {
-    const s: Schedule = { id: 'both', runAt: MON_1730.toISOString(), cron: '0 0 * * *' }
-    expect(isScheduleDue(s, MON_1730)).toBe(true)
-    expect(isScheduleDue(s, new Date(2026, 6, 27, 0, 0))).toBe(false)
-  })
-})
-
-describe('nextRun', () => {
-  it('finds the next cron occurrence', () => {
-    const from = new Date(2026, 6, 27, 17, 31) // just after 17:30
-    const next = nextRun({ id: 'eod', cron: '30 17 * * 1-5' }, from)
-    // Next weekday 17:30 is Tuesday the 28th.
-    expect(next).toEqual(new Date(2026, 6, 28, 17, 30))
-  })
-
-  it('returns null for a one-off already in the past', () => {
-    const past = new Date(2020, 0, 1, 0, 0).toISOString()
-    expect(nextRun({ id: 'old', runAt: past }, MON_1730)).toBeNull()
-  })
-
-  it('returns the one-off instant when still in the future', () => {
-    const future = new Date(2026, 6, 27, 18, 0)
-    expect(nextRun({ id: 'soon', runAt: future.toISOString() }, MON_1730)).toEqual(future)
-  })
-})
-
-describe('createScheduler', () => {
-  it('fires a due schedule exactly once per minute across repeated ticks', () => {
-    const onFire = vi.fn()
-    let clock = MON_1730
-    const scheduler = createScheduler({
-      schedules: [{ id: 'eod', cron: '30 17 * * 1-5' }],
-      onFire,
-      now: () => clock,
-    })
-    // Two ticks in the same minute (the 30s interval fires twice a minute).
-    scheduler.tick()
-    scheduler.tick()
-    expect(onFire).toHaveBeenCalledTimes(1)
-    expect(onFire).toHaveBeenCalledWith(expect.objectContaining({ id: 'eod' }), clock)
-
-    // Advance a minute past the match: no new fire.
-    clock = new Date(2026, 6, 27, 17, 31)
-    scheduler.tick()
-    expect(onFire).toHaveBeenCalledTimes(1)
-  })
-
-  it('fires a one-off only once, ever', () => {
-    const onFire = vi.fn()
-    let clock = MON_1730
-    const scheduler = createScheduler({
-      schedules: [{ id: 'once', runAt: MON_1730.toISOString() }],
-      onFire,
-      now: () => clock,
-    })
-    scheduler.tick()
-    // Same minute again, and a later matching-looking minute: still once.
-    scheduler.tick()
-    clock = new Date(MON_1730.getTime() + 60_000)
-    scheduler.tick()
-    expect(onFire).toHaveBeenCalledTimes(1)
-  })
-
-  it('skips disabled schedules', () => {
-    const onFire = vi.fn()
-    const scheduler = createScheduler({
-      schedules: [{ id: 'x', cron: '30 17 * * *', enabled: false }],
-      onFire,
-      now: () => MON_1730,
-    })
-    scheduler.tick()
-    expect(onFire).not.toHaveBeenCalled()
-  })
-
-  it('start()/stop() drive ticks on the interval', () => {
-    vi.useFakeTimers()
-    try {
-      const onFire = vi.fn()
-      const scheduler = createScheduler({
-        schedules: [{ id: 'min', cron: '* * * * *' }],
-        onFire,
-        now: () => new Date(2026, 6, 27, 17, 30, 0),
-        intervalMs: 30_000,
-      })
-      scheduler.start()
-      vi.advanceTimersByTime(30_000)
-      expect(onFire).toHaveBeenCalledTimes(1) // once per minute despite 2 ticks
-      scheduler.stop()
-      vi.advanceTimersByTime(120_000)
-      expect(onFire).toHaveBeenCalledTimes(1) // stopped: no more fires
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-
-  it('upcoming() reports the next run per schedule', () => {
-    const scheduler = createScheduler({
-      schedules: [
-        { id: 'eod', cron: '30 17 * * 1-5' },
-        { id: 'old', runAt: new Date(2020, 0, 1).toISOString() },
-      ],
-      onFire: () => {},
-      now: () => new Date(2026, 6, 27, 17, 31),
-    })
-    const up = scheduler.upcoming()
-    expect(up.find((u) => u.id === 'eod')?.at).toEqual(new Date(2026, 6, 28, 17, 30))
-    expect(up.find((u) => u.id === 'old')?.at).toBeNull()
-  })
-})