@northguild/gmt 1.15.0 → 1.16.0

package/dist/internal/temporalCompat/calendarDateArithmetic.js

@@ -0,0 +1,199 @@
+import { calendarFieldsOf, hasReadCorrection } from "./calendarFields.js";
+import { isDefectPresent } from "./capabilities.js";
+import { hebrewArithmeticModel } from "./hebrewArithmetic.js";
+import { indianArithmeticModel } from "./indianArithmetic.js";
+import { isLargeMonthSpan, isLargeYearSpan } from "./largeMonthSpan.js";
+import { isNonIsoDateUntilResult, nonIsoDateAdd, nonIsoDateUntil, } from "./nonIsoArithmetic.js";
+import { readArithmeticModel } from "./readArithmeticModel.js";
+const ISO_CALENDAR = "iso8601";
+const DATE_UNITS = new Set([
+    "year",
+    "month",
+    "week",
+    "day",
+]);
+/**
+ * The owned Hebrew and Indian arithmetic answers whenever an operation's years come within this
+ * many years of the corrected range, so that no step of it (a Surpasses candidate overshoots by at
+ * most one unit) reaches the runtime's wrong reads or arithmetic.
+ */
+const CORRECTED_RANGE_MARGIN_YEARS = 2;
+const ownedModels = {
+    hebrew: hebrewArithmeticModel,
+    indian: indianArithmeticModel,
+};
+function fieldsOf(duration) {
+    return {
+        years: duration.years,
+        months: duration.months,
+        weeks: duration.weeks,
+        days: duration.days,
+    };
+}
+/**
+ * D2: while buddhist reads are corrected, buddhist arithmetic is ISO arithmetic. The Intl
+ * era/monthCode proposal makes buddhist month numbers, month codes and days identical to ISO 8601
+ * with year = ISO year + 543, so NonISODateAdd/Until give exactly the ISO results.
+ */
+function usesIsoArithmetic(calendarId) {
+    return (calendarId === "buddhist" &&
+        hasReadCorrection(calendarId, Number.NEGATIVE_INFINITY));
+}
+/** The owned model for `calendarId` when its read correction is active in this runtime. */
+function activeOwnedModel(calendarId) {
+    const model = ownedModels[calendarId];
+    return model !== undefined &&
+        hasReadCorrection(calendarId, Number.NEGATIVE_INFINITY)
+        ? model
+        : undefined;
+}
+function reachesCorrectedRange(calendarId, years) {
+    return hasReadCorrection(calendarId, Math.min(...years) - CORRECTED_RANGE_MARGIN_YEARS);
+}
+function untilWorkaroundNeeded(calendarId) {
+    return (isDefectPresent("D1", calendarId) ||
+        isDefectPresent("D10", calendarId) ||
+        isDefectPresent("D6", calendarId) ||
+        isDefectPresent("D7", calendarId));
+}
+function verifiedPolyfillUntil(one, two, largestUnit) {
+    const calendarId = one.calendarId;
+    if (largestUnit === "month" &&
+        isLargeYearSpan(calendarFieldsOf(one, calendarId).year, calendarFieldsOf(two, calendarId).year)) {
+        // D9: the polyfill counts months one at a time; the spec loops count whole years instead.
+        return nonIsoDateUntil(readArithmeticModel(calendarId), one, two, largestUnit);
+    }
+    let result;
+    try {
+        result = fieldsOf(one.until(two, { largestUnit }));
+    }
+    catch (error) {
+        // Any throw but a RangeError is a polyfill defect, not a spec answer (an assertion from a
+        // #3292 port without the tc39/proposal-temporal#3329 fix): the spec algorithm answers.
+        if (error instanceof RangeError && !untilWorkaroundNeeded(calendarId)) {
+            throw error;
+        }
+        return nonIsoDateUntil(readArithmeticModel(calendarId), one, two, largestUnit);
+    }
+    if (!isDefectPresent("D6", calendarId) &&
+        !isDefectPresent("D7", calendarId)) {
+        return result;
+    }
+    const model = readArithmeticModel(calendarId);
+    return isNonIsoDateUntilResult(model, one, two, largestUnit, result)
+        ? result
+        : nonIsoDateUntil(model, one, two, largestUnit);
+}
+/**
+ * `one.until(two, { largestUnit })`'s date fields, made correct where `@js-temporal/polyfill` is not
+ * (TC39 `CalendarDateUntil`, Intl era/monthCode proposal `NonISODateUntil`). Both dates must carry
+ * the same calendar.
+ *
+ * - `iso8601` is the polyfill's own `until`, untouched.
+ * - `"day"` / `"week"` are ISO `until`: days do not depend on the calendar.
+ * - D6/D7: the polyfill answers first; while its probe fails, the answer is kept only when it is
+ *   exactly the spec's (`isNonIsoDateUntilResult`), otherwise the spec loops recompute it.
+ * - D1: a polyfill RangeError near a range limit is answered by the spec loops.
+ * - D2/D3/D4/D5: in a corrected range the spec loops run over ISO (buddhist) or the owned Hebrew
+ *   and Indian arithmetic.
+ * - D9: months counted across `LARGE_MONTH_SPAN` months or more run the spec loops, whose month
+ *   counts are bounded.
+ */
+export function calendarDateUntil(one, two, largestUnit) {
+    const calendarId = one.calendarId;
+    if (calendarId === ISO_CALENDAR) {
+        return fieldsOf(one.until(two, { largestUnit }));
+    }
+    if (!DATE_UNITS.has(largestUnit)) {
+        throw new RangeError(`${String(largestUnit)} is not a date unit`);
+    }
+    if (largestUnit === "week" ||
+        largestUnit === "day" ||
+        usesIsoArithmetic(calendarId)) {
+        return fieldsOf(one
+            .withCalendar(ISO_CALENDAR)
+            .until(two.withCalendar(ISO_CALENDAR), { largestUnit }));
+    }
+    const owned = activeOwnedModel(calendarId);
+    if (owned !== undefined &&
+        reachesCorrectedRange(calendarId, [
+            owned.fields(one).year,
+            owned.fields(two).year,
+        ])) {
+        return nonIsoDateUntil(owned, one, two, largestUnit);
+    }
+    return verifiedPolyfillUntil(one, two, largestUnit);
+}
+/**
+ * The owned (Hebrew, Indian) model's sum, when `date`'s calendar has an active owned model and
+ * either end reaches the corrected range; otherwise undefined, and the polyfill answers.
+ */
+function ownedDateAdd(date, fields, overflow) {
+    const calendarId = date.calendarId;
+    const owned = activeOwnedModel(calendarId);
+    if (owned === undefined) {
+        return undefined;
+    }
+    // Owned arithmetic is the spec's for every year, so its RangeErrors stand; its result is kept
+    // when either end reaches the corrected range, and the polyfill answers elsewhere.
+    const result = nonIsoDateAdd(owned, date, fields, overflow);
+    return reachesCorrectedRange(calendarId, [
+        owned.fields(date).year,
+        owned.fields(result).year,
+    ])
+        ? result.withCalendar(calendarId)
+        : undefined;
+}
+/**
+ * `date.add(duration, { overflow })`, made correct where `@js-temporal/polyfill` is not (TC39
+ * `CalendarDateAdd`, Intl era/monthCode proposal `NonISODateAdd`).
+ *
+ * - `iso8601` is the polyfill's own `add`, untouched.
+ * - Weeks and days alone are ISO day arithmetic.
+ * - D1: a polyfill RangeError near a range limit is answered by the spec algorithm.
+ * - D2/D3/D4/D5: in a corrected range the spec algorithm runs over ISO (buddhist) or the owned
+ *   Hebrew and Indian arithmetic.
+ * - D9: `LARGE_MONTH_SPAN` months or more run the spec algorithm, whose month jumps are bounded.
+ *
+ * @returns a PlainDate in `date`'s calendar; throws RangeError out of range or on `reject`
+ */
+export function calendarDateAdd(date, duration, overflow) {
+    const calendarId = date.calendarId;
+    if (calendarId === ISO_CALENDAR) {
+        return date.add(duration, { overflow });
+    }
+    const fields = {
+        years: duration.years ?? 0,
+        months: duration.months ?? 0,
+        weeks: duration.weeks ?? 0,
+        days: duration.days ?? 0,
+    };
+    if ((fields.years === 0 && fields.months === 0) ||
+        usesIsoArithmetic(calendarId)) {
+        return date
+            .withCalendar(ISO_CALENDAR)
+            .add(fields, { overflow })
+            .withCalendar(calendarId);
+    }
+    const ownedResult = ownedDateAdd(date, fields, overflow);
+    if (ownedResult !== undefined) {
+        return ownedResult;
+    }
+    if (isLargeMonthSpan(fields.months)) {
+        // D9: the polyfill adds months one at a time; the spec algorithm jumps whole years instead.
+        return nonIsoDateAdd(readArithmeticModel(calendarId), date, fields, overflow).withCalendar(calendarId);
+    }
+    try {
+        return date.add(fields, { overflow });
+    }
+    catch (error) {
+        // As in verifiedPolyfillUntil: a throw that is not a RangeError (tc39/proposal-temporal#3329)
+        // always takes the spec algorithm, which throws the RangeError itself for an out-of-range sum.
+        if (error instanceof RangeError &&
+            !isDefectPresent("D1", calendarId) &&
+            !isDefectPresent("D10", calendarId)) {
+            throw error;
+        }
+        return nonIsoDateAdd(readArithmeticModel(calendarId), date, fields, overflow).withCalendar(calendarId);
+    }
+}

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

@@ -0,0 +1,36 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { type FieldKey } from "./fieldSearch.js";
+export type CalendarDateFields = FieldKey | {
+    era: string;
+    eraYear: number;
+    month: number;
+    day: number;
+};
+/**
+ * `Temporal.PlainDate.from({ ...fields, calendar: calendarId }, { overflow: "reject" })`, made
+ * correct where `@js-temporal/polyfill` is not.
+ *
+ * The polyfill answers first, and its result is kept whenever its fields read back unchanged
+ * through `calendarFieldsOf`. Only when it throws or reads back differently, for a defect the
+ * installed runtime has (probed once per calendar) and inside that defect's range, does the
+ * read-only field search answer instead:
+ *
+ * - **D1:** the polyfill's `calendarToIsoDate` probes outside the legacy `Date` range within about
+ *   a year of both limits and throws `Invalid ISO date` (hebrew, buddhist, islamic-*, persian,
+ *   indian). Retired by a js-temporal release porting proposal-temporal `a41eb67` + `af0cb4b`.
+ * - **D2, D3, D4, D5:** the runtime's own reads are wrong (buddhist before 1582-10-15, Hebrew years
+ *   <= 0, Indian before ISO year 1), so its fields → ISO is too; the search runs over the
+ *   corrected reads. Retired with the read corrections in `calendarFields.ts`.
+ * - **D8:** era codes that only the pre-proposal polyfill accepts (`japanese-inverse`) are
+ *   rejected, as a fixed runtime rejects them.
+ * - **D10:** a polyfill porting proposal-temporal #3292 without the tc39/proposal-temporal#3329 fix
+ *   skips a 5- or 6-day month 13 (ethioaa, and so coptic and ethiopic) in far years. While its
+ *   probe fails, every year searches. Any throw other than a `RangeError` also searches, whatever
+ *   the probes say.
+ *
+ * Era input is never searched: only "japanese" uses eras here, and it has no D1 window.
+ *
+ * @returns a PlainDate calendared as `calendarId`; throws RangeError for fields that do not name
+ *   an in-range date
+ */
+export declare function calendarDateFromFields(calendarId: string, fields: CalendarDateFields, overflow: "reject"): Temporal.PlainDate;

package/dist/internal/temporalCompat/calendarDateFromFields.js

@@ -0,0 +1,120 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { calendarFieldsOf, hasReadCorrection } from "./calendarFields.js";
+import { isDefectPresent } from "./capabilities.js";
+import { isoForFields } from "./fieldSearch.js";
+/** Era codes polyfill 0.5.1 accepts that the Intl era/monthCode proposal does not (D8). */
+const PRE_PROPOSAL_ERAS = new Set(["japanese-inverse"]);
+const edgeYearsCache = new Map();
+function readYear(iso, calendarId) {
+    try {
+        return calendarFieldsOf(Temporal.PlainDate.from(iso), calendarId).year;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The calendar years of the TC39 PlainDate limits in `calendarId`. */
+function edgeYears(calendarId) {
+    let years = edgeYearsCache.get(calendarId);
+    if (years === undefined) {
+        years = {
+            min: readYear("-271821-04-19", calendarId),
+            max: readYear("+275760-09-13", calendarId),
+        };
+        edgeYearsCache.set(calendarId, years);
+    }
+    return years;
+}
+/**
+ * D1 per-call guard: the polyfill's fields → ISO bisection overshoots only within about a year of
+ * a range limit (at most 357 days in the scans), so only years next to an edge year need the search.
+ */
+function isNearEdgeYear(calendarId, year) {
+    const { min, max } = edgeYears(calendarId);
+    return ((min !== undefined && year <= min + 1) ||
+        (max !== undefined && year >= max - 1));
+}
+function needsFieldSearch(calendarId, year) {
+    return (hasReadCorrection(calendarId, year) ||
+        (isDefectPresent("D1", calendarId) && isNearEdgeYear(calendarId, year)) ||
+        isDefectPresent("D10", calendarId));
+}
+/**
+ * True when the polyfill failed with anything but the `RangeError` Temporal specifies for fields
+ * that name no date: an internal assertion (tc39/proposal-temporal#3329, a port of #3292 without
+ * its fix) or a `TypeError` from a broken read. The field search then answers, as the spec would,
+ * rather than the public wrapper turning the throw into its sentinel.
+ */
+function isPolyfillDefectError(error) {
+    return error !== undefined && !(error instanceof RangeError);
+}
+function readBackMatches(date, calendarId, fields) {
+    if ("era" in fields) {
+        // An era year outside its era's span resolves arithmetically (e.g. heisei 40 is 2028), so
+        // it legitimately reads back under another era. With overflow "reject", month and day are
+        // already validated by the polyfill.
+        return true;
+    }
+    const read = calendarFieldsOf(date, calendarId);
+    return (read.year === fields.year &&
+        read.month === fields.month &&
+        read.day === fields.day);
+}
+function rejectPreProposalEra(calendarId, fields) {
+    if ("era" in fields &&
+        PRE_PROPOSAL_ERAS.has(fields.era) &&
+        isDefectPresent("D8", calendarId)) {
+        throw new RangeError(`Unknown ${calendarId} era: ${fields.era}`);
+    }
+}
+/**
+ * `Temporal.PlainDate.from({ ...fields, calendar: calendarId }, { overflow: "reject" })`, made
+ * correct where `@js-temporal/polyfill` is not.
+ *
+ * The polyfill answers first, and its result is kept whenever its fields read back unchanged
+ * through `calendarFieldsOf`. Only when it throws or reads back differently, for a defect the
+ * installed runtime has (probed once per calendar) and inside that defect's range, does the
+ * read-only field search answer instead:
+ *
+ * - **D1:** the polyfill's `calendarToIsoDate` probes outside the legacy `Date` range within about
+ *   a year of both limits and throws `Invalid ISO date` (hebrew, buddhist, islamic-*, persian,
+ *   indian). Retired by a js-temporal release porting proposal-temporal `a41eb67` + `af0cb4b`.
+ * - **D2, D3, D4, D5:** the runtime's own reads are wrong (buddhist before 1582-10-15, Hebrew years
+ *   <= 0, Indian before ISO year 1), so its fields → ISO is too; the search runs over the
+ *   corrected reads. Retired with the read corrections in `calendarFields.ts`.
+ * - **D8:** era codes that only the pre-proposal polyfill accepts (`japanese-inverse`) are
+ *   rejected, as a fixed runtime rejects them.
+ * - **D10:** a polyfill porting proposal-temporal #3292 without the tc39/proposal-temporal#3329 fix
+ *   skips a 5- or 6-day month 13 (ethioaa, and so coptic and ethiopic) in far years. While its
+ *   probe fails, every year searches. Any throw other than a `RangeError` also searches, whatever
+ *   the probes say.
+ *
+ * Era input is never searched: only "japanese" uses eras here, and it has no D1 window.
+ *
+ * @returns a PlainDate calendared as `calendarId`; throws RangeError for fields that do not name
+ *   an in-range date
+ */
+export function calendarDateFromFields(calendarId, fields, overflow) {
+    rejectPreProposalEra(calendarId, fields);
+    let polyfillError;
+    try {
+        const result = Temporal.PlainDate.from({ ...fields, calendar: calendarId }, { overflow });
+        if (readBackMatches(result, calendarId, fields)) {
+            return result;
+        }
+    }
+    catch (error) {
+        polyfillError = error;
+    }
+    if ("era" in fields ||
+        !(isPolyfillDefectError(polyfillError) ||
+            needsFieldSearch(calendarId, fields.year))) {
+        throw (polyfillError ??
+            new RangeError(`${calendarId} fields do not read back unchanged`));
+    }
+    const iso = isoForFields(calendarId, fields);
+    if (iso === null) {
+        throw new RangeError(`No in-range ${calendarId} date ${fields.year}-${fields.month}-${fields.day}`);
+    }
+    return iso.withCalendar(calendarId);
+}

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

@@ -0,0 +1,25 @@
+import type { Temporal } from "@js-temporal/polyfill";
+/** A date's fields in one calendar. `month` is ordinal (Hebrew leap year: `M05L` is 6). */
+export interface CalendarFields {
+    year: number;
+    month: number;
+    monthCode: string;
+    day: number;
+    /** As the runtime reads it; corrected only for "japanese", the one calendar GMT tags with an era. */
+    era: string | undefined;
+    eraYear: number | undefined;
+}
+/**
+ * The fields of `date` in the Temporal calendar `calendarId`. Every calendar-field read in GMT's
+ * calendar string formatters and in the field search goes through here, so the runtime's read is
+ * corrected in one place, and only where a capability probe shows the runtime is wrong (D2, D3,
+ * D4, D5, D8 in README.md). Otherwise this is exactly `date.withCalendar(calendarId)`'s fields.
+ */
+export declare function calendarFieldsOf(date: Temporal.PlainDate, calendarId: string): CalendarFields;
+/**
+ * True when reads of `calendarYear` in `calendarId` are corrected in this runtime, so the
+ * polyfill's own fields → ISO conversion for that year cannot be trusted either. The year ranges
+ * are supersets of each defect's reach: Hebrew years <= 0 hold every D3/D4 date, and every ISO
+ * date before year 1 lies in a Saka year whose Chaitra 1 falls in a Gregorian year <= 0.
+ */
+export declare function hasReadCorrection(calendarId: string, calendarYear: number): boolean;

package/dist/internal/temporalCompat/calendarFields.js

@@ -0,0 +1,131 @@
+import { isDefectPresent } from "./capabilities.js";
+import { fixedFromIso } from "./fixedDay.js";
+import { hebrewFieldsFromFixed, hebrewNewYear } from "./hebrewArithmetic.js";
+import { indianFieldsFromIso, SAKA_YEAR_OFFSET } from "./indianArithmetic.js";
+/**
+ * Buddhist year = ISO year + 543 for every date, month and day identical to ISO: the Intl
+ * era/monthCode proposal's calendar table (era `be`, epoch year -543), test262
+ * extreme-dates.js and add/proleptic-buddhist.js.
+ */
+const BUDDHIST_YEAR_OFFSET = 543;
+/** The first Meiji era year in the proposal's era table; earlier dates are `ce`. */
+const FIRST_MEIJI_ERA_YEAR = 6;
+function runtimeRead(date, calendarId) {
+    const read = date.withCalendar(calendarId);
+    return {
+        year: read.year,
+        month: read.month,
+        monthCode: read.monthCode,
+        day: read.day,
+        era: read.era,
+        eraYear: read.eraYear,
+    };
+}
+function isoFields(date) {
+    return date.withCalendar("iso8601");
+}
+function hebrewCorrectionActive() {
+    return isDefectPresent("D3", "hebrew") || isDefectPresent("D4", "hebrew");
+}
+/**
+ * D2: polyfill 0.5.1 reads buddhist through ICU4C's Julian/Gregorian hybrid, wrong for every
+ * date before 1582-10-15. Retired by a js-temporal release containing 2bb6ba1.
+ */
+function buddhistFields(date) {
+    if (!isDefectPresent("D2", "buddhist")) {
+        return runtimeRead(date, "buddhist");
+    }
+    const iso = isoFields(date);
+    return {
+        year: iso.year + BUDDHIST_YEAR_OFFSET,
+        month: iso.month,
+        monthCode: iso.monthCode,
+        day: iso.day,
+        era: undefined,
+        eraYear: undefined,
+    };
+}
+/** D3 + D4: Hebrew years <= 0 (see hebrewArithmetic.ts). */
+function hebrewFields(date) {
+    const iso = isoFields(date);
+    const fixed = fixedFromIso(iso.year, iso.month, iso.day);
+    if (fixed >= hebrewNewYear(1) || !hebrewCorrectionActive()) {
+        return runtimeRead(date, "hebrew");
+    }
+    return {
+        ...hebrewFieldsFromFixed(fixed),
+        era: undefined,
+        eraYear: undefined,
+    };
+}
+/** D5: Indian dates before ISO year 1 (see indianArithmetic.ts). */
+function indianFields(date) {
+    const iso = isoFields(date);
+    if (iso.year >= 1 || !isDefectPresent("D5", "indian")) {
+        return runtimeRead(date, "indian");
+    }
+    return {
+        ...indianFieldsFromIso(iso.year, iso.month, iso.day),
+        era: undefined,
+        eraYear: undefined,
+    };
+}
+/**
+ * D8: polyfill 0.5.1 predates the Intl era/monthCode proposal's era codes. It reads `japanese`
+ * where the proposal has `ce`, `japanese-inverse` for `bce`, and starts `meiji` at year 1 in
+ * 1868, where the proposal keeps `ce` through 1872-12-31 and starts `meiji` at year 6. Retired by
+ * a js-temporal release containing 2bb6ba1.
+ */
+function japaneseFields(date) {
+    const read = runtimeRead(date, "japanese");
+    if (!isDefectPresent("D8", "japanese")) {
+        return read;
+    }
+    if (read.era === "japanese-inverse") {
+        return { ...read, era: "bce", eraYear: 1 - read.year };
+    }
+    if (read.era === "japanese" ||
+        (read.era === "meiji" && (read.eraYear ?? 0) < FIRST_MEIJI_ERA_YEAR)) {
+        return { ...read, era: "ce", eraYear: read.year };
+    }
+    return read;
+}
+/**
+ * The fields of `date` in the Temporal calendar `calendarId`. Every calendar-field read in GMT's
+ * calendar string formatters and in the field search goes through here, so the runtime's read is
+ * corrected in one place, and only where a capability probe shows the runtime is wrong (D2, D3,
+ * D4, D5, D8 in README.md). Otherwise this is exactly `date.withCalendar(calendarId)`'s fields.
+ */
+export function calendarFieldsOf(date, calendarId) {
+    switch (calendarId) {
+        case "buddhist":
+            return buddhistFields(date);
+        case "hebrew":
+            return hebrewFields(date);
+        case "indian":
+            return indianFields(date);
+        case "japanese":
+            return japaneseFields(date);
+        default:
+            return runtimeRead(date, calendarId);
+    }
+}
+/**
+ * True when reads of `calendarYear` in `calendarId` are corrected in this runtime, so the
+ * polyfill's own fields → ISO conversion for that year cannot be trusted either. The year ranges
+ * are supersets of each defect's reach: Hebrew years <= 0 hold every D3/D4 date, and every ISO
+ * date before year 1 lies in a Saka year whose Chaitra 1 falls in a Gregorian year <= 0.
+ */
+export function hasReadCorrection(calendarId, calendarYear) {
+    switch (calendarId) {
+        case "buddhist":
+            return isDefectPresent("D2", calendarId);
+        case "hebrew":
+            return calendarYear <= 0 && hebrewCorrectionActive();
+        case "indian":
+            return (calendarYear + SAKA_YEAR_OFFSET <= 0 &&
+                isDefectPresent("D5", calendarId));
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,28 @@
+import { type DefectId, type Repro } from "./repros.js";
+/** The repro's output, or `ERR <name>: <message>` when it throws. */
+export declare function runRepro(repro: Pick<Repro, "run">): string;
+/** True when a repro's output is the spec-correct value, i.e. the installed runtime is fixed. */
+export declare function reproPasses(repro: Pick<Repro, "expected">, output: string): boolean;
+/**
+ * True when any repro for this defect and Temporal calendar id fails in the installed runtime.
+ * A calendar with no repro for the defect is not affected by it.
+ */
+export declare function isDefectPresent(defect: DefectId, calendar: string): boolean;
+/**
+ * True when this runtime never retries the calendar nudge window (defect D11).
+ *
+ * TC39 bounds a duration between `relativeTo + r1 units` and `relativeTo + r2 units`, and recomputes
+ * the window one unit further along when the target falls outside it. A runtime that computes the
+ * window once answers `Duration#total`, `Duration#round` and `until`/`since` with a calendar
+ * `smallestUnit` over the wrong bounds. Only a `relativeTo` on the 29th, 30th or 31st can reach it,
+ * because only there does adding a month constrain the day. ISO-only: the non-ISO calendars already
+ * take the spec path through `isCalendarArithmeticCompatNeeded`.
+ */
+export declare function isNudgeWindowCompatNeeded(): boolean;
+/**
+ * True when calendar arithmetic in `calendarId` needs the compat layer in this runtime: any of its
+ * add, until or read probes fails (CORE-6 spec §3.6.2). `iso8601` never does, and costs nothing.
+ * Callers that own a spec path for a whole operation (zoned differences, `Duration` rounding,
+ * totals and comparisons) take it when this is true.
+ */
+export declare function isCalendarArithmeticCompatNeeded(calendarId: string): boolean;

package/dist/internal/temporalCompat/capabilities.js

@@ -0,0 +1,74 @@
+import { repros } from "./repros.js";
+/*
+ * Lazy, memoized capability probes: one answer per (defect, calendar), computed the first time a
+ * workaround asks and cached for the life of the process. Results are deterministic for a given
+ * polyfill + ICU, and the polyfill is imported once, so a cached answer never goes stale.
+ *
+ * A workaround whose probe passes never runs: behaviour is the polyfill's own. Tests never force a
+ * probe; they assert spec-correct outputs that hold either way (CORE-6 spec §4.5).
+ */
+/** The repro's output, or `ERR <name>: <message>` when it throws. */
+export function runRepro(repro) {
+    try {
+        return repro.run();
+    }
+    catch (error) {
+        const { name, message } = error instanceof Error ? error : new Error(String(error));
+        return `ERR ${name}: ${message}`;
+    }
+}
+/** True when a repro's output is the spec-correct value, i.e. the installed runtime is fixed. */
+export function reproPasses(repro, output) {
+    return output === repro.expected;
+}
+const cache = new Map();
+/**
+ * True when any repro for this defect and Temporal calendar id fails in the installed runtime.
+ * A calendar with no repro for the defect is not affected by it.
+ */
+export function isDefectPresent(defect, calendar) {
+    const key = `${defect}/${calendar}`;
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const present = repros.some((repro) => repro.defect === defect &&
+        repro.calendar === calendar &&
+        !reproPasses(repro, runRepro(repro)));
+    cache.set(key, present);
+    return present;
+}
+/**
+ * True when this runtime never retries the calendar nudge window (defect D11).
+ *
+ * TC39 bounds a duration between `relativeTo + r1 units` and `relativeTo + r2 units`, and recomputes
+ * the window one unit further along when the target falls outside it. A runtime that computes the
+ * window once answers `Duration#total`, `Duration#round` and `until`/`since` with a calendar
+ * `smallestUnit` over the wrong bounds. Only a `relativeTo` on the 29th, 30th or 31st can reach it,
+ * because only there does adding a month constrain the day. ISO-only: the non-ISO calendars already
+ * take the spec path through `isCalendarArithmeticCompatNeeded`.
+ */
+export function isNudgeWindowCompatNeeded() {
+    return isDefectPresent("D11", "iso8601");
+}
+/** Defects that make the runtime's calendar arithmetic or reads differ from the spec. */
+const ARITHMETIC_DEFECTS = [
+    "D1",
+    "D2",
+    "D3",
+    "D4",
+    "D5",
+    "D6",
+    "D7",
+    "D10",
+];
+/**
+ * True when calendar arithmetic in `calendarId` needs the compat layer in this runtime: any of its
+ * add, until or read probes fails (CORE-6 spec §3.6.2). `iso8601` never does, and costs nothing.
+ * Callers that own a spec path for a whole operation (zoned differences, `Duration` rounding,
+ * totals and comparisons) take it when this is true.
+ */
+export function isCalendarArithmeticCompatNeeded(calendarId) {
+    return (calendarId !== "iso8601" &&
+        ARITHMETIC_DEFECTS.some((defect) => isDefectPresent(defect, calendarId)));
+}

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

@@ -0,0 +1,21 @@
+import { Temporal } from "@js-temporal/polyfill";
+export interface FieldKey {
+    year: number;
+    month: number;
+    day: number;
+}
+/** True when `date` is the last representable date, +275760-09-13. */
+export declare function isLastRepresentableDate(date: Temporal.PlainDate): boolean;
+/**
+ * The latest in-range ISO date whose `calendarId` key is at or before `target`, or `null` when
+ * `target` precedes the first representable date. Throws RangeError if the search fails to
+ * converge (callers return their sentinel).
+ */
+export declare function floorDateForFields(calendarId: string, target: FieldKey): Temporal.PlainDate | null;
+/**
+ * `floorDateForFields` within `[from, from + days]` (clamped to the range): `null` when `target`
+ * precedes `from`, the window's last date when `target` is at or past it.
+ */
+export declare function floorDateForFieldsBetween(calendarId: string, target: FieldKey, from: Temporal.PlainDate, days: number): Temporal.PlainDate | null;
+/** The ISO date (iso8601) whose `calendarId` fields are exactly `target`, or `null`. */
+export declare function isoForFields(calendarId: string, target: FieldKey): Temporal.PlainDate | null;