@cosyte/dates 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+### Minor Changes
+
+- 6ba2afd: First release of `@cosyte/dates`: validate, render and convert the date parts the `@cosyte/*` parsers return, without adding precision a value did not state or guessing a time zone.
+
+  What you can depend on from this release: `validateParts`, `isValidParts` and `assertValidParts`, which report every fault in a value and name the rule each one broke; `precisionOf`; `toISO`, which renders ISO 8601 at the value's own precision; `toTemporal`, which returns the narrowest Temporal type that carries everything the value states; `toZonedDateTime` and `toInstant`, which need a time of day and a zone and never fall back to the host zone or to UTC; the re-exported `Temporal`; the shape of `DateParts`; the issue codes; and the four error classes, `DatePartsError`, `MissingZoneError`, `PrecisionError` and `AmbiguousLocalTimeError`.
+
+  What the version number promises: while it is below 1.0.0, a breaking change to any of the above ships in a new minor version, never a patch, and its entry here says what broke and what to do instead. A fix that changes nothing else a consumer relies on ships as a patch.
+
+  Not covered yet: parsing vendor date text (the parsers do that), two-digit years (never interpreted), arithmetic, comparison or formatting helpers (convert with `toTemporal()` and use Temporal for those), locale-aware output, years outside 1000 to 9999, calendars other than the proleptic Gregorian, and leap seconds.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cosyte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+<a href="https://cosyte.com">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://cosyte.com/tile/cosyte-lockup-tile-on-dark-1200x300.png">
+    <img alt="Cosyte: a plus mark set in two overlapping rounded squares, one solid and one outlined, beside the Cosyte wordmark" src="https://cosyte.com/tile/cosyte-lockup-tile-on-light-1200x300.png">
+  </picture>
+</a>
+
+# @cosyte/dates
+
+> Work with the dates the @cosyte/* parsers give you, without losing what the wire actually said.
+
+[![npm version](https://img.shields.io/npm/v/@cosyte/dates.svg)](https://www.npmjs.com/package/@cosyte/dates)
+[![CI](https://github.com/cosyte/dates/actions/workflows/ci.yml/badge.svg)](https://github.com/cosyte/dates/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/cosyte/dates/blob/main/LICENSE)
+[![Node](https://img.shields.io/badge/node-%3E%3D22.0.0-brightgreen.svg)](https://nodejs.org)
+
+Date and time utilities for the @cosyte/* healthcare parsers: precision-preserving conversion and validation that never guesses a timezone.
+
+## Why this exists
+
+Healthcare parsers hand back dates that are deliberately not JavaScript `Date`
+objects. An HL7 v2 `|1970|` is a year, `|19880507|` is a calendar day, and a
+value with no offset is the sender's local time by the standard's own words. The
+parsers preserve exactly that and refuse to invent the rest, which is why they
+carry no date library at all.
+
+That fidelity leaves a gap: a developer still has to validate, compare and
+convert those values, and the obvious tools all model an absolute instant. Reach
+for `new Date('1988')` and you have silently acquired a month, a day, a midnight
+and a timezone that nobody sent you. This package is the opt-in companion that
+closes the gap without any of that, so the parsers stay zero-dependency and
+nobody has their date library chosen for them.
+
+## Status
+
+**0.1.0. The public API is settled and safe to depend on.** The exported
+functions, the shape of `DateParts`, the issue codes and the error classes are
+what this package intends to keep. While the version is below 1.0.0, a breaking
+change to any of them ships in a new minor version, never a patch, and the
+changelog says what broke and what to do instead.
+
+Not covered at 0.1.0, and named so the boundary is not a surprise:
+
+- **No parsing of vendor date text.** This package consumes parts that a
+  `@cosyte/*` parser already produced. Format strings and vendor token grammars
+  live in the parsers' profile systems, not here.
+- **No two-digit years, ever.** `year` must be four digits. There is no century
+  window, no pivot, and no configuration that adds one.
+- **No arithmetic, comparison or formatting helpers.** Convert with
+  `toTemporal()` and use Temporal for the rest.
+- **No locale-aware or human-readable output.** `toISO()` renders ISO 8601 and
+  nothing else.
+- **Years 1000 to 9999 only**, in the proleptic Gregorian calendar. No other
+  calendar system, and no leap seconds.
+
+## Install
+
+```sh
+pnpm add @cosyte/dates
+```
+
+Node `>=22.0.0`. ESM only: this package ships no CommonJS build, so `require()`
+will not load it.
+
+It carries exactly one runtime dependency, [`temporal-polyfill`][polyfill],
+because `Temporal.PlainDate` is the only widely available type that can hold a
+calendar date with no time of day and no zone. `Temporal` is re-exported from
+this package, so a consumer works with the same objects rather than installing a
+second copy.
+
+[polyfill]: https://www.npmjs.com/package/temporal-polyfill
+
+## Usage
+
+```js
+import { precisionOf, toISO, toInstant, toTemporal, validateParts } from '@cosyte/dates';
+
+// A date of birth that arrived as a year and nothing more. It stays a year.
+const birthYear = { year: 1988 };
+console.log(toISO(birthYear), '| precision:', precisionOf(birthYear));
+
+// A calendar date. No midnight is invented, and no zone is attached.
+const admitted = { year: 1988, month: 5, day: 7 };
+console.log(toISO(admitted), '| Temporal:', toTemporal(admitted).constructor.name);
+
+// A timestamp whose sender stated its offset. The offset is kept exactly.
+const collected = { year: 1988, month: 5, day: 7, hour: 13, minute: 45, offsetMinutes: 330 };
+console.log(toISO(collected), '->', toInstant(collected).toString());
+
+// The same timestamp with an unknown offset. Nothing guesses one.
+const unknownZone = { year: 1988, month: 5, day: 7, hour: 13, minute: 45 };
+try {
+  toInstant(unknownZone);
+} catch (error) {
+  console.log(error.name);
+}
+
+// A date that does not exist is refused, and says which rule it broke.
+const result = validateParts({ year: 2025, month: 2, day: 29 });
+console.log(result.valid ? 'valid' : result.issues[0].message);
+```
+
+```text
+1988 | precision: year
+1988-05-07 | Temporal: PlainDate
+1988-05-07T13:45+05:30 -> 1988-05-07T08:15:00Z
+MissingZoneError
+day 29 does not exist: February 2025 has 28 days, because 2025 is not a leap year in the proleptic Gregorian calendar
+```
+
+That output is identical under every host `TZ`, and
+`test/readme.test.ts` runs this exact block against the built package and
+compares it character for character.
+
+More runnable programs, one for each job this package does, are in
+[`examples/`](https://github.com/cosyte/dates/tree/main/examples), and the full
+guide is at [docs.cosyte.com/dates](https://docs.cosyte.com/dates).
+
+## PHI and safety
+
+A date of birth is PHI, and a wrong conversion is the quiet kind of defect: it
+returns a plausible date rather than an error, and a consumer that has already
+written it into a record does not learn of it from a later fix. What this
+package does about that:
+
+- **It writes nothing, anywhere.** No logging, no telemetry, no files, no
+  network. Nothing is written to stdout or stderr, on any code path including
+  every error path. `test/package-contract.test.ts` proves it by running every
+  public entry point in a child process and asserting both streams are empty and
+  that nothing was written to the working directory.
+- **It retains nothing.** Every function is pure and holds no state between
+  calls. A value passed in is not cached, memoised or referenced after return.
+- **It refuses rather than guesses.** No century window, no host timezone
+  fallback, no midnight for a date with no time, no picking one side of a
+  daylight-saving transition, no rounding a sub-second value to make it fit.
+  Each of those raises a named error instead.
+- **Diagnostics quote one component, never the whole value.** A validation
+  message names the component at fault and the value of THAT component
+  (`month must be an integer in 1-12 ...; received the number 13`). It never
+  assembles the full date into an error string.
+
+What the consumer still owns: whether to log an error message that may contain
+one component of a patient's date of birth, how the parts got there, and where
+the converted value goes next. This package is a pure function in the middle.
+
+## API
+
+| export                             | what it does                                                                                                                                                               |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `validateParts(value)`             | Checks a value against the contract. Never throws. Returns every fault, not just the first.                                                                                |
+| `isValidParts(value)`              | The same check as a type guard.                                                                                                                                            |
+| `assertValidParts(value)`          | Returns the recognised components, or throws `DatePartsError`.                                                                                                             |
+| `precisionOf(value)`               | The least significant present component: `'year'` through `'fraction'`.                                                                                                    |
+| `toISO(value)`                     | ISO 8601 at the value's own precision. `1988`, `1988-05`, `1988-05-07T13:45+05:30`.                                                                                        |
+| `toTemporal(value)`                | The narrowest Temporal type that carries everything the value states: `PlainYearMonth`, `PlainDate`, `PlainDateTime`, or `ZonedDateTime` when the value carries an offset. |
+| `toZonedDateTime(value, options?)` | The value placed in a stated zone. Needs a time of day and a zone.                                                                                                         |
+| `toInstant(value, options?)`       | The absolute instant, same requirements.                                                                                                                                   |
+| `Temporal`                         | The Temporal implementation this package converts into.                                                                                                                    |
+
+Errors: `DatePartsError` (carries the same `issues` the validator reports),
+`MissingZoneError`, `PrecisionError`, `AmbiguousLocalTimeError`.
+
+The caveats that bite:
+
+- A value's OWN `offsetMinutes` always wins. `options` apply only when the
+  offset is unknown, so passing a `timeZone` never re-zones data the sender
+  already qualified.
+- `toTemporal()` throws for a year-only value, because Temporal has no year-only
+  type and this package will not invent a month to reach one.
+- An absent `offsetMinutes` means UNKNOWN. It does not mean UTC, and it does not
+  mean the host zone.
+
+## Compatibility
+
+The input shape is the spec-native parts value the `@cosyte/*` parsers produce:
+`month` is 1 to 12, not JavaScript's 0 to 11, and components run from `year`
+downward with no gaps. Handled: year, month, day, hour, minute, second,
+sub-second down to one nanosecond, and a signed offset in minutes.
+
+`fraction` must be a whole number of nanoseconds, which is nine decimal places of
+a second and Temporal's own floor. A value carrying finer detail is REFUSED with
+`finer-than-nanosecond` rather than rounded to fit, because a silent round is the
+class of change this package exists to not make.
+
+Known NOT handled, deliberately: two-digit years, leap seconds, calendars other
+than the proleptic Gregorian, years outside 1000 to 9999, sub-second detail finer
+than one nanosecond, an offset on a value that states no time of day, and any
+zone abbreviation such as `CST` (they are ambiguous across regions, so an IANA
+identifier or a numeric offset is required).
+
+## Contributing
+
+Issues and pull requests are welcome at
+[github.com/cosyte/dates](https://github.com/cosyte/dates). A contribution has
+to clear the same gate CI runs on every push: `pnpm run build`, `pnpm run
+attw`, `pnpm run typecheck`, `pnpm run lint`, `pnpm run test`, `pnpm run
+examples`, and `bash scripts/check-no-emdash.sh`. New behaviour needs a test, and anything
+touching conversion needs one that pins the exact output rather than a shape.
+
+## License
+
+MIT, Cosyte. See [LICENSE](https://github.com/cosyte/dates/blob/main/LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,246 @@
+import { Temporal } from 'temporal-polyfill';
+export { Temporal } from 'temporal-polyfill';
+
+/**
+ * The date-parts value every `@cosyte/*` parser hands back, and the only shape
+ * this package accepts.
+ *
+ * Two rules make it a contract rather than a bag of numbers.
+ *
+ * 1. CONTIGUITY. Components are present from the most significant downward with
+ *    no gaps. `{ year, month }` is legal; `{ year, day }` is not.
+ * 2. PRECISION IS WHAT IS PRESENT. The least significant present component IS
+ *    the precision of the value. Nothing here adds a component that was not
+ *    supplied, and an absent `offsetMinutes` means the offset is UNKNOWN, which
+ *    is not the same as UTC and not the same as the host zone.
+ *
+ * `month` is SPEC-NATIVE 1-12, not JavaScript's 0-11.
+ */
+interface DateParts {
+    /** Four digits, 1000-9999. Required. Two-digit years are never interpreted. */
+    readonly year?: number;
+    /** 1-12, spec-native. January is 1. */
+    readonly month?: number;
+    /** 1-31, and a day that exists in the given month of the given year. */
+    readonly day?: number;
+    /** 0-23. */
+    readonly hour?: number;
+    /** 0-59. */
+    readonly minute?: number;
+    /** 0-59. Leap seconds are not representable. */
+    readonly second?: number;
+    /** Sub-second precision as a fraction of one second: `0 <= fraction < 1`. */
+    readonly fraction?: number;
+    /**
+     * Signed minutes from UTC, -1439 to 1439. ABSENT means the offset is unknown.
+     * It never means zero, and it is never filled in from the host zone.
+     */
+    readonly offsetMinutes?: number;
+}
+/** The precision ladder, most significant first. */
+declare const PRECISION_LADDER: readonly ["year", "month", "day", "hour", "minute", "second", "fraction"];
+/** The least significant component present in a value IS its precision. */
+type Precision = (typeof PRECISION_LADDER)[number];
+/** Every component name the contract defines. */
+type PartName = Precision | 'offsetMinutes';
+/** What a diagnostic says went wrong. */
+type IssueCode = 
+/** The argument is not a date-parts object at all. */
+'not-a-parts-object'
+/** A more significant component is absent while a less significant one is present. */
+ | 'missing-component'
+/** Reading the component threw, so its value could not be seen at all. */
+ | 'unreadable'
+/** The component is present but is not a number. */
+ | 'not-a-number'
+/** The component is a number but is `NaN` or infinite. */
+ | 'not-finite'
+/** The component must be a whole number and is not. */
+ | 'not-an-integer'
+/** The component is outside the range the contract gives it. */
+ | 'out-of-range'
+/** The year is not four digits. No century window is ever applied. */
+ | 'year-not-four-digits'
+/** The sub-second value carries detail below nanosecond resolution. */
+ | 'finer-than-nanosecond'
+/** An offset was given for a value that states no time of day. */
+ | 'offset-without-time-of-day'
+/** The components are each in range but together denote no real date. */
+ | 'no-such-calendar-date';
+/** One thing wrong with one component, named. */
+interface ValidationIssue {
+    /** The component at fault, or `'value'` when the argument itself is wrong. */
+    readonly component: PartName | 'value';
+    readonly code: IssueCode;
+    /** Human-readable, names the component and the range or calendar rule broken. */
+    readonly message: string;
+}
+/** A validated value, carrying only the recognised components that were present. */
+interface ValidPartsResult {
+    readonly valid: true;
+    readonly parts: DateParts;
+    readonly precision: Precision;
+}
+/** An invalid value, with every fault found rather than only the first. */
+interface InvalidPartsResult {
+    readonly valid: false;
+    readonly issues: readonly ValidationIssue[];
+}
+type ValidationResult = ValidPartsResult | InvalidPartsResult;
+/**
+ * How to place a value that carries no offset of its own onto the timeline.
+ *
+ * A value that DOES carry `offsetMinutes` is never re-zoned: its own offset is
+ * what the sender said, and overriding it here would move the instant.
+ */
+interface ZoneOptions {
+    /** An IANA time zone identifier, for example `'America/New_York'`. */
+    readonly timeZone?: string;
+    /** A fixed offset in signed minutes from UTC, -1439 to 1439. */
+    readonly offsetMinutes?: number;
+}
+
+/**
+ * A conversion was asked for a value that validation reports invalid.
+ *
+ * `issues` is the SAME array `validateParts()` returns for that value, so a
+ * caller that catches this never has to validate again to learn what was wrong,
+ * and a conversion never returns a coerced or clamped stand-in.
+ */
+declare class DatePartsError extends Error {
+    readonly issues: readonly ValidationIssue[];
+    constructor(issues: readonly ValidationIssue[]);
+}
+/**
+ * An absolute instant was asked for, and nothing said which zone the local time
+ * is in.
+ *
+ * This package never falls back to the host timezone, to UTC, or to any other
+ * default, because a fallback turns an unknown into a plausible wrong answer.
+ */
+declare class MissingZoneError extends Error {
+    constructor(message: string);
+}
+/**
+ * The value does not carry enough precision for what was asked, and supplying
+ * the missing components would mean inventing them.
+ */
+declare class PrecisionError extends Error {
+    /** The precision the value actually has. */
+    readonly precision: string;
+    constructor(message: string, precision: string);
+}
+/**
+ * A local time was placed in a named zone where it does not exist, or exists
+ * twice.
+ *
+ * Both cases are resolved by REFUSING rather than by picking. A daylight-saving
+ * transition is exactly where a silent choice shifts a clinical timeline by an
+ * hour, so the caller is told and decides.
+ */
+declare class AmbiguousLocalTimeError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * Check a value against the date-parts contract.
+ *
+ * Every fault is reported, not only the first, and every diagnostic names the
+ * component at fault together with the range or calendar rule it broke. Nothing
+ * is coerced, clamped or inferred: a value that does not satisfy the contract
+ * comes back invalid rather than corrected.
+ *
+ * This function never throws, for any argument at all. Hostile input (`null`, a
+ * string, a JavaScript `Date`, `NaN`, `Infinity`, a non-integer component, a
+ * component that throws when it is read) is reported, not raised.
+ *
+ * Components are looked up by name, so an object carrying them on its prototype
+ * (a class instance with accessors, which is a shape a parser may well hand
+ * over) is read the same way a plain object literal is.
+ */
+declare function validateParts(value: unknown): ValidationResult;
+/** A type guard over {@link validateParts}, for callers that want a boolean. */
+declare function isValidParts(value: unknown): value is DateParts;
+/**
+ * Validate and return the recognised components, or throw {@link DatePartsError}
+ * carrying the same diagnostics {@link validateParts} would have reported.
+ */
+declare function assertValidParts(value: unknown): DateParts;
+/**
+ * The precision of a value: its least significant present component.
+ *
+ * Throws {@link DatePartsError} for a value that does not satisfy the contract,
+ * because an invalid value has no precision to report.
+ */
+declare function precisionOf(value: unknown): Precision;
+
+/** The narrowest Temporal type that carries everything a value states, and nothing more. */
+type TemporalValue = Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+/**
+ * Render a value as an ISO 8601 string AT ITS OWN PRECISION.
+ *
+ * A year-only value renders `1988`; a month-only value renders `1988-05`. No
+ * component the value did not state is ever added, so nothing here turns a year
+ * of birth into the first of January.
+ *
+ * The result is a pure function of the parts. It does not read the host clock or
+ * the host time zone, so it is identical under every `TZ`.
+ *
+ * @throws {DatePartsError} if the value does not satisfy the contract.
+ */
+declare function toISO(value: unknown): string;
+/**
+ * Convert to the narrowest Temporal type that carries everything the value
+ * states, and nothing it does not.
+ *
+ * | precision of the value | result |
+ * |---|---|
+ * | `month` | `Temporal.PlainYearMonth` |
+ * | `day` | `Temporal.PlainDate`, with no time of day and no zone |
+ * | `hour` and finer, no offset | `Temporal.PlainDateTime`, with no zone |
+ * | `hour` and finer, with `offsetMinutes` | `Temporal.ZonedDateTime` at that exact offset |
+ *
+ * A year-only value has no Temporal counterpart and raises
+ * {@link PrecisionError} rather than acquiring a month. Use {@link toISO} for
+ * those, and {@link precisionOf} to branch.
+ *
+ * Components below the value's own precision are zero in the Temporal object,
+ * because Temporal has no partial type below `PlainYearMonth`. The value's real
+ * precision is still available from {@link precisionOf}; it is not lost, it just
+ * cannot be carried by the returned object.
+ *
+ * @throws {DatePartsError} if the value does not satisfy the contract.
+ * @throws {PrecisionError} for a year-only value.
+ */
+declare function toTemporal(value: unknown): TemporalValue;
+/**
+ * Place a value on the timeline in a stated zone.
+ *
+ * Requires a time of day. A day-precision value is a calendar date, and turning
+ * one into a zoned instant means choosing midnight, which is a component the
+ * value does not carry. Use {@link toTemporal} for those.
+ *
+ * Requires a zone. If the value carries `offsetMinutes` that offset is used and
+ * PRESERVED EXACTLY, never normalised to UTC or to the host zone, and `options`
+ * are not consulted. Otherwise `options.timeZone` or `options.offsetMinutes`
+ * must say which zone the local time is in.
+ *
+ * A local time that a named zone skips or repeats across a daylight-saving
+ * transition raises {@link AmbiguousLocalTimeError} rather than resolving to
+ * one of the two candidates, because a silent pick shifts the value by an hour.
+ *
+ * @throws {DatePartsError} if the value does not satisfy the contract.
+ * @throws {PrecisionError} if the value states no time of day.
+ * @throws {MissingZoneError} if nothing says which zone applies.
+ * @throws {AmbiguousLocalTimeError} at a daylight-saving transition.
+ */
+declare function toZonedDateTime(value: unknown, options?: ZoneOptions): Temporal.ZonedDateTime;
+/**
+ * The absolute instant a value denotes, in a stated zone.
+ *
+ * Same requirements as {@link toZonedDateTime}: a time of day, and a zone that
+ * something states. Nothing is defaulted.
+ */
+declare function toInstant(value: unknown, options?: ZoneOptions): Temporal.Instant;
+
+export { AmbiguousLocalTimeError, type DateParts, DatePartsError, type InvalidPartsResult, type IssueCode, MissingZoneError, PRECISION_LADDER, type PartName, type Precision, PrecisionError, type TemporalValue, type ValidPartsResult, type ValidationIssue, type ValidationResult, type ZoneOptions, assertValidParts, isValidParts, precisionOf, toISO, toInstant, toTemporal, toZonedDateTime, validateParts };

package/dist/index.js

@@ -0,0 +1,484 @@
+import { Temporal } from 'temporal-polyfill';
+export { Temporal } from 'temporal-polyfill';
+
+// src/types.ts
+var PRECISION_LADDER = [
+  "year",
+  "month",
+  "day",
+  "hour",
+  "minute",
+  "second",
+  "fraction"
+];
+
+// src/errors.ts
+var DatePartsError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`invalid date parts: ${issues.map((issue) => issue.message).join("; ")}`);
+    this.name = "DatePartsError";
+    this.issues = issues;
+  }
+};
+var MissingZoneError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MissingZoneError";
+  }
+};
+var PrecisionError = class extends Error {
+  /** The precision the value actually has. */
+  precision;
+  constructor(message, precision) {
+    super(message);
+    this.name = "PrecisionError";
+    this.precision = precision;
+  }
+};
+var AmbiguousLocalTimeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousLocalTimeError";
+  }
+};
+
+// src/fraction.ts
+var NANOSECOND_DIGITS = 9;
+var PLAIN_DECIMAL = /^0(?:\.(\d+))?$/;
+var EXPONENTIAL_DECIMAL = /^(\d)(?:\.(\d+))?e-(\d+)$/;
+function fractionDigits(fraction) {
+  const text = String(fraction);
+  const plain = PLAIN_DECIMAL.exec(text);
+  if (plain !== null) return plain[1] ?? "";
+  const exponential = EXPONENTIAL_DECIMAL.exec(text);
+  if (exponential === null) return void 0;
+  const lead = exponential[1] ?? "";
+  const rest = exponential[2] ?? "";
+  const exponent = Number(exponential[3]);
+  return "0".repeat(exponent - 1) + lead + rest;
+}
+function nanosecondsOf(fraction) {
+  const digits = fractionDigits(fraction);
+  if (digits === void 0 || digits.length > NANOSECOND_DIGITS) return void 0;
+  return digits === "" ? 0 : Number(digits.padEnd(NANOSECOND_DIGITS, "0"));
+}
+function readFraction(fraction) {
+  if (!Number.isFinite(fraction) || fraction < 0 || fraction >= 1) {
+    return {
+      ok: false,
+      issue: {
+        component: "fraction",
+        code: "out-of-range",
+        message: `fraction is a share of one second and must satisfy 0 <= fraction < 1; received the number ${String(fraction)}`
+      }
+    };
+  }
+  const nanoseconds = nanosecondsOf(fraction);
+  if (nanoseconds === void 0) {
+    return {
+      ok: false,
+      issue: {
+        component: "fraction",
+        code: "finer-than-nanosecond",
+        message: `fraction carries detail finer than one nanosecond, which this package will not round away; received the number ${String(fraction)}. One nanosecond is nine decimal places of a second, and it is the finest value Temporal can hold`
+      }
+    };
+  }
+  return { ok: true, nanoseconds };
+}
+
+// src/validate.ts
+var ALL_PARTS = [...PRECISION_LADDER, "offsetMinutes"];
+var INTEGER_RANGES = {
+  year: [1e3, 9999],
+  month: [1, 12],
+  day: [1, 31],
+  hour: [0, 23],
+  minute: [0, 59],
+  second: [0, 59],
+  offsetMinutes: [-1439, 1439]
+};
+var RANGE_NOTES = {
+  month: " (spec-native, January is 1, not 0)",
+  offsetMinutes: " (signed minutes from UTC)"
+};
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var MONTH_LENGTHS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function daysInMonth(year, month) {
+  if (month === 2) return isLeapYear(year) ? 29 : 28;
+  return MONTH_LENGTHS[month - 1] ?? 0;
+}
+function monthName(month) {
+  return MONTH_NAMES[month - 1] ?? `month ${String(month)}`;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "number") {
+    if (Number.isNaN(value)) return "NaN";
+    if (!Number.isFinite(value)) return value > 0 ? "Infinity" : "-Infinity";
+    return `the number ${String(value)}`;
+  }
+  if (typeof value === "string") return "a string";
+  if (typeof value === "boolean") return `the boolean ${String(value)}`;
+  if (typeof value === "bigint") return "a bigint";
+  if (typeof value === "symbol") return "a symbol";
+  if (typeof value === "function") return "a function";
+  if (Array.isArray(value)) return "an array";
+  return "an object";
+}
+function invalid(issues) {
+  return { valid: false, issues };
+}
+function readComponent(source, name) {
+  try {
+    return { ok: true, raw: source[name] };
+  } catch {
+    return {
+      ok: false,
+      issue: {
+        component: name,
+        code: "unreadable",
+        message: `${name} could not be read: the property threw when accessed, so this package cannot see what value it holds and will not guess one`
+      }
+    };
+  }
+}
+function validateParts(value) {
+  if (typeof value !== "object" || value === null) {
+    return invalid([
+      {
+        component: "value",
+        code: "not-a-parts-object",
+        message: `a date-parts value must be an object carrying the components the contract names; received ${describe(value)}`
+      }
+    ]);
+  }
+  if (value instanceof Date) {
+    return invalid([
+      {
+        component: "value",
+        code: "not-a-parts-object",
+        message: "a JavaScript Date is an absolute instant, not a date-parts value: it cannot express a year-only or month-only date, and it carries no offset of its own. Pass the parts the parser returned"
+      }
+    ]);
+  }
+  if (Array.isArray(value)) {
+    return invalid([
+      {
+        component: "value",
+        code: "not-a-parts-object",
+        message: "a date-parts value must be an object with named components; received an array, whose positions this package will not guess at"
+      }
+    ]);
+  }
+  const source = value;
+  const issues = [];
+  const present = /* @__PURE__ */ new Set();
+  const values = {};
+  for (const name of ALL_PARTS) {
+    const read = readComponent(source, name);
+    if (!read.ok) {
+      present.add(name);
+      issues.push(read.issue);
+      continue;
+    }
+    const raw = read.raw;
+    if (raw === void 0) continue;
+    present.add(name);
+    if (typeof raw !== "number") {
+      issues.push({
+        component: name,
+        code: "not-a-number",
+        message: `${name} must be a number; received ${describe(raw)}`
+      });
+      continue;
+    }
+    if (!Number.isFinite(raw)) {
+      issues.push({
+        component: name,
+        code: "not-finite",
+        message: `${name} must be a finite number; received ${describe(raw)}`
+      });
+      continue;
+    }
+    if (name === "fraction") {
+      const reading = readFraction(raw);
+      if (reading.ok) values.fraction = raw;
+      else issues.push(reading.issue);
+      continue;
+    }
+    if (!Number.isInteger(raw)) {
+      issues.push({
+        component: name,
+        code: "not-an-integer",
+        message: `${name} must be a whole number; received the number ${String(raw)}`
+      });
+      continue;
+    }
+    const [low, high] = INTEGER_RANGES[name];
+    if (raw < low || raw > high) {
+      issues.push(
+        name === "year" ? {
+          component: "year",
+          code: "year-not-four-digits",
+          message: `year must be a four-digit year in ${String(low)}-${String(high)}; received the number ${String(raw)}. This package applies no century window and never interprets a two-digit year`
+        } : {
+          component: name,
+          code: "out-of-range",
+          message: `${name} must be an integer in ${String(low)}-${String(high)}${RANGE_NOTES[name] ?? ""}; received the number ${String(raw)}`
+        }
+      );
+      continue;
+    }
+    values[name] = raw;
+  }
+  checkContiguity(present, issues);
+  checkOffsetHasTimeOfDay(present, issues);
+  checkCalendarDate(values, issues);
+  if (issues.length > 0) return invalid(issues);
+  const parts = {};
+  for (const name of ALL_PARTS) {
+    const held = values[name];
+    if (held !== void 0) parts[name] = held;
+  }
+  return { valid: true, parts, precision: deepestPresent(present) };
+}
+function deepestPresent(present) {
+  let deepest;
+  for (const name of PRECISION_LADDER) {
+    if (present.has(name)) deepest = name;
+  }
+  return deepest;
+}
+function checkContiguity(present, issues) {
+  const deepest = deepestPresent(present);
+  if (deepest === void 0) {
+    issues.push({
+      component: "year",
+      code: "missing-component",
+      message: "year is missing: a date-parts value must carry at least a year, and this package never infers one"
+    });
+    return;
+  }
+  const deepestIndex = PRECISION_LADDER.indexOf(deepest);
+  for (let index = 0; index < deepestIndex; index += 1) {
+    const name = PRECISION_LADDER[index];
+    if (name === void 0 || present.has(name)) continue;
+    issues.push({
+      component: name,
+      code: "missing-component",
+      message: `${name} is missing while ${deepest} is present: components run from year downward with no gaps, and this package never infers the one you left out`
+    });
+  }
+}
+function checkOffsetHasTimeOfDay(present, issues) {
+  if (!present.has("offsetMinutes") || present.has("hour")) return;
+  issues.push({
+    component: "offsetMinutes",
+    code: "offset-without-time-of-day",
+    message: "offsetMinutes is present but the value states no time of day: an offset qualifies a clock time, it cannot be rendered without one, and dropping it silently is not an option this package takes"
+  });
+}
+function checkCalendarDate(values, issues) {
+  const { year, month, day } = values;
+  if (year === void 0 || month === void 0 || day === void 0) return;
+  const limit = daysInMonth(year, month);
+  if (day <= limit) return;
+  const leapNote = month === 2 ? `, because ${String(year)} is ${isLeapYear(year) ? "a" : "not a"} leap year in the proleptic Gregorian calendar` : "";
+  issues.push({
+    component: "day",
+    code: "no-such-calendar-date",
+    message: `day ${String(day)} does not exist: ${monthName(month)} ${String(year)} has ${String(limit)} days${leapNote}`
+  });
+}
+function isValidParts(value) {
+  return validateParts(value).valid;
+}
+function assertValidParts(value) {
+  const result = validateParts(value);
+  if (!result.valid) throw new DatePartsError(result.issues);
+  return result.parts;
+}
+function precisionOf(value) {
+  const result = validateParts(value);
+  if (!result.valid) throw new DatePartsError(result.issues);
+  return result.precision;
+}
+function check(value) {
+  const result = validateParts(value);
+  if (!result.valid) throw new DatePartsError(result.issues);
+  return { parts: result.parts, precision: result.precision };
+}
+function atLeast(precision, floor) {
+  return PRECISION_LADDER.indexOf(precision) >= PRECISION_LADDER.indexOf(floor);
+}
+function pad(value, width) {
+  return String(value).padStart(width, "0");
+}
+function formatOffset(offsetMinutes) {
+  const sign = offsetMinutes < 0 ? "-" : "+";
+  const absolute = Math.abs(offsetMinutes);
+  return `${sign}${pad(Math.trunc(absolute / 60), 2)}:${pad(absolute % 60, 2)}`;
+}
+function nanosecondsOf2(fraction) {
+  const reading = readFraction(fraction);
+  if (!reading.ok) throw new DatePartsError([reading.issue]);
+  return reading.nanoseconds;
+}
+function formatFraction(fraction) {
+  const digits = pad(nanosecondsOf2(fraction), 9).replace(/0+$/, "");
+  return `.${digits === "" ? "0" : digits}`;
+}
+function subSecondFields(fraction) {
+  if (fraction === void 0) return {};
+  const nanoseconds = nanosecondsOf2(fraction);
+  return {
+    millisecond: Math.floor(nanoseconds / 1e6),
+    microsecond: Math.floor(nanoseconds % 1e6 / 1e3),
+    nanosecond: nanoseconds % 1e3
+  };
+}
+function toISO(value) {
+  const { parts, precision } = check(value);
+  const suffix = parts.offsetMinutes === void 0 ? "" : formatOffset(parts.offsetMinutes);
+  let out = pad(parts.year ?? 0, 4);
+  if (precision === "year") return out;
+  out += `-${pad(parts.month ?? 0, 2)}`;
+  if (precision === "month") return out;
+  out += `-${pad(parts.day ?? 0, 2)}`;
+  if (precision === "day") return out;
+  out += `T${pad(parts.hour ?? 0, 2)}`;
+  if (precision === "hour") return out + suffix;
+  out += `:${pad(parts.minute ?? 0, 2)}`;
+  if (precision === "minute") return out + suffix;
+  out += `:${pad(parts.second ?? 0, 2)}`;
+  if (precision === "second") return out + suffix;
+  out += formatFraction(parts.fraction ?? 0);
+  return out + suffix;
+}
+function toTemporal(value) {
+  const { parts, precision } = check(value);
+  if (precision === "year") {
+    throw new PrecisionError(
+      "Temporal has no year-only type, and this package will not invent a month to reach one. Use toISO() to render a year-precision value, or precisionOf() to branch before converting",
+      precision
+    );
+  }
+  const year = parts.year ?? 0;
+  const month = parts.month ?? 0;
+  if (precision === "month") {
+    return Temporal.PlainYearMonth.from({ year, month }, { overflow: "reject" });
+  }
+  const day = parts.day ?? 0;
+  if (precision === "day") {
+    return Temporal.PlainDate.from({ year, month, day }, { overflow: "reject" });
+  }
+  const fields = {
+    year,
+    month,
+    day,
+    hour: parts.hour ?? 0,
+    minute: parts.minute ?? 0,
+    second: parts.second ?? 0,
+    ...subSecondFields(parts.fraction)
+  };
+  if (parts.offsetMinutes !== void 0) {
+    return Temporal.ZonedDateTime.from(
+      { ...fields, timeZone: formatOffset(parts.offsetMinutes) },
+      { overflow: "reject" }
+    );
+  }
+  return Temporal.PlainDateTime.from(fields, { overflow: "reject" });
+}
+function assertKnownTimeZone(timeZone) {
+  try {
+    Temporal.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(timeZone);
+  } catch {
+    throw new RangeError(
+      `unknown time zone ${JSON.stringify(timeZone)}: supply an IANA identifier such as "America/New_York", or an offset such as "+05:30"`
+    );
+  }
+}
+function assertUsableOffset(offsetMinutes) {
+  if (!Number.isInteger(offsetMinutes) || offsetMinutes < -1439 || offsetMinutes > 1439) {
+    throw new RangeError(
+      `offsetMinutes must be an integer in -1439-1439 (signed minutes from UTC); received ${String(offsetMinutes)}`
+    );
+  }
+}
+function resolveTimeZone(parts, options) {
+  if (parts.offsetMinutes !== void 0) return formatOffset(parts.offsetMinutes);
+  if (options?.timeZone !== void 0 && options.offsetMinutes !== void 0) {
+    throw new TypeError(
+      "supply either timeZone or offsetMinutes, not both: two answers to one question is a guess waiting to happen"
+    );
+  }
+  if (options?.offsetMinutes !== void 0) {
+    assertUsableOffset(options.offsetMinutes);
+    return formatOffset(options.offsetMinutes);
+  }
+  if (options?.timeZone !== void 0) {
+    assertKnownTimeZone(options.timeZone);
+    return options.timeZone;
+  }
+  throw new MissingZoneError(
+    "this value carries no offsetMinutes, and no zone was supplied: an absolute instant needs a zone, and this package supplies none. Pass { timeZone } or { offsetMinutes }. It will not fall back to the host time zone, to UTC, or to any other default, because a fallback turns an unknown offset into a plausible wrong instant"
+  );
+}
+function toZonedDateTime(value, options) {
+  const { parts, precision } = check(value);
+  if (!atLeast(precision, "hour")) {
+    const alsoNoZone = parts.offsetMinutes === void 0 && options?.timeZone === void 0 && options?.offsetMinutes === void 0;
+    throw new PrecisionError(
+      `an absolute instant needs a time of day, and this value has ${precision} precision. Supplying one would mean inventing components the value does not carry. Use toTemporal() for the calendar value${alsoNoZone ? ". The zone is missing too: this value carries no offsetMinutes and no { timeZone } or { offsetMinutes } was supplied, and neither the host time zone nor UTC will be used in their place" : ""}`,
+      precision
+    );
+  }
+  const timeZone = resolveTimeZone(parts, options);
+  const local = Temporal.PlainDateTime.from(
+    {
+      year: parts.year ?? 0,
+      month: parts.month ?? 0,
+      day: parts.day ?? 0,
+      hour: parts.hour ?? 0,
+      minute: parts.minute ?? 0,
+      second: parts.second ?? 0,
+      ...subSecondFields(parts.fraction)
+    },
+    { overflow: "reject" }
+  );
+  const earliest = local.toZonedDateTime(timeZone, { disambiguation: "earlier" });
+  const latest = local.toZonedDateTime(timeZone, { disambiguation: "later" });
+  if (!earliest.equals(latest)) {
+    const skipped = !earliest.toPlainDateTime().equals(local);
+    throw new AmbiguousLocalTimeError(
+      skipped ? `${local.toString()} does not exist in ${timeZone}: a daylight-saving transition skips it, so there is no instant to return. Say which side of the transition you mean by passing that offset as { offsetMinutes }` : `${local.toString()} happens twice in ${timeZone}: a daylight-saving transition repeats it, at ${earliest.offset} and again at ${latest.offset}, so there is no single instant to return. Choose the one you mean and pass it as { offsetMinutes }`
+    );
+  }
+  return earliest;
+}
+function toInstant(value, options) {
+  return toZonedDateTime(value, options).toInstant();
+}
+
+export { AmbiguousLocalTimeError, DatePartsError, MissingZoneError, PRECISION_LADDER, PrecisionError, assertValidParts, isValidParts, precisionOf, toISO, toInstant, toTemporal, toZonedDateTime, validateParts };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/errors.ts","../src/fraction.ts","../src/validate.ts","../src/convert.ts"],"names":["nanosecondsOf"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * The date-parts value every `@cosyte/*` parser hands back, and the only shape\n * this package accepts.\n *\n * Two rules make it a contract rather than a bag of numbers.\n *\n * 1. CONTIGUITY. Components are present from the most significant downward with\n *    no gaps. `{ year, month }` is legal; `{ year, day }` is not.\n * 2. PRECISION IS WHAT IS PRESENT. The least significant present component IS\n *    the precision of the value. Nothing here adds a component that was not\n *    supplied, and an absent `offsetMinutes` means the offset is UNKNOWN, which\n *    is not the same as UTC and not the same as the host zone.\n *\n * `month` is SPEC-NATIVE 1-12, not JavaScript's 0-11.\n */\nexport interface DateParts {\n  /** Four digits, 1000-9999. Required. Two-digit years are never interpreted. */\n  readonly year?: number;\n  /** 1-12, spec-native. January is 1. */\n  readonly month?: number;\n  /** 1-31, and a day that exists in the given month of the given year. */\n  readonly day?: number;\n  /** 0-23. */\n  readonly hour?: number;\n  /** 0-59. */\n  readonly minute?: number;\n  /** 0-59. Leap seconds are not representable. */\n  readonly second?: number;\n  /** Sub-second precision as a fraction of one second: `0 <= fraction < 1`. */\n  readonly fraction?: number;\n  /**\n   * Signed minutes from UTC, -1439 to 1439. ABSENT means the offset is unknown.\n   * It never means zero, and it is never filled in from the host zone.\n   */\n  readonly offsetMinutes?: number;\n}\n\n/** The precision ladder, most significant first. */\nexport const PRECISION_LADDER = [\n  'year',\n  'month',\n  'day',\n  'hour',\n  'minute',\n  'second',\n  'fraction',\n] as const;\n\n/** The least significant component present in a value IS its precision. */\nexport type Precision = (typeof PRECISION_LADDER)[number];\n\n/** Every component name the contract defines. */\nexport type PartName = Precision | 'offsetMinutes';\n\n/** What a diagnostic says went wrong. */\nexport type IssueCode =\n  /** The argument is not a date-parts object at all. */\n  | 'not-a-parts-object'\n  /** A more significant component is absent while a less significant one is present. */\n  | 'missing-component'\n  /** Reading the component threw, so its value could not be seen at all. */\n  | 'unreadable'\n  /** The component is present but is not a number. */\n  | 'not-a-number'\n  /** The component is a number but is `NaN` or infinite. */\n  | 'not-finite'\n  /** The component must be a whole number and is not. */\n  | 'not-an-integer'\n  /** The component is outside the range the contract gives it. */\n  | 'out-of-range'\n  /** The year is not four digits. No century window is ever applied. */\n  | 'year-not-four-digits'\n  /** The sub-second value carries detail below nanosecond resolution. */\n  | 'finer-than-nanosecond'\n  /** An offset was given for a value that states no time of day. */\n  | 'offset-without-time-of-day'\n  /** The components are each in range but together denote no real date. */\n  | 'no-such-calendar-date';\n\n/** One thing wrong with one component, named. */\nexport interface ValidationIssue {\n  /** The component at fault, or `'value'` when the argument itself is wrong. */\n  readonly component: PartName | 'value';\n  readonly code: IssueCode;\n  /** Human-readable, names the component and the range or calendar rule broken. */\n  readonly message: string;\n}\n\n/** A validated value, carrying only the recognised components that were present. */\nexport interface ValidPartsResult {\n  readonly valid: true;\n  readonly parts: DateParts;\n  readonly precision: Precision;\n}\n\n/** An invalid value, with every fault found rather than only the first. */\nexport interface InvalidPartsResult {\n  readonly valid: false;\n  readonly issues: readonly ValidationIssue[];\n}\n\nexport type ValidationResult = ValidPartsResult | InvalidPartsResult;\n\n/**\n * How to place a value that carries no offset of its own onto the timeline.\n *\n * A value that DOES carry `offsetMinutes` is never re-zoned: its own offset is\n * what the sender said, and overriding it here would move the instant.\n */\nexport interface ZoneOptions {\n  /** An IANA time zone identifier, for example `'America/New_York'`. */\n  readonly timeZone?: string;\n  /** A fixed offset in signed minutes from UTC, -1439 to 1439. */\n  readonly offsetMinutes?: number;\n}\n","import type { ValidationIssue } from './types.js';\n\n/**\n * A conversion was asked for a value that validation reports invalid.\n *\n * `issues` is the SAME array `validateParts()` returns for that value, so a\n * caller that catches this never has to validate again to learn what was wrong,\n * and a conversion never returns a coerced or clamped stand-in.\n */\nexport class DatePartsError extends Error {\n  readonly issues: readonly ValidationIssue[];\n\n  constructor(issues: readonly ValidationIssue[]) {\n    super(`invalid date parts: ${issues.map((issue) => issue.message).join('; ')}`);\n    this.name = 'DatePartsError';\n    this.issues = issues;\n  }\n}\n\n/**\n * An absolute instant was asked for, and nothing said which zone the local time\n * is in.\n *\n * This package never falls back to the host timezone, to UTC, or to any other\n * default, because a fallback turns an unknown into a plausible wrong answer.\n */\nexport class MissingZoneError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'MissingZoneError';\n  }\n}\n\n/**\n * The value does not carry enough precision for what was asked, and supplying\n * the missing components would mean inventing them.\n */\nexport class PrecisionError extends Error {\n  /** The precision the value actually has. */\n  readonly precision: string;\n\n  constructor(message: string, precision: string) {\n    super(message);\n    this.name = 'PrecisionError';\n    this.precision = precision;\n  }\n}\n\n/**\n * A local time was placed in a named zone where it does not exist, or exists\n * twice.\n *\n * Both cases are resolved by REFUSING rather than by picking. A daylight-saving\n * transition is exactly where a silent choice shifts a clinical timeline by an\n * hour, so the caller is told and decides.\n */\nexport class AmbiguousLocalTimeError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'AmbiguousLocalTimeError';\n  }\n}\n","import type { ValidationIssue } from './types.js';\n\n/**\n * Reading a `fraction` as whole nanoseconds, EXACTLY.\n *\n * One function answers \"how many nanoseconds is this?\" for the whole package, so\n * the validator and every converter cannot disagree about a value: a fraction the\n * validator accepts is one every converter can render, and a fraction any of them\n * refuses is refused by all of them with the same diagnostic.\n *\n * The count is read from the value's own decimal digits rather than computed as\n * `fraction * 1e9`. Binary floating point cannot hold most decimal fractions, so\n * that product misses whole nanoseconds by a hair and any tolerance wide enough\n * to forgive the hair is also wide enough to swallow a real difference. Digits\n * are exact and need no tolerance at all.\n */\n\n/** Temporal's resolution floor, and this package's: nine decimal places. */\nconst NANOSECOND_DIGITS = 9;\n\n/** `0`, or `0.` followed by the sub-second digits. */\nconst PLAIN_DECIMAL = /^0(?:\\.(\\d+))?$/;\n\n/** JavaScript prints a magnitude below `1e-6` in exponential form: `1e-9`, `1.5e-7`. */\nconst EXPONENTIAL_DECIMAL = /^(\\d)(?:\\.(\\d+))?e-(\\d+)$/;\n\n/**\n * The digits after the decimal point of the shortest decimal that round-trips to\n * `fraction`, or `undefined` if the value has no such form.\n *\n * The shortest round-tripping decimal is the value's canonical spelling: it is\n * what `0.123456789` was written as, and every longer decimal that lands on the\n * same double is the same double.\n */\nfunction fractionDigits(fraction: number): string | undefined {\n  const text = String(fraction);\n\n  const plain = PLAIN_DECIMAL.exec(text);\n  if (plain !== null) return plain[1] ?? '';\n\n  const exponential = EXPONENTIAL_DECIMAL.exec(text);\n  if (exponential === null) return undefined;\n\n  const lead = exponential[1] ?? '';\n  const rest = exponential[2] ?? '';\n  const exponent = Number(exponential[3]);\n  return '0'.repeat(exponent - 1) + lead + rest;\n}\n\n/**\n * The whole nanoseconds `fraction` denotes, or `undefined` when it carries detail\n * finer than one nanosecond.\n *\n * `fraction` must already be known finite and in `[0, 1)`; {@link readFraction}\n * is the entry point that establishes both. The result is therefore always in\n * `[0, 999999999]`, never a whole second.\n */\nexport function nanosecondsOf(fraction: number): number | undefined {\n  const digits = fractionDigits(fraction);\n  if (digits === undefined || digits.length > NANOSECOND_DIGITS) return undefined;\n  return digits === '' ? 0 : Number(digits.padEnd(NANOSECOND_DIGITS, '0'));\n}\n\n/** A fraction read as whole nanoseconds, or the diagnostic that refuses it. */\nexport type FractionReading =\n  | { readonly ok: true; readonly nanoseconds: number }\n  | { readonly ok: false; readonly issue: ValidationIssue };\n\n/**\n * Check a `fraction` against the contract and read it as whole nanoseconds.\n *\n * Nothing is rounded. A value carrying detail below one nanosecond is REFUSED,\n * because rounding it away would silently change what the sender said, and this\n * package exists to not do that.\n */\nexport function readFraction(fraction: number): FractionReading {\n  if (!Number.isFinite(fraction) || fraction < 0 || fraction >= 1) {\n    return {\n      ok: false,\n      issue: {\n        component: 'fraction',\n        code: 'out-of-range',\n        message: `fraction is a share of one second and must satisfy 0 <= fraction < 1; received the number ${String(fraction)}`,\n      },\n    };\n  }\n\n  const nanoseconds = nanosecondsOf(fraction);\n  if (nanoseconds === undefined) {\n    return {\n      ok: false,\n      issue: {\n        component: 'fraction',\n        code: 'finer-than-nanosecond',\n        message: `fraction carries detail finer than one nanosecond, which this package will not round away; received the number ${String(fraction)}. One nanosecond is nine decimal places of a second, and it is the finest value Temporal can hold`,\n      },\n    };\n  }\n\n  return { ok: true, nanoseconds };\n}\n","import { DatePartsError } from './errors.js';\nimport { readFraction } from './fraction.js';\nimport { PRECISION_LADDER } from './types.js';\nimport type {\n  DateParts,\n  InvalidPartsResult,\n  PartName,\n  Precision,\n  ValidationIssue,\n  ValidationResult,\n} from './types.js';\n\nconst ALL_PARTS: readonly PartName[] = [...PRECISION_LADDER, 'offsetMinutes'];\n\ntype IntegerPart = Exclude<PartName, 'fraction'>;\n\nconst INTEGER_RANGES: Readonly<Record<IntegerPart, readonly [number, number]>> = {\n  year: [1000, 9999],\n  month: [1, 12],\n  day: [1, 31],\n  hour: [0, 23],\n  minute: [0, 59],\n  second: [0, 59],\n  offsetMinutes: [-1439, 1439],\n};\n\nconst RANGE_NOTES: Readonly<Partial<Record<IntegerPart, string>>> = {\n  month: ' (spec-native, January is 1, not 0)',\n  offsetMinutes: ' (signed minutes from UTC)',\n};\n\nconst MONTH_NAMES = [\n  'January',\n  'February',\n  'March',\n  'April',\n  'May',\n  'June',\n  'July',\n  'August',\n  'September',\n  'October',\n  'November',\n  'December',\n] as const;\n\nconst MONTH_LENGTHS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] as const;\n\n/** Proleptic Gregorian, applied to every year in range with no exceptions. */\nfunction isLeapYear(year: number): boolean {\n  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);\n}\n\nfunction daysInMonth(year: number, month: number): number {\n  if (month === 2) return isLeapYear(year) ? 29 : 28;\n  return MONTH_LENGTHS[month - 1] ?? 0;\n}\n\nfunction monthName(month: number): string {\n  return MONTH_NAMES[month - 1] ?? `month ${String(month)}`;\n}\n\n/** A short, non-throwing description of a value, for diagnostics. */\nfunction describe(value: unknown): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n  if (typeof value === 'number') {\n    if (Number.isNaN(value)) return 'NaN';\n    if (!Number.isFinite(value)) return value > 0 ? 'Infinity' : '-Infinity';\n    return `the number ${String(value)}`;\n  }\n  if (typeof value === 'string') return 'a string';\n  if (typeof value === 'boolean') return `the boolean ${String(value)}`;\n  if (typeof value === 'bigint') return 'a bigint';\n  if (typeof value === 'symbol') return 'a symbol';\n  if (typeof value === 'function') return 'a function';\n  if (Array.isArray(value)) return 'an array';\n  return 'an object';\n}\n\nfunction invalid(issues: readonly ValidationIssue[]): InvalidPartsResult {\n  return { valid: false, issues };\n}\n\n/**\n * Read one named component off a candidate parts object.\n *\n * A component can be an accessor, and an accessor can throw. Reading it is\n * therefore guarded, so that a hostile or merely broken object is REPORTED like\n * any other fault rather than raising out of a function whose whole contract is\n * that it answers instead of throwing.\n */\nfunction readComponent(\n  source: Record<string, unknown>,\n  name: PartName,\n):\n  | { readonly ok: true; readonly raw: unknown }\n  | { readonly ok: false; readonly issue: ValidationIssue } {\n  try {\n    return { ok: true, raw: source[name] };\n  } catch {\n    return {\n      ok: false,\n      issue: {\n        component: name,\n        code: 'unreadable',\n        message: `${name} could not be read: the property threw when accessed, so this package cannot see what value it holds and will not guess one`,\n      },\n    };\n  }\n}\n\n/**\n * Check a value against the date-parts contract.\n *\n * Every fault is reported, not only the first, and every diagnostic names the\n * component at fault together with the range or calendar rule it broke. Nothing\n * is coerced, clamped or inferred: a value that does not satisfy the contract\n * comes back invalid rather than corrected.\n *\n * This function never throws, for any argument at all. Hostile input (`null`, a\n * string, a JavaScript `Date`, `NaN`, `Infinity`, a non-integer component, a\n * component that throws when it is read) is reported, not raised.\n *\n * Components are looked up by name, so an object carrying them on its prototype\n * (a class instance with accessors, which is a shape a parser may well hand\n * over) is read the same way a plain object literal is.\n */\nexport function validateParts(value: unknown): ValidationResult {\n  if (typeof value !== 'object' || value === null) {\n    return invalid([\n      {\n        component: 'value',\n        code: 'not-a-parts-object',\n        message: `a date-parts value must be an object carrying the components the contract names; received ${describe(value)}`,\n      },\n    ]);\n  }\n\n  if (value instanceof Date) {\n    return invalid([\n      {\n        component: 'value',\n        code: 'not-a-parts-object',\n        message:\n          'a JavaScript Date is an absolute instant, not a date-parts value: it cannot express a year-only or month-only date, and it carries no offset of its own. Pass the parts the parser returned',\n      },\n    ]);\n  }\n\n  if (Array.isArray(value)) {\n    return invalid([\n      {\n        component: 'value',\n        code: 'not-a-parts-object',\n        message:\n          'a date-parts value must be an object with named components; received an array, whose positions this package will not guess at',\n      },\n    ]);\n  }\n\n  const source = value as Record<string, unknown>;\n  const issues: ValidationIssue[] = [];\n  const present = new Set<PartName>();\n  const values: Partial<Record<PartName, number>> = {};\n\n  for (const name of ALL_PARTS) {\n    const read = readComponent(source, name);\n    if (!read.ok) {\n      present.add(name);\n      issues.push(read.issue);\n      continue;\n    }\n\n    const raw = read.raw;\n    // An explicit `undefined` reads as absent, the way an optional property does.\n    if (raw === undefined) continue;\n    present.add(name);\n\n    if (typeof raw !== 'number') {\n      issues.push({\n        component: name,\n        code: 'not-a-number',\n        message: `${name} must be a number; received ${describe(raw)}`,\n      });\n      continue;\n    }\n\n    if (!Number.isFinite(raw)) {\n      issues.push({\n        component: name,\n        code: 'not-finite',\n        message: `${name} must be a finite number; received ${describe(raw)}`,\n      });\n      continue;\n    }\n\n    if (name === 'fraction') {\n      const reading = readFraction(raw);\n      if (reading.ok) values.fraction = raw;\n      else issues.push(reading.issue);\n      continue;\n    }\n\n    if (!Number.isInteger(raw)) {\n      issues.push({\n        component: name,\n        code: 'not-an-integer',\n        message: `${name} must be a whole number; received the number ${String(raw)}`,\n      });\n      continue;\n    }\n\n    const [low, high] = INTEGER_RANGES[name];\n    if (raw < low || raw > high) {\n      issues.push(\n        name === 'year'\n          ? {\n              component: 'year',\n              code: 'year-not-four-digits',\n              message: `year must be a four-digit year in ${String(low)}-${String(high)}; received the number ${String(raw)}. This package applies no century window and never interprets a two-digit year`,\n            }\n          : {\n              component: name,\n              code: 'out-of-range',\n              message: `${name} must be an integer in ${String(low)}-${String(high)}${RANGE_NOTES[name] ?? ''}; received the number ${String(raw)}`,\n            },\n      );\n      continue;\n    }\n\n    values[name] = raw;\n  }\n\n  checkContiguity(present, issues);\n  checkOffsetHasTimeOfDay(present, issues);\n  checkCalendarDate(values, issues);\n\n  if (issues.length > 0) return invalid(issues);\n\n  const parts: { -readonly [K in keyof DateParts]?: number } = {};\n  for (const name of ALL_PARTS) {\n    const held = values[name];\n    if (held !== undefined) parts[name] = held;\n  }\n\n  return { valid: true, parts, precision: deepestPresent(present) as Precision };\n}\n\nfunction deepestPresent(present: ReadonlySet<PartName>): Precision | undefined {\n  let deepest: Precision | undefined;\n  for (const name of PRECISION_LADDER) {\n    if (present.has(name)) deepest = name;\n  }\n  return deepest;\n}\n\nfunction checkContiguity(present: ReadonlySet<PartName>, issues: ValidationIssue[]): void {\n  const deepest = deepestPresent(present);\n\n  if (deepest === undefined) {\n    issues.push({\n      component: 'year',\n      code: 'missing-component',\n      message:\n        'year is missing: a date-parts value must carry at least a year, and this package never infers one',\n    });\n    return;\n  }\n\n  const deepestIndex = PRECISION_LADDER.indexOf(deepest);\n  for (let index = 0; index < deepestIndex; index += 1) {\n    const name = PRECISION_LADDER[index];\n    if (name === undefined || present.has(name)) continue;\n    issues.push({\n      component: name,\n      code: 'missing-component',\n      message: `${name} is missing while ${deepest} is present: components run from year downward with no gaps, and this package never infers the one you left out`,\n    });\n  }\n}\n\nfunction checkOffsetHasTimeOfDay(present: ReadonlySet<PartName>, issues: ValidationIssue[]): void {\n  if (!present.has('offsetMinutes') || present.has('hour')) return;\n  issues.push({\n    component: 'offsetMinutes',\n    code: 'offset-without-time-of-day',\n    message:\n      'offsetMinutes is present but the value states no time of day: an offset qualifies a clock time, it cannot be rendered without one, and dropping it silently is not an option this package takes',\n  });\n}\n\nfunction checkCalendarDate(\n  values: Partial<Record<PartName, number>>,\n  issues: ValidationIssue[],\n): void {\n  const { year, month, day } = values;\n  if (year === undefined || month === undefined || day === undefined) return;\n\n  const limit = daysInMonth(year, month);\n  if (day <= limit) return;\n\n  const leapNote =\n    month === 2\n      ? `, because ${String(year)} is ${isLeapYear(year) ? 'a' : 'not a'} leap year in the proleptic Gregorian calendar`\n      : '';\n  issues.push({\n    component: 'day',\n    code: 'no-such-calendar-date',\n    message: `day ${String(day)} does not exist: ${monthName(month)} ${String(year)} has ${String(limit)} days${leapNote}`,\n  });\n}\n\n/** A type guard over {@link validateParts}, for callers that want a boolean. */\nexport function isValidParts(value: unknown): value is DateParts {\n  return validateParts(value).valid;\n}\n\n/**\n * Validate and return the recognised components, or throw {@link DatePartsError}\n * carrying the same diagnostics {@link validateParts} would have reported.\n */\nexport function assertValidParts(value: unknown): DateParts {\n  const result = validateParts(value);\n  if (!result.valid) throw new DatePartsError(result.issues);\n  return result.parts;\n}\n\n/**\n * The precision of a value: its least significant present component.\n *\n * Throws {@link DatePartsError} for a value that does not satisfy the contract,\n * because an invalid value has no precision to report.\n */\nexport function precisionOf(value: unknown): Precision {\n  const result = validateParts(value);\n  if (!result.valid) throw new DatePartsError(result.issues);\n  return result.precision;\n}\n","import { Temporal } from 'temporal-polyfill';\n\nimport {\n  AmbiguousLocalTimeError,\n  DatePartsError,\n  MissingZoneError,\n  PrecisionError,\n} from './errors.js';\nimport { readFraction } from './fraction.js';\nimport { PRECISION_LADDER } from './types.js';\nimport type { DateParts, Precision, ZoneOptions } from './types.js';\nimport { validateParts } from './validate.js';\n\n/** The narrowest Temporal type that carries everything a value states, and nothing more. */\nexport type TemporalValue =\n  Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime;\n\ninterface Checked {\n  readonly parts: DateParts;\n  readonly precision: Precision;\n}\n\nfunction check(value: unknown): Checked {\n  const result = validateParts(value);\n  if (!result.valid) throw new DatePartsError(result.issues);\n  return { parts: result.parts, precision: result.precision };\n}\n\nfunction atLeast(precision: Precision, floor: Precision): boolean {\n  return PRECISION_LADDER.indexOf(precision) >= PRECISION_LADDER.indexOf(floor);\n}\n\nfunction pad(value: number, width: number): string {\n  return String(value).padStart(width, '0');\n}\n\n/**\n * Signed minutes rendered as `+HH:MM` or `-HH:MM`.\n *\n * A present offset of zero renders `+00:00` rather than `Z`, so the ISO string\n * says the same thing the parts do: an offset was stated, and it was zero. An\n * ABSENT offset renders nothing at all, because unknown is not UTC.\n */\nfunction formatOffset(offsetMinutes: number): string {\n  const sign = offsetMinutes < 0 ? '-' : '+';\n  const absolute = Math.abs(offsetMinutes);\n  return `${sign}${pad(Math.trunc(absolute / 60), 2)}:${pad(absolute % 60, 2)}`;\n}\n\n/**\n * The whole nanoseconds a fraction denotes.\n *\n * Every converter reads a fraction through the SAME function the validator uses,\n * so a value the validator has just certified can never reach a converter that\n * disagrees with it. A fraction the reader refuses is refused here with the\n * validator's own diagnostic rather than by leaking whatever Temporal makes of\n * a nonsense field.\n *\n * @throws {DatePartsError} if the fraction is not a whole number of nanoseconds.\n */\nfunction nanosecondsOf(fraction: number): number {\n  const reading = readFraction(fraction);\n  if (!reading.ok) throw new DatePartsError([reading.issue]);\n  return reading.nanoseconds;\n}\n\n/** Sub-second digits, trimmed of trailing zeros but never to nothing. */\nfunction formatFraction(fraction: number): string {\n  const digits = pad(nanosecondsOf(fraction), 9).replace(/0+$/, '');\n  return `.${digits === '' ? '0' : digits}`;\n}\n\nfunction subSecondFields(fraction: number | undefined): {\n  millisecond?: number;\n  microsecond?: number;\n  nanosecond?: number;\n} {\n  if (fraction === undefined) return {};\n  const nanoseconds = nanosecondsOf(fraction);\n  return {\n    millisecond: Math.floor(nanoseconds / 1e6),\n    microsecond: Math.floor((nanoseconds % 1e6) / 1e3),\n    nanosecond: nanoseconds % 1e3,\n  };\n}\n\n/**\n * Render a value as an ISO 8601 string AT ITS OWN PRECISION.\n *\n * A year-only value renders `1988`; a month-only value renders `1988-05`. No\n * component the value did not state is ever added, so nothing here turns a year\n * of birth into the first of January.\n *\n * The result is a pure function of the parts. It does not read the host clock or\n * the host time zone, so it is identical under every `TZ`.\n *\n * @throws {DatePartsError} if the value does not satisfy the contract.\n */\nexport function toISO(value: unknown): string {\n  const { parts, precision } = check(value);\n  const suffix = parts.offsetMinutes === undefined ? '' : formatOffset(parts.offsetMinutes);\n\n  let out = pad(parts.year ?? 0, 4);\n  if (precision === 'year') return out;\n\n  out += `-${pad(parts.month ?? 0, 2)}`;\n  if (precision === 'month') return out;\n\n  out += `-${pad(parts.day ?? 0, 2)}`;\n  if (precision === 'day') return out;\n\n  out += `T${pad(parts.hour ?? 0, 2)}`;\n  if (precision === 'hour') return out + suffix;\n\n  out += `:${pad(parts.minute ?? 0, 2)}`;\n  if (precision === 'minute') return out + suffix;\n\n  out += `:${pad(parts.second ?? 0, 2)}`;\n  if (precision === 'second') return out + suffix;\n\n  out += formatFraction(parts.fraction ?? 0);\n  return out + suffix;\n}\n\n/**\n * Convert to the narrowest Temporal type that carries everything the value\n * states, and nothing it does not.\n *\n * | precision of the value | result |\n * |---|---|\n * | `month` | `Temporal.PlainYearMonth` |\n * | `day` | `Temporal.PlainDate`, with no time of day and no zone |\n * | `hour` and finer, no offset | `Temporal.PlainDateTime`, with no zone |\n * | `hour` and finer, with `offsetMinutes` | `Temporal.ZonedDateTime` at that exact offset |\n *\n * A year-only value has no Temporal counterpart and raises\n * {@link PrecisionError} rather than acquiring a month. Use {@link toISO} for\n * those, and {@link precisionOf} to branch.\n *\n * Components below the value's own precision are zero in the Temporal object,\n * because Temporal has no partial type below `PlainYearMonth`. The value's real\n * precision is still available from {@link precisionOf}; it is not lost, it just\n * cannot be carried by the returned object.\n *\n * @throws {DatePartsError} if the value does not satisfy the contract.\n * @throws {PrecisionError} for a year-only value.\n */\nexport function toTemporal(value: unknown): TemporalValue {\n  const { parts, precision } = check(value);\n\n  if (precision === 'year') {\n    throw new PrecisionError(\n      'Temporal has no year-only type, and this package will not invent a month to reach one. Use toISO() to render a year-precision value, or precisionOf() to branch before converting',\n      precision,\n    );\n  }\n\n  const year = parts.year ?? 0;\n  const month = parts.month ?? 0;\n\n  if (precision === 'month') {\n    return Temporal.PlainYearMonth.from({ year, month }, { overflow: 'reject' });\n  }\n\n  const day = parts.day ?? 0;\n  if (precision === 'day') {\n    return Temporal.PlainDate.from({ year, month, day }, { overflow: 'reject' });\n  }\n\n  const fields = {\n    year,\n    month,\n    day,\n    hour: parts.hour ?? 0,\n    minute: parts.minute ?? 0,\n    second: parts.second ?? 0,\n    ...subSecondFields(parts.fraction),\n  };\n\n  if (parts.offsetMinutes !== undefined) {\n    return Temporal.ZonedDateTime.from(\n      { ...fields, timeZone: formatOffset(parts.offsetMinutes) },\n      { overflow: 'reject' },\n    );\n  }\n\n  return Temporal.PlainDateTime.from(fields, { overflow: 'reject' });\n}\n\nfunction assertKnownTimeZone(timeZone: string): void {\n  try {\n    // A fixed epoch, so this probe never reads the host clock or the host zone.\n    Temporal.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(timeZone);\n  } catch {\n    throw new RangeError(\n      `unknown time zone ${JSON.stringify(timeZone)}: supply an IANA identifier such as \"America/New_York\", or an offset such as \"+05:30\"`,\n    );\n  }\n}\n\nfunction assertUsableOffset(offsetMinutes: number): void {\n  if (!Number.isInteger(offsetMinutes) || offsetMinutes < -1439 || offsetMinutes > 1439) {\n    throw new RangeError(\n      `offsetMinutes must be an integer in -1439-1439 (signed minutes from UTC); received ${String(offsetMinutes)}`,\n    );\n  }\n}\n\n/**\n * Decide which zone places this value on the timeline, or refuse.\n *\n * The value's OWN `offsetMinutes` always wins. That is what the sender said, and\n * re-zoning it on a caller's say-so would move the instant. `options` therefore\n * apply only to a value whose offset is unknown, which is exactly the case they\n * exist for.\n */\nfunction resolveTimeZone(parts: DateParts, options: ZoneOptions | undefined): string {\n  if (parts.offsetMinutes !== undefined) return formatOffset(parts.offsetMinutes);\n\n  if (options?.timeZone !== undefined && options.offsetMinutes !== undefined) {\n    throw new TypeError(\n      'supply either timeZone or offsetMinutes, not both: two answers to one question is a guess waiting to happen',\n    );\n  }\n\n  if (options?.offsetMinutes !== undefined) {\n    assertUsableOffset(options.offsetMinutes);\n    return formatOffset(options.offsetMinutes);\n  }\n\n  if (options?.timeZone !== undefined) {\n    assertKnownTimeZone(options.timeZone);\n    return options.timeZone;\n  }\n\n  throw new MissingZoneError(\n    'this value carries no offsetMinutes, and no zone was supplied: an absolute instant needs a zone, and this package supplies none. Pass { timeZone } or { offsetMinutes }. It will not fall back to the host time zone, to UTC, or to any other default, because a fallback turns an unknown offset into a plausible wrong instant',\n  );\n}\n\n/**\n * Place a value on the timeline in a stated zone.\n *\n * Requires a time of day. A day-precision value is a calendar date, and turning\n * one into a zoned instant means choosing midnight, which is a component the\n * value does not carry. Use {@link toTemporal} for those.\n *\n * Requires a zone. If the value carries `offsetMinutes` that offset is used and\n * PRESERVED EXACTLY, never normalised to UTC or to the host zone, and `options`\n * are not consulted. Otherwise `options.timeZone` or `options.offsetMinutes`\n * must say which zone the local time is in.\n *\n * A local time that a named zone skips or repeats across a daylight-saving\n * transition raises {@link AmbiguousLocalTimeError} rather than resolving to\n * one of the two candidates, because a silent pick shifts the value by an hour.\n *\n * @throws {DatePartsError} if the value does not satisfy the contract.\n * @throws {PrecisionError} if the value states no time of day.\n * @throws {MissingZoneError} if nothing says which zone applies.\n * @throws {AmbiguousLocalTimeError} at a daylight-saving transition.\n */\nexport function toZonedDateTime(value: unknown, options?: ZoneOptions): Temporal.ZonedDateTime {\n  const { parts, precision } = check(value);\n\n  if (!atLeast(precision, 'hour')) {\n    // A value below hour precision that also states no zone is missing BOTH, and\n    // hearing about them one at a time is how a caller fixes one and comes back.\n    // The precision is what is reported, because supplying a zone would not make\n    // this value convertible, but the message says the zone is absent too, and\n    // says as firmly as the zone refusal does that nothing will be defaulted.\n    const alsoNoZone =\n      parts.offsetMinutes === undefined &&\n      options?.timeZone === undefined &&\n      options?.offsetMinutes === undefined;\n\n    throw new PrecisionError(\n      `an absolute instant needs a time of day, and this value has ${precision} precision. Supplying one would mean inventing components the value does not carry. Use toTemporal() for the calendar value${\n        alsoNoZone\n          ? '. The zone is missing too: this value carries no offsetMinutes and no { timeZone } or { offsetMinutes } was supplied, and neither the host time zone nor UTC will be used in their place'\n          : ''\n      }`,\n      precision,\n    );\n  }\n\n  const timeZone = resolveTimeZone(parts, options);\n  const local = Temporal.PlainDateTime.from(\n    {\n      year: parts.year ?? 0,\n      month: parts.month ?? 0,\n      day: parts.day ?? 0,\n      hour: parts.hour ?? 0,\n      minute: parts.minute ?? 0,\n      second: parts.second ?? 0,\n      ...subSecondFields(parts.fraction),\n    },\n    { overflow: 'reject' },\n  );\n\n  // Ambiguity is established by ASKING, not by catching. The two disambiguation\n  // rules agree on every local time a zone maps exactly once, and disagree on\n  // exactly the times a transition skips or repeats. Reading the answer off a\n  // thrown message would instead relabel any other failure as a transition, and\n  // a fixed offset zone, which has no transitions at all, would be told it did.\n  const earliest = local.toZonedDateTime(timeZone, { disambiguation: 'earlier' });\n  const latest = local.toZonedDateTime(timeZone, { disambiguation: 'later' });\n\n  if (!earliest.equals(latest)) {\n    // A repeated local time still reads back as itself, at two offsets. A skipped\n    // one cannot: both rules move it off the gap, so the wall clock shifts.\n    const skipped = !earliest.toPlainDateTime().equals(local);\n    throw new AmbiguousLocalTimeError(\n      skipped\n        ? `${local.toString()} does not exist in ${timeZone}: a daylight-saving transition skips it, so there is no instant to return. Say which side of the transition you mean by passing that offset as { offsetMinutes }`\n        : `${local.toString()} happens twice in ${timeZone}: a daylight-saving transition repeats it, at ${earliest.offset} and again at ${latest.offset}, so there is no single instant to return. Choose the one you mean and pass it as { offsetMinutes }`,\n    );\n  }\n\n  return earliest;\n}\n\n/**\n * The absolute instant a value denotes, in a stated zone.\n *\n * Same requirements as {@link toZonedDateTime}: a time of day, and a zone that\n * something states. Nothing is defaulted.\n */\nexport function toInstant(value: unknown, options?: ZoneOptions): Temporal.Instant {\n  return toZonedDateTime(value, options).toInstant();\n}\n"]}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@cosyte/dates",
+  "version": "0.1.0",
+  "description": "Date and time utilities for the @cosyte/* healthcare parsers: precision-preserving conversion and validation that never guesses a timezone.",
+  "license": "MIT",
+  "author": "Cosyte",
+  "type": "module",
+  "sideEffects": false,
+  "homepage": "https://docs.cosyte.com/dates",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cosyte/dates.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cosyte/dates/issues"
+  },
+  "keywords": [
+    "date",
+    "datetime",
+    "healthcare",
+    "hl7",
+    "fhir",
+    "temporal",
+    "iso-8601",
+    "precision",
+    "timezone",
+    "validation",
+    "typescript"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "temporal-polyfill": "1.0.4"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.4",
+    "@changesets/cli": "2.31.0",
+    "@cosyte/script-utils": "0.1.1",
+    "@eslint/js": "10.0.1",
+    "@types/node": "22.20.1",
+    "eslint": "10.9.1",
+    "prettier": "3.9.6",
+    "tsup": "8.5.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.68.0",
+    "vitest": "4.1.11"
+  },
+  "scripts": {
+    "build": "tsup",
+    "changeset": "changeset",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint . --max-warnings=0",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.{ts,mjs}\" \"examples/**/*.{ts,md}\" \"docs-content/**/*.{md,json}\" \"*.{ts,json,md,yml}\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.{ts,mjs}\" \"examples/**/*.{ts,md}\" \"docs-content/**/*.{md,json}\" \"*.{ts,json,md,yml}\"",
+    "test": "vitest run",
+    "test:tz": "TZ=UTC vitest run && TZ=Pacific/Kiritimati vitest run",
+    "examples": "tsx scripts/run-examples.ts",
+    "clean": "rm -rf dist coverage .tmp dist-artifacts",
+    "attw": "node scripts/attw.mjs --profile esm-only",
+    "pack:docs": "bash scripts/build-docs-artifacts.sh",
+    "check:no-emdash": "bash scripts/check-no-emdash.sh",
+    "check:no-internal-refs": "node scripts/check-no-internal-refs.mjs",
+    "version": "changeset version && prettier --write package.json CHANGELOG.md",
+    "release": "changeset publish"
+  }
+}