@northguild/gmt 1.15.0 → 1.17.0

package/dist/internal/temporalCompat/nonIsoArithmetic.d.ts

@@ -0,0 +1,59 @@
+import { Temporal } from "@js-temporal/polyfill";
+/** A date's fields in one calendar. `month` is ordinal. */
+export interface CalendarDateParts {
+    year: number;
+    month: number;
+    monthCode: string;
+    day: number;
+}
+export interface YearMonth {
+    year: number;
+    month: number;
+}
+export interface DateDurationFields {
+    years: number;
+    months: number;
+    weeks: number;
+    days: number;
+}
+export type ArithmeticOverflow = "constrain" | "reject";
+/**
+ * Integer questions about one calendar's months. `null` answers mean "this month lies outside the
+ * TC39 PlainDate range, so nothing about it can be read": the algorithms only ask about such a month
+ * when the date they would build is out of range too, which the spec turns into a RangeError or, in
+ * `NonISODateSurpasses`, into "surpasses".
+ */
+export interface ArithmeticModel {
+    /** Temporal calendar id. */
+    calendarId: string;
+    fields(date: Temporal.PlainDate): CalendarDateParts;
+    /** Ordinal of `monthCode` in `year`; `"missing"` when that year has no such month (a leap month). */
+    monthOrdinal(year: number, monthCode: string): number | "missing" | null;
+    /** `BalanceNonISODate(year, month + months, 1)`: `month` may exceed the year's month count. */
+    addMonths(start: YearMonth, months: number): YearMonth | null;
+    /** Signed month count between two month starts (an estimate is enough: callers adjust). */
+    monthsBetween(from: YearMonth, to: YearMonth): number;
+    daysInMonth(month: YearMonth): number | null;
+    /** The ISO-calendared date of these fields; throws RangeError when they are invalid or out of range. */
+    toDate(year: number, month: number, day: number): Temporal.PlainDate;
+}
+/** `ParseMonthCode` ordering: `M05 < M05L < M06` (grammar, not calendar data). */
+export declare function compareMonthCodes(a: string, b: string): number;
+/**
+ * `NonISODateAdd(calendar, date, duration, overflow)`. Weeks and days are ISO day arithmetic, as in
+ * the spec's final `BalanceNonISODate` + `CalendarIntegersToISO`.
+ *
+ * @returns the result as an ISO-calendared PlainDate; throws RangeError out of range or on reject
+ */
+export declare function nonIsoDateAdd(model: ArithmeticModel, date: Temporal.PlainDate, duration: DateDurationFields, overflow: ArithmeticOverflow): Temporal.PlainDate;
+/**
+ * `NonISODateUntil(calendar, one, two, largestUnit)` for `largestUnit` year or month (days and
+ * weeks are calendar-independent: callers use ISO `until`).
+ */
+export declare function nonIsoDateUntil(model: ArithmeticModel, one: Temporal.PlainDate, two: Temporal.PlainDate, largestUnit: "year" | "month"): DateDurationFields;
+/**
+ * True when `result` is exactly `NonISODateUntil(one, two, largestUnit)`: it does not surpass, its
+ * signs agree, and adding one more of each unit it could hold does surpass (so no unit is short).
+ * The per-call guard that keeps a correct polyfill answer.
+ */
+export declare function isNonIsoDateUntilResult(model: ArithmeticModel, one: Temporal.PlainDate, two: Temporal.PlainDate, largestUnit: "year" | "month", result: DateDurationFields): boolean;

package/dist/internal/temporalCompat/nonIsoArithmetic.js

@@ -0,0 +1,220 @@
+import { Temporal } from "@js-temporal/polyfill";
+const ISO_CALENDAR = "iso8601";
+/** The estimates below are off by at most one unit; a few extra steps cost nothing. */
+const MAX_ADJUSTMENTS = 4;
+/** A leap month recurs within one Metonic cycle, so a year lacking it is found within 19 years. */
+const LEAP_MONTH_SEARCH_YEARS = 19;
+const MONTH_CODE = /^M(\d{2})(L?)$/;
+const constrainedMonthCodes = new Map();
+/** `ParseMonthCode` ordering: `M05 < M05L < M06` (grammar, not calendar data). */
+export function compareMonthCodes(a, b) {
+    const matchA = MONTH_CODE.exec(a);
+    const matchB = MONTH_CODE.exec(b);
+    if (!matchA || !matchB) {
+        throw new RangeError(`Invalid month code: ${matchA ? b : a}`);
+    }
+    return (Number(matchA[1]) - Number(matchB[1]) ||
+        Number(matchA[2] === "L") - Number(matchB[2] === "L"));
+}
+/**
+ * The month code the runtime constrains a leap month code to in a year without it (Hebrew
+ * `M05L` → `M06`), read once per calendar from the polyfill at a modern year, where its constrain
+ * behaviour is correct. GMT never states the mapping itself.
+ */
+function constrainedMonthCode(calendarId, monthCode) {
+    const key = `${calendarId}/${monthCode}`;
+    const cached = constrainedMonthCodes.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const modernYear = Temporal.PlainDate.from("2000-01-01").withCalendar(calendarId).year;
+    for (let offset = 0; offset < LEAP_MONTH_SEARCH_YEARS; offset++) {
+        const fields = {
+            calendar: calendarId,
+            year: modernYear + offset,
+            monthCode,
+            day: 1,
+        };
+        try {
+            Temporal.PlainDate.from(fields, { overflow: "reject" });
+        }
+        catch (error) {
+            if (!(error instanceof RangeError)) {
+                throw error;
+            }
+            const code = Temporal.PlainDate.from(fields, {
+                overflow: "constrain",
+            }).monthCode;
+            constrainedMonthCodes.set(key, code);
+            return code;
+        }
+    }
+    throw new RangeError(`${calendarId} has ${monthCode} in every year`);
+}
+/** `ConstrainMonthCode`: the ordinal month for `monthCode` in `year`, or `null` outside the range. */
+function constrainMonthCode(model, year, monthCode, overflow) {
+    const ordinal = model.monthOrdinal(year, monthCode);
+    if (ordinal !== "missing") {
+        return ordinal;
+    }
+    if (overflow === "reject") {
+        throw new RangeError(`${model.calendarId} year ${year} has no month ${monthCode}`);
+    }
+    const constrained = model.monthOrdinal(year, constrainedMonthCode(model.calendarId, monthCode));
+    if (constrained === "missing") {
+        throw new RangeError(`${model.calendarId} year ${year} has no month for ${monthCode}`);
+    }
+    return constrained;
+}
+function compareByMonthCode(year, monthCode, day, target) {
+    return (year - target.year ||
+        compareMonthCodes(monthCode, target.monthCode) ||
+        day - target.day);
+}
+function compareByOrdinal(year, month, day, target) {
+    return year - target.year || month - target.month || day - target.day;
+}
+function requireInRange(value, what) {
+    if (value === null) {
+        throw new RangeError(`${what} is outside the representable range`);
+    }
+    return value;
+}
+/** The day of `month` regulated per `overflow`, as an ISO-calendared date (RangeError out of range). */
+function regulatedDate(model, month, day, overflow) {
+    // An unknown length means the month runs past the range limit; `day` is then either an in-range
+    // day of it or past the limit, where `toDate` throws as the spec's ISODateWithinLimits does.
+    const length = model.daysInMonth(month);
+    if (length !== null && day > length) {
+        if (overflow === "reject") {
+            throw new RangeError(`Day ${day} is past the end of ${model.calendarId} ${month.year}-${month.month}`);
+        }
+        return model.toDate(month.year, month.month, length);
+    }
+    return model.toDate(month.year, month.month, day);
+}
+/** `NonISODateAdd` steps 1–9 for years and months only, as an ISO-calendared date. */
+function addYearsAndMonths(model, from, years, months, overflow) {
+    const year = from.year + years;
+    const startMonth = requireInRange(constrainMonthCode(model, year, from.monthCode, overflow), `${model.calendarId} ${year}-${from.monthCode}`);
+    const month = requireInRange(model.addMonths({ year, month: startMonth }, months), `${model.calendarId} month ${months} after ${year}-${startMonth}`);
+    return regulatedDate(model, month, from.day, overflow);
+}
+/**
+ * `NonISODateAdd(calendar, date, duration, overflow)`. Weeks and days are ISO day arithmetic, as in
+ * the spec's final `BalanceNonISODate` + `CalendarIntegersToISO`.
+ *
+ * @returns the result as an ISO-calendared PlainDate; throws RangeError out of range or on reject
+ */
+export function nonIsoDateAdd(model, date, duration, overflow) {
+    return addYearsAndMonths(model, model.fields(date), duration.years, duration.months, overflow).add({ days: 7 * duration.weeks + duration.days });
+}
+/**
+ * `NonISODateSurpasses(calendar, sign, from, to, years, months, weeks, days)`. A month or date the
+ * model cannot place lies beyond the range in the direction of `sign`, hence past `to`.
+ */
+function nonIsoDateSurpasses(model, sign, from, to, duration) {
+    const year = from.year + duration.years;
+    if (sign * compareByMonthCode(year, from.monthCode, from.day, to) > 0) {
+        return true;
+    }
+    const startMonth = constrainMonthCode(model, year, from.monthCode, "constrain");
+    const month = startMonth === null
+        ? null
+        : model.addMonths({ year, month: startMonth }, duration.months);
+    if (month === null ||
+        sign * compareByOrdinal(month.year, month.month, from.day, to) > 0) {
+        return true;
+    }
+    if (duration.weeks === 0 && duration.days === 0) {
+        return false;
+    }
+    try {
+        const end = regulatedDate(model, month, from.day, "constrain").add({
+            days: 7 * duration.weeks + duration.days,
+        });
+        return sign * Temporal.PlainDate.compare(end, to.date) > 0;
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return true;
+        }
+        throw error;
+    }
+}
+/** The largest count (from `estimate`, toward `sign`) that does not surpass. */
+function maximizeCount(estimate, sign, surpasses) {
+    let count = sign * estimate > 0 ? estimate : 0;
+    for (let step = 0; count !== 0 && surpasses(count); step++) {
+        if (step === MAX_ADJUSTMENTS) {
+            throw new RangeError("Calendar difference estimate did not converge");
+        }
+        count -= sign;
+    }
+    for (let step = 0; !surpasses(count + sign); step++) {
+        if (step === MAX_ADJUSTMENTS) {
+            throw new RangeError("Calendar difference estimate did not converge");
+        }
+        count += sign;
+    }
+    return count;
+}
+function durationOf(years, months, days = 0) {
+    return { years, months, weeks: 0, days };
+}
+/** `NonISODateSurpasses` from `one` toward `two`, with the two dates' fields read once. */
+function surpassesBetween(model, sign, one, two) {
+    const from = model.fields(one);
+    const to = { ...model.fields(two), date: two };
+    return (duration) => nonIsoDateSurpasses(model, sign, from, to, duration);
+}
+/**
+ * `NonISODateUntil(calendar, one, two, largestUnit)` for `largestUnit` year or month (days and
+ * weeks are calendar-independent: callers use ISO `until`).
+ */
+export function nonIsoDateUntil(model, one, two, largestUnit) {
+    const sign = -Temporal.PlainDate.compare(one, two);
+    if (sign === 0) {
+        return durationOf(0, 0);
+    }
+    const from = model.fields(one);
+    const to = model.fields(two);
+    const surpasses = surpassesBetween(model, sign, one, two);
+    const years = largestUnit === "year"
+        ? maximizeCount(to.year - from.year, sign, (count) => surpasses(durationOf(count, 0)))
+        : 0;
+    const year = from.year + years;
+    const startMonth = years === 0
+        ? from.month
+        : requireInRange(constrainMonthCode(model, year, from.monthCode, "constrain"), `${model.calendarId} ${year}-${from.monthCode}`);
+    const months = maximizeCount(model.monthsBetween({ year, month: startMonth }, to), sign, (count) => surpasses(durationOf(years, count)));
+    const intermediate = addYearsAndMonths(model, from, years, months, "constrain");
+    const { days } = intermediate.until(two.withCalendar(ISO_CALENDAR), {
+        largestUnit: "days",
+    });
+    return durationOf(years, months, days);
+}
+/**
+ * True when `result` is exactly `NonISODateUntil(one, two, largestUnit)`: it does not surpass, its
+ * signs agree, and adding one more of each unit it could hold does surpass (so no unit is short).
+ * The per-call guard that keeps a correct polyfill answer.
+ */
+export function isNonIsoDateUntilResult(model, one, two, largestUnit, result) {
+    const sign = -Temporal.PlainDate.compare(one, two);
+    const { years, months, weeks, days } = result;
+    if (sign === 0) {
+        return years === 0 && months === 0 && weeks === 0 && days === 0;
+    }
+    if (weeks !== 0 ||
+        sign * years < 0 ||
+        sign * months < 0 ||
+        sign * days < 0 ||
+        (largestUnit === "month" && years !== 0)) {
+        return false;
+    }
+    const surpasses = surpassesBetween(model, sign, one, two);
+    return (!surpasses(durationOf(years, months, days)) &&
+        surpasses(durationOf(years, months, days + sign)) &&
+        surpasses(durationOf(years, months + sign)) &&
+        (largestUnit === "month" || surpasses(durationOf(years + sign, 0))));
+}

package/dist/internal/temporalCompat/readArithmeticModel.d.ts

@@ -0,0 +1,3 @@
+import type { ArithmeticModel } from "./nonIsoArithmetic.js";
+/** The read-backed arithmetic model for a Temporal calendar id (one per calendar, memoized). */
+export declare function readArithmeticModel(calendarId: string): ArithmeticModel;

package/dist/internal/temporalCompat/readArithmeticModel.js

@@ -0,0 +1,284 @@
+import { calendarDateFromFields } from "./calendarDateFromFields.js";
+import { calendarFieldsOf } from "./calendarFields.js";
+import { floorDateForFields, floorDateForFieldsBetween, isLastRepresentableDate, } from "./fieldSearch.js";
+import { addManyMonths, countManyMonths, isLargeMonthSpan, isLargeYearSpan, } from "./largeMonthSpan.js";
+/*
+ * The integer month questions `nonIsoArithmetic.ts` asks, answered without any calendar rule:
+ * - reads through `calendarFieldsOf` (correct for every in-range date),
+ * - fields → ISO through `calendarDateFromFields` (the polyfill, or the field search near a limit),
+ * - polyfill month arithmetic between **day-1** dates, which never constrains a day and so is
+ *   correct in 0.5.1 wherever it does not throw (spec §3.5).
+ *
+ * The polyfill throws within about a year of a range limit (D1). There, months are stepped one at
+ * a time from the field search, and the polyfill only counts or jumps between month starts away
+ * from the limit.
+ */
+const ISO_CALENDAR = "iso8601";
+const LAST = Number.MAX_SAFE_INTEGER;
+/** Days searched past a month's first day for its last day: more than any calendar month has. */
+const MONTH_SEARCH_DAYS = 64;
+/**
+ * Months stepped one at a time next to a limit. The polyfill's D1 windows reach at most 357 days
+ * from a limit (persian at the minimum, CORE-6 spec §1.3), which 14 months always clear.
+ */
+const EDGE_WALK_MONTHS = 14;
+const JUMP_BACKOFF_MONTHS = [
+    EDGE_WALK_MONTHS,
+    2 * EDGE_WALK_MONTHS,
+    3 * EDGE_WALK_MONTHS,
+];
+const CACHE_LIMIT = 1024;
+const MONTH_CODE = /^M(\d{2})(L?)$/;
+const models = new Map();
+const lastMonths = new Map();
+function compareYearMonths(a, b) {
+    return a.year - b.year || a.month - b.month;
+}
+function unlessRangeError(run) {
+    try {
+        return run();
+    }
+    catch (error) {
+        if (error instanceof RangeError) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function requireMonth(month) {
+    if (month === null) {
+        throw new RangeError("Month is outside the representable range");
+    }
+    return month;
+}
+/** Day 1 of `month`, calendared; undefined when it does not exist or lies outside the range. */
+function monthStart(calendarId, month) {
+    return unlessRangeError(() => calendarDateFromFields(calendarId, { year: month.year, month: month.month, day: 1 }, "reject"));
+}
+/** The last ordinal month of `year`, or null when no day of that year is representable. */
+function lastMonthOf(calendarId, year) {
+    const key = `${calendarId}/${year}`;
+    const cached = lastMonths.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const floor = floorDateForFields(calendarId, {
+        year,
+        month: LAST,
+        day: LAST,
+    });
+    const read = floor === null ? null : calendarFieldsOf(floor, calendarId);
+    const result = floor !== null && read?.year === year
+        ? { month: read.month, complete: !isLastRepresentableDate(floor) }
+        : null;
+    if (lastMonths.size >= CACHE_LIMIT) {
+        lastMonths.clear();
+    }
+    lastMonths.set(key, result);
+    return result;
+}
+function stepMonth(calendarId, month, sign) {
+    if (sign < 0) {
+        if (month.month > 1) {
+            return { year: month.year, month: month.month - 1 };
+        }
+        const previous = lastMonthOf(calendarId, month.year - 1);
+        return previous === null
+            ? null
+            : { year: month.year - 1, month: previous.month };
+    }
+    const last = lastMonthOf(calendarId, month.year);
+    if (last === null) {
+        return null;
+    }
+    if (month.month < last.month) {
+        return { year: month.year, month: month.month + 1 };
+    }
+    return last.complete ? { year: month.year + 1, month: 1 } : null;
+}
+function walkMonths(calendarId, start, months) {
+    const sign = Math.sign(months);
+    let current = start;
+    for (let step = 0; current !== null && step < Math.abs(months); step++) {
+        current = stepMonth(calendarId, current, sign);
+    }
+    return current;
+}
+function polyfillAddMonths(calendarId, start, months) {
+    const origin = monthStart(calendarId, start);
+    if (origin === undefined) {
+        return undefined;
+    }
+    const moved = unlessRangeError(() => calendarFieldsOf(origin.add({ months }), calendarId));
+    return moved?.day === 1
+        ? { year: moved.year, month: moved.month }
+        : undefined;
+}
+function addMonths(calendarId, start, months) {
+    if (months === 0) {
+        return start;
+    }
+    if (isLargeMonthSpan(months)) {
+        // D9: jump whole years instead of the polyfill's month-by-month loop.
+        return addManyMonths(calendarId, start, months, (from, count) => addMonths(calendarId, from, count), (from, to) => monthsBetween(calendarId, from, to));
+    }
+    const jumped = polyfillAddMonths(calendarId, start, months);
+    if (jumped !== undefined) {
+        return jumped;
+    }
+    return addMonthsNearLimit(calendarId, start, months);
+}
+/**
+ * Near a limit: leave a month that begins before the range, jump to a month start short of the
+ * limit, and step the rest.
+ */
+function addMonthsNearLimit(calendarId, start, months) {
+    const sign = Math.sign(months);
+    let origin = start;
+    let remaining = months;
+    if (monthStart(calendarId, origin) === undefined) {
+        origin = stepMonth(calendarId, origin, sign);
+        remaining -= sign;
+        if (origin === null || remaining === 0) {
+            return origin;
+        }
+    }
+    for (const backoff of JUMP_BACKOFF_MONTHS) {
+        if (Math.abs(remaining) <= backoff) {
+            return walkMonths(calendarId, origin, remaining);
+        }
+        const anchor = polyfillAddMonths(calendarId, origin, remaining - sign * backoff);
+        if (anchor !== undefined) {
+            return walkMonths(calendarId, anchor, sign * backoff);
+        }
+    }
+    throw new RangeError(`Cannot add ${months} months to ${calendarId} ${start.year}-${start.month}`);
+}
+function polyfillMonthsBetween(calendarId, from, to) {
+    const start = monthStart(calendarId, from);
+    const end = monthStart(calendarId, to);
+    if (start === undefined || end === undefined) {
+        return undefined;
+    }
+    return unlessRangeError(() => start.until(end, { largestUnit: "months" }).months);
+}
+function monthsBetween(calendarId, from, to) {
+    const sign = Math.sign(compareYearMonths(to, from));
+    if (sign === 0) {
+        return 0;
+    }
+    if (isLargeYearSpan(from.year, to.year)) {
+        // D9: count whole years instead of the polyfill's month-by-month loop.
+        return countManyMonths(calendarId, from, to, (one, two) => monthsBetween(calendarId, one, two));
+    }
+    const direct = polyfillMonthsBetween(calendarId, from, to);
+    if (direct !== undefined) {
+        return direct;
+    }
+    return monthsBetweenNearLimit(calendarId, from, to, sign);
+}
+/**
+ * Near a limit: count the months at each end one at a time, and let the polyfill count between
+ * the month starts left in the middle.
+ */
+function monthsBetweenNearLimit(calendarId, from, to, sign) {
+    let low = from;
+    let high = to;
+    let count = 0;
+    for (let step = 0; step < EDGE_WALK_MONTHS && compareYearMonths(low, high) !== 0; step++) {
+        low = requireMonth(stepMonth(calendarId, low, sign));
+        count += sign;
+    }
+    for (let step = 0; step < EDGE_WALK_MONTHS && compareYearMonths(low, high) !== 0; step++) {
+        high = requireMonth(stepMonth(calendarId, high, -sign));
+        count += sign;
+    }
+    if (compareYearMonths(low, high) === 0) {
+        return count;
+    }
+    const middle = polyfillMonthsBetween(calendarId, low, high);
+    if (middle === undefined) {
+        throw new RangeError(`Cannot count ${calendarId} months from ${from.year}-${from.month} to ${to.year}-${to.month}`);
+    }
+    return count + middle;
+}
+/**
+ * The latest in-range date at or before the last day of `month`: searched in a window after the
+ * month's first day when that day is readable, with a read-back that the next day starts a new
+ * month (otherwise, and when day 1 is not readable, over the whole range).
+ */
+function lastDayFloor(calendarId, month) {
+    const target = { year: month.year, month: month.month, day: LAST };
+    const start = monthStart(calendarId, month);
+    const windowed = start === undefined
+        ? null
+        : floorDateForFieldsBetween(calendarId, target, start, MONTH_SEARCH_DAYS);
+    if (windowed !== null &&
+        (isLastRepresentableDate(windowed) ||
+            calendarFieldsOf(windowed.add({ days: 1 }), calendarId).month !==
+                month.month)) {
+        return windowed;
+    }
+    return floorDateForFields(calendarId, target);
+}
+function daysInMonth(calendarId, month) {
+    const floor = lastDayFloor(calendarId, month);
+    if (floor === null || isLastRepresentableDate(floor)) {
+        return null;
+    }
+    const read = calendarFieldsOf(floor, calendarId);
+    return read.year === month.year && read.month === month.month
+        ? read.day
+        : null;
+}
+/** The month code of `month`, or undefined when no day of it can be read. */
+function monthCodeAt(calendarId, month) {
+    const start = monthStart(calendarId, month);
+    if (start !== undefined) {
+        return calendarFieldsOf(start, calendarId).monthCode;
+    }
+    const floor = floorDateForFields(calendarId, { ...month, day: LAST });
+    const read = floor === null ? null : calendarFieldsOf(floor, calendarId);
+    return read?.year === month.year && read.month === month.month
+        ? read.monthCode
+        : undefined;
+}
+/**
+ * The ordinal of `monthCode` in `year`. By the month code grammar a code's ordinal is its number,
+ * or one more when a leap month precedes it in that year, and a leap code `MxxL` directly follows
+ * `Mxx` (the proposal allows at most one leap month per year). Both candidates are read back.
+ */
+function monthOrdinal(calendarId, year, monthCode) {
+    const match = MONTH_CODE.exec(monthCode);
+    if (!match) {
+        throw new RangeError(`Invalid month code: ${monthCode}`);
+    }
+    const number = Number(match[1]);
+    const candidates = match[2] === "L" ? [number + 1] : [number, number + 1];
+    let unreadable = false;
+    for (const ordinal of candidates) {
+        const code = monthCodeAt(calendarId, { year, month: ordinal });
+        if (code === monthCode) {
+            return ordinal;
+        }
+        unreadable ||= code === undefined;
+    }
+    return unreadable ? null : "missing";
+}
+/** The read-backed arithmetic model for a Temporal calendar id (one per calendar, memoized). */
+export function readArithmeticModel(calendarId) {
+    let model = models.get(calendarId);
+    if (model === undefined) {
+        model = {
+            calendarId,
+            fields: (date) => calendarFieldsOf(date, calendarId),
+            monthOrdinal: (year, monthCode) => monthOrdinal(calendarId, year, monthCode),
+            addMonths: (start, months) => addMonths(calendarId, start, months),
+            monthsBetween: (from, to) => monthsBetween(calendarId, from, to),
+            daysInMonth: (month) => daysInMonth(calendarId, month),
+            toDate: (year, month, day) => calendarDateFromFields(calendarId, { year, month, day }, "reject").withCalendar(ISO_CALENDAR),
+        };
+        models.set(calendarId, model);
+    }
+    return model;
+}

package/dist/internal/temporalCompat/repros.d.ts

@@ -0,0 +1,31 @@
+/** Defect ids from the CORE-6 calendar-correctness spec §1.2. */
+export type DefectId = "D1" | "D2" | "D3" | "D4" | "D5" | "D6" | "D7" | "D8" | "D10" | "D11";
+/**
+ * Zoned defects worked around in `internal/zonedWallClock*`: the range-limit defects (upstream
+ * issue drafts A, B and D in the CORE-6 polyfill research) and zoned.E, the transition search
+ * floored at 1847-01-01 (js-temporal/temporal-polyfill#372). Canary-only: no capability probe
+ * gates them, because those fallbacks already run only when the polyfill throws, returns an
+ * unchecked UTC value, or (zoned.E) is asked about an instant before 1847, where GMT computes the
+ * spec's answer from offsets.
+ */
+export type ZonedDefectId = "zoned.A" | "zoned.B" | "zoned.D" | "zoned.E";
+/**
+ * D9: non-ISO months added and counted one month at a time (`largeMonthSpan.ts`). Canary-only: no
+ * capability probe gates it, because a probe large enough to show the cost would be the abort
+ * itself, and timing is not deterministic. The workaround runs only for amounts of at least
+ * `LARGE_MONTH_SPAN` months and computes the spec's answer, so it changes no output either way.
+ */
+export type BoundedWorkDefectId = "D9";
+export interface Repro {
+    defect: DefectId | ZonedDefectId | BoundedWorkDefectId;
+    /** Temporal calendar id the repro exercises. */
+    calendar: string;
+    /** Short name, unique per defect and calendar. */
+    name: string;
+    /** The spec-correct output of `run()`. */
+    expected: string;
+    run: () => string;
+}
+export declare const repros: readonly Repro[];
+/** The repro with this defect, calendar and name, if any. */
+export declare function findRepro(defect: DefectId | ZonedDefectId | BoundedWorkDefectId, calendar: string, name: string): Repro | undefined;