@cocoar/vue-calendar 1.16.0

package/README.md

@@ -0,0 +1,257 @@
+# @cocoar/vue-calendar
+
+> **Vue 3 calendar component built around `Temporal`.** Day / Week /
+> Month / Agenda views, drag-and-drop with cross-zone safety, and an
+> 8-invariant architecture (C1–C8) drawn from the
+> ["Time in Software, Done Right"][articles] article series.
+
+[articles]: https://dev.to/bwi/why-a-date-is-not-a-point-in-time-ad8
+
+## Install
+
+```bash
+pnpm add @cocoar/vue-calendar
+```
+
+Peer deps: `vue ^3.5`, `@cocoar/vue-ui workspace:*`,
+`@cocoar/vue-localization workspace:*`. Direct dep:
+`@js-temporal/polyfill ^0.5` (re-exported as `Temporal`).
+
+## Quick start
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue';
+import {
+  CoarCalendar,
+  Temporal,
+  useCalendar,
+  type CalendarEvent,
+} from '@cocoar/vue-calendar';
+
+// Events are Temporal-typed (C1) — never strings, Date,
+// PlainDateTime, or Instant on the public surface. The library
+// throws at the boundary if you try.
+const events = ref<CalendarEvent[]>([
+  {
+    id: 'standup',
+    start: Temporal.ZonedDateTime.from('2026-06-15T09:00:00[Europe/Vienna]'),
+    end:   Temporal.ZonedDateTime.from('2026-06-15T09:30:00[Europe/Vienna]'),
+    meta: { title: 'Daily Standup' },
+  },
+  {
+    id: 'vacation',
+    start: Temporal.PlainDate.from('2026-06-22'), // all-day → PlainDate
+    end:   Temporal.PlainDate.from('2026-06-27'),
+    meta: { title: 'Vacation' },
+  },
+]);
+
+const { builder, api } = useCalendar();
+builder
+  .events(events)
+  .timezone('Europe/Vienna')         // C5 display zone — REQUIRED
+  .locale('de-AT')                    // C6 (independent of timeStyle / hour12)
+  .firstDayOfWeek(1)                  // 0 = Sun, 1 = Mon, …
+  .view('week')
+  .date(Temporal.PlainDate.from('2026-06-15'))
+  .dstPolicy('compatible')            // C4 — explicit DST policy
+  .onEventDrop(({ event, next, target }) => {
+    // C3: next.start / next.end keep their per-endpoint source zones.
+    //     For a Tokyo→Vienna flight, next.start.timeZoneId stays
+    //     'Asia/Tokyo' even when displayed in Vienna.
+    // C5: target.displayZone is the zone the user's eyes saw at drop.
+    // C4: target.disambiguation is 'gap' | 'overlap' | null (DST outcome).
+    saveEvent({ id: event.id, start: next.start, end: next.end });
+  });
+</script>
+
+<template>
+  <CoarCalendar :builder="builder" />
+</template>
+```
+
+That's it. Drag events, switch views, navigate dates — all wired.
+
+## API contract for backends (Article 8)
+
+The library ships two helpers that mirror Article 8's recommended
+wire shape (`{ local, timeZoneId }`):
+
+```ts
+import {
+  parseScheduledTime,
+  formatScheduledTime,
+} from '@cocoar/vue-calendar';
+
+// Wire → Temporal (use this when deserialising backend payloads):
+const start = parseScheduledTime({
+  local: '2026-06-15T09:00:00',
+  timeZoneId: 'Europe/Vienna',
+  dstPolicy: 'compatible', // optional, default
+});
+
+// Temporal → wire (use this when shipping back to the backend):
+const wire = formatScheduledTime(event.start);
+// → { local: '2026-06-15T09:00:00', timeZoneId: 'Europe/Vienna' }
+```
+
+The shape is stable across:
+
+- Frontend pickers (Article 8 — "DateTimePickers that don't lie")
+- .NET / NodaTime backends (Article 6 — `LocalDateTime + TimeZoneId`)
+- PostgreSQL storage (Article 7 — `local_start text + time_zone_id text`)
+
+## The 8 invariants (C1–C8)
+
+| Article basis | Invariant | What it means |
+|---|---|---|
+| 1, 2, 4, 8 | **C1** Temporal-only public surface | Strings / `Date` / `PlainDateTime` / `Instant` rejected at the boundary by `validateCalendarEvent`. |
+| 4, 5 | **C2** Single drop pipeline | Exactly one function (`applyMoveToEvent`) converts a UI drop → new endpoints. Mouse, keyboard, touch all reach it once. |
+| 4 | **C3** Source zone preserved per-endpoint | Cross-zone events are first-class. A Tokyo→Vienna flight keeps both endpoints in their source zones across every drag. |
+| 5 | **C4** DST disambiguation explicit | `DstPolicy` is a required arg of every wall-time → instant conversion. No silent default. |
+| 3, 4 | **C5** Display zone vs source zone separate | `EventDropPayload.target.displayZone` (what the user saw) and `next.start.timeZoneId` (where the event lives) are distinct fields. |
+| 9 | **C6** Three independent display decisions | `locale`, `dateStyle`, `timeStyle`, `hour12` are independent setters. `buildFormatOptions` is the only `Intl` merge point. |
+| spirit | **C7** Reactivity by reads | Every consumer function (`canDrop`, `eventsLoader`, `eventRenderer`) is read on every invocation, never captured at setup. |
+| 5 | **C8** Recurrence is a first-class type | `RecurringSeries` lives separately from `CalendarEvent`. `expandSeries` ships as a throwing stub until Phase 4. |
+
+The conformance test suite at `src/core/__tests__/timezone/` pins
+every invariant.
+
+## What's NOT in the public surface (intentional)
+
+- **`EventIndex`** — bucketing utility kept private. Consumers wanting
+  a sidebar / minimap will get a public composable in Phase 4+ (otherwise
+  misuse silently drifts from the actual grid).
+- **ISO strings on event start/end** — would re-introduce the
+  Article-1 "guess the zone" failure mode. Use `Temporal.ZonedDateTime`
+  or `Temporal.PlainDate`. The wire helpers above handle deserialisation.
+- **`Date` / `PlainDateTime` / `Instant`** — same reason. Throws at
+  the events-source watch with the offending event id named.
+- **`'EST'` / `'CET'` / `'GMT'` abbreviations** — Article 2 calls these
+  out as ambiguous. Use full IANA zones (`Europe/Vienna`,
+  `America/New_York`, etc.). Temporal's polyfill resolves abbreviations
+  to fixed-offset zones, but consumers are encouraged not to.
+
+## Cross-zone events — what "preserve source zone" actually means
+
+A flight Tokyo → Vienna stored as
+
+```ts
+{
+  id: 'flight',
+  start: Temporal.ZonedDateTime.from('2026-06-15T22:00:00[Asia/Tokyo]'),
+  end:   Temporal.ZonedDateTime.from('2026-06-16T06:00:00[Europe/Vienna]'),
+}
+```
+
+renders correctly in any display zone — the calendar always shows the
+right wall-clock per the user's display zone. When the user **drags
+the start handle** to a new slot in the Vienna-rendered calendar:
+
+- **C3 means the event's `start.timeZoneId` stays `'Asia/Tokyo'`** in
+  the drop payload. The stored intent is preserved.
+- This means `next.start.toString()` reports a **Tokyo wall-time** —
+  which is *not* the Vienna wall-time the user clicked. If the user
+  clicked 14:00 Vienna in summer, `next.start` is the Tokyo wall-time
+  of that same instant (≈ 21:00 Tokyo).
+- The drop payload's `target.date` + `target.minutes` + `target.displayZone`
+  capture what the user's eyes saw (Article 3 — fairness contract).
+- If a consumer needs the Vienna wall-time directly, they can compute
+  `next.start.withTimeZone('Europe/Vienna').toPlainTime()` on the spot.
+
+**Why this design:** Article 4 is explicit — store intent, derive math.
+A flight scheduled in Tokyo means "depart at this wall-clock in Tokyo";
+re-anchoring start to Vienna would silently destroy that intent the
+moment a user (or admin) drags the event in a different display zone.
+The trade-off is that consumers reading `next.start.toString()` see
+the source-zone wall-time, not the click-zone wall-time.
+
+For a meeting that should **be re-anchored to the click-zone** (a
+local meeting that just happens to be viewed from somewhere else), set
+`event.start.timeZoneId === builder.timezone()` — when source and
+display zone match, click-zone and source-zone wall-times are identical.
+
+## Standalone sub-views
+
+Each sub-view works without the `<CoarCalendar>` shell — useful for
+sidebars, widgets, embedded month-pickers. The flat `CalendarBuilder`
+carries every view's config, so a sub-view consumes the SAME builder
+type the shell does:
+
+```vue
+<script setup lang="ts">
+import { CoarMonthView, useMonthView, Temporal } from '@cocoar/vue-calendar';
+
+const { builder } = useMonthView(); // pre-locks view + availableViews
+builder.timezone('Europe/Vienna').date(Temporal.PlainDate.from('2026-06-15'));
+</script>
+
+<template>
+  <CoarMonthView :builder="builder" />
+</template>
+```
+
+When mounted standalone, the sub-view sets `state.view` to its
+intended value and mounts its own `useViewWindow` (single writer per
+the C5 invariant).
+
+## Known scope cuts (post-2.0.0)
+
+- **Recurrence engine** — `expandSeries(...)` is a typed throwing stub.
+  The contract (`RecurringSeries` shape, `dstPolicy` argument) is stable,
+  but the engine wires up in Phase 4. Consumers porting from FullCalendar /
+  ICS feeds should construct concrete events in their data layer for now.
+- **Global-event type** — Article 5's "global events" (same instant
+  worldwide — product launches, livestreams) have no first-class
+  `event.kind === 'global'` discriminator. Consumers model them as
+  `Temporal.ZonedDateTime` in `'UTC'` and accept that the calendar
+  re-renders them in the display zone (which is the conceptually correct
+  behaviour, just not the typed-vocabulary the article recommends).
+- **Tzdb update / future-event recalc** — Article 4 § "What Happens When
+  Rules Change" is a consumer concern. The library stores
+  `Temporal.ZonedDateTime` (which contains the IANA zone, not a baked-in
+  offset), so re-rendering after a tzdb update is automatic. Recalculating
+  cached `instantUtc` values in your data layer is consumer code, not
+  calendar code.
+- **Timezone abbreviations (`'EST'`, `'CET'`, etc.)** — the underlying
+  Temporal polyfill resolves these to fixed-offset zones rather than
+  rejecting them. The calendar accepts whatever Temporal accepts.
+- **`onMoreClick`** — typed setter exists, but the "+N more" overflow
+  surface in `<CoarMonthView>` is a post-2.0 visual-polish item. Setting
+  the handler today emits a one-shot dev-warn; the handler starts firing
+  once the overflow surface ships.
+
+## Architecture decisions (locked)
+
+In short:
+
+- **D1** — `RecurringSeries` is a first-class type from day one;
+  `expandSeries` throws informatively until Phase 4 wires the engine.
+- **D2** — All-day drops preserve **day-count duration only**.
+  Calendar UIs don't have a "+1 month" gesture; spans are always
+  preserved as day-counts (May 5–10 → drag onto June 5 → June 5–10).
+- **D3** — `parseScheduledTime` / `formatScheduledTime` /
+  `parsePlainDate` are public helpers (the wire-contract surface).
+- **D4** — `canDrop` runs on every hit-test. If you have expensive
+  validation logic, memoize it consumer-side; the library reading fresh
+  state is the correct behaviour.
+- **D5** — One `dstPolicy` per builder. Per-operation policies are a
+  YAGNI for now.
+
+## Status
+
+Feature-complete for the initial release (Temporal-only public API,
+C1–C8 invariants, all four views, drag-and-drop, virtualization). The
+repo's release version is calculated by GitVersion at publish time, so
+this package's `package.json` carries a placeholder `0.0.1` like
+everything else in the workspace — the actual semver number lives in
+CI.
+
+Post-launch backlog: recurrence engine (`expandSeries` is a typed
+throwing stub today), Ctrl+C / Ctrl+V copy-paste, "+ N more" overflow
+signal in `<CoarMonthView>`, preemptive DST-gap visual marker.
+
+## License
+
+Apache-2.0. Same as the rest of the Cocoar UI Vue suite.

package/dist/__test-utils__/event-fixtures.d.ts

@@ -0,0 +1,4 @@
+import { Temporal } from '@js-temporal/polyfill';
+export declare const zdt: (iso: string, zone?: string) => Temporal.ZonedDateTime;
+export declare const pd: (iso: string) => Temporal.PlainDate;
+//# sourceMappingURL=event-fixtures.d.ts.map

package/dist/__test-utils__/event-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-fixtures.d.ts","sourceRoot":"","sources":["../../src/__test-utils__/event-fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEjD,eAAO,MAAM,GAAG,GAAI,KAAK,MAAM,EAAE,aAAY,KAAG,QAAQ,CAAC,aAKxD,CAAC;AAEF,eAAO,MAAM,EAAE,GAAI,KAAK,MAAM,KAAG,QAAQ,CAAC,SACZ,CAAC"}

package/dist/builders/calendar-builder-internals.d.ts

@@ -0,0 +1,14 @@
+import { ViewWindow } from '../core';
+/** Privileged method symbol — see `CalendarBuilder` for the impl. */
+export declare const SET_VISIBLE_RANGE: unique symbol;
+/** Privileged method symbol — see `CalendarBuilder` for the impl. */
+export declare const INVALIDATE_LOADER_CACHE: unique symbol;
+/**
+ * Type-narrowed surface a `CalendarBuilder` exposes to internal
+ * composables (only `useViewWindow` today).
+ */
+export interface PrivilegedBuilder {
+    [SET_VISIBLE_RANGE](window: ViewWindow | null): void;
+    [INVALIDATE_LOADER_CACHE](): void;
+}
+//# sourceMappingURL=calendar-builder-internals.d.ts.map

package/dist/builders/calendar-builder-internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar-builder-internals.d.ts","sourceRoot":"","sources":["../../src/builders/calendar-builder-internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,EAAE,OAAO,MAAkD,CAAC;AAE1F,qEAAqE;AACrE,eAAO,MAAM,uBAAuB,EAAE,OAAO,MAE5C,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,CAAC,iBAAiB,CAAC,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;IACrD,CAAC,uBAAuB,CAAC,IAAI,IAAI,CAAC;CACnC"}

package/dist/builders/calendar-builder.d.ts

@@ -0,0 +1,296 @@
+import { MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { CalendarEvent, CalendarView, DayOfWeek, ViewWindow, Temporal } from '../core';
+import { SET_VISIBLE_RANGE, INVALIDATE_LOADER_CACHE } from './calendar-builder-internals';
+import { CalendarDensity, CanDropFn, DateClickHandler, DayHeaderRenderer, DstPolicy, EventClickHandler, EventDoubleClickHandler, EventDropHandler, EventRenderer, EventsLoader, MoreClickHandler, RangeChangeHandler, TimeClickHandler, TimeRange } from './types';
+/**
+ * Reactive state owned by a `CalendarBuilder`. All reads go through
+ * `toValue()` for `MaybeRefOrGetter<T>` fields and `.value` for
+ * `Ref<T>` fields. Function fields (canDrop / handlers / renderers)
+ * are stored verbatim and called at the read site.
+ */
+export interface CalendarBuilderState<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    events: MaybeRefOrGetter<CalendarEvent<TMeta>[]> | null;
+    eventsLoader: EventsLoader<TMeta> | null;
+    /** Display zone (C5). Defaults to the browser's IANA zone. */
+    timezone: MaybeRefOrGetter<string>;
+    locale: MaybeRefOrGetter<string>;
+    /** Locale-derived when undefined (Article 9 — defaults are not decisions). */
+    firstDayOfWeek: MaybeRefOrGetter<DayOfWeek | undefined>;
+    density: MaybeRefOrGetter<CalendarDensity>;
+    /** Intl date style (C6 — independent of timeStyle / hour12).
+     *  Locale-derived when undefined (Article 9). */
+    dateStyle: MaybeRefOrGetter<'short' | 'medium' | 'long' | 'full' | undefined>;
+    /** Intl time style (C6). */
+    /** Intl time style (C6). Locale-derived when undefined (Article 9). */
+    timeStyle: MaybeRefOrGetter<'short' | 'medium' | 'long' | undefined>;
+    /** 12h vs 24h clock (C6 — independent of locale). */
+    hour12: MaybeRefOrGetter<boolean | undefined>;
+    /** DST disambiguation policy (C4). Default `'compatible'`. */
+    dstPolicy: MaybeRefOrGetter<DstPolicy>;
+    /** Subset of CalendarView the view-switcher offers. */
+    availableViews: MaybeRefOrGetter<readonly CalendarView[]>;
+    timeRange: MaybeRefOrGetter<TimeRange>;
+    slotDuration: MaybeRefOrGetter<number>;
+    pixelsPerHour: MaybeRefOrGetter<number>;
+    maxEventsPerCell: MaybeRefOrGetter<number>;
+    agendaLengthDays: MaybeRefOrGetter<number>;
+    showEmptyDays: MaybeRefOrGetter<boolean>;
+    /** Active view. Held as Ref so api.setView can write back. */
+    view: Ref<CalendarView>;
+    /** Cursor date. Held as Ref so api.next/prev/goTo can write back. */
+    date: Ref<Temporal.PlainDate>;
+    canDrop: CanDropFn<TMeta> | null;
+    eventRenderer: EventRenderer<TMeta> | null;
+    dayHeaderRenderer: DayHeaderRenderer | null;
+    onEventClick: EventClickHandler<TMeta> | null;
+    onEventDoubleClick: EventDoubleClickHandler<TMeta> | null;
+    onEventDrop: EventDropHandler<TMeta> | null;
+    onDateClick: DateClickHandler | null;
+    onTimeClick: TimeClickHandler | null;
+    onMoreClick: MoreClickHandler<TMeta> | null;
+    onRangeChange: RangeChangeHandler | null;
+}
+/**
+ * Imperative + reactive surface returned alongside the builder.
+ */
+export interface CalendarApi<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /** `true` while at least one `eventsLoader` invocation is in flight. */
+    readonly loading: Readonly<Ref<boolean>>;
+    /** Currently rendered window. `null` before first paint. */
+    readonly visibleRange: Readonly<ShallowRef<ViewWindow | null>>;
+    /** `true` once the active view's grid has reported ready. */
+    readonly gridReady: Readonly<Ref<boolean>>;
+    goTo(date: Temporal.PlainDate): void;
+    goToToday(): void;
+    next(): void;
+    prev(): void;
+    setView(view: CalendarView): void;
+    /** Wired in Session 3 (component-side). No-op until then. */
+    scrollToTime(time: Temporal.PlainTime): void;
+    /** Wired in Session 3 (component-side). No-op until then. */
+    scrollToDate(date: Temporal.PlainDate): void;
+    /** Invalidate the entire loader cache and re-fetch the current window. */
+    refresh(): void;
+    /** Invalidate any cached entries that intersect `window` and re-fetch
+     *  if the current window intersects. */
+    refreshRange(window: ViewWindow): void;
+    /** Synchronous read of the current window. `null` before first paint. */
+    getVisibleRange(): ViewWindow | null;
+    /** Snapshot of events visible in the current window — from
+     *  `events()` source if set, else the loader cache (or empty if no
+     *  cache hit yet). */
+    getVisibleEvents(): CalendarEvent<TMeta>[];
+}
+export declare class CalendarBuilder<TMeta extends Record<string, unknown> = Record<string, unknown>> {
+    /** Reactive state — single source of truth (C7 read site). */
+    readonly state: CalendarBuilderState<TMeta>;
+    /** Imperative + reactive surface. */
+    readonly api: CalendarApi<TMeta>;
+    private readonly _loading;
+    private readonly _visibleRange;
+    private readonly _gridReady;
+    /** Active view's scroll-to-time delegate. View registers on mount
+     *  via `_setScrollToTime(fn)` and clears on unmount. */
+    private _scrollToTimeImpl;
+    /** Active view's scroll-to-date delegate. */
+    private _scrollToDateImpl;
+    /** Map<windowKey, events>. Wrapped in shallowRef so cache swaps
+     *  trigger reactivity for `getVisibleEvents`. */
+    private readonly _loaderCache;
+    /** In-flight loader counter — `loading.value = (counter > 0)`.
+     *  Counter (not boolean) so concurrent fetches don't race the flag. */
+    private _inFlight;
+    /** Pending debounced loader handle — cleared on subsequent
+     *  `_setVisibleRange` calls within the debounce window. */
+    private _debounceHandle;
+    /**
+     * Generation counter — bumped on `refresh()` so an in-flight loader
+     * whose result arrives AFTER an invalidation is discarded instead
+     * of poisoning the cache.
+     */
+    private _generation;
+    /** Effect scope for builder-owned watchers (audit fix #1 — events
+     *  source watcher). Cleaned up if/when a `.dispose()` is added in
+     *  Phase 4+; currently builders live for the page lifetime. */
+    private readonly _scope;
+    /** Tracks event-array references already validated, so re-renders
+     *  don't re-walk them. Per-event-object validation; consumers who
+     *  recreate event objects on every render pay the validation cost
+     *  every render (cheap — a few `instanceof` checks). */
+    private readonly _validatedEventObjects;
+    private constructor();
+    /** Factory — keep `new` private so the only entry point is
+     *  `useCalendar()`. */
+    static create<TMeta extends Record<string, unknown> = Record<string, unknown>>(): CalendarBuilder<TMeta>;
+    /**
+     * Bind the event source. Mutually exclusive with `eventsLoader()`
+     * — calling this clears any previously-set loader and drops the
+     * cache (cache only makes sense for loader mode).
+     *
+     * The library accepts ONLY `Temporal.ZonedDateTime` (timed) or
+     * `Temporal.PlainDate` (all-day) on event start/end. Strings,
+     * `Date`, floating `PlainDateTime` etc. throw at index-insert via
+     * `validateCalendarEvent` (C1).
+     */
+    events(source: MaybeRefOrGetter<CalendarEvent<TMeta>[]>): this;
+    /**
+     * Bind a calendar-managed loader. Called whenever the visible
+     * window changes; results cached per `(view, timezone, start, end)`
+     * so navigation back to a previously-seen window doesn't re-fetch.
+     * Mutually exclusive with `events()`.
+     */
+    eventsLoader(loader: EventsLoader<TMeta>): this;
+    /** C5 — Display zone (IANA). Source zones on individual events
+     *  remain independent and per-endpoint preserved (C3). */
+    timezone(tz: MaybeRefOrGetter<string>): this;
+    locale(loc: MaybeRefOrGetter<string>): this;
+    firstDayOfWeek(d: MaybeRefOrGetter<DayOfWeek>): this;
+    density(d: MaybeRefOrGetter<CalendarDensity>): this;
+    /** C6 — independent of timeStyle / hour12. */
+    dateStyle(s: MaybeRefOrGetter<'short' | 'medium' | 'long' | 'full'>): this;
+    /** C6 — independent of dateStyle / hour12. */
+    timeStyle(s: MaybeRefOrGetter<'short' | 'medium' | 'long'>): this;
+    /**
+     * C6 — independent of locale. `undefined` lets Intl derive from
+     * locale (default); `true` / `false` overrides explicitly.
+     */
+    hour12(h: MaybeRefOrGetter<boolean | undefined>): this;
+    /**
+     * C4 — DST disambiguation policy. Read by every wall-time → instant
+     * conversion in the drop pipeline. Default `'compatible'`.
+     */
+    dstPolicy(p: MaybeRefOrGetter<DstPolicy>): this;
+    /**
+     * Active view. Setter accepts a `Ref<CalendarView>` (two-way
+     * binding) or a plain value (wrapped into an internal ref).
+     * Function-getters are rejected — `api.setView` must be able to
+     * write back.
+     */
+    view(v: Ref<CalendarView> | CalendarView): this;
+    availableViews(views: MaybeRefOrGetter<readonly CalendarView[]>): this;
+    /**
+     * Cursor date. Setter accepts a `Ref<PlainDate>` or a plain
+     * `PlainDate`; function-getters rejected (api.next/prev/goTo
+     * must write).
+     */
+    date(d: Ref<Temporal.PlainDate> | Temporal.PlainDate): this;
+    /** Time-grid view setting (`day` / `week`). */
+    timeRange(r: MaybeRefOrGetter<TimeRange>): this;
+    slotDuration(minutes: MaybeRefOrGetter<number>): this;
+    pixelsPerHour(px: MaybeRefOrGetter<number>): this;
+    /** Month view setting — pills before "+N more". */
+    maxEventsPerCell(n: MaybeRefOrGetter<number>): this;
+    /** Agenda view setting — number of days the linear list covers. */
+    agendaLengthDays(n: MaybeRefOrGetter<number>): this;
+    /** Agenda view setting — show day headers even when no events. */
+    showEmptyDays(b: MaybeRefOrGetter<boolean>): this;
+    /**
+     * Drop validator. Read on EVERY hit-test (C7 + D4 — no library-
+     * side memoization). If you do expensive work in here, memoize
+     * client-side; the library reading fresh state is the correct
+     * behaviour and intentionally not cached.
+     *
+     * @example
+     * ```ts
+     * // Consumer-side memoization for expensive checks:
+     * const memoized = computed(() => {
+     *   const rules = expensivelyCompiledRules.value;
+     *   return (event, target) => rules.matches(event, target);
+     * });
+     * builder.canDrop(memoized.value);
+     * ```
+     */
+    canDrop(fn: CanDropFn<TMeta>): this;
+    eventRenderer(r: EventRenderer<TMeta>): this;
+    dayHeaderRenderer(r: DayHeaderRenderer): this;
+    onEventClick(h: EventClickHandler<TMeta>): this;
+    onEventDoubleClick(h: EventDoubleClickHandler<TMeta>): this;
+    onEventDrop(h: EventDropHandler<TMeta>): this;
+    onDateClick(h: DateClickHandler): this;
+    onTimeClick(h: TimeClickHandler): this;
+    /**
+     * Audit Session 5 N1 — `onMoreClick` is wired by month-view's
+     * "+N more" overflow surface, which is a Session 3.5+ visual
+     * polish item. The setter is honoured today (handler stored on
+     * state, read-on-fire), but the overflow trigger is not yet
+     * implemented in `<CoarMonthView>`. A one-shot dev-warn surfaces
+     * the gap so consumers don't ship features that never fire.
+     */
+    onMoreClick(h: MoreClickHandler<TMeta>): this;
+    onRangeChange(h: RangeChangeHandler): this;
+    private _goTo;
+    private _goToToday;
+    private _navigate;
+    private _setView;
+    /**
+     * SOLE writer of `_visibleRange`. Called by `useViewWindow` only.
+     *
+     * **Audit fix #2 (Session 2):** symbol-keyed instead of
+     * underscore-prefixed-public so consumers cannot forge windows by
+     * calling `builder._setVisibleRange(...)` from outside. The symbol
+     * is exported from `calendar-builder-internals.ts` which is
+     * intentionally NOT in `index.ts`'s public surface.
+     *
+     * Side effects:
+     *   1. Updates the readonly `api.visibleRange` ref.
+     *   2. Fires the consumer's `onRangeChange` handler (deduped via
+     *      window-equality check — no-op if the window didn't change).
+     *   3. Schedules a debounced loader call if `eventsLoader` is set
+     *      and the cache doesn't already have this window.
+     *
+     * @internal symbol-keyed; reachable only via the internal symbol.
+     */
+    [SET_VISIBLE_RANGE](window: ViewWindow | null): void;
+    /**
+     * Invalidate the entire loader cache. Called by `api.refresh()`.
+     * Bumps the generation counter so any in-flight loader resolves
+     * into the void instead of poisoning fresh data.
+     *
+     * @internal symbol-keyed; reachable only via the internal symbol.
+     */
+    [INVALIDATE_LOADER_CACHE](): void;
+    private _maybeScheduleLoad;
+    private _runLoader;
+    /**
+     * Audit fix #1 — validate every event in `events` against C1 at the
+     * runtime boundary. WeakSet-memoized per-event-object so repeated
+     * renders of the same array don't pay the cost.
+     *
+     * Throws on the first bad event with `validateCalendarEvent`'s
+     * error (which names the event id). Loader path catches this in
+     * the `.catch` and logs without caching; events-source path lets
+     * it propagate so the consumer's render fails loudly (Article 9 —
+     * silent partial-render hiding bad data is the worse outcome).
+     */
+    private _validateEvents;
+    private _warnedScrollMethods;
+    /**
+     * Audit fix #16 — `scrollTo*` is wired by component mount in
+     * Session 3. Until then, calling it is a no-op; in dev we log
+     * once-per-method so consumer e2e tests don't false-pass.
+     */
+    private _warnScrollNotWired;
+    private _refresh;
+    private _refreshRange;
+    private _getVisibleEvents;
+    /**
+     * Snapshot of the loader cache keys for diagnostics / tests.
+     * Not part of the public API surface.
+     *
+     * @internal
+     */
+    _debug_cacheKeys(): string[];
+    /**
+     * Current in-flight counter for diagnostics / tests.
+     *
+     * @internal
+     */
+    _debug_inFlight(): number;
+    /** @internal */
+    _setScrollToTime(fn: ((time: Temporal.PlainTime) => void) | undefined): void;
+    /** @internal */
+    _setScrollToDate(fn: ((date: Temporal.PlainDate) => void) | undefined): void;
+    /** @internal */
+    _setGridReady(ready: boolean): void;
+}
+//# sourceMappingURL=calendar-builder.d.ts.map

package/dist/builders/calendar-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calendar-builder.d.ts","sourceRoot":"","sources":["../../src/builders/calendar-builder.ts"],"names":[],"mappings":"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"}

package/dist/builders/event-zone-hints.d.ts

@@ -0,0 +1,20 @@
+import { CalendarEvent } from '../core';
+export interface EventZoneHints {
+    /** True when the timed event's source zone is `'UTC'`. */
+    isUtcAnchored: boolean;
+    /**
+     * The event's source `timeZoneId` IF it differs from the display
+     * zone AND the event is NOT UTC-anchored (UTC-anchored gets its own
+     * "global" hint, separate semantic). `null` otherwise.
+     */
+    sourceZone: string | null;
+}
+/**
+ * Compute zone-hint flags for the calendar's default decoration layer.
+ *
+ * All-day events (`start instanceof Temporal.PlainDate`) have no zone
+ * by definition — they return `NO_HINTS` so callers can short-circuit
+ * before rendering any decoration.
+ */
+export declare function getEventZoneHints(event: CalendarEvent, displayZone: string | undefined): EventZoneHints;
+//# sourceMappingURL=event-zone-hints.d.ts.map

package/dist/builders/event-zone-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-zone-hints.d.ts","sourceRoot":"","sources":["../../src/builders/event-zone-hints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,aAAa,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAID;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,aAAa,EACpB,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,cAAc,CAMhB"}

package/dist/builders/render-helpers.d.ts

@@ -0,0 +1,19 @@
+import { FunctionalComponent } from 'vue';
+import { Temporal } from '../core';
+import { DayHeaderRenderer, EventRenderer, EventRendererCtx } from './types';
+export interface RenderEventProps {
+    renderer: EventRenderer;
+    ctx: EventRendererCtx;
+}
+export declare const RenderEvent: FunctionalComponent<RenderEventProps>;
+export interface DayHeaderCtx {
+    date: Temporal.PlainDate;
+    isToday: boolean;
+    isWeekend: boolean;
+}
+export interface RenderDayHeaderProps {
+    renderer: DayHeaderRenderer;
+    ctx: DayHeaderCtx;
+}
+export declare const RenderDayHeader: FunctionalComponent<RenderDayHeaderProps>;
+//# sourceMappingURL=render-helpers.d.ts.map

package/dist/builders/render-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-helpers.d.ts","sourceRoot":"","sources":["../../src/builders/render-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAkB,KAAK,mBAAmB,EAA0B,MAAM,KAAK,CAAC;AACvF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAElF,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,aAAa,CAAC;IACxB,GAAG,EAAE,gBAAgB,CAAC;CACvB;AAED,eAAO,MAAM,WAAW,EAAE,mBAAmB,CAAC,gBAAgB,CAa7D,CAAC;AAIF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,QAAQ,CAAC,SAAS,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,GAAG,EAAE,YAAY,CAAC;CACnB;AAED,eAAO,MAAM,eAAe,EAAE,mBAAmB,CAAC,oBAAoB,CAQrE,CAAC"}