@svgrid/enterprise 2.2.1 → 2.3.0

package/src/index.ts

@@ -54,6 +54,82 @@ export { installEnterprise, type EnterpriseGridApi, type EnterpriseAIApi, type E
 // renderer so `<SvGrid scheduler={...}>` shows a Month/Week/Day/Agenda calendar.
 // The pure model helpers + config types live in @svgrid/grid; import them from there.
 export { enableSchedulerView, SvGridScheduler } from './scheduler'
+// Kanban board view (Pro). `enableBoardView()` registers the renderer so
+// `<SvGrid board={...}>` shows lanes of cards. Config types live in @svgrid/grid.
+export { enableBoardView, SvGridBoard } from './board'
+// In-grid pivot mode (Pro). `enablePivot()` registers the pivot engine so
+// `<SvGrid pivot={...}>` renders a pivot table in place of the flat table.
+export { enablePivot } from './pivot-enable'
+// Scheduler Pro feature surface (dependencies, multi-assignment + summaries,
+// axis collapse + zoom). Config type extends the free grid's SchedulerConfig;
+// the pure models are unit-tested framework-free helpers the renderer consumes.
+export type { SchedulerProConfig } from './scheduler-config'
+export {
+  buildDependencyGraph,
+  topoOrder,
+  hasCycle,
+  requiredStart,
+  cascade,
+  violations,
+  type DependencyType,
+  type SchedulerDependency,
+  type EventTimes,
+  type DependencyGraph,
+  type CascadeOptions,
+} from './scheduler-dependencies'
+export {
+  expandAssignments,
+  resourceLoad,
+  overallocations,
+  assignedMinutes,
+  type SchedulerAssignment,
+  type Allocation,
+  type Overallocation,
+} from './scheduler-assignments'
+export {
+  columnSummaries,
+  sumReducer,
+  countReducer,
+  busyMinutesReducer,
+  type ColumnReducer,
+  type SummaryItem,
+} from './scheduler-summary'
+export {
+  buildAxis,
+  timeToX,
+  xToTime,
+  resolveZoom,
+  zoomPresets,
+  type Axis,
+  type AxisSegment,
+  type AxisSegmentKind,
+  type BuildAxisOptions,
+  type ZoomLevel,
+  type ZoomMajorUnit,
+} from './scheduler-axis'
+export {
+  buildResourceRows,
+  visibleResourceIds,
+  type SchedulerResourceGroup,
+  type ResourceRow,
+} from './scheduler-resource-tree'
+export { heatCells, heatPeak, type HeatCell } from './scheduler-heatmap'
+export {
+  respectsBuffer,
+  withinDurationBounds,
+  afterLead,
+  type BusyEvent,
+  type GapMin,
+} from './scheduler-booking'
+export {
+  availableSlots,
+  mergeIntervals,
+  subtractIntervals,
+  type Interval,
+  type Slot,
+  type SlotOptions,
+} from './scheduler-slots'
+export { mergeBusy, commonFree } from './scheduler-freebusy'
 export {
   createStagedEditing,
   type StagedChange,
@@ -141,6 +217,7 @@ export {
   dummyJsonAdapter,
   jsonServerAdapter,
   introspectSupabaseTable,
+  listSupabaseTables,
   createSupabaseRealtime,
   createRelationLookup,
   createSupabaseAuth,
@@ -240,6 +317,7 @@ export {
   emitStudioApp,
   sampleApps,
   getSampleApp,
+  starterProject,
   liveDataSamples,
   getLiveDataSample,
   type SampleApp,
@@ -360,50 +438,106 @@ export {
   type Well,
 } from './pivot-designer'
 
-export {
-  // Provider plumbing
-  setAIProvider,
-  getAIProvider,
-  hasAIProvider,
-  mockAIProvider,
-  type AIProvider,
-  type AIRequest,
-  type AITask,
-  // Filter
-  aiFilter,
-  type AIFilterOptions,
-  type AIFilterResult,
-  type AIFilterClause,
-  type AISortClause,
-  // Smart fill
-  aiSmartFill,
-  type AISmartFillOptions,
-  type AISmartFillResult,
-  type AISmartFillExample,
-  // Summarize
-  aiSummarize,
-  type AISummarizeOptions,
-  type AISummarizeTarget,
-  type AISummary,
-  // Classify
-  aiClassify,
-  type AIClassifyOptions,
-  type AIClassifyResult,
-  // Natural-language export
-  aiExport,
-  type AIExportOptions,
-  type AIExportPlan,
-  // Anomaly detection
-  aiFindAnomalies,
-  type AIAnomaly,
-  type AIAnomalyOptions,
-  type AIAnomalyResult,
-  // Natural-language chart ("chart this")
-  aiChart,
-  enableAiCharting,
-  disableAiCharting,
-  type AIChartOptions,
-  type AIChartPlan,
-  type AIChartType,
-} from './ai'
+// The AI helpers (setAIProvider, aiFilter, aiSmartFill, aiSummarize, aiClassify,
+// aiExport, aiFindAnomalies, aiChart, enableAiCharting, ...) are now BUILT-IN and
+// FREE in @svgrid/grid - import them from there. Enterprise only registers its
+// export engine so AI-planned Excel/PDF exports can run (see install.ts).
 export { pivotToChartSpec, type PivotChartOptions } from './pivot-chart'
+
+// Expression / query language (Pro). One predicate/scalar/change model that
+// powers alerts (and, in time, styled + calculated columns). Leaf comparisons
+// reuse the grid's own `applyExcelFilter`, so operators match the filter row.
+export {
+  evaluatePredicate,
+  evaluateScalar,
+  evaluateChange,
+  BUILTIN_FUNCTION_NAMES,
+  isBuiltinFunction,
+} from './expressions/evaluate'
+export {
+  parsePredicate,
+  stringifyPredicate,
+  stringifyScalar,
+  validateExpression,
+  collectColumnRefs,
+  ExpressionParseError,
+} from './expressions/parse'
+export {
+  OPERATORS,
+  operatorMeta,
+  operatorsForType,
+  isValueless,
+  isSetOperator,
+  isRangeOperator,
+  columnById,
+  resolveColumnRef,
+  columnLabel,
+  columnRefText,
+  type ExprColumn,
+  type ExprColumnType,
+  type OperatorMeta,
+} from './expressions/expression-columns'
+export type {
+  ScalarExpr,
+  PredicateExpr,
+  ChangeExpr,
+  ComparisonOp,
+  ArithmeticOp,
+  AggFn,
+  EvalContext,
+  ExprRow,
+} from './expressions/expression-types'
+export { default as SvExpressionEditor } from './SvExpressionEditor.svelte'
+
+// Alert Rules engine (Pro). Declarative "when this holds / this moves -> toast /
+// badge / highlight / flash / prevent-edit / log". Authored at runtime,
+// persisted, shareable. Surfacing reuses the grid's toast + conditional-format
+// engines; `<SvGridAlerts>` is the runtime overlay the consumer mounts.
+export { enableAlerts } from './alerts'
+export {
+  createAlertEngine,
+  renderTemplate,
+  type AlertEngine,
+  type AlertEngineOptions,
+  type ValidateEditResult,
+} from './alerts/alert-engine'
+export {
+  attachAlertEngine,
+  applyAlertEvents,
+  type AlertAttachment,
+  type AttachAlertOptions,
+  type FlashTarget,
+} from './alerts/alert-engine-attach'
+export {
+  memoryAlertRules,
+  localStorageAlertRules,
+  createAlertRules,
+  type AlertRulesStorage,
+  type AlertRulesManager,
+} from './alerts/alert-storage'
+export {
+  createAlertObserver,
+  type AlertObserver,
+  type AlertObserverOptions,
+} from './alerts/alert-observer'
+export {
+  createAlertScheduler,
+  type AlertScheduler,
+  type AlertSchedulerMode,
+} from './alerts/alert-scheduler'
+export { toConditionalFormats, rulesToConditionalFormats, type StylingContext } from './alerts/alert-formats'
+export { alertStore } from './alerts/alert-store.svelte'
+export type {
+  AlertRule,
+  AlertEvent,
+  AlertTrigger,
+  AlertAction,
+  AlertActionKind,
+  AlertActionStyle,
+  AlertScope,
+  AlertSeverity,
+} from './alerts/alert-types'
+export { default as SvGridAlerts } from './SvGridAlerts.svelte'
+export { default as SvAlertRuleEditor } from './SvAlertRuleEditor.svelte'
+export { default as SvAlertsManager } from './SvAlertsManager.svelte'
+export { default as SvAlertsPanel } from './SvAlertsPanel.svelte'

package/src/install.ts

@@ -10,9 +10,11 @@ import { printGrid, type PrintOptions } from './print'
 import { importData, type ImportOptions, type ImportResult } from './import'
 import { isLicenseKeySet } from './license'
 import { emitUnlicensedNudge } from './watermark'
+// AI helpers are built-in + free in @svgrid/grid now; enterprise just wires them
+// into the Pro API and registers its export engine so AI exports can write xlsx/pdf.
 import {
   aiFilter, aiSmartFill, aiSummarize, aiClassify, aiExport, aiFindAnomalies,
-  aiChart, enableAiCharting,
+  aiChart, enableAiCharting, registerExportProvider,
   type AIChartOptions, type AIChartPlan,
   type AIFilterOptions, type AIFilterResult,
   type AISmartFillOptions, type AISmartFillResult,
@@ -20,13 +22,15 @@ import {
   type AIClassifyOptions, type AIClassifyResult,
   type AIExportOptions, type AIExportPlan,
   type AIAnomalyOptions, type AIAnomalyResult,
-} from './ai'
+} from '@svgrid/grid'
 import {
   createPivotModel,
   type PivotConfig,
   type PivotResult,
 } from './pivot'
 import { enableSchedulerView } from './scheduler'
+import { enableBoardView } from './board'
+import { enablePivot } from './pivot-enable'
 
 export type EnterpriseAIApi<TData extends RowData> = {
   /** Natural-language -> filter + sort plan (and optionally apply it). */
@@ -128,6 +132,12 @@ export function installEnterprise<
   enableAiCharting(pro)
   // Register the scheduler / calendar view (no-op without the `scheduler` prop).
   enableSchedulerView()
+  // Register the Kanban board view (no-op without the `board` prop).
+  enableBoardView()
+  // Register the export engine so built-in AI exports (aiExport) can write the
+  // enterprise formats (xlsx / pdf / ...); free grids without it get the plan only.
+  registerExportProvider(exportGrid as never)
+  enablePivot()
   pro.pivot = {
     build: (config) =>
       createPivotModel<TFeatures, TData>(pro.getData(), config),

package/src/pivot-enable.ts

@@ -0,0 +1,44 @@
+/**
+ * In-grid pivot (Pro). `enablePivot()` registers the pivot ENGINE with the grid
+ * so `<SvGrid pivot={...}>` renders a pivot table in place of the flat table -
+ * the same grid, aggregated with nested column headers. The engine (which turns
+ * rows into a pivot result) is `createPivotModel`; the grid ships the `pivot`
+ * prop + config types for free and looks the engine up through the
+ * `registerPivotEngine` seam.
+ *
+ * Soft-gated like the rest of Enterprise: it works without a license key but the
+ * grid shows the unlicensed watermark + a one-time console nudge.
+ *
+ * ```ts
+ * import { setLicenseKey, enablePivot } from '@svgrid/enterprise'
+ * setLicenseKey('YOUR-KEY')
+ * enablePivot()
+ * // then: <SvGrid {data} {columns} pivot={{ rows: ['region'], cols: ['quarter'], values: [{ field: 'sales', agg: 'sum' }] }} />
+ * ```
+ */
+import { registerPivotEngine, type PivotEngine } from '@svgrid/grid'
+import { isLicenseKeySet } from './license'
+import { emitUnlicensedNudge } from './watermark'
+import { createPivotModel, type PivotConfig } from './pivot'
+
+let enabled = false
+
+// The grid's `PivotEngine` seam is generic over row type; `createPivotModel` is
+// the concrete implementation. Bridge them with a single boundary cast.
+const pivotEngine: PivotEngine = (data, config) =>
+  createPivotModel(
+    data as ReadonlyArray<Record<string, unknown>>,
+    config as unknown as PivotConfig<Record<string, unknown>>,
+  ) as never
+
+/**
+ * Register the Enterprise pivot engine. Idempotent - safe to call from every
+ * component that uses `pivot`, or once at app start. Also invoked by
+ * {@link installEnterprise} so wiring the Pro API turns pivot on too.
+ */
+export function enablePivot(): void {
+  if (enabled) return
+  enabled = true
+  registerPivotEngine(pivotEngine)
+  if (!isLicenseKeySet()) emitUnlicensedNudge()
+}

package/src/scheduler-assignments.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest'
+import {
+  assignedMinutes,
+  expandAssignments,
+  overallocations,
+  resourceLoad,
+  type SchedulerAssignment,
+} from './scheduler-assignments'
+
+type Ev = { key: string; start: Date; end: Date; resource?: string }
+const D = (h: number) => new Date(2026, 0, 5, h, 0, 0, 0)
+const ev = (key: string, s: number, e: number, resource?: string): Ev => ({ key, start: D(s), end: D(e), resource })
+
+const opts = {
+  keyOf: (e: Ev) => e.key,
+  startOf: (e: Ev) => e.start,
+  endOf: (e: Ev) => e.end,
+  resourceOf: (e: Ev) => e.resource,
+}
+
+describe('expandAssignments', () => {
+  it('renders one event once per assigned resource', () => {
+    const events = [ev('e1', 9, 11)]
+    const assigns: SchedulerAssignment[] = [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e1', resourceId: 'r2' },
+    ]
+    const out = expandAssignments(events, assigns, opts)
+    expect(out.map((a) => a.resourceId).sort()).toEqual(['r1', 'r2'])
+    expect(out.every((a) => a.units === 1)).toBe(true)
+  })
+
+  it('dedupes duplicate resource assignments to the max units', () => {
+    const out = expandAssignments([ev('e1', 9, 11)], [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
+      { id: 'a2', eventId: 'e1', resourceId: 'r1', units: 0.8 },
+    ], opts)
+    expect(out).toHaveLength(1)
+    expect(out[0]!.units).toBe(0.8)
+  })
+
+  it('falls back to resourceOf when the event has no assignment', () => {
+    const out = expandAssignments([ev('e1', 9, 11, 'rX')], [], opts)
+    expect(out).toEqual([expect.objectContaining({ resourceId: 'rX', units: 1 })])
+  })
+
+  it('drops an event with neither assignment nor resource', () => {
+    const out = expandAssignments([ev('e1', 9, 11)], [], opts)
+    expect(out).toHaveLength(0)
+  })
+})
+
+describe('resourceLoad', () => {
+  it('sums units of overlapping allocations on the resource', () => {
+    const events = [ev('e1', 9, 11), ev('e2', 10, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 1 },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1', units: 0.5 },
+    ], opts)
+    expect(resourceLoad(allocs, 'r1', D(10), D(11))).toBe(1.5) // both overlap 10-11
+    expect(resourceLoad(allocs, 'r1', D(9), D(10))).toBe(1) // only e1
+    expect(resourceLoad(allocs, 'r2', D(9), D(12))).toBe(0)
+  })
+})
+
+describe('overallocations', () => {
+  it('flags buckets where load exceeds capacity', () => {
+    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
+    ], opts)
+    const buckets = [{ start: D(9), end: D(10) }, { start: D(10), end: D(11) }]
+    const over = overallocations(allocs, ['r1'], buckets, 1)
+    expect(over).toHaveLength(2) // 2 concurrent > capacity 1, in both buckets
+    expect(over[0]).toMatchObject({ resourceId: 'r1', load: 2, capacity: 1 })
+  })
+
+  it('respects a per-resource capacity function', () => {
+    const events = [ev('e1', 9, 12), ev('e2', 9, 12)]
+    const allocs = expandAssignments(events, [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1' },
+      { id: 'a2', eventId: 'e2', resourceId: 'r1' },
+    ], opts)
+    const over = overallocations(allocs, ['r1'], [{ start: D(9), end: D(10) }], () => 2)
+    expect(over).toHaveLength(0) // capacity 2 absorbs 2 concurrent
+  })
+})
+
+describe('assignedMinutes', () => {
+  it('totals weighted minutes across allocations', () => {
+    const allocs = expandAssignments([ev('e1', 9, 11)], [
+      { id: 'a1', eventId: 'e1', resourceId: 'r1', units: 0.5 },
+    ], opts)
+    expect(assignedMinutes(allocs, 'r1')).toBe(60) // 120 min * 0.5
+  })
+})

package/src/scheduler-assignments.ts

@@ -0,0 +1,134 @@
+/**
+ * scheduler-assignments - the pure core behind Scheduler Pro *multi-assignment*
+ * (one event assigned to several resources) and the *resource utilization
+ * histogram*. No Svelte, no DOM. Generic over the event shape via accessor
+ * callbacks so it needs no dependency on the grid's ResolvedEvent.
+ */
+
+/** A many-to-many event <-> resource link, with an optional allocation (0..1). */
+export type SchedulerAssignment = {
+  id: string
+  eventId: string
+  resourceId: string
+  /** Allocation fraction, default 1 (full). Summed for histogram / overallocation. */
+  units?: number
+}
+
+/** One event placed on one resource (the flattened render unit). */
+export type Allocation<E = unknown> = {
+  event: E
+  key: string
+  resourceId: string
+  units: number
+  start: Date
+  end: Date
+}
+
+export type ExpandOptions<E> = {
+  keyOf: (e: E) => string
+  startOf: (e: E) => Date
+  endOf: (e: E) => Date
+  /** Single-resource fallback when an event has no assignment. */
+  resourceOf?: (e: E) => string | undefined
+}
+
+const MS_MIN = 60_000
+
+/**
+ * Flatten events into per-resource allocations. An event with assignments renders
+ * once per assigned resource (deduped by eventId+resourceId, keeping the max
+ * units); an event with none falls back to its single `resourceOf` (units 1), or
+ * is dropped when it has neither. The result drives the resource-column bucketing.
+ */
+export function expandAssignments<E>(
+  events: ReadonlyArray<E>,
+  assignments: ReadonlyArray<SchedulerAssignment>,
+  opts: ExpandOptions<E>,
+): Allocation<E>[] {
+  // Group assignments by eventId, collapsing duplicate resources to the max units.
+  const byEvent = new Map<string, Map<string, number>>()
+  for (const a of assignments) {
+    if (!a || !a.eventId || !a.resourceId) continue
+    let m = byEvent.get(a.eventId)
+    if (!m) byEvent.set(a.eventId, (m = new Map()))
+    const units = a.units == null ? 1 : a.units
+    m.set(a.resourceId, Math.max(m.get(a.resourceId) ?? 0, units))
+  }
+
+  const out: Allocation<E>[] = []
+  for (const e of events) {
+    const key = opts.keyOf(e)
+    const start = opts.startOf(e)
+    const end = opts.endOf(e)
+    const m = byEvent.get(key)
+    if (m && m.size) {
+      for (const [resourceId, units] of m) out.push({ event: e, key, resourceId, units, start, end })
+    } else {
+      const resourceId = opts.resourceOf?.(e)
+      if (resourceId != null) out.push({ event: e, key, resourceId, units: 1, start, end })
+    }
+  }
+  return out
+}
+
+/** True when `[aStart,aEnd)` overlaps `[bStart,bEnd)`. */
+function overlaps(aStart: Date, aEnd: Date, bStart: Date, bEnd: Date): boolean {
+  return aStart.getTime() < bEnd.getTime() && aEnd.getTime() > bStart.getTime()
+}
+
+/**
+ * Summed allocation units on `resourceId` overlapping the bucket
+ * `[bucketStart, bucketEnd)` - the height of one histogram bar.
+ */
+export function resourceLoad<E>(
+  allocs: ReadonlyArray<Allocation<E>>,
+  resourceId: string,
+  bucketStart: Date,
+  bucketEnd: Date,
+): number {
+  let load = 0
+  for (const a of allocs) {
+    if (a.resourceId !== resourceId) continue
+    if (overlaps(a.start, a.end, bucketStart, bucketEnd)) load += a.units
+  }
+  return load
+}
+
+/** One over-capacity bucket (summed load exceeds the resource capacity). */
+export type Overallocation = { resourceId: string; start: Date; end: Date; load: number; capacity: number }
+
+/**
+ * Buckets where a resource's summed load exceeds its capacity. `buckets` are the
+ * axis intervals to test; `capacity` is a flat number or a per-resource function
+ * (default 1). Used to tint histogram bars / flag conflicts.
+ */
+export function overallocations<E>(
+  allocs: ReadonlyArray<Allocation<E>>,
+  resourceIds: ReadonlyArray<string>,
+  buckets: ReadonlyArray<{ start: Date; end: Date }>,
+  capacity: number | ((resourceId: string) => number) = 1,
+): Overallocation[] {
+  const capOf = typeof capacity === 'function' ? capacity : () => capacity
+  const out: Overallocation[] = []
+  for (const resourceId of resourceIds) {
+    const cap = capOf(resourceId)
+    for (const b of buckets) {
+      const load = resourceLoad(allocs, resourceId, b.start, b.end)
+      if (load > cap + 1e-9) out.push({ resourceId, start: b.start, end: b.end, load, capacity: cap })
+    }
+  }
+  return out
+}
+
+/**
+ * Total assigned minutes per resource across `allocs` (a simple utilization
+ * roll-up for a legend / header, independent of buckets).
+ */
+export function assignedMinutes<E>(allocs: ReadonlyArray<Allocation<E>>, resourceId: string): number {
+  let mins = 0
+  for (const a of allocs) {
+    if (a.resourceId !== resourceId) continue
+    mins += ((a.end.getTime() - a.start.getTime()) / MS_MIN) * a.units
+  }
+  return mins
+}

package/src/scheduler-axis.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import { buildAxis, resolveZoom, timeToX, xToTime, zoomPresets } from './scheduler-axis'
+
+const day = (d: number, h = 0) => new Date(2026, 0, d, h, 0, 0, 0)
+
+describe('buildAxis - linear (no collapse)', () => {
+  it('maps a full day linearly at pxPerMinute', () => {
+    const axis = buildAxis(day(5), day(6), { pxPerMinute: 1 }) // 1px/min => 1440px
+    expect(axis.totalPx).toBe(1440)
+    expect(timeToX(day(5, 12), axis)).toBe(720) // noon = halfway
+  })
+
+  it('timeToX / xToTime round-trip within a working span', () => {
+    const axis = buildAxis(day(5), day(6), { pxPerMinute: 1 })
+    const t = day(5, 9)
+    expect(xToTime(timeToX(t, axis), axis).getTime()).toBe(t.getTime())
+  })
+})
+
+describe('buildAxis - business hours collapse', () => {
+  it('collapses nights to a fixed gap so working hours dominate', () => {
+    const axis = buildAxis(day(5), day(7), {
+      pxPerMinute: 1,
+      businessHours: { start: 9, end: 17 }, // 8h = 480px working
+      collapseNonWorking: true,
+      collapsedGapPx: 10,
+    })
+    const working = axis.segments.filter((s) => s.kind === 'working')
+    const collapsed = axis.segments.filter((s) => s.kind === 'collapsed')
+    expect(working).toHaveLength(2) // two work days
+    expect(working[0]!.px).toBe(480)
+    // Gaps: before day5 9am, night between, after day6 5pm - each a collapsed 10px.
+    expect(collapsed.every((s) => s.px === 10)).toBe(true)
+    expect(axis.totalPx).toBe(480 * 2 + 10 * collapsed.length)
+  })
+
+  it('omits gaps entirely when collapsedGapPx is 0', () => {
+    const axis = buildAxis(day(5), day(6), {
+      pxPerMinute: 1,
+      businessHours: { start: 9, end: 17 },
+      collapseNonWorking: true,
+      collapsedGapPx: 0,
+    })
+    expect(axis.totalPx).toBe(480) // just the working span
+  })
+})
+
+describe('buildAxis - weekend collapse', () => {
+  it('collapses whole non-working days', () => {
+    // Jan 2026: 3rd = Sat, 4th = Sun. Range Fri Jan 2 -> Mon Jan 5.
+    const axis = buildAxis(day(2), day(5), {
+      pxPerMinute: 1,
+      nonWorkingDays: [0, 6],
+      collapseWeekends: true,
+      collapsedGapPx: 8,
+    })
+    const collapsed = axis.segments.filter((s) => s.kind === 'collapsed')
+    // Sat + Sun are contiguous non-working, so they coalesce to ONE 8px gap.
+    expect(collapsed).toHaveLength(1)
+    expect(collapsed[0]!.px).toBe(8)
+    expect(collapsed[0]!.start.getDate()).toBe(3) // Sat
+    expect(collapsed[0]!.end.getDate()).toBe(5) // through to Mon 00:00
+    // Fri (full day) + Mon-partial working stays full width.
+    const working = axis.segments.filter((s) => s.kind === 'working')
+    expect(working.reduce((sum, s) => sum + s.px, 0)).toBe(1440) // Fri = 1440px working (24h, no business hours)
+  })
+})
+
+describe('buildAxis - piecewise mapping across a collapsed gap', () => {
+  it('maps times on either side of a gap to the right x', () => {
+    const axis = buildAxis(day(5), day(7), {
+      pxPerMinute: 1,
+      businessHours: { start: 9, end: 17 },
+      collapseNonWorking: true,
+      collapsedGapPx: 10,
+    })
+    // End of day 5 work (17:00) sits at leading-gap + 480 working px.
+    const lead = axis.segments[0]!.px // leading collapsed gap (00:00-09:00)
+    expect(timeToX(day(5, 17), axis)).toBe(lead + 480)
+    // Start of day 6 work (09:00) sits one more gap past that.
+    expect(timeToX(day(6, 9), axis)).toBe(lead + 480 + 10)
+  })
+
+  it('round-trips a working-time point through x and back', () => {
+    const axis = buildAxis(day(5), day(7), {
+      pxPerMinute: 1,
+      businessHours: { start: 9, end: 17 },
+      collapseNonWorking: true,
+      collapsedGapPx: 10,
+    })
+    const t = day(6, 13)
+    expect(xToTime(timeToX(t, axis), axis).getTime()).toBe(t.getTime())
+  })
+})
+
+describe('resolveZoom', () => {
+  it('passes a ZoomLevel through and computes pxPerMinute', () => {
+    const level = zoomPresets.find((z) => z.id === 'hour')!
+    const r = resolveZoom(level)
+    expect(r.level.id).toBe('hour')
+    expect(r.pxPerMinute).toBeCloseTo(level.pxPerTick / level.tickMinutes)
+  })
+  it('treats a number as a clamped ladder index', () => {
+    expect(resolveZoom(0).level).toBe(zoomPresets[0])
+    expect(resolveZoom(999).level).toBe(zoomPresets[zoomPresets.length - 1])
+    expect(resolveZoom(-5).level).toBe(zoomPresets[0])
+  })
+})