diff --git a/package/src/calendar-types.ts b/package/src/calendar-types.ts
index 2aaf065..3ff8d47 100644
--- a/package/src/calendar-types.ts
+++ b/package/src/calendar-types.ts
@@ -53,7 +53,9 @@ interface CalendarProviderPropsBase<F extends ValueFormat = ValueFormat> {
    */
   locale?: string;
   /**
-   * Custom Temporal namespace for environments without native Temporal support.
+   * The `Temporal` implementation to use. Not bundled — provide a `Temporal`
+   * namespace (e.g. from `temporal-polyfill` or `@js-temporal/polyfill`) unless
+   * the host exposes native `Temporal`. See `RootOwnProps.temporal` for links.
    */
   temporal?: TemporalNamespace;
   /**
diff --git a/package/src/formats/date.ts b/package/src/formats/date.ts
index cd27338..dd51723 100644
--- a/package/src/formats/date.ts
+++ b/package/src/formats/date.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/object.ts b/package/src/formats/object.ts
index 88bb4a1..6418475 100644
--- a/package/src/formats/object.ts
+++ b/package/src/formats/object.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/plain-date-time.ts b/package/src/formats/plain-date-time.ts
index fe2aca2..cad6d6c 100644
--- a/package/src/formats/plain-date-time.ts
+++ b/package/src/formats/plain-date-time.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/plain-date.ts b/package/src/formats/plain-date.ts
index 505b9b5..d9154b4 100644
--- a/package/src/formats/plain-date.ts
+++ b/package/src/formats/plain-date.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/plain-month-day.ts b/package/src/formats/plain-month-day.ts
index 3bdcd5f..6c985a7 100644
--- a/package/src/formats/plain-month-day.ts
+++ b/package/src/formats/plain-month-day.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/plain-year-month.ts b/package/src/formats/plain-year-month.ts
index 1f64b39..1e18aae 100644
--- a/package/src/formats/plain-year-month.ts
+++ b/package/src/formats/plain-year-month.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/formats/zoned-date-time.ts b/package/src/formats/zoned-date-time.ts
index f3f79a5..85b833b 100644
--- a/package/src/formats/zoned-date-time.ts
+++ b/package/src/formats/zoned-date-time.ts
@@ -99,8 +99,6 @@ export { computeWeeksInWindow } from "../compute-weeks-in-window";
 
 export { resolveFirstWeek, resolveFirstWeekSpec } from "../resolve-first-week";
 
-export { Temporal } from "../temporal-polyfill";
-
 export { useCalendarStable, useCalendarState } from "../calendar-context";
 
 export { useMonthViewStable, useMonthViewState } from "../month-view-context";
diff --git a/package/src/index.ts b/package/src/index.ts
index a616154..e99024a 100644
--- a/package/src/index.ts
+++ b/package/src/index.ts
@@ -36,7 +36,6 @@ export {
 export { computePreviewRange } from "./root-selection";
 export { computeWeeksInWindow } from "./compute-weeks-in-window";
 export { resolveFirstWeek, resolveFirstWeekSpec } from "./resolve-first-week";
-export { Temporal } from "./temporal-polyfill";
 export { useCalendarStable, useCalendarState } from "./calendar-context";
 export { useMonthViewStable, useMonthViewState } from "./month-view-context";
 export { useViewContext } from "./view-context";
diff --git a/package/src/month-view-types.ts b/package/src/month-view-types.ts
index 25a2543..5954506 100644
--- a/package/src/month-view-types.ts
+++ b/package/src/month-view-types.ts
@@ -33,15 +33,19 @@ export interface MonthViewRootProps {
   overflowBehavior?: MonthOverflowBehavior | undefined;
   /**
    * The controlled visible month. When provided, the component is controlled.
+   *
+   * Interpreted in the ISO calendar (the year/month are read as ISO values).
+   * The `locale` only affects how the month is displayed, so this value
+   * round-trips directly with {@link onMonthChange}.
    */
   month?: Temporal.PlainYearMonth | undefined;
   /**
-   * The initial visible month (uncontrolled).
+   * The initial visible month (uncontrolled). Interpreted in the ISO calendar.
    */
   defaultMonth?: Temporal.PlainYearMonth | undefined;
   /**
    * Called when the visible month changes via navigation or focus movement.
-   * Not called on initial mount.
+   * Not called on initial mount. The argument is an ISO `PlainYearMonth`.
    */
   onMonthChange?: ((month: Temporal.PlainYearMonth) => void) | undefined;
   /** React children. */
diff --git a/package/src/month-view.test.tsx b/package/src/month-view.test.tsx
index 1bdb1ac..1dcabea 100644
--- a/package/src/month-view.test.tsx
+++ b/package/src/month-view.test.tsx
@@ -1504,6 +1504,135 @@ describe("numberOfMonths", () => {
   });
 });
 
+describe("non-Gregorian locale (th-TH)", () => {
+  // th-TH defaults to the Buddhist calendar (ISO year + 543). All
+  // PlainYearMonth values the component exposes must be ISO; the locale
+  // calendar only affects display.
+  const thProps = { ...defaultProps, locale: "th-TH" } as const;
+  const march15 = Temporal.PlainDate.from("2026-03-15");
+
+  /** Captures rootState.viewing from MonthView context. */
+  function ViewingCapture({
+    onCapture,
+  }: {
+    onCapture: (viewing: Temporal.PlainYearMonth) => void;
+  }) {
+    const { rootState } = useMonthViewState();
+    onCapture(rootState.viewing as Temporal.PlainYearMonth);
+    return null;
+  }
+
+  it("onMonthChange emits an ISO PlainYearMonth, not the locale calendar", () => {
+    const onMonthChange = vi.fn();
+    const { container, unmount } = render(
+      <MonthView
+        {...thProps}
+        defaultValue={march15}
+        onMonthChange={onMonthChange}
+      >
+        <NextMonthButton data-testid="next" />
+      </MonthView>,
+    );
+
+    act(() => {
+      container
+        .querySelector('[data-testid="next"]')!
+        .dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    });
+
+    expect(onMonthChange).toHaveBeenCalledTimes(1);
+    const arg = onMonthChange.mock.calls[0]![0];
+    // ISO April 2026 — NOT Buddhist-2026 (which is ISO 1483-06).
+    expect(arg.toString()).toBe("2026-04");
+    expect(arg.year).toBe(2026);
+    expect(arg.month).toBe(4);
+
+    unmount();
+  });
+
+  it("rootState.viewing is an ISO PlainYearMonth", () => {
+    let viewing: Temporal.PlainYearMonth | undefined;
+    const { unmount } = render(
+      <MonthView {...thProps} defaultValue={march15}>
+        <ViewingCapture
+          onCapture={(v) => {
+            viewing = v;
+          }}
+        />
+      </MonthView>,
+    );
+
+    expect(viewing!.toString()).toBe("2026-03");
+
+    unmount();
+  });
+
+  it("NavButtonState.target is an ISO PlainYearMonth", () => {
+    let nextTarget: Temporal.PlainYearMonth | undefined;
+    const { unmount } = render(
+      <MonthView {...thProps} defaultValue={march15}>
+        <NextMonthButton
+          render={(props, state) => {
+            nextTarget = state.target;
+            return <button {...props} />;
+          }}
+        />
+      </MonthView>,
+    );
+
+    // Next from ISO March 2026 → ISO April 2026, not Buddhist.
+    expect(nextTarget!.toString()).toBe("2026-04");
+
+    unmount();
+  });
+
+  it("still renders the month label in the locale calendar", () => {
+    const { container, unmount } = render(
+      <MonthView {...thProps} defaultValue={march15}>
+        <MonthYearString data-testid="label" />
+      </MonthView>,
+    );
+
+    // ISO 2026 → Buddhist Era 2569.
+    expect(
+      container.querySelector('[data-testid="label"]')!.textContent,
+    ).toContain("2569");
+
+    unmount();
+  });
+
+  it("controlled round-trips without a century jump", () => {
+    function Harness() {
+      const [month, setMonth] = useState(
+        Temporal.PlainYearMonth.from("2026-03"),
+      );
+      return (
+        <MonthView {...thProps} month={month} onMonthChange={setMonth}>
+          <MonthYearString data-testid="label" />
+          <NextMonthButton data-testid="next" />
+        </MonthView>
+      );
+    }
+
+    const { container, unmount } = render(<Harness />);
+    const label = () =>
+      container.querySelector('[data-testid="label"]')!.textContent ?? "";
+    expect(label()).toContain("2569"); // March 2569 BE
+
+    act(() => {
+      container
+        .querySelector('[data-testid="next"]')!
+        .dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    });
+
+    // Advanced one month, still Buddhist 2569 — not jumped ~543 years.
+    expect(label()).toContain("2569");
+    expect(label()).not.toContain("3112");
+
+    unmount();
+  });
+});
+
 describe("outsideDays", () => {
   const march15 = Temporal.PlainDate.from("2026-03-15");
 
diff --git a/package/src/month-view.tsx b/package/src/month-view.tsx
index 7fe7f7f..9476d9c 100644
--- a/package/src/month-view.tsx
+++ b/package/src/month-view.tsx
@@ -14,7 +14,6 @@ import type {
 } from "./month-view-types";
 import type { MonthData, RootState, ValueFormat } from "./types";
 import {
-  calendarForLocale,
   computeAdjacentMonth,
   focusedDateForMonth,
   getMonthWeeks,
@@ -105,21 +104,21 @@ function MonthViewRoot(props: MonthViewRootProps) {
     [],
   );
 
-  const localeCalendar = useMemo(() => calendarForLocale(locale), [locale]);
-
   // Always-current ref so callbacks/effects don't re-subscribe on every
   // onMonthChange identity change.
   const onMonthChangeRef = useRef(onMonthChange);
   onMonthChangeRef.current = onMonthChange;
 
   // Request the parent move the view to `{year, month}` (controlled mode).
+  // Built in ISO — `year`/`month` are ISO numbers, and the locale calendar
+  // only affects display (see MonthYearString). Passing `calendar` here would
+  // reinterpret the ISO numbers as locale-calendar fields (e.g. Buddhist),
+  // shifting the value by centuries.
   const notifyMonth = useCallback(
     (year: number, month: number) => {
-      onMonthChangeRef.current?.(
-        T.PlainYearMonth.from({ year, month, calendar: localeCalendar }),
-      );
+      onMonthChangeRef.current?.(T.PlainYearMonth.from({ year, month }));
     },
-    [T, localeCalendar],
+    [T],
   );
 
   // Whether `{year, month}` falls within the currently displayed window.
@@ -343,14 +342,14 @@ function MonthViewRoot(props: MonthViewRootProps) {
   );
 
   // --- viewingYearMonth (for the render-prop rootState) ---
+  // ISO — the locale calendar only affects display, not this value.
   const viewingYearMonth = useMemo(
     () =>
       T.PlainYearMonth.from({
         year: currentMonth.year,
         month: currentMonth.month,
-        calendar: localeCalendar,
       }),
-    [currentMonth, T, localeCalendar],
+    [currentMonth, T],
   );
 
   // --- Fire onMonthChange when uncontrolled navigation moves the view (not on
diff --git a/package/src/navigation.tsx b/package/src/navigation.tsx
index bcf3ad9..6cba259 100644
--- a/package/src/navigation.tsx
+++ b/package/src/navigation.tsx
@@ -16,7 +16,7 @@ import type {
   NextMonthButtonProps,
   NavButtonState,
 } from "./types";
-import { selectedToZdt, zdtToNativeDate, calendarForLocale } from "./utils";
+import { selectedToZdt, zdtToNativeDate } from "./utils";
 
 const dateStringStateAttributesMapping = {
   root: () => null,
@@ -166,7 +166,7 @@ function MonthYearStringFn(
     ...otherProps
   } = props;
   const monthIndex = monthIndexProp ?? 0;
-  const { locale } = useCalendarStable();
+  const { locale, temporal: T } = useCalendarStable();
   const monthViewStable = useMonthViewStable();
   const {
     currentMonth: currentDateTime,
@@ -186,15 +186,19 @@ function MonthYearStringFn(
   const displayYear = monthData?.year ?? currentDateTime.year;
   const displayMonth = monthData?.month ?? currentDateTime.month;
 
-  const displayDate = new Date(displayYear, displayMonth - 1, 1);
   const defaultOptions: Intl.DateTimeFormatOptions = options ?? {
     month: "long",
     year: "numeric",
   };
-  const formatted = displayDate.toLocaleDateString(
-    locales ?? locale,
-    defaultOptions,
-  );
+  // Format through Temporal
+  // `displayYear`/`displayMonth` are ISO; formatting an ISO
+  // `PlainDate` (not `PlainYearMonth`, which throws on calendar mismatch)
+  // lets Intl render it in the locale's calendar (e.g. Buddhist for th-TH).
+  const formatted = T.PlainDate.from({
+    year: displayYear,
+    month: displayMonth,
+    day: 1,
+  }).toLocaleString(locales ?? locale, defaultOptions);
 
   const state = useMemo<MonthYearStringState>(
     () => ({
@@ -246,7 +250,6 @@ function useNavButton<F extends ValueFormat = ValueFormat>(
     disabled: globalDisabled,
     minValue,
     maxValue,
-    locale,
     temporal: T,
   } = useCalendarStable();
   const monthViewStable = useMonthViewStable();
@@ -304,16 +307,11 @@ function useNavButton<F extends ValueFormat = ValueFormat>(
     );
   }, [globalDisabled, destYear, destMonth, boundValue, direction]);
 
-  const localeCalendar = useMemo(() => calendarForLocale(locale), [locale]);
-
+  // ISO — `destYear`/`destMonth` are ISO numbers; the locale calendar only
+  // affects display, so it must not be injected into this value.
   const target = useMemo(
-    () =>
-      T.PlainYearMonth.from({
-        year: destYear,
-        month: destMonth,
-        calendar: localeCalendar,
-      }),
-    [destYear, destMonth, T, localeCalendar],
+    () => T.PlainYearMonth.from({ year: destYear, month: destMonth }),
+    [destYear, destMonth, T],
   );
 
   const state = useMemo<NavButtonState<F>>(
diff --git a/package/src/temporal-polyfill.test.ts b/package/src/temporal-polyfill.test.ts
deleted file mode 100644
index e5616d6..0000000
--- a/package/src/temporal-polyfill.test.ts
+++ /dev/null
@@ -1,333 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Temporal } from "./temporal-polyfill";
-
-const T = Temporal;
-
-function date(iso: string) {
-  return T.PlainDate.from(iso);
-}
-
-describe("PlainDate.from", () => {
-  it("parses ISO string", () => {
-    const d = date("2026-03-15");
-    expect(d.year).toBe(2026);
-    expect(d.month).toBe(3);
-    expect(d.day).toBe(15);
-  });
-
-  it("parses ISO string with time portion (ignores time)", () => {
-    const d = T.PlainDate.from("2026-03-15T10:30:00");
-    expect(d.year).toBe(2026);
-    expect(d.month).toBe(3);
-    expect(d.day).toBe(15);
-  });
-
-  it("creates from object", () => {
-    const d = T.PlainDate.from({ year: 2026, month: 2, day: 28 });
-    expect(d.toString()).toBe("2026-02-28");
-  });
-
-  it("constrains overflow day", () => {
-    const d = T.PlainDate.from(
-      { year: 2026, month: 2, day: 31 },
-      { overflow: "constrain" },
-    );
-    expect(d.day).toBe(28);
-  });
-
-  it("constrains overflow day for leap year", () => {
-    const d = T.PlainDate.from(
-      { year: 2024, month: 2, day: 31 },
-      { overflow: "constrain" },
-    );
-    expect(d.day).toBe(29);
-  });
-});
-
-describe("PlainDate.compare", () => {
-  it.each<{
-    description: string;
-    a: string;
-    b: string;
-    expected: number;
-  }>([
-    {
-      description: "equal dates",
-      a: "2026-03-15",
-      b: "2026-03-15",
-      expected: 0,
-    },
-    {
-      description: "a before b (day)",
-      a: "2026-03-14",
-      b: "2026-03-15",
-      expected: -1,
-    },
-    {
-      description: "a after b (day)",
-      a: "2026-03-16",
-      b: "2026-03-15",
-      expected: 1,
-    },
-    {
-      description: "a before b (month)",
-      a: "2026-02-15",
-      b: "2026-03-15",
-      expected: -1,
-    },
-    {
-      description: "a before b (year)",
-      a: "2025-03-15",
-      b: "2026-03-15",
-      expected: -1,
-    },
-  ])("$description", ({ a, b, expected }) => {
-    expect(T.PlainDate.compare(date(a), date(b))).toBe(expected);
-  });
-});
-
-describe("PlainDate add/subtract", () => {
-  it("adds days", () => {
-    expect(date("2026-03-15").add({ days: 5 }).toString()).toBe("2026-03-20");
-  });
-
-  it("adds weeks", () => {
-    expect(date("2026-03-15").add({ weeks: 2 }).toString()).toBe("2026-03-29");
-  });
-
-  it("adds months with day clamping (Jan 31 + 1 month)", () => {
-    expect(date("2026-01-31").add({ months: 1 }).toString()).toBe("2026-02-28");
-  });
-
-  it("adds months with day clamping (Jan 31 + 1 month, leap year)", () => {
-    expect(date("2024-01-31").add({ months: 1 }).toString()).toBe("2024-02-29");
-  });
-
-  it("subtracts days", () => {
-    expect(date("2026-03-15").subtract({ days: 5 }).toString()).toBe(
-      "2026-03-10",
-    );
-  });
-
-  it("subtracts months", () => {
-    expect(date("2026-03-31").subtract({ months: 1 }).toString()).toBe(
-      "2026-02-28",
-    );
-  });
-
-  it("crosses year boundary forward", () => {
-    expect(date("2026-12-31").add({ days: 1 }).toString()).toBe("2027-01-01");
-  });
-
-  it("crosses year boundary backward", () => {
-    expect(date("2027-01-01").subtract({ days: 1 }).toString()).toBe(
-      "2026-12-31",
-    );
-  });
-
-  it("adds months crossing year boundary", () => {
-    expect(date("2026-11-15").add({ months: 3 }).toString()).toBe("2027-02-15");
-  });
-});
-
-describe("PlainDate since/until", () => {
-  it("positive days", () => {
-    expect(date("2026-03-20").since(date("2026-03-10")).days).toBe(10);
-  });
-
-  it("negative days", () => {
-    expect(date("2026-03-10").since(date("2026-03-20")).days).toBe(-10);
-  });
-
-  it("zero days", () => {
-    expect(date("2026-03-15").since(date("2026-03-15")).days).toBe(0);
-  });
-
-  it("until returns positive for future dates", () => {
-    expect(date("2026-03-10").until(date("2026-03-20")).days).toBe(10);
-  });
-});
-
-describe("PlainDate dayOfWeek", () => {
-  it.each<{ description: string; d: string; expected: number }>([
-    { description: "2026-03-15 is Sunday", d: "2026-03-15", expected: 7 },
-    { description: "2026-03-16 is Monday", d: "2026-03-16", expected: 1 },
-    { description: "2026-03-17 is Tuesday", d: "2026-03-17", expected: 2 },
-    { description: "2026-03-21 is Saturday", d: "2026-03-21", expected: 6 },
-  ])("$description", ({ d, expected }) => {
-    expect(date(d).dayOfWeek).toBe(expected);
-  });
-});
-
-describe("PlainDate daysInMonth", () => {
-  it.each<{ description: string; d: string; expected: number }>([
-    { description: "Feb non-leap", d: "2026-02-01", expected: 28 },
-    { description: "Feb leap", d: "2024-02-01", expected: 29 },
-    { description: "30-day month (Apr)", d: "2026-04-15", expected: 30 },
-    { description: "31-day month (Mar)", d: "2026-03-15", expected: 31 },
-  ])("$description", ({ d, expected }) => {
-    expect(date(d).daysInMonth).toBe(expected);
-  });
-});
-
-describe("PlainDate toString roundtrip", () => {
-  it("roundtrips through from/toString", () => {
-    const iso = "2026-03-15";
-    expect(T.PlainDate.from(date(iso).toString()).toString()).toBe(iso);
-  });
-});
-
-describe("PlainDate equals", () => {
-  it("returns true for same date", () => {
-    expect(date("2026-03-15").equals(date("2026-03-15"))).toBe(true);
-  });
-
-  it("returns false for different date", () => {
-    expect(date("2026-03-15").equals(date("2026-03-16"))).toBe(false);
-  });
-});
-
-describe("PlainDateTime", () => {
-  it("from string", () => {
-    const dt = T.PlainDateTime.from("2026-03-15T10:30:45");
-    expect(dt.year).toBe(2026);
-    expect(dt.hour).toBe(10);
-    expect(dt.minute).toBe(30);
-    expect(dt.second).toBe(45);
-  });
-
-  it("from object", () => {
-    const dt = T.PlainDateTime.from({
-      year: 2026,
-      month: 3,
-      day: 15,
-      hour: 10,
-    });
-    expect(dt.hour).toBe(10);
-    expect(dt.minute).toBe(0);
-  });
-
-  it("toPlainDate", () => {
-    const dt = T.PlainDateTime.from("2026-03-15T10:30:00");
-    expect(dt.toPlainDate().toString()).toBe("2026-03-15");
-  });
-});
-
-describe("PlainMonthDay", () => {
-  it("from object", () => {
-    const md = T.PlainMonthDay.from({ month: 7, day: 4 });
-    expect(md.monthCode).toBe("M07");
-    expect(md.day).toBe(4);
-  });
-
-  it("toPlainDate with year", () => {
-    const md = T.PlainMonthDay.from({ month: 2, day: 28 });
-    const pd = md.toPlainDate({ year: 2026 });
-    expect(pd.toString()).toBe("2026-02-28");
-  });
-});
-
-describe("PlainYearMonth", () => {
-  it("from object", () => {
-    const ym = T.PlainYearMonth.from({ year: 2026, month: 6 });
-    expect(ym.year).toBe(2026);
-    expect(ym.month).toBe(6);
-  });
-
-  it("toPlainDate with day", () => {
-    const ym = T.PlainYearMonth.from({ year: 2026, month: 6 });
-    expect(ym.toPlainDate({ day: 15 }).toString()).toBe("2026-06-15");
-  });
-
-  it("daysInMonth", () => {
-    expect(T.PlainYearMonth.from({ year: 2026, month: 2 }).daysInMonth).toBe(
-      28,
-    );
-    expect(T.PlainYearMonth.from({ year: 2024, month: 2 }).daysInMonth).toBe(
-      29,
-    );
-  });
-});
-
-describe("ZonedDateTime", () => {
-  it("extracts components in UTC", () => {
-    const pdt = T.PlainDateTime.from("2026-03-15T10:30:00");
-    const zdt = pdt.toZonedDateTime("UTC");
-    expect(zdt.year).toBe(2026);
-    expect(zdt.month).toBe(3);
-    expect(zdt.day).toBe(15);
-    expect(zdt.hour).toBe(10);
-    expect(zdt.minute).toBe(30);
-    expect(zdt.timeZoneId).toBe("UTC");
-  });
-
-  it("extracts components in a non-UTC timezone", () => {
-    const pdt = T.PlainDateTime.from("2026-03-15T10:30:00");
-    const zdt = pdt.toZonedDateTime("America/New_York");
-    expect(zdt.year).toBe(2026);
-    expect(zdt.month).toBe(3);
-    expect(zdt.day).toBe(15);
-    expect(zdt.hour).toBe(10);
-    expect(zdt.timeZoneId).toBe("America/New_York");
-  });
-
-  it("toPlainDate roundtrip", () => {
-    const pd = date("2026-06-20");
-    const zdt = pd.toZonedDateTime("America/New_York");
-    expect(zdt.toPlainDate().toString()).toBe("2026-06-20");
-  });
-
-  it("toPlainDateTime roundtrip", () => {
-    const pdt = T.PlainDateTime.from("2026-03-15T14:30:00");
-    const zdt = pdt.toZonedDateTime("UTC");
-    const roundtrip = zdt.toPlainDateTime();
-    expect(roundtrip.hour).toBe(14);
-    expect(roundtrip.minute).toBe(30);
-  });
-
-  it("epochMilliseconds is valid", () => {
-    const zdt = T.Now.zonedDateTimeISO("UTC");
-    expect(typeof zdt.epochMilliseconds).toBe("number");
-    expect(Math.abs(zdt.epochMilliseconds - Date.now())).toBeLessThan(1000);
-  });
-});
-
-describe("Now", () => {
-  it("timeZoneId returns a non-empty string", () => {
-    const tz = T.Now.timeZoneId();
-    expect(typeof tz).toBe("string");
-    expect(tz.length).toBeGreaterThan(0);
-  });
-
-  it("zonedDateTimeISO returns current time", () => {
-    const zdt = T.Now.zonedDateTimeISO("UTC");
-    expect(zdt.year).toBeGreaterThan(2020);
-  });
-
-  it("plainDateISO returns today", () => {
-    const pd = T.Now.plainDateISO();
-    expect(pd.year).toBeGreaterThan(2020);
-    expect(pd.month).toBeGreaterThanOrEqual(1);
-    expect(pd.month).toBeLessThanOrEqual(12);
-  });
-});
-
-describe("PlainDate → ZonedDateTime → PlainDate roundtrip", () => {
-  it.each(["2026-01-01", "2026-06-15", "2026-12-31", "2024-02-29"])(
-    "%s roundtrips through UTC",
-    (iso) => {
-      const pd = date(iso);
-      const zdt = pd.toZonedDateTime("UTC");
-      expect(zdt.toPlainDate().toString()).toBe(iso);
-    },
-  );
-
-  it.each(["2026-01-01", "2026-06-15", "2026-12-31"])(
-    "%s roundtrips through America/New_York",
-    (iso) => {
-      const pd = date(iso);
-      const zdt = pd.toZonedDateTime("America/New_York");
-      expect(zdt.toPlainDate().toString()).toBe(iso);
-    },
-  );
-});
diff --git a/package/src/temporal-polyfill.ts b/package/src/temporal-polyfill.ts
deleted file mode 100644
index a9fc18c..0000000
--- a/package/src/temporal-polyfill.ts
+++ /dev/null
@@ -1,627 +0,0 @@
-import type { TemporalNamespace } from "./types";
-
-// ---------------------------------------------------------------------------
-// Helpers (private)
-// ---------------------------------------------------------------------------
-
-function daysInMonth(year: number, month: number): number {
-  return new Date(year, month, 0).getDate();
-}
-
-function toUTC(y: number, m: number, d: number): number {
-  return Date.UTC(y, m - 1, d);
-}
-
-function isoWeekday(utcDate: Date): number {
-  const dow = utcDate.getUTCDay();
-  return dow === 0 ? 7 : dow;
-}
-
-function pad2(n: number): string {
-  return n < 10 ? `0${n}` : `${n}`;
-}
-
-function clamp(val: number, min: number, max: number): number {
-  return val < min ? min : val > max ? max : val;
-}
-
-function parseDateISO(str: string): {
-  year: number;
-  month: number;
-  day: number;
-} {
-  const [datePart] = str.split("T");
-  const [y, m, d] = datePart?.split("-").map(Number) ?? [];
-  if (y === undefined || m === undefined || d === undefined) {
-    throw new RangeError(`Invalid ISO date string: ${str}`);
-  }
-  return { year: y, month: m, day: d };
-}
-
-function parseDateTimeISO(str: string): {
-  year: number;
-  month: number;
-  day: number;
-  hour: number;
-  minute: number;
-  second: number;
-} {
-  const [datePart, timePart] = str.split("T");
-  const [y, m, d] = datePart?.split("-").map(Number) ?? [];
-  if (y === undefined || m === undefined || d === undefined) {
-    throw new RangeError(`Invalid ISO date-time string: ${str}`);
-  }
-  if (!timePart)
-    return { year: y, month: m, day: d, hour: 0, minute: 0, second: 0 };
-  const [h, min, s] = timePart.split(":").map(Number);
-  return {
-    year: y,
-    month: m,
-    day: d,
-    hour: h || 0,
-    minute: min || 0,
-    second: s || 0,
-  };
-}
-
-// Cache Intl.DateTimeFormat instances per timezone
-const dtfCache = new Map<string, Intl.DateTimeFormat>();
-
-function getDTF(tz: string): Intl.DateTimeFormat {
-  let dtf = dtfCache.get(tz);
-  if (!dtf) {
-    dtf = new Intl.DateTimeFormat("en-US", {
-      timeZone: tz,
-      year: "numeric",
-      month: "numeric",
-      day: "numeric",
-      hour: "numeric",
-      minute: "numeric",
-      second: "numeric",
-      hour12: false,
-    });
-    dtfCache.set(tz, dtf);
-  }
-  return dtf;
-}
-
-interface TzParts {
-  year: number;
-  month: number;
-  day: number;
-  hour: number;
-  minute: number;
-  second: number;
-}
-
-function extractTzParts(epochMs: number, tz: string): TzParts {
-  const dtf = getDTF(tz);
-  const parts = dtf.formatToParts(new Date(epochMs));
-  const vals: Record<string, number> = {};
-  for (const p of parts) {
-    if (p.type !== "literal") {
-      vals[p.type] = Number(p.value);
-    }
-  }
-  const { year, month, day, hour, minute, second } = vals;
-  if (
-    year === undefined ||
-    month === undefined ||
-    day === undefined ||
-    hour === undefined ||
-    minute === undefined ||
-    second === undefined
-  ) {
-    throw new RangeError(`Invalid time zone: ${tz}`);
-  }
-  return {
-    year,
-    month,
-    day,
-    hour: hour === 24 ? 0 : hour,
-    minute,
-    second,
-  };
-}
-
-function wallToEpoch(
-  y: number,
-  m: number,
-  d: number,
-  h: number,
-  min: number,
-  s: number,
-  tz: string,
-): number {
-  const utcGuess = Date.UTC(y, m - 1, d, h, min, s);
-  const inTz = extractTzParts(utcGuess, tz);
-  const wallOfGuess = Date.UTC(
-    inTz.year,
-    inTz.month - 1,
-    inTz.day,
-    inTz.hour,
-    inTz.minute,
-    inTz.second,
-  );
-  return utcGuess - (wallOfGuess - utcGuess);
-}
-
-// ---------------------------------------------------------------------------
-// MiniPlainDate
-// ---------------------------------------------------------------------------
-
-class MiniPlainDate {
-  readonly year: number;
-  readonly month: number;
-  readonly day: number;
-
-  constructor(year: number, month: number, day: number) {
-    this.year = year;
-    this.month = month;
-    this.day = day;
-  }
-
-  get dayOfWeek(): number {
-    return isoWeekday(new Date(toUTC(this.year, this.month, this.day)));
-  }
-
-  get daysInWeek(): number {
-    return 7;
-  }
-
-  get daysInMonth(): number {
-    return daysInMonth(this.year, this.month);
-  }
-
-  get monthCode(): string {
-    return `M${pad2(this.month)}`;
-  }
-
-  add(dur: {
-    days?: number;
-    weeks?: number;
-    months?: number;
-    years?: number;
-  }): MiniPlainDate {
-    let y = this.year + (dur.years || 0);
-    let m = this.month + (dur.months || 0);
-
-    // Resolve month overflow/underflow
-    while (m > 12) {
-      m -= 12;
-      y += 1;
-    }
-    while (m < 1) {
-      m += 12;
-      y -= 1;
-    }
-
-    // Clamp day to valid range for new month
-    const d = Math.min(this.day, daysInMonth(y, m));
-
-    // Add days and weeks via epoch arithmetic
-    const totalDays = (dur.days || 0) + (dur.weeks || 0) * 7;
-    if (totalDays === 0) return new MiniPlainDate(y, m, d);
-
-    const epoch = toUTC(y, m, d) + totalDays * 86400000;
-    const ud = new Date(epoch);
-    return new MiniPlainDate(
-      ud.getUTCFullYear(),
-      ud.getUTCMonth() + 1,
-      ud.getUTCDate(),
-    );
-  }
-
-  subtract(dur: {
-    days?: number;
-    weeks?: number;
-    months?: number;
-    years?: number;
-  }): MiniPlainDate {
-    return this.add({
-      ...(dur.days && { days: -dur.days }),
-      ...(dur.weeks && { weeks: -dur.weeks }),
-      ...(dur.months && { months: -dur.months }),
-      ...(dur.years && { years: -dur.years }),
-    });
-  }
-
-  since(other: MiniPlainDate, _opts?: any): { days: number } {
-    const thisUTC = toUTC(this.year, this.month, this.day);
-    const otherUTC = toUTC(other.year, other.month, other.day);
-    return { days: Math.round((thisUTC - otherUTC) / 86400000) };
-  }
-
-  until(other: MiniPlainDate, _opts?: any): { days: number } {
-    const thisUTC = toUTC(this.year, this.month, this.day);
-    const otherUTC = toUTC(other.year, other.month, other.day);
-    return { days: Math.round((otherUTC - thisUTC) / 86400000) };
-  }
-
-  equals(other: MiniPlainDate): boolean {
-    return (
-      this.year === other.year &&
-      this.month === other.month &&
-      this.day === other.day
-    );
-  }
-
-  toString(): string {
-    return `${String(this.year).padStart(4, "0")}-${pad2(this.month)}-${pad2(this.day)}`;
-  }
-
-  toZonedDateTime(tz: string | { timeZone: string }): MiniZonedDateTime {
-    const tzId = typeof tz === "string" ? tz : tz.timeZone;
-    return this.toPlainDateTime().toZonedDateTime(tzId);
-  }
-
-  toPlainDateTime(timeLike?: {
-    hour?: number;
-    minute?: number;
-    second?: number;
-  }): MiniPlainDateTime {
-    return new MiniPlainDateTime(
-      this.year,
-      this.month,
-      this.day,
-      timeLike?.hour ?? 0,
-      timeLike?.minute ?? 0,
-      timeLike?.second ?? 0,
-    );
-  }
-
-  toPlainMonthDay(): MiniPlainMonthDay {
-    return new MiniPlainMonthDay(this.month, this.day);
-  }
-
-  toPlainYearMonth(): MiniPlainYearMonth {
-    return new MiniPlainYearMonth(this.year, this.month);
-  }
-
-  toLocaleString(
-    locale?: string | string[],
-    options?: Intl.DateTimeFormatOptions,
-  ): string {
-    return new Date(toUTC(this.year, this.month, this.day)).toLocaleDateString(
-      locale,
-      {
-        timeZone: "UTC",
-        ...options,
-      },
-    );
-  }
-}
-
-// ---------------------------------------------------------------------------
-// MiniPlainDateTime
-// ---------------------------------------------------------------------------
-
-class MiniPlainDateTime {
-  readonly year: number;
-  readonly month: number;
-  readonly day: number;
-  readonly hour: number;
-  readonly minute: number;
-  readonly second: number;
-
-  constructor(
-    year: number,
-    month: number,
-    day: number,
-    hour = 0,
-    minute = 0,
-    second = 0,
-  ) {
-    this.year = year;
-    this.month = month;
-    this.day = day;
-    this.hour = hour;
-    this.minute = minute;
-    this.second = second;
-  }
-
-  get dayOfWeek(): number {
-    return isoWeekday(new Date(toUTC(this.year, this.month, this.day)));
-  }
-
-  get daysInMonth(): number {
-    return daysInMonth(this.year, this.month);
-  }
-
-  toZonedDateTime(tz: string | { timeZone: string }): MiniZonedDateTime {
-    const tzId = typeof tz === "string" ? tz : tz.timeZone;
-    const epoch = wallToEpoch(
-      this.year,
-      this.month,
-      this.day,
-      this.hour,
-      this.minute,
-      this.second,
-      tzId,
-    );
-    return new MiniZonedDateTime(epoch, tzId);
-  }
-
-  toPlainDate(): MiniPlainDate {
-    return new MiniPlainDate(this.year, this.month, this.day);
-  }
-
-  toString(): string {
-    return `${String(this.year).padStart(4, "0")}-${pad2(this.month)}-${pad2(this.day)}T${pad2(this.hour)}:${pad2(this.minute)}:${pad2(this.second)}`;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// MiniPlainMonthDay
-// ---------------------------------------------------------------------------
-
-class MiniPlainMonthDay {
-  readonly monthCode: string;
-  readonly month: number;
-  readonly day: number;
-
-  constructor(month: number, day: number) {
-    this.month = month;
-    this.day = day;
-    this.monthCode = `M${pad2(month)}`;
-  }
-
-  toPlainDate(fields: { year: number }): MiniPlainDate {
-    return new MiniPlainDate(fields.year, this.month, this.day);
-  }
-
-  equals(other: MiniPlainMonthDay): boolean {
-    return this.month === other.month && this.day === other.day;
-  }
-
-  toString(): string {
-    return `${pad2(this.month)}-${pad2(this.day)}`;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// MiniPlainYearMonth
-// ---------------------------------------------------------------------------
-
-class MiniPlainYearMonth {
-  readonly year: number;
-  readonly month: number;
-
-  constructor(year: number, month: number) {
-    this.year = year;
-    this.month = month;
-  }
-
-  get monthCode(): string {
-    return `M${pad2(this.month)}`;
-  }
-
-  get daysInMonth(): number {
-    return daysInMonth(this.year, this.month);
-  }
-
-  toPlainDate(fields: { day: number }): MiniPlainDate {
-    return new MiniPlainDate(this.year, this.month, fields.day);
-  }
-
-  add(dur: { months?: number; years?: number }): MiniPlainYearMonth {
-    let y = this.year + (dur.years || 0);
-    let m = this.month + (dur.months || 0);
-    while (m > 12) {
-      m -= 12;
-      y += 1;
-    }
-    while (m < 1) {
-      m += 12;
-      y -= 1;
-    }
-    return new MiniPlainYearMonth(y, m);
-  }
-
-  subtract(dur: { months?: number; years?: number }): MiniPlainYearMonth {
-    return this.add({
-      ...(dur.months && { months: -dur.months }),
-      ...(dur.years && { years: -dur.years }),
-    });
-  }
-
-  equals(other: MiniPlainYearMonth): boolean {
-    return this.year === other.year && this.month === other.month;
-  }
-
-  toString(): string {
-    return `${String(this.year).padStart(4, "0")}-${pad2(this.month)}`;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// MiniZonedDateTime
-// ---------------------------------------------------------------------------
-
-class MiniZonedDateTime {
-  readonly epochMilliseconds: number;
-  readonly timeZoneId: string;
-  private _parts?: TzParts;
-
-  constructor(epochMs: number, timeZoneId: string) {
-    this.epochMilliseconds = epochMs;
-    this.timeZoneId = timeZoneId;
-  }
-
-  private get parts(): TzParts {
-    if (!this._parts) {
-      this._parts = extractTzParts(this.epochMilliseconds, this.timeZoneId);
-    }
-    return this._parts;
-  }
-
-  get year(): number {
-    return this.parts.year;
-  }
-  get month(): number {
-    return this.parts.month;
-  }
-  get day(): number {
-    return this.parts.day;
-  }
-  get hour(): number {
-    return this.parts.hour;
-  }
-  get minute(): number {
-    return this.parts.minute;
-  }
-  get second(): number {
-    return this.parts.second;
-  }
-
-  get dayOfWeek(): number {
-    return isoWeekday(new Date(toUTC(this.year, this.month, this.day)));
-  }
-
-  toPlainDate(): MiniPlainDate {
-    return new MiniPlainDate(this.year, this.month, this.day);
-  }
-
-  toPlainDateTime(): MiniPlainDateTime {
-    return new MiniPlainDateTime(
-      this.year,
-      this.month,
-      this.day,
-      this.hour,
-      this.minute,
-      this.second,
-    );
-  }
-
-  toPlainTime(): { hour: number; minute: number; second: number } {
-    return { hour: this.hour, minute: this.minute, second: this.second };
-  }
-
-  toPlainYearMonth(): MiniPlainYearMonth {
-    return new MiniPlainYearMonth(this.year, this.month);
-  }
-
-  toString(): string {
-    return `${String(this.year).padStart(4, "0")}-${pad2(this.month)}-${pad2(this.day)}T${pad2(this.hour)}:${pad2(this.minute)}:${pad2(this.second)}[${this.timeZoneId}]`;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Static constructors
-// ---------------------------------------------------------------------------
-
-const PlainDate = {
-  from(item: any, options?: { overflow?: string }): MiniPlainDate {
-    if (typeof item === "string") {
-      const { year, month, day } = parseDateISO(item);
-      if (options?.overflow === "constrain") {
-        return new MiniPlainDate(
-          year,
-          month,
-          clamp(day, 1, daysInMonth(year, month)),
-        );
-      }
-      return new MiniPlainDate(year, month, day);
-    }
-    const year = item.year;
-    const month = item.month;
-    let day = item.day;
-    if (options?.overflow === "constrain") {
-      day = clamp(day, 1, daysInMonth(year, month));
-    }
-    return new MiniPlainDate(year, month, day);
-  },
-
-  compare(a: MiniPlainDate, b: MiniPlainDate): number {
-    if (a.year !== b.year) return Math.sign(a.year - b.year);
-    if (a.month !== b.month) return Math.sign(a.month - b.month);
-    if (a.day !== b.day) return Math.sign(a.day - b.day);
-    return 0;
-  },
-};
-
-const PlainDateTime = {
-  from(item: any, _options?: { overflow?: string }): MiniPlainDateTime {
-    if (typeof item === "string") {
-      const { year, month, day, hour, minute, second } = parseDateTimeISO(item);
-      return new MiniPlainDateTime(year, month, day, hour, minute, second);
-    }
-    return new MiniPlainDateTime(
-      item.year,
-      item.month,
-      item.day,
-      item.hour ?? 0,
-      item.minute ?? 0,
-      item.second ?? 0,
-    );
-  },
-};
-
-const PlainMonthDay = {
-  from(item: any): MiniPlainMonthDay {
-    if (typeof item === "string") {
-      // "MM-DD" or "YYYY-MM-DD" — take last two numeric segments
-      const [first, second, third] = item.split("-").map(Number);
-      if (first === undefined || second === undefined) {
-        throw new RangeError(`Invalid ISO month-day string: ${item}`);
-      }
-      if (third !== undefined) return new MiniPlainMonthDay(second, third);
-      return new MiniPlainMonthDay(first, second);
-    }
-    const month =
-      item.month ??
-      (item.monthCode ? Number.parseInt(item.monthCode.slice(1), 10) : 1);
-    return new MiniPlainMonthDay(month, item.day);
-  },
-};
-
-const PlainYearMonth = {
-  from(item: any): MiniPlainYearMonth {
-    if (typeof item === "string") {
-      const [y, m] = item.split("-").map(Number);
-      if (y === undefined || m === undefined) {
-        throw new RangeError(`Invalid ISO year-month string: ${item}`);
-      }
-      return new MiniPlainYearMonth(y, m);
-    }
-    return new MiniPlainYearMonth(item.year, item.month);
-  },
-
-  compare(a: MiniPlainYearMonth, b: MiniPlainYearMonth): number {
-    if (a.year !== b.year) return Math.sign(a.year - b.year);
-    if (a.month !== b.month) return Math.sign(a.month - b.month);
-    return 0;
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Now
-// ---------------------------------------------------------------------------
-
-const Now = {
-  timeZoneId(): string {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone;
-  },
-
-  zonedDateTimeISO(tz?: string): MiniZonedDateTime {
-    return new MiniZonedDateTime(Date.now(), tz ?? Now.timeZoneId());
-  },
-
-  plainDateISO(): MiniPlainDate {
-    const tz = Now.timeZoneId();
-    const parts = extractTzParts(Date.now(), tz);
-    return new MiniPlainDate(parts.year, parts.month, parts.day);
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Export
-// ---------------------------------------------------------------------------
-
-export const Temporal = {
-  Now,
-  PlainDate,
-  PlainDateTime,
-  PlainMonthDay,
-  PlainYearMonth,
-} as unknown as TemporalNamespace;
diff --git a/package/src/test-temporal.ts b/package/src/test-temporal.ts
index 0d6486b..432abea 100644
--- a/package/src/test-temporal.ts
+++ b/package/src/test-temporal.ts
@@ -1,5 +1,4 @@
 import { Temporal as FullTemporal } from "@js-temporal/polyfill";
-import { Temporal as MiniTemporal } from "./temporal-polyfill";
 import type { TemporalNamespace } from "./types";
 
 export const temporalVariants: { name: string; T: TemporalNamespace }[] = [
@@ -13,5 +12,4 @@ export const temporalVariants: { name: string; T: TemporalNamespace }[] = [
       PlainYearMonth: FullTemporal.PlainYearMonth,
     },
   },
-  { name: "mini polyfill", T: MiniTemporal },
 ];
diff --git a/package/src/types.ts b/package/src/types.ts
index 6d90a9d..ff9d2b7 100644
--- a/package/src/types.ts
+++ b/package/src/types.ts
@@ -276,9 +276,16 @@ interface RootOwnPropsBase<F extends ValueFormat = ValueFormat> {
    */
   locale?: string;
   /**
-   * Custom Temporal namespace for environments without native Temporal support.
-   * Typically the `Temporal` export from `@js-temporal/polyfill`. When using
-   * `@js-temporal/polyfill`.
+   * The `Temporal` implementation to use. This library does not bundle one:
+   * provide a `Temporal` namespace here unless the host already exposes the
+   * native `Temporal` API. Two well-supported polyfills:
+   *
+   * - `temporal-polyfill` — https://github.com/fullcalendar/temporal-polyfill
+   * - `@js-temporal/polyfill` — https://github.com/js-temporal/temporal-polyfill
+   *
+   * @example
+   * import { Temporal } from "temporal-polyfill";
+   * <MonthView temporal={Temporal} … />
    */
   temporal?: TemporalNamespace;
   /**
diff --git a/package/src/utils.test.ts b/package/src/utils.test.ts
index 3949366..4070019 100644
--- a/package/src/utils.test.ts
+++ b/package/src/utils.test.ts
@@ -3,7 +3,6 @@ import { describe, it, expect } from "vitest";
 import { temporalVariants } from "./test-temporal";
 import type { TemporalNamespace } from "./types";
 import {
-  calendarForLocale,
   resolveTemporal,
   getSystemTimeZone,
   toZonedDateTime,
@@ -32,18 +31,6 @@ const T: TemporalNamespace = {
   PlainYearMonth: Temporal.PlainYearMonth,
 };
 
-describe("calendarForLocale", () => {
-  it("returns 'gregory' for en-US", () => {
-    expect(calendarForLocale("en-US")).toBe("gregory");
-  });
-
-  it("returns a calendar string for an empty locale (runtime default)", () => {
-    const result = calendarForLocale("");
-    expect(typeof result).toBe("string");
-    expect(result.length).toBeGreaterThan(0);
-  });
-});
-
 describe("resolveTemporal", () => {
   it("returns the provided namespace when given", () => {
     expect(resolveTemporal(T)).toBe(T);
diff --git a/package/src/utils.ts b/package/src/utils.ts
index fd5af91..f93fb30 100644
--- a/package/src/utils.ts
+++ b/package/src/utils.ts
@@ -6,21 +6,15 @@ import type {
   WeekStartDay,
 } from "./types";
 
-/**
- * Returns the default calendar system for a given locale (e.g. `"gregory"` for `"en-US"`).
- *
- * @param locale - A BCP 47 locale string. Falls back to the runtime default when empty.
- */
-export function calendarForLocale(locale: string): string {
-  return new Intl.DateTimeFormat(locale || undefined).resolvedOptions()
-    .calendar;
-}
-
 /**
  * Resolves a {@link TemporalNamespace} instance.
  *
- * Returns `provided` when given, otherwise checks `globalThis.Temporal`.
- * Throws if neither is available.
+ * Returns `provided` when given, otherwise native `globalThis.Temporal`. This
+ * library does not bundle a `Temporal` implementation — if neither is
+ * available, it throws. Provide one via the `temporal` prop, e.g. the
+ * `Temporal` export from `temporal-polyfill`
+ * (https://github.com/fullcalendar/temporal-polyfill) or `@js-temporal/polyfill`
+ * (https://github.com/js-temporal/temporal-polyfill).
  *
  * @param provided - An explicit Temporal polyfill or namespace.
  */
@@ -32,7 +26,7 @@ export function resolveTemporal(
     return (globalThis as any).Temporal;
   }
   throw new Error(
-    "DatePicker: Temporal is not available. Pass a Temporal polyfill via the `temporal` prop, or use a browser that supports the Temporal API natively.",
+    "DatePicker: Temporal is not available. Pass a Temporal implementation via the `temporal` prop — e.g. `temporal-polyfill` or `@js-temporal/polyfill` — or run where the native Temporal API exists.",
   );
 }