@svgrid/enterprise 2.5.2 → 2.6.0

package/dist/scheduler-dependencies.js

@@ -0,0 +1,179 @@
+/**
+ * scheduler-dependencies - the pure, framework-free core behind the Scheduler Pro
+ * *event dependencies* feature (predecessor / successor links + auto-reschedule).
+ * No Svelte, no DOM: just graph + date math over the native `Date`, so every rule
+ * here is unit-tested directly (mirrors scheduler-model.ts in @svgrid/grid).
+ *
+ * A dependency links a predecessor event to a successor with one of the four
+ * classic types (FS / SS / FF / SF) and an optional `lag` (minutes; negative = a
+ * lead). When a predecessor moves or resizes, {@link cascade} pushes successors
+ * forward just enough to keep every link legal, preserving each event's duration.
+ * Cascading never pulls an event earlier - it only resolves violations forward,
+ * the standard auto-schedule behaviour.
+ *
+ * Deliberately avoids the arg-less `new Date()` / `Date.now()` - callers pass the
+ * current event times in; working-time skipping is injected as a `snapForward`
+ * hook so this file needs no knowledge of shifts / business hours.
+ */
+const MS_MIN = 60000;
+/** Sub-second slack so exact-touching links (successor.start == pred.end) are legal. */
+const EPS_MS = 1000;
+/** Build the adjacency indexes for `deps`. */
+export function buildDependencyGraph(deps) {
+    const succ = new Map();
+    const pred = new Map();
+    const byId = new Map();
+    const nodes = new Set();
+    const list = [];
+    for (const d of deps) {
+        if (!d || !d.from || !d.to || d.from === d.to)
+            continue; // ignore malformed / self links
+        list.push(d);
+        byId.set(d.id, d);
+        nodes.add(d.from);
+        nodes.add(d.to);
+        (succ.get(d.from) ?? succ.set(d.from, []).get(d.from)).push(d);
+        (pred.get(d.to) ?? pred.set(d.to, []).get(d.to)).push(d);
+    }
+    return { deps: list, succ, pred, byId, nodes };
+}
+/**
+ * Kahn topological order of the graph's nodes. Returns `{ order, cyclicIds }`:
+ * `order` is a safe processing order for the acyclic part (predecessors before
+ * successors); `cyclicIds` are the ids of links that could not be ordered because
+ * they take part in a cycle (cascade ignores them so it can never loop).
+ */
+export function topoOrder(graph) {
+    const indeg = new Map();
+    for (const n of graph.nodes)
+        indeg.set(n, 0);
+    for (const d of graph.deps)
+        indeg.set(d.to, (indeg.get(d.to) ?? 0) + 1);
+    const queue = [];
+    for (const [n, deg] of indeg)
+        if (deg === 0)
+            queue.push(n);
+    // Stable: process in insertion order for deterministic output.
+    const order = [];
+    const settled = new Set();
+    while (queue.length) {
+        const n = queue.shift();
+        order.push(n);
+        settled.add(n);
+        for (const d of graph.succ.get(n) ?? []) {
+            const deg = (indeg.get(d.to) ?? 0) - 1;
+            indeg.set(d.to, deg);
+            if (deg === 0)
+                queue.push(d.to);
+        }
+    }
+    // Any node not settled sits inside (or downstream of) a cycle; links whose
+    // successor never settled are the cyclic ones.
+    const cyclicIds = new Set();
+    for (const d of graph.deps)
+        if (!settled.has(d.to))
+            cyclicIds.add(d.id);
+    return { order, cyclicIds };
+}
+/** True when `deps` contain a cycle. */
+export function hasCycle(deps) {
+    return topoOrder(buildDependencyGraph(deps)).cyclicIds.size > 0;
+}
+/**
+ * The earliest legal start for the successor of `dep`, given the predecessor's
+ * resolved times and the successor's own `durationMs` (kept constant). Encodes the
+ * FS / SS / FF / SF semantics plus `lag` (minutes).
+ */
+export function requiredStart(predTimes, dep, successorDurationMs) {
+    const lagMs = (dep.lag ?? 0) * MS_MIN;
+    const type = dep.type ?? 'FS';
+    let t;
+    switch (type) {
+        case 'FS':
+            t = predTimes.end.getTime() + lagMs;
+            break;
+        case 'SS':
+            t = predTimes.start.getTime() + lagMs;
+            break;
+        case 'FF':
+            t = predTimes.end.getTime() + lagMs - successorDurationMs;
+            break;
+        case 'SF':
+            t = predTimes.start.getTime() + lagMs - successorDurationMs;
+            break;
+    }
+    return new Date(t);
+}
+/**
+ * Forward-cascade successors so every dependency is satisfied. `times` maps row
+ * key -> current [start,end] (the just-moved predecessor already carries its NEW
+ * time). Processing runs in topological order, so multi-hop chains and diamonds
+ * (two paths into one successor) resolve to the latest required start in a single
+ * pass. Each shifted event keeps its duration. Returns ONLY the events whose times
+ * changed (never the untouched ones, never the moved predecessor itself unless a
+ * link also forces it). Cyclic links are ignored.
+ */
+export function cascade(times, deps, opts = {}) {
+    const graph = buildDependencyGraph(deps);
+    const { order, cyclicIds } = topoOrder(graph);
+    // Working copy we mutate as we walk downstream.
+    const cur = new Map();
+    for (const [k, v] of times)
+        cur.set(k, { start: v.start, end: v.end });
+    const changed = new Map();
+    for (const key of order) {
+        const links = graph.pred.get(key);
+        if (!links || !links.length)
+            continue;
+        const self = cur.get(key);
+        if (!self)
+            continue;
+        const durationMs = self.end.getTime() - self.start.getTime();
+        let minStartMs = self.start.getTime();
+        for (const dep of links) {
+            if (cyclicIds.has(dep.id))
+                continue;
+            const pred = cur.get(dep.from);
+            if (!pred)
+                continue;
+            const req = requiredStart(pred, dep, durationMs).getTime();
+            if (req > minStartMs)
+                minStartMs = req;
+        }
+        if (minStartMs <= self.start.getTime())
+            continue; // already legal - never pull earlier
+        let newStart = new Date(minStartMs);
+        if (opts.snapForward)
+            newStart = opts.snapForward(newStart);
+        const newEnd = new Date(newStart.getTime() + durationMs);
+        const next = { start: newStart, end: newEnd };
+        cur.set(key, next);
+        changed.set(key, next);
+    }
+    return changed;
+}
+/**
+ * The dependencies currently unsatisfied by `times` (successor starts too early
+ * for the link). Used to paint violation-state arrows. Cyclic links are skipped.
+ */
+export function violations(times, deps) {
+    const graph = buildDependencyGraph(deps);
+    const { cyclicIds } = topoOrder(graph);
+    const out = [];
+    for (const dep of graph.deps) {
+        if (cyclicIds.has(dep.id))
+            continue;
+        const pred = times.get(dep.from);
+        const succ = times.get(dep.to);
+        if (!pred || !succ)
+            continue;
+        const durationMs = succ.end.getTime() - succ.start.getTime();
+        const req = requiredStart(pred, dep, durationMs).getTime();
+        // A link on end (FF / SF) constrains the successor's end; compare that edge.
+        const type = dep.type ?? 'FS';
+        const actual = type === 'FF' || type === 'SF' ? succ.end.getTime() - durationMs : succ.start.getTime();
+        if (actual + EPS_MS < req)
+            out.push(dep);
+    }
+    return out;
+}

package/dist/scheduler-freebusy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * scheduler-freebusy - the pure core behind Scheduler Pro's *free/busy* and
+ * *cross-attendee find-a-time*. No Svelte, no DOM. Merges each attendee's busy
+ * intervals and finds the windows when EVERYONE is free (long enough for a meeting).
+ * Deterministic - the caller supplies all dates. Reuses the interval algebra from
+ * scheduler-slots (`mergeIntervals` / `subtractIntervals`).
+ */
+import { type Interval } from './scheduler-slots';
+export type { Interval };
+/** Union of a set of busy intervals into a sorted, disjoint list (an alias of the
+ *  slots merge, named for the free/busy domain). */
+export declare function mergeBusy(intervals: ReadonlyArray<Interval>): Interval[];
+/**
+ * The windows within `[dayStart, dayEnd]` when EVERY attendee is free, each at
+ * least `durationMin` long. `busyByPerson` is one busy list per attendee; a person
+ * with no entry is treated as fully free. The result is the complement of the union
+ * of all busy time, filtered to windows that can fit the meeting.
+ */
+export declare function commonFree(busyByPerson: ReadonlyArray<ReadonlyArray<Interval>>, dayStart: Date, dayEnd: Date, durationMin: number): Interval[];

package/{src/scheduler-freebusy.ts → dist/scheduler-freebusy.js}

@@ -5,32 +5,22 @@
  * Deterministic - the caller supplies all dates. Reuses the interval algebra from
  * scheduler-slots (`mergeIntervals` / `subtractIntervals`).
  */
-import { mergeIntervals, subtractIntervals, type Interval } from './scheduler-slots'
-
-export type { Interval }
-
-const MS_MIN = 60_000
-
+import { mergeIntervals, subtractIntervals } from './scheduler-slots';
+const MS_MIN = 60000;
 /** Union of a set of busy intervals into a sorted, disjoint list (an alias of the
  *  slots merge, named for the free/busy domain). */
-export function mergeBusy(intervals: ReadonlyArray<Interval>): Interval[] {
-  return mergeIntervals(intervals)
+export function mergeBusy(intervals) {
+    return mergeIntervals(intervals);
 }
-
 /**
  * The windows within `[dayStart, dayEnd]` when EVERY attendee is free, each at
  * least `durationMin` long. `busyByPerson` is one busy list per attendee; a person
  * with no entry is treated as fully free. The result is the complement of the union
  * of all busy time, filtered to windows that can fit the meeting.
  */
-export function commonFree(
-  busyByPerson: ReadonlyArray<ReadonlyArray<Interval>>,
-  dayStart: Date,
-  dayEnd: Date,
-  durationMin: number,
-): Interval[] {
-  const allBusy = mergeIntervals(busyByPerson.flat())
-  const free = subtractIntervals({ start: dayStart, end: dayEnd }, allBusy)
-  const minMs = Math.max(0, durationMin) * MS_MIN
-  return free.filter((f) => f.end.getTime() - f.start.getTime() >= minMs)
+export function commonFree(busyByPerson, dayStart, dayEnd, durationMin) {
+    const allBusy = mergeIntervals(busyByPerson.flat());
+    const free = subtractIntervals({ start: dayStart, end: dayEnd }, allBusy);
+    const minMs = Math.max(0, durationMin) * MS_MIN;
+    return free.filter((f) => f.end.getTime() - f.start.getTime() >= minMs);
 }

package/{src/scheduler-heatmap.ts → dist/scheduler-heatmap.d.ts}

@@ -8,17 +8,15 @@
  * intensity (0..1) + an over-capacity flag per cell; it then paints the cell with
  * a theme colour at that intensity.
  */
-
 /** One background cell: its axis geometry + normalized load intensity. */
 export type HeatCell = {
-  leftPct: number
-  widthPct: number
-  /** 0..1, load scaled against `peak` (clamped). */
-  intensity: number
-  /** True when the raw load exceeds capacity. */
-  over: boolean
-}
-
+    leftPct: number;
+    widthPct: number;
+    /** 0..1, load scaled against `peak` (clamped). */
+    intensity: number;
+    /** True when the raw load exceeds capacity. */
+    over: boolean;
+};
 /**
  * Build the per-tick heat cells for one resource row. `ticks` supply the axis
  * geometry, `loads` the load in each tick (same length/order), `capacity` the
@@ -26,30 +24,9 @@ export type HeatCell = {
  * (usually a global peak so rows are comparable). Zero-load ticks are still
  * emitted (intensity 0) so the caller can decide whether to paint them.
  */
-export function heatCells(
-  ticks: ReadonlyArray<{ leftPct: number; widthPct: number }>,
-  loads: ReadonlyArray<number>,
-  capacity: number,
-  peak: number,
-): HeatCell[] {
-  const scale = Math.max(peak, capacity, 1)
-  const out: HeatCell[] = []
-  for (let i = 0; i < ticks.length; i++) {
-    const t = ticks[i]!
-    const load = loads[i] ?? 0
-    out.push({
-      leftPct: t.leftPct,
-      widthPct: t.widthPct,
-      intensity: Math.max(0, Math.min(1, load / scale)),
-      over: load > capacity + 1e-9,
-    })
-  }
-  return out
-}
-
+export declare function heatCells(ticks: ReadonlyArray<{
+    leftPct: number;
+    widthPct: number;
+}>, loads: ReadonlyArray<number>, capacity: number, peak: number): HeatCell[];
 /** The peak load across a set of per-resource load rows (for a shared scale). */
-export function heatPeak(loadRows: ReadonlyArray<ReadonlyArray<number>>, floor = 1): number {
-  let peak = floor
-  for (const row of loadRows) for (const v of row) if (v > peak) peak = v
-  return peak
-}
+export declare function heatPeak(loadRows: ReadonlyArray<ReadonlyArray<number>>, floor?: number): number;

package/dist/scheduler-heatmap.js

@@ -0,0 +1,41 @@
+/**
+ * scheduler-heatmap - the pure core behind Scheduler Pro's *utilization heatmap*.
+ * No Svelte, no DOM. Distinct from the histogram (a bar strip): the heatmap tints
+ * a resource row's BACKGROUND per time-bucket by how loaded that resource is.
+ *
+ * The renderer computes each bucket's load (with `resourceLoad` / `overlapCount`
+ * from the assignment / model helpers) and passes it here to get a normalized
+ * intensity (0..1) + an over-capacity flag per cell; it then paints the cell with
+ * a theme colour at that intensity.
+ */
+/**
+ * Build the per-tick heat cells for one resource row. `ticks` supply the axis
+ * geometry, `loads` the load in each tick (same length/order), `capacity` the
+ * resource's capacity (over that = `over`), and `peak` the normalization scale
+ * (usually a global peak so rows are comparable). Zero-load ticks are still
+ * emitted (intensity 0) so the caller can decide whether to paint them.
+ */
+export function heatCells(ticks, loads, capacity, peak) {
+    const scale = Math.max(peak, capacity, 1);
+    const out = [];
+    for (let i = 0; i < ticks.length; i++) {
+        const t = ticks[i];
+        const load = loads[i] ?? 0;
+        out.push({
+            leftPct: t.leftPct,
+            widthPct: t.widthPct,
+            intensity: Math.max(0, Math.min(1, load / scale)),
+            over: load > capacity + 1e-9,
+        });
+    }
+    return out;
+}
+/** The peak load across a set of per-resource load rows (for a shared scale). */
+export function heatPeak(loadRows, floor = 1) {
+    let peak = floor;
+    for (const row of loadRows)
+        for (const v of row)
+            if (v > peak)
+                peak = v;
+    return peak;
+}

package/dist/scheduler-resource-tree.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 declare function buildResourceRows<R extends MinResource>(resources: ReadonlyArray<R>, groups: ReadonlyArray<SchedulerResourceGroup>, groupOf: (r: R) => string | undefined, collapsed?: ReadonlySet<string>): ResourceRow<R>[];
+/** The leaf resource ids actually visible (resource rows only) in tree order. */
+export declare function visibleResourceIds<R extends MinResource>(rows: ReadonlyArray<ResourceRow<R>>): string[];
+export {};

package/dist/scheduler-resource-tree.js

@@ -0,0 +1,78 @@
+/**
+ * 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).
+ */
+/**
+ * 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(resources, groups, groupOf, collapsed = new Set()) {
+    const groupById = new Map();
+    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();
+    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();
+    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();
+    const leafIds = (gid) => {
+        if (leafSeen.has(gid))
+            return []; // cycle guard
+        leafSeen.add(gid);
+        const ids = [];
+        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 = [];
+    const walked = new Set();
+    const walk = (g, depth) => {
+        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(rows) {
+    return rows.filter((r) => r.kind === 'resource').map((r) => r.id);
+}

package/dist/scheduler-slots.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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;
+};
+/** Merge overlapping / touching intervals into a sorted, disjoint list. */
+export declare function mergeIntervals(intervals: ReadonlyArray<Interval>): Interval[];
+/** The parts of `[base]` not covered by any of the (merged) `occupied` intervals. */
+export declare function subtractIntervals(base: Interval, occupied: ReadonlyArray<Interval>): Interval[];
+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 declare function availableSlots(opts: SlotOptions): Slot[];

package/dist/scheduler-slots.js

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+const MS_MIN = 60000;
+/** Merge overlapping / touching intervals into a sorted, disjoint list. */
+export function mergeIntervals(intervals) {
+    const sorted = [...intervals]
+        .filter((i) => i.end.getTime() > i.start.getTime())
+        .sort((a, b) => a.start.getTime() - b.start.getTime());
+    const out = [];
+    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, occupied) {
+    const occ = mergeIntervals(occupied);
+    const out = [];
+    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;
+}
+/**
+ * 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) {
+    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 = opts.busy.map((b) => ({
+        start: new Date(b.start.getTime() - bufB),
+        end: new Date(b.end.getTime() + bufA),
+    }));
+    const out = [];
+    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/dist/scheduler-summary.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+/** 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;
+};
+/**
+ * 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 declare function columnSummaries<E, TData>(events: ReadonlyArray<E>, columns: ReadonlyArray<{
+    start: Date;
+    end: Date;
+}>, reducer: ColumnReducer<TData>, opts: SummaryOptions<E, TData>): Array<string | number>;
+/** Built-in reducer: sum a numeric row field. */
+export declare function sumReducer<TData>(field: keyof TData & string): ColumnReducer<TData>;
+/** Built-in reducer: count events. */
+export declare const countReducer: "count";
+/** Built-in reducer: total column-clipped busy minutes across the column's events. */
+export declare function busyMinutesReducer<TData>(): (items: SummaryItem<TData>[]) => number;