@jarenjs/core 0.49.2 → 0.66.1

package/dist/types/stats.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @file Descriptive statistics over a sample of numbers: the mean, the
+ * sample variance and its root, the median, and a quantile that will
+ * not answer until told which quantile it is being asked for.
+ *
+ * Before this file the suite computed these in two places with two
+ * quantile rules — linear interpolation in the query layer's statistics
+ * pack, nearest rank in the benchmark harness — and each was the right
+ * rule for its consumer: an interpolated percentile is what an analyst
+ * expects of `$percentile`, while a benchmark row of eleven readings
+ * should not publish a latency nobody measured. Both rules stay; the
+ * definitions move here so that there is one of each, and `quantile`
+ * makes the caller name its method, because "the 95th percentile" of a
+ * small sample is a different number under every one of the seven
+ * common definitions and a default would decide silently.
+ *
+ * Every function answers `undefined` for a sample it cannot summarize —
+ * an empty one, or fewer than two values for a variance — rather than
+ * `NaN` or `0`: a number that was not measured must not format as one.
+ * The caller's array is never reordered; a quantile sorts a copy.
+ * Values are numbers by contract and are not checked one by one.
+ */
+/**
+ * The arithmetic mean.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for an empty sample
+ */
+export declare function mean(values: readonly number[]): number | undefined;
+/**
+ * The SAMPLE variance, with Bessel's correction (`n − 1`): the sample is
+ * taken as drawn from a population it did not enumerate, which is what a
+ * benchmark's rounds and a query's rows both are.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for fewer than two values
+ */
+export declare function variance(values: readonly number[]): number | undefined;
+/**
+ * The sample standard deviation — the root of {@link variance}.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` where the variance is
+ */
+export declare function stddev(values: readonly number[]): number | undefined;
+/**
+ * The median: the middle value, or the mean of the two middle values
+ * when the sample has an even count.
+ *
+ * This is NOT `quantile(values, 0.5, …)` under either method, and on an
+ * even count the three disagree: for `[1, 2, 3, 4]` the median is `2.5`,
+ * the nearest-rank p50 is `2`, and the linear p50 is `2.5` only because
+ * that sample happens to be evenly spaced. A consumer publishing a "p50"
+ * beside a "p95" wants `quantile` with its method named; a consumer
+ * asking for the median wants this.
+ * @param {readonly number[]} values
+ * @returns {number | undefined} `undefined` for an empty sample
+ */
+export declare function median(values: readonly number[]): number | undefined;
+export type QuantileMethod = 'nearest-rank' | 'linear';
+/**
+ * The `p`-quantile of a sample, `p` on `[0, 1]`, under a NAMED method.
+ *
+ * The method is required, not defaulted: on a small sample the common
+ * definitions disagree by whole values, and a caller who did not say
+ * which one it wanted has published a number it cannot explain.
+ * @param {readonly number[]} values
+ * @param {number} p - the probability, `0` (the minimum) to `1` (the maximum)
+ * @param {{ method: QuantileMethod }} options
+ * @returns {number | undefined} `undefined` for an empty sample
+ * @throws {TypeError} when `method` is absent or not one of {@link QuantileMethod}
+ * @throws {RangeError} when `p` is not a number in `[0, 1]`
+ */
+export declare function quantile(values: readonly number[], p: number, options: {
+    method: QuantileMethod;
+}): number | undefined;

package/dist/types/string.d.ts

@@ -54,6 +54,19 @@ export declare function getStringLength(str: string, useGrapheme?: boolean): num
  * @returns {number} Number of occurrences in [start, end)
  */
 export declare function countCharCode(str: string, code: number, start?: number, end?: number): number;
+/**
+ * The UTF-8 byte length of a slice of a string — the one measure every
+ * byte bound in the suite counts (a body limit, a page, a change
+ * record, a parser's record or token limit) — computed without encoding
+ * a copy: one byte below U+0080, two below U+0800, four for a surrogate
+ * pair (one code point), three otherwise; a lone surrogate counts three,
+ * as its replacement would.
+ * @param {string} str
+ * @param {number} [start] - Inclusive start offset (defaults to 0)
+ * @param {number} [end] - Exclusive end offset (defaults to full length)
+ * @returns {number} The UTF-8 bytes of `str[start, end)`
+ */
+export declare function utf8ByteLength(str: string, start?: number, end?: number): number;
 /**
  * Count the Unicode code points of a string (surrogate-pair aware;
  * a lone surrogate counts as one code point).

package/docs/DATES.md

@@ -21,7 +21,9 @@ Parsing: `parseRFC3339Parts(str)` → a flat **parts** record
 `{year, month, day, hours, minutes, seconds, offset}`. Absent fields are
 `-1` sentinels; `offset` is minutes east of UTC, `0` for `Z` and `null`
 when the string carried none. The inverse is `formatRFC3339Parts(parts)`
-(round-trips the offset). `epochOfRFC3339Parts(parts)` → epoch ms: a
+(round-trips the offset and up to six fractional-second digits, dropping
+trailing zeros). The `SSS` formatting token writes the first three fraction
+digits. `epochOfRFC3339Parts(parts)` → epoch ms: a
 date-only reads as UTC midnight, an offset shifts to its instant, and a
 time-only has **no** instant — it returns `NaN` rather than inventing a
 day. `getDateTypeOf*` variants produce a `Date` for callers that want

package/docs/GEO.md

@@ -22,10 +22,10 @@ the *wrong sign* on near-collinear input, which makes containment
 contradict itself. `orient2dFast` is the naive form, exported for
 callers that provably do not care. Every winding and containment answer
 in this module rests on this sign; its cost is the deliberate
-point-in-polygon loss on the benchmark page (<!--bm:geo.pip2000-->0.5×<!--/bm--> against
+point-in-polygon loss on the benchmark page (<!--fact:geo.pip2000-->0.5×<!--/fact--> against
 Turf at 2000 vertices, kept on purpose). Every loss the kernel carries is
 published in [ARCHITECTURE](../ARCHITECTURE.md), derived from the committed
-measurement: <!--bm:geo.losses-->three rows lose to a rival: point in polygon (2000-vertex) at 0.5× (turf), bounding box (2000-vertex) at 0.9× (turf), index build (100k boxes) at 0.8× (flatbush)<!--/bm-->.
+measurement: <!--fact:geo.losses-->three rows lose to a rival: point in polygon (2000-vertex) at 0.5× (turf), bounding box (2000-vertex) at 0.9× (turf), index build (100k boxes) at 0.8× (flatbush)<!--/fact-->.
 
 ## Distance — `distance.js`
 

package/docs/SERIES.md

@@ -177,6 +177,20 @@ with no provider is a refusal, never a quiet fall back to UTC — which is
 right for Amsterdam for none of the year and *looks* right for eight
 months of it.
 
+The seam is crossed, not closed. `@jarenjs/locales/intl-zones` ships
+`createIntlZoneProvider()`, a provider over the host's own ICU data —
+the one copy of the tzdb that is already installed and already
+maintained — that a caller passes as `provider`. It is opt-in and on
+its own subpath, because ICU output moves between hosts and may not be
+anyone's default; it never reads the host's own zone, because every
+call names its zone and there is no default that asks the process
+where it is; and it answers a gap and a fold exactly, proved by a
+transition corpus rather than by examples. Nothing about the seam
+moves: this kernel still bundles no zone data and reaches for no
+`Intl`, a named zone with no provider is still a refusal, and a host
+with a tzdb of its own still passes that instead. The provider's own
+document is [`@jarenjs/locales`' README](../../locales/README.md).
+
 ## Buckets, resampling and fill — `bucket.js`
 
 Two questions that are always asked together and are not the same
@@ -311,32 +325,33 @@ downsampleSeries(readings, { target: 2000 });   // → { points, sourceCount, re
 
 ## What it costs
 
-Measured by `benchmark/series.js` over <!--bm:series.corpus-->100,000 samples at 1-second spacing, Node v24.19.0<!--/bm-->,
+Measured by `benchmark/series.js` over <!--fact:series.corpus-->100,000 samples at 1-second spacing, Node v24.19.0<!--/fact-->,
 which gates every timing on equivalence first: no number below is printed
 unless the kernel answered the identical rows the references did.
 
 The kernel is not the ceiling and does not claim to be. A one-pass loop
 written for one question validates nothing, normalizes nothing and
-returns a bare pair. Against those loops the kernel costs <!--bm:series.kernelVsCeiling-->3.4× the one-pass bucket loop and 6.2× the one-pass ring sum<!--/bm-->,
-and against the vocabulary a consumer had instead it is <!--bm:series.kernelVsQuery-->73.6× faster than the generic query bucket and 81.2× faster than the labelled count window<!--/bm-->.
+returns a bare pair. Against those loops the kernel costs <!--fact:series.kernelVsCeiling-->3.3× the one-pass bucket loop and 6.0× the one-pass ring sum<!--/fact-->,
+and against the vocabulary a consumer had instead it is <!--fact:series.kernelVsQuery-->76.7× faster than the generic query bucket and 78.5× faster than the labelled count window<!--/fact-->.
 
-<!--bm:series.kernelTable-->
+<!--fact:series.kernelTable-->
 | operation | median | rows | against | what that is | ratio |
 |---|---:|---:|---:|---|---:|
-| `resampleSeries`, 60 s buckets | 1.5 ms | 1,667 | 0.45 ms | one-pass loop | 3.4× |
-| `resampleSeries`, + linear fill | 1.1 ms | 1,657 | 1 ms | the same buckets, omitting | 1.0× |
-| `rollingSeries`, 60 s window | 7.2 ms | 100,000 | 1.2 ms | one-pass ring sum | 6.2× |
-| `asOfJoin`, one left row per 100 | 1.7 ms | 1,000 | 2.2 ms | one index read per row | 0.8× |
-| `downsampleSeries`, lttb, gap corpus | 1.6 ms | 2,000 | 1.8 ms | the same line with no holes in it | 0.9× |
-<!--/bm-->
+| `resampleSeries`, 60 s buckets | 1.6 ms | 1,667 | 0.47 ms | one-pass loop | 3.3× |
+| `resampleSeries`, + linear fill | 1.1 ms | 1,657 | 1 ms | the same buckets, omitting | 1.1× |
+| `rollingSeries`, 60 s window | 7.6 ms | 100,000 | 1.3 ms | one-pass ring sum | 6.0× |
+| `asOfJoin`, one left row per 100 | 1.7 ms | 1,000 | 1.7 ms | one index read per row | 1.0× |
+| `downsampleSeries`, lttb, gap corpus | 1.7 ms | 2,000 | 1.9 ms | the same line with no holes in it | 0.9× |
+<!--/fact-->
 
-A row that loses stays in, and the two shapes of the same join are published side by side rather than the flattering one alone. <!--bm:series.asofShape-->The as-of join costs 14.7× a handful of index reads, and beats them by 1.3× once there is one left row per hundred right ones. The reason is the shape rather than the engine: a b-tree pays per probe, and a sorted walk pays for the whole right side whether it was asked one question or a thousand.<!--/bm-->
+A row that loses stays in, and the two shapes of the same join are published side by side rather than the flattering one alone. <!--fact:series.asofShape-->The as-of join costs 19.7× a handful of index reads, and narrows to 1.0× the same join once there is one left row per hundred right ones — still the statement's win, published as one. The reason is the shape rather than the engine: a b-tree pays per probe, and a sorted walk pays for the whole right side whether it was asked one question or a thousand.<!--/fact-->
 
-And the seam has a price that this corpus cannot charge it. <!--bm:series.zoneCost-->Walking every boundary through an injected zone provider costs 1.0× the integer ladder over an identical answer — near parity because it is near nothing, since the benchmark corpus spans 28 hours and holds two daily boundaries. What the suite gates instead is that the provider is consulted per boundary rather than per sample.<!--/bm-->
+And the seam has a price that this corpus cannot charge it. <!--fact:series.zoneCost-->Walking every boundary through the shipped Intl zone provider costs 1.1× the integer ladder over an identical answer — a handful of ICU reads against the whole ladder, since the benchmark corpus spans 28 hours and holds two daily boundaries. What the suite gates is that the provider is consulted per boundary rather than per sample.<!--/fact-->
 
 ## Not here
 
-Named time zones are injected, never bundled; recurrence grammars
+Named time zones are injected, never bundled — the provider over host
+ICU lives opt-in in `@jarenjs/locales`, not here; recurrence grammars
 (RRULE, iCalendar) and any kind of scheduling solver are somebody else's
 layer. This module supplies the algebra those are built from, and
 nothing that needs a clock, a locale or a zone database to be correct.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/core",
   "private": false,
-  "version": "0.49.2",
+  "version": "0.66.1",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -40,6 +40,10 @@
       "types": "./dist/types/array.d.ts",
       "default": "./src/array.js"
     },
+    "./async": {
+      "types": "./dist/types/async.d.ts",
+      "default": "./src/async.js"
+    },
     "./bigint": {
       "types": "./dist/types/bigint.d.ts",
       "default": "./src/bigint.js"
@@ -104,6 +108,14 @@
       "types": "./dist/types/object.d.ts",
       "default": "./src/object.js"
     },
+    "./random": {
+      "types": "./dist/types/random.d.ts",
+      "default": "./src/random.js"
+    },
+    "./runtime": {
+      "types": "./dist/types/runtime.d.ts",
+      "default": "./src/runtime.js"
+    },
     "./scan": {
       "types": "./dist/types/scan.d.ts",
       "default": "./src/scan.js"
@@ -120,6 +132,10 @@
       "types": "./dist/types/series/*.d.ts",
       "default": "./src/series/*.js"
     },
+    "./stats": {
+      "types": "./dist/types/stats.d.ts",
+      "default": "./src/stats.js"
+    },
     "./string": {
       "types": "./dist/types/string.d.ts",
       "default": "./src/string.js"

package/src/async.js

@@ -0,0 +1,285 @@
+//@ts-check
+/**
+ * @file The bounded ordered asynchronous map: run a worker over a list
+ * with never more than `limit` calls in flight, and answer the results
+ * in the list's order. Before this file the same twelve lines lived in
+ * the AI package's program runner and in the benchmark harness, and a
+ * downstream consumer had written them a third time; a pool that exists
+ * once is one whose edge behavior can be pinned once.
+ *
+ * The contract, in full:
+ *
+ *  - results are in INPUT order, whatever order the workers finish in;
+ *  - never more than `limit` workers are in flight; `limit` must be a
+ *    number of at least 1 (`Infinity` is allowed and means unbounded) —
+ *    anything else is a `TypeError`, never a silent clamp, because a
+ *    limit of 0 is a bug in the caller and "sequential" is spelled 1;
+ *  - a worker rejection stops dispatch: no item starts after it, the
+ *    workers already in flight are awaited, and only then does the map
+ *    reject with that first rejection. A worker that throws
+ *    synchronously is a rejection;
+ *  - an abort does the same, rejecting with the signal's reason; a signal
+ *    that is already aborted rejects before any worker runs;
+ *  - so when the returned promise settles, NO worker is still running —
+ *    the caller can close whatever the workers were using.
+ *
+ * The map does not retry, rate-limit, delay per origin or know anything
+ * about what the worker does; those are the caller's policies around it.
+ */
+
+import { isThenable } from './function.js';
+
+/**
+ * @template T, R
+ * @param {readonly T[]} items
+ * @param {number} limit - workers in flight at once; a number >= 1, `Infinity` for unbounded
+ * @param {(item: T, index: number) => Promise<R> | R} worker
+ * @param {{ signal?: AbortSignal }} [options]
+ * @returns {Promise<R[]>} the results, in input order
+ * @throws {TypeError} (as a rejection) when `limit` is not a number >= 1
+ */
+export async function mapConcurrent(items, limit, worker, options = {}) {
+  if (typeof limit !== 'number' || !(limit >= 1))
+    throw new TypeError(`mapConcurrent needs a limit of at least 1, got ${String(limit)}`);
+  const { signal } = options;
+  if (signal?.aborted) throw signal.reason;
+  const count = items.length;
+  /** @type {R[]} */
+  const results = new Array(count);
+  if (count === 0) return results;
+
+  let next = 0;
+  // the first failure or abort, kept as a one-element list: the lanes
+  // stop dispatching the moment it is set and drain what they hold
+  /** @type {unknown[]} */
+  const stop = [];
+  /** @type {(() => void) | undefined} */
+  let onAbort;
+  if (signal !== undefined) {
+    onAbort = () => { if (stop.length === 0) stop.push(signal.reason); };
+    signal.addEventListener('abort', onAbort, { once: true });
+  }
+
+  const lane = async () => {
+    while (stop.length === 0) {
+      const index = next++;
+      if (index >= count) return;
+      try {
+        results[index] = await worker(items[index], index);
+      }
+      catch (error) {
+        if (stop.length === 0) stop.push(error);
+      }
+    }
+  };
+  const lanes = Array.from({ length: Math.min(limit, count) }, lane);
+  await Promise.all(lanes);
+  if (onAbort !== undefined) signal?.removeEventListener('abort', onAbort);
+  if (stop.length > 0) throw stop[0];
+  return results;
+}
+
+/**
+ * The underlying sink an awaited sink serializes: `write` answers a
+ * value (the chunk is written) or a promise (the chunk is written when
+ * it settles — a socket waiting for `drain`, a stream waiting for the
+ * consumer's next pull); `end` and `abort` are optional and may answer
+ * either way too.
+ * @template T
+ * @typedef {Object} SinkLike
+ * @property {(chunk: T) => unknown} write
+ * @property {() => unknown} [end]
+ * @property {(reason: unknown) => unknown} [abort]
+ */
+
+/**
+ * The serialized, awaited view of a sink.
+ * @template T
+ * @typedef {Object} AwaitedSink
+ * @property {(chunk: T) => Promise<void> | undefined} write - queue one
+ *   chunk behind every earlier write; `undefined` when the underlying
+ *   write answered synchronously with nothing pending (the fast path),
+ *   else a promise that settles when the underlying write did
+ * @property {() => Promise<void>} end - queue the underlying `end` once
+ *   after every write; repeated calls answer the same promise
+ * @property {(reason?: unknown) => Promise<void>} abort - stop accepting
+ *   writes, reject the writes still queued, and call the underlying
+ *   `abort` once, immediately; repeated calls answer the same promise
+ * @property {() => boolean} failed - whether a write rejected or an abort
+ *   happened; nothing reaches the underlying sink after that
+ * @property {() => boolean} closed - whether `end` or `abort` was called
+ */
+
+/**
+ * Serialize a sink: every write waits for the previous one, `end` waits
+ * for every write, and one failure stops everything after it. This is
+ * the one place the suite decides what "the next chunk" means for a
+ * sink that may answer a promise — a Node response whose `write()` said
+ * `false` (wait for `drain`), a Web `ReadableStream` bridge that waits
+ * for the consumer's pull, a stream runner whose carrier hooks may be
+ * asynchronous — so backpressure is a property of the sink, never of
+ * the code writing into it.
+ *
+ * The contract, in full:
+ *
+ *  - writes reach the underlying sink in call order and never overlap:
+ *    the next underlying write begins only after the previous one
+ *    settled;
+ *  - a synchronous sink stays on a no-extra-promise fast path: while
+ *    nothing is pending and the underlying write answers a non-thenable,
+ *    `write` answers `undefined`; the first thenable answer opens the
+ *    queue, and an idle queue returns to the fast path;
+ *  - `end()` runs the underlying `end` once, after every write queued
+ *    before it; `abort(reason)` runs the underlying `abort` once, at once
+ *    (an abort is urgent — the pending underlying write is not waited
+ *    for), and every write still queued rejects with the reason;
+ *  - a write that throws or rejects (including a throwing `then` getter
+ *    on its answer) fails the sink: its own promise
+ *    rejects, every write queued behind it rejects with the same reason
+ *    without reaching the underlying sink, later writes reject at once,
+ *    and `end()` rejects too — the stream did not end cleanly;
+ *  - `end` and `abort` are mutually terminal: the first one decides, the
+ *    other one (and every repeat) answers the first one's promise; a
+ *    write after either rejects;
+ *  - `write` never throws — a refusal is a rejected promise, so a caller
+ *    handles one shape.
+ *
+ * @template T
+ * @param {SinkLike<T>} sink
+ * @returns {AwaitedSink<T>}
+ * @throws {TypeError} when `sink` has no `write` function
+ */
+export function createAwaitedSink(sink) {
+  if (sink === null || typeof sink !== 'object' || typeof sink.write !== 'function') {
+    throw new TypeError('createAwaitedSink needs a sink with a write function');
+  }
+  /** whether an underlying operation is in flight (it answered a thenable) */
+  let running = false;
+  /**
+   * The operations waiting for the one in flight, in call order.
+   * @type {{ op: () => unknown, resolve: () => void, reject: (reason: unknown) => void }[]}
+   */
+  const queued = [];
+  let failed = false;
+  /** @type {unknown} */
+  let failure;
+  let closed = false;
+  /** @type {Promise<void> | null} the first end()/abort() settlement */
+  let terminal = null;
+
+  /** @param {unknown} reason */
+  const fail = (reason) => {
+    if (failed) return;
+    failed = true;
+    failure = reason;
+  };
+
+  /** Run what is queued, one at a time, until one answers a thenable. */
+  const next = () => {
+    while (!running && queued.length > 0) {
+      const item = /** @type {NonNullable<typeof queued[0]>} */ (queued.shift());
+      if (failed) {
+        item.reject(failure);
+        continue;
+      }
+      let answer;
+      try {
+        answer = item.op();
+        if (!isThenable(answer)) {
+          item.resolve();
+          continue;
+        }
+      }
+      catch (err) {
+        fail(err);
+        item.reject(err);
+        continue;
+      }
+      running = true;
+      Promise.resolve(answer).then(() => {
+        running = false;
+        item.resolve();
+        next();
+      }, (err) => {
+        running = false;
+        fail(err);
+        item.reject(err);
+        next();
+      });
+    }
+  };
+
+  /**
+   * Run one operation behind the queue.
+   * @param {() => unknown} op
+   * @returns {Promise<void> | undefined}
+   */
+  const run = (op) => {
+    if (running || queued.length > 0) {
+      return new Promise((resolve, reject) => { queued.push({ op, resolve, reject }); });
+    }
+    let answer;
+    try {
+      answer = op();
+      if (!isThenable(answer)) return undefined;
+    }
+    catch (err) {
+      fail(err);
+      return Promise.reject(err);
+    }
+    running = true;
+    return new Promise((resolve, reject) => {
+      Promise.resolve(answer).then(() => {
+        running = false;
+        resolve();
+        next();
+      }, (err) => {
+        running = false;
+        fail(err);
+        reject(err);
+        next();
+      });
+    });
+  };
+
+  return {
+    write(chunk) {
+      if (failed) return Promise.reject(failure);
+      if (closed) return Promise.reject(new Error('createAwaitedSink: write after end'));
+      return run(() => sink.write(chunk));
+    },
+    end() {
+      if (terminal !== null) return terminal;
+      closed = true;
+      if (failed) {
+        terminal = Promise.reject(failure);
+        return terminal;
+      }
+      const answer = run(() => (typeof sink.end === 'function' ? sink.end() : undefined));
+      terminal = answer === undefined ? Promise.resolve() : answer;
+      return terminal;
+    },
+    abort(reason) {
+      if (terminal !== null) return terminal;
+      closed = true;
+      const why = reason === undefined ? new Error('createAwaitedSink: aborted') : reason;
+      fail(why);
+      // what is still queued rejects now — an abort does not wait for
+      // the operation in flight, whose late settlement is then ignored
+      const waiting = queued.splice(0, queued.length);
+      for (let i = 0; i < waiting.length; i++) waiting[i].reject(why);
+      let answer;
+      try {
+        answer = typeof sink.abort === 'function' ? sink.abort(why) : undefined;
+      }
+      catch (err) {
+        terminal = Promise.reject(err);
+        return terminal;
+      }
+      terminal = Promise.resolve(answer).then(() => undefined);
+      return terminal;
+    },
+    failed: () => failed,
+    closed: () => closed,
+  };
+}

package/src/dates/format.js

@@ -40,6 +40,13 @@ import {
 const D2 = (n) => (n < 10 ? '0' + n : '' + n);
 const D3 = (n) => (n < 10 ? '00' + n : n < 100 ? '0' + n : '' + n);
 
+// The parser retains up to six fractional digits. Round the whole seconds
+// before extracting them, so subtraction does not expose binary noise.
+/** @param {number} seconds */
+function fractionDigits(seconds) {
+  return seconds.toFixed(6).slice(-6);
+}
+
 function pad(n, width) {
   const s = '' + n;
   return s.length >= width ? s : '0'.repeat(width - s.length) + s;
@@ -86,8 +93,8 @@ const TOKENS = {
   m: (p) => '' + p.minutes,
   ss: (p) => D2(Math.trunc(p.seconds)),
   s: (p) => '' + Math.trunc(p.seconds),
-  SSS: (p) => D3(Math.round((p.seconds - Math.trunc(p.seconds)) * 1000)),
-  S: (p) => '' + Math.trunc((p.seconds - Math.trunc(p.seconds)) * 10),
+  SSS: (p) => fractionDigits(p.seconds).slice(0, 3),
+  S: (p) => fractionDigits(p.seconds).slice(0, 1),
   a: (p, n) => n.meridiem[p.hours < 12 ? 0 : 1],
   XXX: (p) => offsetText(p.offset, true, true),
   XX: (p) => offsetText(p.offset, false, true),
@@ -203,7 +210,8 @@ const FORMAT_TIME = compileDateFormat('HH:mm:ssXXX');
  * `full-time`, and the offset is the record's own rather than UTC.
  *
  * The round trip preserves the *value*, not necessarily the spelling: a
- * fractional second is emitted only when non-zero and without trailing
+ * fractional second keeps the parser's six-digit precision and is emitted
+ * only when non-zero and without trailing
  * zeros, so `…:05.250Z` comes back `…:05.25Z`. The parts record holds
  * the fraction as a number, so the original digit count is not
  * recoverable — a consumer that must reproduce the input byte for byte
@@ -222,9 +230,11 @@ export function formatRFC3339Parts(parts) {
   if (fraction === 0)
     return base;
   // splice the fraction in after the seconds, before the offset
-  const digits = fraction.toFixed(3).slice(1).replace(/0+$/, '');
+  const digits = fractionDigits(parts.seconds).replace(/0+$/, '');
+  if (digits.length === 0)
+    return base;
   const cut = base.length - (FORMAT_OFFSET_LEN(parts));
-  return base.slice(0, cut) + digits + base.slice(cut);
+  return base.slice(0, cut) + '.' + digits + base.slice(cut);
 }
 
 // how many characters the rendered offset takes, so the fraction can be

package/src/dates/rfc3339.js

@@ -5,7 +5,7 @@ import {
   isObjectOfClass,
 } from '../index.js';
 // the calendar rules live in civil.js, which owns the day tables
-import { isLeapYear, daysInMonth } from './civil.js';
+import { isLeapYear, daysInMonth, daysFromCivil } from './civil.js';
 
 export { isLeapYear };
 
@@ -365,18 +365,16 @@ export function epochOfRFC3339Parts(parts) {
     return NaN;
   const seconds = parts.seconds < 0 ? 0 : parts.seconds;
   const whole = Math.floor(seconds);
+  // Civil day numbers preserve year zero's leap day and carries across
+  // year 99; Date.UTC's 1900-based interpretation of 0-99 cannot.
   const ms = Date.UTC(
-    parts.year, parts.month - 1, parts.day,
+    1970, 0, 1 + daysFromCivil(parts.year, parts.month, parts.day),
     parts.hours < 0 ? 0 : parts.hours,
     parts.minutes < 0 ? 0 : parts.minutes,
     whole, Math.round((seconds - whole) * 1000));
   if (ms !== ms)
     return NaN;
-  // Date.UTC maps years 0-99 into the 1900s; restore the real year
-  const utc = new Date(ms);
-  if (parts.year >= 0 && parts.year < 100)
-    utc.setUTCFullYear(parts.year);
-  return utc.getTime() - (parts.offset === null ? 0 : parts.offset) * 60000;
+  return ms - (parts.offset === null ? 0 : parts.offset) * 60000;
 }
 //#endregion