@nomideusz/svelte-calendar 0.21.0 → 1.0.1

package/dist/core/time.d.ts

@@ -16,6 +16,15 @@ export declare function startOfWeek(ms: number, mondayStart?: boolean): number;
 export declare function addDaysMs(ms: number, n: number): number;
 /** Calendar-day difference between two timestamps */
 export declare function diffDays(a: number, b: number): number;
+/**
+ * Whether an event overlaps [start, end). A zero-length event (a deadline,
+ * a marker) has no extent to overlap with, so it counts where it sits —
+ * including exactly at `start`, which the plain interval test drops.
+ */
+export declare function overlapsRange(ev: {
+    start: Date;
+    end: Date;
+}, start: Date, end: Date): boolean;
 /** Zero-pad a number to 2 digits */
 export declare function pad(n: number): string;
 /**

package/dist/core/time.js

@@ -33,6 +33,14 @@ export function addDaysMs(ms, n) {
 export function diffDays(a, b) {
     return differenceInCalendarDays(a, b);
 }
+/**
+ * Whether an event overlaps [start, end). A zero-length event (a deadline,
+ * a marker) has no extent to overlap with, so it counts where it sits —
+ * including exactly at `start`, which the plain interval test drops.
+ */
+export function overlapsRange(ev, start, end) {
+    return ev.start < end && (ev.end > start || ev.start >= start);
+}
 /** Zero-pad a number to 2 digits */
 export function pad(n) {
     return n < 10 ? '0' + n : '' + n;

package/dist/core/timezone.d.ts

@@ -26,9 +26,13 @@ export declare function formatInTimeZone(date: Date | number, timezone: string,
  * real instants. This is how the Calendar's `timezone` prop works: views keep
  * doing plain local-time math on an already-shifted plane.
  *
- * Known limit shared by every wall-clock calendar UI: during a DST fall-back
- * the repeated hour is ambiguous on the wall clock, so writes made inside it
- * resolve to one of the two instants (date-fns-tz picks the offset).
+ * Known limits shared by every wall-clock calendar UI:
+ * - during a DST fall-back in `timezone` the repeated hour is ambiguous on
+ *   the wall clock, so writes made inside it resolve to one of the two
+ *   instants (date-fns-tz picks the offset);
+ * - the plane is made of the *browser's* local Dates, so a wall-clock time
+ *   that does not exist in the browser's own zone (its spring-forward hour,
+ *   when that differs from `timezone`'s) displays an hour late.
  */
 import type { CalendarAdapter } from '../adapters/types.js';
 export declare function wrapAdapterWithTimezone(adapter: CalendarAdapter, timezone: string): CalendarAdapter;

package/dist/core/timezone.js

@@ -62,15 +62,21 @@ export function wrapAdapterWithTimezone(adapter, timezone) {
         ...(obj.start instanceof Date ? { start: fromZonedTime(obj.start, timezone) } : {}),
         ...(obj.end instanceof Date ? { end: fromZonedTime(obj.end, timezone) } : {}),
     });
+    const unzoneRange = (range) => ({
+        start: fromZonedTime(range.start, timezone),
+        end: fromZonedTime(range.end, timezone),
+    });
     const wrapped = {
         async fetchEvents(range) {
-            const events = await adapter.fetchEvents({
-                start: fromZonedTime(range.start, timezone),
-                end: fromZonedTime(range.end, timezone),
-            });
+            const events = await adapter.fetchEvents(unzoneRange(range));
             return events.map(zoneEvent);
         },
     };
+    // Keep the synchronous path: without it a seeded or in-memory adapter
+    // renders empty on the server and flashes a loading state on the client.
+    if (adapter.fetchEventsSync) {
+        wrapped.fetchEventsSync = (range) => adapter.fetchEventsSync(unzoneRange(range))?.map(zoneEvent);
+    }
     if (adapter.createEvent) {
         wrapped.createEvent = async (event) => zoneEvent(await adapter.createEvent(unzonePartial(event)));
     }

package/dist/engine/event-store.svelte.js

@@ -17,7 +17,8 @@
  */
 import { SvelteMap } from 'svelte/reactivity';
 import { untrack } from 'svelte';
-import { sod, addDaysMs } from '../core/time.js';
+import { sod, addDaysMs, overlapsRange } from '../core/time.js';
+import { CalendarReadOnlyError, isReadOnlyError, isNotFoundError } from '../adapters/errors.js';
 /**
  * Create a reactive event store backed by a CalendarAdapter.
  *
@@ -30,15 +31,30 @@ import { sod, addDaysMs } from '../core/time.js';
 export function createEventStore(adapter) {
     const getAdapter = typeof adapter === 'function' ? adapter : () => adapter;
     let eventMap = new SvelteMap();
-    let loading = $state(false);
+    /** The latest load is async and has not resolved yet */
+    let loadPending = $state(false);
+    /** Mutations in flight — a counter, since several can overlap */
+    let mutationsPending = $state(0);
+    const loading = $derived(loadPending || mutationsPending > 0);
     let error = $state(null);
     /** Guards against an older in-flight load pruning a newer one's result */
     let loadSeq = 0;
+    /**
+     * Mutation clock. A load that was already in flight when an event was
+     * added, moved or removed must not undo that write when it lands — its
+     * snapshot predates it. Each mutation stamps its id; a load skips ids
+     * stamped after it started.
+     */
+    let epoch = 0;
+    const touched = new Map();
+    function touch(id) {
+        touched.set(id, ++epoch);
+    }
     // Derived array view of the map — consumers read this.
     const eventArray = $derived([...eventMap.values()]);
     // ── Internal helpers ──
     function overlaps(ev, start, end) {
-        return ev.start < end && ev.end > start;
+        return overlapsRange(ev, start, end);
     }
     function removeEvent(id) {
         eventMap.delete(id);
@@ -49,14 +65,39 @@ export function createEventStore(adapter) {
     // Merge: upsert fetched, don't blow away events outside this range.
     // Inside the range the adapter is authoritative — drop what it no
     // longer returns, or deleted/moved events linger until remount.
-    function merge(fetched, range) {
+    // `since` is the mutation clock when the fetch started: ids written after
+    // that are newer than the adapter's answer and are left as they are.
+    function merge(fetched, range, since = epoch) {
+        const stale = (id) => (touched.get(id) ?? 0) > since;
         const keep = new Set(fetched.map((ev) => ev.id));
         for (const ev of [...eventMap.values()]) {
-            if (!keep.has(ev.id) && overlaps(ev, range.start, range.end))
+            if (!keep.has(ev.id) && !stale(ev.id) && overlaps(ev, range.start, range.end))
                 removeEvent(ev.id);
         }
         for (const ev of fetched)
-            upsertEvent(ev);
+            if (!stale(ev.id))
+                upsertEvent(ev);
+        // Stamps no in-flight load can predate are no longer needed.
+        for (const [id, at] of touched)
+            if (at <= since)
+                touched.delete(id);
+    }
+    async function mutate(run) {
+        mutationsPending++;
+        error = null;
+        try {
+            return await run();
+        }
+        catch (e) {
+            // A refusal (read-only) or "not mine" is an answer the caller acts
+            // on — the Calendar hands the move to the host — not a failure.
+            if (!isReadOnlyError(e) && !isNotFoundError(e))
+                error = e instanceof Error ? e.message : String(e);
+            throw e;
+        }
+        finally {
+            mutationsPending--;
+        }
     }
     // ── Public API ──
     return {
@@ -71,31 +112,46 @@ export function createEventStore(adapter) {
         },
         async load(range) {
             const seq = ++loadSeq;
+            const since = epoch;
             const adapter = getAdapter();
             // In-memory adapters answer at once: no loading state, and a server
             // render already holds the events.
-            const sync = adapter.fetchEventsSync?.(range);
+            let sync;
+            try {
+                sync = adapter.fetchEventsSync?.(range);
+            }
+            catch (e) {
+                // Callers fire load() and forget it (and on the server): a throw
+                // here must land in `error`, never as an unhandled rejection.
+                loadPending = false;
+                error = e instanceof Error ? e.message : String(e);
+                return;
+            }
             if (sync) {
                 error = null;
+                // This load supersedes any async one still in flight, whose
+                // finally will no longer clear the flag.
+                loadPending = false;
                 // Callers load from an effect; reading the map here would make that
                 // effect depend on what it writes.
-                untrack(() => merge(sync, range));
+                untrack(() => merge(sync, range, since));
                 return;
             }
-            loading = true;
+            loadPending = true;
             error = null;
             try {
                 const fetched = await adapter.fetchEvents(range);
                 if (seq !== loadSeq)
                     return; // superseded by a newer load
-                merge(fetched, range);
+                merge(fetched, range, since);
             }
             catch (e) {
-                error = e instanceof Error ? e.message : String(e);
+                if (seq === loadSeq)
+                    error = e instanceof Error ? e.message : String(e);
             }
             finally {
                 if (seq === loadSeq)
-                    loading = false;
+                    loadPending = false;
             }
         },
         forRange(start, end) {
@@ -110,56 +166,35 @@ export function createEventStore(adapter) {
             return eventMap.get(id);
         },
         async add(eventData) {
-            if (!getAdapter().createEvent)
-                throw new Error('Adapter is read-only: createEvent not implemented');
-            loading = true;
-            error = null;
-            try {
-                const created = await getAdapter().createEvent(eventData);
+            const adapter = getAdapter();
+            if (!adapter.createEvent)
+                throw new CalendarReadOnlyError('Adapter is read-only: createEvent not implemented');
+            return mutate(async () => {
+                const created = await adapter.createEvent(eventData);
                 upsertEvent(created);
+                touch(created.id);
                 return created;
-            }
-            catch (e) {
-                error = e instanceof Error ? e.message : String(e);
-                throw e;
-            }
-            finally {
-                loading = false;
-            }
+            });
         },
         async update(id, patch) {
-            if (!getAdapter().updateEvent)
-                throw new Error('Adapter is read-only: updateEvent not implemented');
-            loading = true;
-            error = null;
-            try {
-                const updated = await getAdapter().updateEvent(id, patch);
+            const adapter = getAdapter();
+            if (!adapter.updateEvent)
+                throw new CalendarReadOnlyError('Adapter is read-only: updateEvent not implemented');
+            await mutate(async () => {
+                const updated = await adapter.updateEvent(id, patch);
                 upsertEvent(updated);
-            }
-            catch (e) {
-                error = e instanceof Error ? e.message : String(e);
-                throw e;
-            }
-            finally {
-                loading = false;
-            }
+                touch(id);
+            });
         },
         async remove(id) {
-            if (!getAdapter().deleteEvent)
-                throw new Error('Adapter is read-only: deleteEvent not implemented');
-            loading = true;
-            error = null;
-            try {
-                await getAdapter().deleteEvent(id);
+            const adapter = getAdapter();
+            if (!adapter.deleteEvent)
+                throw new CalendarReadOnlyError('Adapter is read-only: deleteEvent not implemented');
+            await mutate(async () => {
+                await adapter.deleteEvent(id);
                 removeEvent(id);
-            }
-            catch (e) {
-                error = e instanceof Error ? e.message : String(e);
-                throw e;
-            }
-            finally {
-                loading = false;
-            }
+                touch(id);
+            });
         },
         async move(id, newStart, newEnd) {
             // Optimistic update: apply locally first so the UI doesn't flash
@@ -167,6 +202,7 @@ export function createEventStore(adapter) {
             const existing = eventMap.get(id);
             if (existing) {
                 upsertEvent({ ...existing, start: newStart, end: newEnd });
+                touch(id);
             }
             try {
                 await this.update(id, { start: newStart, end: newEnd });
@@ -176,9 +212,10 @@ export function createEventStore(adapter) {
                 // adapter, where the HOST owns persistence (Calendar forwards to
                 // oneventmove). Reverting there snaps the block back to its old
                 // slot for the length of the host's round-trip.
-                const msg = e instanceof Error ? e.message : '';
-                if (existing && !msg.includes('read-only'))
+                if (existing && !isReadOnlyError(e)) {
                     upsertEvent(existing);
+                    touch(id);
+                }
                 throw e;
             }
         },

package/dist/engine/view-state.svelte.d.ts

@@ -15,7 +15,11 @@ export type ViewMode = 'day' | 'week' | 'month';
 export interface ViewStateOptions {
     view?: CalendarViewId;
     mondayStart?: boolean;
-    /** IANA timezone string (e.g. 'America/New_York'). Defaults to local timezone. */
+    /**
+     * IANA timezone string (e.g. 'America/New_York'). Defaults to local timezone.
+     * "Today" (the default focus, `goToday()`) is today in this zone, as a
+     * wall-clock Date on the zoned plane the Calendar's `timezone` prop uses.
+     */
     timezone?: string;
     /** Initial date to focus on (defaults to today). */
     initialDate?: Date;

package/dist/engine/view-state.svelte.js

@@ -12,6 +12,7 @@
  *   vs.goToday()   — jump to today
  */
 import { startOfWeek as calcStartOfWeek, addDaysMs } from '../core/time.js';
+import { nowInZone } from '../core/timezone.js';
 function inferMode(view) {
     if (view.startsWith('day'))
         return 'day';
@@ -52,11 +53,12 @@ function computeRange(focus, mode, mondayStart, dayCount = 7) {
     };
 }
 export function createViewState(options = {}) {
+    const timezone = options.timezone;
+    const today = () => (timezone ? nowInZone(timezone) : new Date());
     let view = $state(options.view ?? 'week-planner');
-    let focusDate = $state(options.initialDate ?? new Date());
+    let focusDate = $state(options.initialDate ?? today());
     let mondayStart = $state(options.mondayStart ?? true);
     let dayCount = $state(options.dayCount ?? 7);
-    const timezone = options.timezone;
     const modeResolver = options.modeForView;
     const mode = $derived(modeResolver?.(view) ?? inferMode(view));
     const range = $derived(computeRange(focusDate, mode, mondayStart, dayCount));
@@ -112,7 +114,7 @@ export function createViewState(options = {}) {
             focusDate = new Date(addDaysMs(focusDate.getTime(), days));
         },
         goToday() {
-            focusDate = new Date();
+            focusDate = today();
         },
     };
 }

package/dist/headless/create-agenda.svelte.d.ts

@@ -9,6 +9,13 @@ export interface AgendaOptions {
     locale?: string;
     /** Number of days to load ahead of focus date for the upcoming list (default: 7) */
     lookahead?: number;
+    /**
+     * Show the agenda in an IANA timezone (e.g. 'Europe/Warsaw'), as the
+     * Calendar's `timezone` prop does: the day, "now" and every event Date are
+     * wall-clock values in that zone. `initialDate` and `setDate()` take real
+     * instants. Default: the viewer's zone.
+     */
+    timezone?: string;
 }
 export interface HeadlessAgenda {
     /** The focused date */
@@ -29,7 +36,7 @@ export interface HeadlessAgenda {
     readonly dayEvents: TimelineEvent[];
     /** All-day or multi-day events */
     readonly allDay: TimelineEvent[];
-    /** Timed events that have ended (today only; empty for other days) */
+    /** Timed events that have ended — measured against now, so every event of a past day and none of a future one */
     readonly past: TimelineEvent[];
     /** Timed events currently in progress */
     readonly current: TimelineEvent[];

package/dist/headless/create-agenda.svelte.js

@@ -33,29 +33,47 @@
 import { untrack } from 'svelte';
 import { createEventStore } from '../engine/event-store.svelte.js';
 import { createClock } from '../core/clock.svelte.js';
-import { sod, addDaysMs, isAllDay, isMultiDay } from '../core/time.js';
+import { sod, addDaysMs, isAllDay, isMultiDay, overlapsRange } from '../core/time.js';
+import { toZonedTime, wrapAdapterWithTimezone } from '../core/timezone.js';
 import { fmtTime as _fmtTime, fmtDuration } from '../core/locale.js';
 import { timeUntilMs, progress as _progress, groupIntoSlots } from '../views/shared/format.js';
 // ─── Implementation ─────────────────────────────────────
 export function createAgenda(options) {
-    const { initialDate, locale, lookahead = 7, } = options;
-    const resolveAdapter = typeof options.adapter === 'function'
+    const { initialDate, locale, lookahead = 7, timezone, } = options;
+    const rawAdapter = typeof options.adapter === 'function'
         ? options.adapter
         : () => options.adapter;
-    const store = $derived(createEventStore(resolveAdapter()));
-    const clock = createClock();
+    const resolveAdapter = timezone
+        ? () => wrapAdapterWithTimezone(rawAdapter(), timezone)
+        : rawAdapter;
+    /** An instant on the plane the day is drawn on (zoned wall-clock with `timezone`). */
+    const plane = (ms) => (timezone ? toZonedTime(ms, timezone).getTime() : ms);
+    // One store for the agenda's life: a getter adapter that changes identity
+    // reloads it instead of rebuilding it empty (every row blinking out).
+    const store = createEventStore(resolveAdapter);
+    const clock = createClock(timezone);
     // ── Focus date (reactive, writable) ──
-    let focusDayMs = $state(sod(initialDate?.getTime() ?? Date.now()));
+    let focusDayMs = $state(sod(initialDate ? plane(initialDate.getTime()) : clock.tick));
     // ── Load events for focus date range ──
-    $effect(() => {
-        const start = new Date(focusDayMs);
-        const end = new Date(addDaysMs(focusDayMs, lookahead));
-        store.load({ start, end });
+    // Eager initial load for synchronous adapters (the server render holds
+    // the rows); the effect's first run then has nothing new to fetch — a
+    // seeded adapter would otherwise refetch the seed at once.
+    let eagerKey = untrack(() => {
+        if (!resolveAdapter().fetchEventsSync)
+            return '';
+        store.load({ start: new Date(focusDayMs), end: new Date(addDaysMs(focusDayMs, lookahead)) });
+        return `${focusDayMs}`;
     });
-    // Eager initial load
-    untrack(() => {
+    $effect(() => {
+        rawAdapter(); // a new adapter reloads
         const start = new Date(focusDayMs);
         const end = new Date(addDaysMs(focusDayMs, lookahead));
+        const key = `${focusDayMs}`;
+        if (key === eagerKey) {
+            eagerKey = '';
+            return;
+        }
+        eagerKey = '';
         store.load({ start, end });
     });
     // ── Day derivations ──
@@ -70,7 +88,7 @@ export function createAgenda(options) {
     }));
     const dayEvents = $derived.by(() => {
         return store.events
-            .filter((ev) => ev.start.getTime() < dayEnd && ev.end.getTime() > focusDayMs)
+            .filter((ev) => overlapsRange(ev, new Date(focusDayMs), new Date(dayEnd)))
             .sort((a, b) => a.start.getTime() - b.start.getTime());
     });
     const allDay = $derived(dayEvents.filter((ev) => isAllDay(ev) || isMultiDay(ev)));
@@ -96,7 +114,7 @@ export function createAgenda(options) {
     function prev() { focusDayMs = addDaysMs(focusDayMs, -1); }
     function next() { focusDayMs = addDaysMs(focusDayMs, 1); }
     function goToday() { focusDayMs = clock.today; }
-    function setDate(date) { focusDayMs = sod(date.getTime()); }
+    function setDate(date) { focusDayMs = sod(plane(date.getTime())); }
     // ── Format helpers ──
     const fmtTime = (d) => _fmtTime(d, locale);
     const fmtDur = (ev) => fmtDuration(ev.start, ev.end);

package/dist/headless/create-calendar.svelte.js

@@ -43,23 +43,25 @@ import { untrack } from 'svelte';
 import { createEventStore } from '../engine/event-store.svelte.js';
 import { createViewState } from '../engine/view-state.svelte.js';
 import { toZonedTime, fromZonedTime, wrapAdapterWithTimezone } from '../core/timezone.js';
+import { isReadOnlyError, isNotFoundError } from '../adapters/errors.js';
 import { createSelection } from '../engine/selection.svelte.js';
 import { createDragState } from '../engine/drag.svelte.js';
 import { createClock } from '../core/clock.svelte.js';
 import { sod, addDaysMs, HOUR_MS, startOfWeek as sowFn, isAllDay, isMultiDay, segmentForDay, } from '../core/time.js';
-import { monthLong, weekdayLong, weekdayShort } from '../core/locale.js';
+import { monthLong, weekdayLong, weekdayShort, fmtWeekRange, getDefaultLocale } from '../core/locale.js';
 export function createCalendar(options) {
     const { adapter, mondayStart: initialMondayStart = true, initialDate: rawInitialDate, locale, visibleHours, snapInterval = 15, equalDays = false, hideDays, blockedSlots, disabledDates, days: initialDayCount = 7, readOnly = false, minDuration, maxDuration, oneventclick, oneventcreate, oneventmove, } = options;
     // ── Create engine ────────────────────────────────────
     const timezone = options.timezone;
     const initialDate = rawInitialDate && timezone ? toZonedTime(rawInitialDate, timezone) : rawInitialDate;
-    const store = createEventStore(timezone ? wrapAdapterWithTimezone(adapter, timezone) : adapter);
+    const effectiveAdapter = timezone ? wrapAdapterWithTimezone(adapter, timezone) : adapter;
+    const store = createEventStore(effectiveAdapter);
     const viewState = createViewState({
         view: options.view ?? 'week-planner',
         mondayStart: initialMondayStart,
         initialDate,
         dayCount: initialDayCount,
-        modeForView: (id) => id.startsWith('day-') ? 'day' : 'week',
+        timezone,
     });
     const selection = createSelection();
     const drag = createDragState();
@@ -71,12 +73,25 @@ export function createCalendar(options) {
     const endHour = visibleHours?.[1] ?? 24;
     const hours = Array.from({ length: endHour - startHour }, (_, i) => startHour + i);
     // ── Load events reactively ───────────────────────────
+    // Eager initial load for synchronous adapters (the server render holds the
+    // events); the effect's first run then has nothing new to fetch.
+    let eagerKey = untrack(() => {
+        if (!effectiveAdapter.fetchEventsSync)
+            return '';
+        const { start, end } = viewState.range;
+        store.load({ start, end });
+        return `${start.getTime()}-${end.getTime()}`;
+    });
     $effect(() => {
         const { start, end } = viewState.range;
+        const key = `${start.getTime()}-${end.getTime()}`;
+        if (key === eagerKey) {
+            eagerKey = '';
+            return;
+        }
+        eagerKey = '';
         store.load({ start, end });
     });
-    // Eager initial load
-    untrack(() => store.load({ start: viewState.range.start, end: viewState.range.end }));
     // ── Compute day cells ────────────────────────────────
     const days = $derived.by(() => {
         const { start, end } = viewState.range;
@@ -165,21 +180,36 @@ export function createCalendar(options) {
         }
         return { past, current, upcoming };
     });
+    // "Now" on the same (zoned) plane as the range. A month view's range spills
+    // into the neighbouring months, so it compares the focused month instead.
+    function includesToday() {
+        const now = clock.tick;
+        if (viewState.mode === 'month') {
+            const f = viewState.focusDate;
+            const n = new Date(now);
+            return f.getMonth() === n.getMonth() && f.getFullYear() === n.getFullYear();
+        }
+        const { start, end } = viewState.range;
+        return now >= start.getTime() && now < end.getTime();
+    }
     // ── Header context ───────────────────────────────────
     const headerContext = $derived.by(() => {
         const mode = viewState.mode;
         const focus = viewState.focusDate;
-        const now = Date.now();
-        const { start, end } = viewState.range;
-        const isViewOnToday = now >= start.getTime() && now < end.getTime();
+        const isViewOnToday = includesToday();
+        const loc = locale ?? getDefaultLocale();
         let dateLabel;
         if (mode === 'day') {
-            dateLabel = focus.toLocaleDateString(locale, {
+            dateLabel = focus.toLocaleDateString(loc, {
                 weekday: 'long', month: 'short', day: 'numeric',
             });
         }
+        else if (mode === 'week') {
+            const { start, end } = viewState.range;
+            dateLabel = fmtWeekRange(start.getTime(), loc, end.getTime() - 1);
+        }
         else {
-            dateLabel = focus.toLocaleDateString(locale, {
+            dateLabel = focus.toLocaleDateString(loc, {
                 month: 'long', year: 'numeric',
             });
         }
@@ -189,7 +219,16 @@ export function createCalendar(options) {
             modes: ['day', 'week', 'month'],
             switchMode: (m) => {
                 const currentView = viewState.view;
-                const currentLabel = currentView.replace(/^(day|week)-/, '');
+                const currentLabel = currentView.replace(/^(day|week|month)-/, '');
+                // Month has one layout of its own; leaving it lands on the planner.
+                if (m === 'month') {
+                    viewState.setView('month-grid');
+                    return;
+                }
+                if (currentView.startsWith('month-')) {
+                    viewState.setView(`${m}-planner`);
+                    return;
+                }
                 viewState.setView(`${m}-${currentLabel}`);
             },
             prev: () => viewState.prev(),
@@ -200,13 +239,11 @@ export function createCalendar(options) {
         };
     });
     const navigationContext = $derived.by(() => {
-        const { start, end } = viewState.range;
-        const now = Date.now();
         return {
             prev: () => viewState.prev(),
             next: () => viewState.next(),
             goToday: () => viewState.goToday(),
-            isViewOnToday: now >= start.getTime() && now < end.getTime(),
+            isViewOnToday: includesToday(),
             focusDate: viewState.focusDate,
             mode: viewState.mode,
         };
@@ -288,15 +325,14 @@ export function createCalendar(options) {
                     oneventmove?.(ev, unzoneDate(start), unzoneDate(end));
             }
             catch (e) {
-                const msg = e instanceof Error ? e.message : '';
                 // Read-only adapter: the host still gets the callback — it owns
                 // persistence and refetches.
-                if (msg.includes('read-only')) {
+                if (isReadOnlyError(e)) {
                     const ev = store.byId(payload.eventId);
                     if (ev)
                         oneventmove?.(ev, unzoneDate(start), unzoneDate(end));
                 }
-                else if (!msg.includes('not found')) {
+                else if (!isNotFoundError(e)) {
                     console.warn('[calendar] drag commit failed:', e);
                 }
                 return null;

package/dist/headless/create-range-agenda.svelte.d.ts

@@ -12,6 +12,13 @@ export interface RangeAgendaOptions {
     initialDate?: Date;
     /** BCP 47 locale tag (e.g. 'en-US', 'pl-PL') for the format helpers */
     locale?: string;
+    /**
+     * Show the agenda in an IANA timezone (e.g. 'Europe/Warsaw'), as the
+     * Calendar's `timezone` prop does: days, "today" and every event Date are
+     * wall-clock values in that zone (read them with `getHours()`, `getDate()`…).
+     * `initialDate` and `setDate()` take real instants. Default: the viewer's zone.
+     */
+    timezone?: string;
 }
 export interface RangeAgendaDay {
     /** Start-of-day timestamp (ms) */