@nomideusz/svelte-calendar 0.20.1 → 1.0.0

package/dist/calendar/Calendar.svelte.d.ts

@@ -1,25 +1,57 @@
-import { type Component, type Snippet } from 'svelte';
+import type { Component, Snippet } from 'svelte';
 import type { CalendarAdapter } from '../adapters/types.js';
 import type { CalendarViewId } from '../engine/view-state.svelte.js';
 import type { TimelineEvent, BlockedSlot } from '../core/types.js';
-import { type CalendarLabels } from '../core/locale.js';
+import type { CalendarLabels } from '../core/locale.js';
 import type { AutoThemeOptions } from '../theme/auto.js';
+import type { HeaderContext, NavigationContext } from '../headless/types.js';
+/**
+ * What the Calendar passes to the active view's component. Engines (store,
+ * view state, drag, labels…) are read from context — `useCalendarContext()`.
+ */
+export interface CalendarViewProps {
+    events: TimelineEvent[];
+    /** The active `--dt-*` theme string */
+    style: string;
+    height: number | null;
+    mode: 'day' | 'week' | 'month';
+    mondayStart: boolean;
+    locale: string | undefined;
+    focusDate: Date;
+    oneventclick: (event: TimelineEvent, anchor?: DOMRect) => void;
+    /** Already gated by `readOnly` and validated; undefined when creating is off */
+    oneventcreate: ((range: {
+        start: Date;
+        end: Date;
+    }) => void) | undefined;
+    onexternaldrop: ((info: {
+        start: Date;
+        dataTransfer: DataTransfer;
+    }) => void) | undefined;
+    readOnly: boolean;
+    visibleHours: [number, number] | undefined;
+    selectedEventId: string | null;
+}
 /** One view registration */
 export interface CalendarView {
     id: CalendarViewId;
+    /** The view-type name shown in the header pills when a mode has several views */
     label: string;
     /** day, week or month */
     mode: 'day' | 'week' | 'month';
-    /** The Svelte component to render */
-    component: Component<Record<string, unknown>>;
-    /** Extra props to pass through (e.g. hourHeight, specialized settings) */
+    /**
+     * The Svelte component to render. It receives `CalendarViewProps` plus
+     * `props`; declare only the ones it uses.
+     */
+    component: Component<any>;
+    /** Extra props passed through to the component */
     props?: Record<string, unknown>;
 }
-interface Props {
+export interface CalendarProps {
     /** Data adapter (required) */
     adapter: CalendarAdapter;
-    /** Registered views */
-    views?: CalendarView[];
+    /** Registered views (default: `defaultViews`) */
+    views?: readonly CalendarView[];
     /** Active view ID (defaults to first registered view) */
     view?: CalendarViewId;
     /** CSS theme string (--dt-* inline style) */
@@ -74,7 +106,10 @@ interface Props {
     showDates?: boolean;
     /** ISO weekdays to hide (1=Mon … 7=Sun). E.g. [6, 7] hides weekends. */
     hideDays?: number[];
-    /** Controlled current date — drives which date the calendar focuses on. */
+    /**
+     * Controlled current date — drives which date the calendar focuses on.
+     * An instant, like `initialDate`: with `timezone` it is read in that zone.
+     */
     currentDate?: Date;
     /** Blocked/unavailable time slots — rendered as hatched regions, prevent event creation. */
     blockedSlots?: BlockedSlot[];
@@ -117,12 +152,12 @@ interface Props {
      * Replace the entire header chrome (date label + mode pills + nav arrows).
      * Receives context: { dateLabel, mode, modes, switchMode, prev, next, goToday, isViewOnToday, focusDate }.
      */
-    header?: Snippet<[import('../headless/types.js').HeaderContext]>;
+    header?: Snippet<[HeaderContext]>;
     /**
      * Replace just the navigation controls (arrows + today button).
      * Receives context: { prev, next, goToday, isViewOnToday, focusDate, mode }.
      */
-    navigation?: Snippet<[import('../headless/types.js').NavigationContext]>;
+    navigation?: Snippet<[NavigationContext]>;
     /** `anchor` is the clicked block's viewport rect where a view has one (planner) — for positioning a FloatingPanel. */
     oneventclick?: (event: TimelineEvent, anchor?: DOMRect) => void;
     oneventcreate?: (range: {
@@ -136,13 +171,25 @@ interface Props {
         start: Date;
         dataTransfer: DataTransfer;
     }) => void;
+    /**
+     * An event was dragged or resized. `newStart`/`newEnd` are real instants.
+     * Fires after the adapter stored the move, or — when the adapter refuses
+     * with a `read-only` error — so the host can store it itself.
+     */
     oneventmove?: (event: TimelineEvent, newStart: Date, newEnd: Date) => void;
+    /** Called with the active view id — once on mount, then on every change. */
     onviewchange?: (viewId: CalendarViewId) => void;
-    /** Called when the focused date changes (navigation, drag-scroll, etc.) */
+    /**
+     * Called with the focused date — once on mount, then whenever it changes
+     * (navigation, scrolling, a tapped day). An instant on the focused day,
+     * like `currentDate` takes, so feeding it back is stable. With `timezone`
+     * read its date in that zone — `formatInTimeZone(d, timezone, …)` or
+     * `toZonedTime(d, timezone)`.
+     */
     ondatechange?: (date: Date) => void;
     /** Called when the pointer enters an event (hover). */
     oneventhover?: (event: TimelineEvent) => void;
-    /** Called when a day cell is clicked (month grid; more views over time). */
+    /** Called when a day cell is clicked (month grid, agenda day heads). An instant, like `ondatechange`. Default: open that day in a day view. */
     ondayclick?: (date: Date) => void;
     /** Surfaced instead of silent console output when loading or mutations fail. */
     onerror?: (error: Error) => void;
@@ -154,6 +201,14 @@ interface Props {
      */
     timezone?: string;
 }
-declare const Calendar: Component<Props, {}, "">;
+/**
+ * The built-in views — the registry a Calendar uses without a `views` prop.
+ * Spread it to add your own view and keep these:
+ * `views={[...defaultViews, { id: 'day-kanban', ... }]}`.
+ * On phones (`mobile: 'auto'`), every view except `*-agenda` and `*-mobile`
+ * swaps to the registered `{mode}-mobile` view, when there is one.
+ */
+export declare const defaultViews: readonly CalendarView[];
+declare const Calendar: Component<CalendarProps, {}, "">;
 type Calendar = ReturnType<typeof Calendar>;
 export default Calendar;

package/dist/calendar/index.d.ts

@@ -1,2 +1,2 @@
-export { default as Calendar } from './Calendar.svelte';
-export type { CalendarView } from './Calendar.svelte';
+export { default as Calendar, defaultViews } from './Calendar.svelte';
+export type { CalendarView, CalendarViewProps, CalendarProps } from './Calendar.svelte';

package/dist/calendar/index.js

@@ -1,2 +1,2 @@
 // ─── Calendar shell barrel export ───────────────────────
-export { default as Calendar } from './Calendar.svelte';
+export { default as Calendar, defaultViews } from './Calendar.svelte';

package/dist/core/clock.svelte.js

@@ -24,8 +24,9 @@ export function createClock(timezone) {
     // With a timezone, ticks are "zoned wall-clock" epoch ms — the same plane
     // the wrapped adapter shifts event Dates into. Views stay zone-agnostic.
     const now = () => (timezone ? toZonedTime(Date.now(), timezone).getTime() : Date.now());
-    let tick = $state(now());
-    let today = $state(sod(tick));
+    const t0 = now();
+    let tick = $state(t0);
+    let today = $state(sod(t0));
     let intervalId = null;
     function start() {
         intervalId = setInterval(() => {

package/dist/core/locale.d.ts

@@ -20,6 +20,8 @@ export interface CalendarLabels {
     month: string;
     planner: string;
     agenda: string;
+    /** The scrolling-weeks view (`week-scroll`) in the view-type pills */
+    scroll: string;
     now: string;
     free: string;
     allDay: string;
@@ -48,6 +50,10 @@ export interface CalendarLabels {
     full: string;
     /** Event status: limited availability */
     limited: string;
+    /** A blocked slot without a label of its own */
+    unavailable: string;
+    /** Shown when a Calendar has no views to render */
+    noViews: string;
     dayNavigation: string;
     weekNavigation: string;
     dayPlanner: string;
@@ -114,7 +120,11 @@ export declare function fmtDay(ms: number, todayMs: number, opts?: {
     short?: boolean;
 }, locale?: string): string;
 /**
- * Format a week range label: "Feb 17 – 23, 2026" or "Jan 27 – Feb 2, 2026"
+ * Format a date range label in the locale's own order:
+ * "Sep 21 – 27, 2026" (en-US), "21–27 wrz 2026" (pl-PL),
+ * "Dec 28, 2026 – Jan 3, 2027" across a year.
+ *
+ * `weekEndMs` is the last day shown (inclusive); default: six days on.
  */
 export declare function fmtWeekRange(weekStartMs: number, locale?: string, weekEndMs?: number): string;
 /**

package/dist/core/locale.js

@@ -7,7 +7,7 @@
  * For date-fns locale integration later, this module can import from
  * `date-fns/locale/*` and pass to `format()`.
  */
-import { DAY_MS } from './time.js';
+import { addDaysMs } from './time.js';
 /** English defaults — used unless overridden via `setLabels()`. */
 export const defaultLabels = {
     today: 'Today',
@@ -18,6 +18,7 @@ export const defaultLabels = {
     month: 'Month',
     planner: 'Planner',
     agenda: 'Agenda',
+    scroll: 'Scroll',
     now: 'now',
     free: 'free',
     allDay: 'All day',
@@ -42,6 +43,8 @@ export const defaultLabels = {
     tentative: 'tentative',
     full: 'full',
     limited: 'limited',
+    unavailable: 'Unavailable',
+    noViews: 'No views registered.',
     dayNavigation: 'Day navigation',
     weekNavigation: 'Week navigation',
     dayPlanner: 'Day planner',
@@ -155,9 +158,9 @@ export function fmtDay(ms, todayMs, opts, locale) {
     const L = _labels;
     if (ms === todayMs)
         return opts?.short ? L.today : `${L.today} · ${short}`;
-    if (ms === todayMs - DAY_MS)
+    if (ms === addDaysMs(todayMs, -1))
         return opts?.short ? L.yesterday : `${L.yesterday} · ${short}`;
-    if (ms === todayMs + DAY_MS)
+    if (ms === addDaysMs(todayMs, 1))
         return opts?.short ? L.tomorrow : `${L.tomorrow} · ${short}`;
     if (opts?.short) {
         return new Date(ms).toLocaleDateString(loc, { weekday: 'short', day: 'numeric' });
@@ -165,23 +168,20 @@ export function fmtDay(ms, todayMs, opts, locale) {
     return new Date(ms).toLocaleDateString(loc, { weekday: 'short', month: 'short', day: 'numeric' });
 }
 /**
- * Format a week range label: "Feb 17 – 23, 2026" or "Jan 27 – Feb 2, 2026"
+ * Format a date range label in the locale's own order:
+ * "Sep 21 – 27, 2026" (en-US), "21–27 wrz 2026" (pl-PL),
+ * "Dec 28, 2026 – Jan 3, 2027" across a year.
+ *
+ * `weekEndMs` is the last day shown (inclusive); default: six days on.
  */
 export function fmtWeekRange(weekStartMs, locale, weekEndMs) {
     const loc = locale ?? defaultLocale;
     const s = new Date(weekStartMs);
-    const e = new Date(weekEndMs ?? weekStartMs + 6 * DAY_MS);
-    const sm = s.toLocaleDateString(loc, { month: 'short' });
-    const em = e.toLocaleDateString(loc, { month: 'short' });
-    const sy = s.getFullYear();
-    const ey = e.getFullYear();
-    if (sy !== ey) {
-        return `${sm} ${s.getDate()}, ${sy} – ${em} ${e.getDate()}, ${ey}`;
-    }
-    if (sm !== em) {
-        return `${sm} ${s.getDate()} – ${em} ${e.getDate()}, ${ey}`;
-    }
-    return `${sm} ${s.getDate()} – ${e.getDate()}, ${ey}`;
+    const e = new Date(weekEndMs ?? addDaysMs(weekStartMs, 6));
+    const fmt = new Intl.DateTimeFormat(loc, { month: 'short', day: 'numeric', year: 'numeric' });
+    // Thin/narrow spaces around the dash vary by engine; plain spaces keep
+    // the label stable across browsers and in tests.
+    return fmt.formatRange(s, e).replace(/[\u2009\u202f]/g, ' ');
 }
 // ─── Shared time / duration formatting ──────────────────
 /**

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;
@@ -74,8 +82,7 @@ export function isMultiDay(ev) {
 export function isAllDay(ev) {
     if (ev.allDay)
         return true;
-    const duration = ev.end.getTime() - ev.start.getTime();
-    if (duration < DAY_MS)
+    if (ev.end.getTime() < addDaysMs(ev.start.getTime(), 1))
         return false;
     const s = ev.start;
     return s.getHours() === 0 && s.getMinutes() === 0 && s.getSeconds() === 0;
@@ -86,7 +93,7 @@ export function isAllDay(ev) {
  */
 export function segmentForDay(ev, dayMs) {
     const dayStart = sod(dayMs);
-    const dayEnd = dayStart + DAY_MS;
+    const dayEnd = addDaysMs(dayStart, 1);
     const evStart = ev.start.getTime();
     const evEnd = ev.end.getTime();
     // No overlap
@@ -95,8 +102,8 @@ export function segmentForDay(ev, dayMs) {
     const firstDayMs = sod(evStart);
     // For end time: if event ends exactly at midnight, last day is the day before
     const lastDayMs = sod(evEnd - 1);
-    const totalDays = Math.floor((lastDayMs - firstDayMs) / DAY_MS) + 1;
-    const dayIndex = Math.floor((dayStart - firstDayMs) / DAY_MS) + 1;
+    const totalDays = diffDays(lastDayMs, firstDayMs) + 1;
+    const dayIndex = diffDays(dayStart, firstDayMs) + 1;
     return {
         ev,
         start: new Date(Math.max(evStart, dayStart)),

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, DAY_MS } 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, DAY_MS } 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) {
@@ -103,63 +159,42 @@ export function createEventStore(adapter) {
         },
         forDay(date) {
             const dayStart = new Date(sod(date.getTime()));
-            const dayEnd = new Date(dayStart.getTime() + DAY_MS);
+            const dayEnd = new Date(addDaysMs(dayStart.getTime(), 1));
             return eventArray.filter((ev) => overlaps(ev, dayStart, dayEnd));
         },
         byId(id) {
             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;