@jarenjs/locales 0.49.2 → 0.66.1

package/README.md

@@ -139,6 +139,59 @@ object, and a bundler drops the provider from a bundle that never calls
 it. ICU has no date-format display names, so that member carries the
 repository's English ones unless `options.formatNames` overrides them.
 
+### The optional `Intl` zone provider
+
+The same idea one seam over. `@jarenjs/core/series` reads its calendar
+boundaries on a clock, and a clock that is a named zone needs a
+`provider` — a tzdb — that the kernel refuses to bundle, because a
+bundled table is megabytes that go stale on a government's timetable.
+`createIntlZoneProvider(options?)` is that provider, over the host's ICU:
+
+```js
+import { createIntlZoneProvider } from '@jarenjs/locales/intl-zones';
+import { resolveClock, compileBuckets } from '@jarenjs/core/series';
+
+const provider = createIntlZoneProvider();
+
+const clock = resolveClock({ zone: 'Europe/Amsterdam', provider, disambiguation: 'later' });
+clock.epochOf({ year: 2026, month: 3, day: 29, hours: 2, minutes: 30, seconds: 0 });
+// 2026-03-29T01:30:00Z — 02:30 never happened that morning; 'later' is 03:30 CEST
+
+compileBuckets('P1D', { zone: 'Australia/Adelaide', provider }).floor(Date.UTC(2026, 3, 5, 12));
+// 2026-04-04T13:30:00Z — local midnight on the day the clock went back, 25 hours long
+```
+
+The seam is unchanged: `@jarenjs/core` still bundles no zone data, a
+named zone with no provider is still a refusal, and this module is what
+a host passes to answer it. Three rules hold it honest. **It never reads
+the host's own zone** — every call names its zone, and there is no
+default that asks the process where it is, because that hidden clock is
+exactly what the seam exists to forbid. **An unknown name is a refusal
+naming it**, never a quiet UTC that is right for eight months of the
+year. And **the hard half is answered exactly**: on a spring-forward day
+02:30 never happens and on a fall-back day it happens twice, so
+`toEpoch(parts, zone, disambiguation)` verifies every candidate instant
+by reading its wall clock back. Two that read back are a fold, and
+`'earlier'`/`'later'` are the smaller and the larger; none is a gap, and
+`'earlier'` is the wall clock read with the offset in force after the
+transition (that far *before* the gap), `'later'` the reading with the
+offset before it (that far after) — one transition apart either way.
+`'reject'`, the kernel's default, answers both with `NaN`, which the
+kernel turns into a refusal naming the local time. Offsets are derived
+from the wall clock rather than parsed from a `GMT+02:00` string, so a
+historical `-00:44:30` is exact.
+
+Like `createIntlDateLocale`, it is opt-in for the reason the header of
+that module gives: ICU output moves between Node versions and between a
+browser and a server. Here that means the *tzdata* — a zone whose rules
+changed last year answers differently on a host whose ICU predates the
+change — so a consumer that needs the same instant on every host pins
+the tzdata its hosts run. Nothing runs at module load, and a bundler
+drops the provider from a bundle that never calls it. Formatters are
+built once per zone and kept in a bounded, least-recently-used cache of
+`ZONE_CACHE_LIMIT` zones (`options.zones` resizes it), so a generated
+stream of zone names cannot grow it without limit.
+
 ## Authoring a pack
 
 A catalog is a plain flat object; each entry is either a **template
@@ -212,3 +265,29 @@ Rules of the road:
 
 The named export is the locale tag camel-cased (`zhTW`), the subpath keeps
 the tag itself (`@jarenjs/locales/zh-tw`).
+
+## Exports
+
+Every subpath a consumer can import, derived from the manifest by
+`npm run docs:derive` (`npm run docs:check` fails when the two drift):
+
+<!--fact:exports.locales-->
+| Import | Kind | Declarations |
+|---|---|---|
+| `@jarenjs/locales` | JavaScript | declared |
+| `@jarenjs/locales/dates` | JavaScript | declared |
+| `@jarenjs/locales/intl-dates` | JavaScript | declared |
+| `@jarenjs/locales/intl-zones` | JavaScript | declared |
+| `@jarenjs/locales/ar` | JavaScript | declared |
+| `@jarenjs/locales/de` | JavaScript | declared |
+| `@jarenjs/locales/es` | JavaScript | declared |
+| `@jarenjs/locales/fr` | JavaScript | declared |
+| `@jarenjs/locales/ja` | JavaScript | declared |
+| `@jarenjs/locales/ko` | JavaScript | declared |
+| `@jarenjs/locales/nl` | JavaScript | declared |
+| `@jarenjs/locales/pt` | JavaScript | declared |
+| `@jarenjs/locales/ru` | JavaScript | declared |
+| `@jarenjs/locales/tr` | JavaScript | declared |
+| `@jarenjs/locales/zh-tw` | JavaScript | declared |
+| `@jarenjs/locales/package.json` | metadata | — |
+<!--/fact-->

package/dist/types/index.d.ts

@@ -17,7 +17,11 @@
  * formatter and a UI read; importing that subpath directly costs no
  * `Intl` construction at all, which is what keeps server-rendered output
  * byte-stable. `createIntlDateLocale` (`./intl-dates`) is the opt-in
- * provider for hosts that want the platform's locales instead.
+ * provider for hosts that want the platform's locales instead, and
+ * `createIntlZoneProvider` (`./intl-zones`) is its twin one seam over:
+ * the zone provider `@jarenjs/core/series` takes for a named zone, over
+ * the host's ICU. It is reached only by its own subpath and an explicit
+ * call, which is what keeps the default path free of `Intl` work.
  */
 export { dateMessagesEn, compileDateLocale, RELATIVE_UNITS } from './dates.js';
 export { createIntlDateLocale } from './intl-dates.js';

package/dist/types/intl-zones.d.ts

@@ -0,0 +1,41 @@
+/**
+ * How many zones' formatters stay resident at once. A formatter is
+ * expensive to build and cheap to reuse, and a host serving a handful of
+ * zones wants each built once; the bound is what keeps a generated or
+ * hostile stream of zone names from growing the map without limit.
+ */
+export declare const ZONE_CACHE_LIMIT = 32;
+/**
+ * Build a zone provider from the host's ICU time-zone data.
+ *
+ * `toParts(epoch, zone)` is a formatted read. `toEpoch(parts, zone,
+ * disambiguation)` inverts a function that is neither injective nor
+ * total: it guesses an instant by reading the wall clock as UTC,
+ * corrects it by the offset in force there and again by the offset in
+ * force at the corrected instant, adds the offsets in force a day either
+ * side so both sides of any transition are represented, and then
+ * verifies every distinct candidate by reading its wall clock back.
+ * Exactly one candidate that reads back as asked is the instant. Two
+ * are a fold - the hour that happened twice - and `earlier` and `later`
+ * are the smaller and the larger. None is a gap - the hour that never
+ * happened - and `earlier` is the wall clock read with the offset in
+ * force after the transition (the instant that far before the gap),
+ * `later` the reading with the offset before it (that far after); the
+ * two are one transition apart. `reject`, the kernel's default, answers
+ * either case with `NaN`, which `@jarenjs/core/series` turns into a
+ * refusal naming the local time.
+ *
+ * An unknown zone name is a refusal naming it, never a quiet UTC, and
+ * no call reads the host's own zone.
+ *
+ * @param {{ zones?: number }} [options] - `zones`: how many zones'
+ *   formatters stay resident (default `ZONE_CACHE_LIMIT`)
+ * @returns {import('@jarenjs/core/series').ZoneProvider}
+ * @example
+ * const provider = createIntlZoneProvider();
+ * resolveClock({ zone: 'Europe/Amsterdam', provider, disambiguation: 'later' });
+ * compileBuckets('P1M', { zone: 'Australia/Adelaide', provider });
+ */
+export declare function createIntlZoneProvider(options?: {
+    zones?: number;
+}): import('@jarenjs/core/series').ZoneProvider;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/locales",
   "private": false,
-  "version": "0.49.2",
+  "version": "0.66.1",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",
@@ -19,6 +19,10 @@
       "types": "./dist/types/intl-dates.d.ts",
       "default": "./src/intl-dates.js"
     },
+    "./intl-zones": {
+      "types": "./dist/types/intl-zones.d.ts",
+      "default": "./src/intl-zones.js"
+    },
     "./ar": {
       "types": "./dist/types/ar.d.ts",
       "default": "./src/ar.js"
@@ -98,6 +102,6 @@
     "prepack": "npm run build:types"
   },
   "dependencies": {
-    "@jarenjs/core": "^0.49.2"
+    "@jarenjs/core": "^0.66.1"
   }
 }

package/src/ar.js

@@ -224,6 +224,8 @@ export const ar = {
   'contract/seq-regression': 'خالف دفق العملية ⁨{op}⁩ ترتيب seq الخاص به',
   'contract/stream-error': 'انتهى دفق العملية ⁨{op}⁩ بخطأ من الخادم (⁨{code}⁩)',
   'contract/heartbeat-missed': 'ظل دفق العملية ⁨{op}⁩ صامتًا لمدة {ms} مللي ثانية',
+  'contract/slow-consumer': 'انتهى دفق العملية ⁨{op}⁩: تأخر المستهلك عن طابوره المحدود',
+  'contract/reconnect-exhausted': 'تعذّر إعادة إنشاء دفق العملية ⁨{op}⁩ بعد {attempts} محاولات (الأخيرة: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/de.js

@@ -167,6 +167,8 @@ export const de = {
   'contract/seq-regression': 'der Stream der Operation {op} hat seine seq-Reihenfolge verletzt',
   'contract/stream-error': 'der Stream der Operation {op} endete mit einem Serverfehler ({code})',
   'contract/heartbeat-missed': 'der Stream der Operation {op} blieb {ms} ms lang still',
+  'contract/slow-consumer': 'der Stream der Operation {op} wurde beendet: der Verbraucher blieb hinter seiner begrenzten Warteschlange zurück',
+  'contract/reconnect-exhausted': 'der Stream der Operation {op} konnte nach {attempts} Versuchen nicht wiederhergestellt werden (zuletzt: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/es.js

@@ -167,6 +167,8 @@ export const es = {
   'contract/seq-regression': 'el flujo de la operación {op} violó el orden de sus seq',
   'contract/stream-error': 'el flujo de la operación {op} terminó con un error del servidor ({code})',
   'contract/heartbeat-missed': 'el flujo de la operación {op} quedó en silencio durante {ms} ms',
+  'contract/slow-consumer': 'el flujo de la operación {op} terminó: el consumidor se quedó atrás de su cola acotada',
+  'contract/reconnect-exhausted': 'el flujo de la operación {op} no pudo restablecerse tras {attempts} intentos (último: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/fr.js

@@ -167,6 +167,8 @@ export const fr = {
   'contract/seq-regression': "le flux de l'opération {op} a violé l'ordre de ses seq",
   'contract/stream-error': "le flux de l'opération {op} s'est terminé par une erreur serveur ({code})",
   'contract/heartbeat-missed': "le flux de l'opération {op} est resté silencieux pendant {ms} ms",
+  'contract/slow-consumer': "le flux de l'opération {op} s'est terminé : le consommateur a pris du retard sur sa file bornée",
+  'contract/reconnect-exhausted': "le flux de l'opération {op} n'a pas pu être rétabli après {attempts} tentatives (dernière : {lastCode})",
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/index.js

@@ -19,7 +19,11 @@
  * formatter and a UI read; importing that subpath directly costs no
  * `Intl` construction at all, which is what keeps server-rendered output
  * byte-stable. `createIntlDateLocale` (`./intl-dates`) is the opt-in
- * provider for hosts that want the platform's locales instead.
+ * provider for hosts that want the platform's locales instead, and
+ * `createIntlZoneProvider` (`./intl-zones`) is its twin one seam over:
+ * the zone provider `@jarenjs/core/series` takes for a named zone, over
+ * the host's ICU. It is reached only by its own subpath and an explicit
+ * call, which is what keeps the default path free of `Intl` work.
  */
 
 export { dateMessagesEn, compileDateLocale, RELATIVE_UNITS } from './dates.js';

package/src/intl-zones.js

@@ -0,0 +1,271 @@
+//@ts-check
+
+/**
+ * The opt-in `Intl` zone provider: the `ZoneProvider` the temporal
+ * kernel's clock seam asks for, sourced from the host's ICU time-zone
+ * data instead of from a database this repository would have to ship.
+ *
+ * It is a separate module and an explicit call because it is the one
+ * thing the default may not be. A named zone in `@jarenjs/core/series`
+ * is a refusal until a provider is passed, and that refusal is the
+ * point: a tzdb goes stale on a government's timetable, so the only
+ * honest copy is the host's own, and the host must say so by
+ * constructing one. ICU output also moves between Node versions and
+ * between a browser and a server - a zone whose rules changed last
+ * year answers differently on a host whose ICU predates the change -
+ * so a consumer that needs the same instant on every host pins the
+ * tzdata its hosts run, not this module.
+ *
+ * Nothing here runs at module load: the `Intl` objects are built inside
+ * the factory, so importing the module allocates nothing and a bundle
+ * that never calls it carries no ICU work.
+ *
+ * The provider never asks the host what zone it is in. Every call names
+ * its zone, and there is no default that reads the process's - that is
+ * the hidden clock the seam exists to forbid, and a provider that read
+ * it would smuggle the non-determinism back in invisibly.
+ */
+
+import { createBoundedCache } from '@jarenjs/core/cache';
+import { daysFromCivil } from '@jarenjs/core/dates/civil';
+import { epochOfRFC3339Parts } from '@jarenjs/core/dates/rfc3339';
+
+/**
+ * How many zones' formatters stay resident at once. A formatter is
+ * expensive to build and cheap to reuse, and a host serving a handful of
+ * zones wants each built once; the bound is what keeps a generated or
+ * hostile stream of zone names from growing the map without limit.
+ */
+export const ZONE_CACHE_LIMIT = 32;
+
+/** What a caller may ask for when a local time is ambiguous or absent. */
+const DISAMBIGUATION = Object.freeze(['reject', 'earlier', 'later']);
+
+const MINUTE = 60000;
+const DAY = 86400000;
+
+/** The instants a `Date` can hold: beyond it ICU has nothing to read. */
+const RANGE = 8.64e15;
+
+/**
+ * Refuse an instant the platform cannot represent by name, rather than
+ * letting ICU's own `Invalid time value` — which names nothing — escape.
+ * @param {any} epoch
+ * @returns {number}
+ */
+function checkInstant(epoch) {
+  if (typeof epoch !== 'number' || !Number.isFinite(epoch) || Math.abs(epoch) > RANGE)
+    throw new TypeError(`an instant is a finite number of epoch milliseconds within ±${RANGE}, not ${epoch}`);
+  return epoch;
+}
+
+/**
+ * The formatter that reads a wall clock in one zone. The locale is
+ * pinned to `en-US` with Latin digits because the output is parsed, not
+ * shown; the calendar to `gregory` because the kernel's dates are
+ * proleptic Gregorian; the hour cycle to `h23` so midnight reads `00`
+ * rather than `24`; and the era is read so a year before 1 comes back
+ * as the kernel counts it.
+ * @param {string} zone
+ * @returns {Intl.DateTimeFormat}
+ */
+function createFormatter(zone) {
+  try {
+    return new Intl.DateTimeFormat('en-US', {
+      timeZone: zone,
+      calendar: 'gregory',
+      numberingSystem: 'latn',
+      hourCycle: 'h23',
+      era: 'short',
+      year: 'numeric',
+      month: 'numeric',
+      day: 'numeric',
+      hour: 'numeric',
+      minute: 'numeric',
+      second: 'numeric',
+    });
+  }
+  catch {
+    // ICU throws for a name it does not know; a name it would quietly
+    // map onto something else is exactly what the caller must not get
+    throw new TypeError(`'${zone}' is not a time zone this host's ICU knows`);
+  }
+}
+
+/**
+ * The wall clock at an instant, and the offset that produced it. The
+ * offset is not read from a formatted `GMT+02:00` string but derived:
+ * the wall clock re-read as UTC minus the instant is the offset, exact
+ * to the second, which is what a historical `-00:44:30` needs.
+ * @param {Intl.DateTimeFormat} format
+ * @param {number} epoch
+ * @returns {{ year: number, month: number, day: number, hours: number,
+ *   minutes: number, seconds: number, offset: number }}
+ */
+function readParts(format, epoch) {
+  let year = 0;
+  let month = 0;
+  let day = 0;
+  let hours = 0;
+  let minutes = 0;
+  let seconds = 0;
+  let beforeChrist = false;
+  for (const part of format.formatToParts(epoch)) {
+    switch (part.type) {
+      case 'year': year = Number(part.value); break;
+      case 'month': month = Number(part.value); break;
+      case 'day': day = Number(part.value); break;
+      case 'hour': hours = Number(part.value); break;
+      case 'minute': minutes = Number(part.value); break;
+      case 'second': seconds = Number(part.value); break;
+      case 'era': beforeChrist = part.value.charCodeAt(0) === 0x42; break; // 'B'
+      default: break;
+    }
+  }
+  if (beforeChrist)
+    year = 1 - year;
+  const wholeSecond = Math.floor(epoch / 1000) * 1000;
+  // Use the core calendar for every year, including year zero and BCE.
+  const wall = daysFromCivil(year, month, day) * DAY
+    + ((hours * 60 + minutes) * 60 + seconds) * 1000;
+  const offset = (wall - wholeSecond) / MINUTE;
+  return { year, month, day, hours, minutes, seconds: seconds + (epoch - wholeSecond) / 1000, offset };
+}
+
+/**
+ * The wall clock a caller asked for, in the kernel's shape: an absent or
+ * negative time member is midnight's, as `epochOfRFC3339Parts` reads a
+ * negative one.
+ * @param {any} parts
+ * @returns {{ year: number, month: number, day: number, hours: number,
+ *   minutes: number, seconds: number }}
+ */
+function wantedWall(parts) {
+  const clamp = (value) => (typeof value === 'number' && value > 0 ? value : 0);
+  return {
+    year: parts.year,
+    month: parts.month,
+    day: parts.day,
+    hours: clamp(parts.hours),
+    minutes: clamp(parts.minutes),
+    seconds: clamp(parts.seconds),
+  };
+}
+
+/**
+ * Whether a wall clock the zone reports is the one that was asked for.
+ * @param {ReturnType<typeof readParts>} read
+ * @param {ReturnType<typeof wantedWall>} wanted
+ * @returns {boolean}
+ */
+function sameWall(read, wanted) {
+  return read.year === wanted.year && read.month === wanted.month && read.day === wanted.day
+    && read.hours === wanted.hours && read.minutes === wanted.minutes
+    && Math.floor(read.seconds) === Math.floor(wanted.seconds);
+}
+
+/**
+ * Build a zone provider from the host's ICU time-zone data.
+ *
+ * `toParts(epoch, zone)` is a formatted read. `toEpoch(parts, zone,
+ * disambiguation)` inverts a function that is neither injective nor
+ * total: it guesses an instant by reading the wall clock as UTC,
+ * corrects it by the offset in force there and again by the offset in
+ * force at the corrected instant, adds the offsets in force a day either
+ * side so both sides of any transition are represented, and then
+ * verifies every distinct candidate by reading its wall clock back.
+ * Exactly one candidate that reads back as asked is the instant. Two
+ * are a fold - the hour that happened twice - and `earlier` and `later`
+ * are the smaller and the larger. None is a gap - the hour that never
+ * happened - and `earlier` is the wall clock read with the offset in
+ * force after the transition (the instant that far before the gap),
+ * `later` the reading with the offset before it (that far after); the
+ * two are one transition apart. `reject`, the kernel's default, answers
+ * either case with `NaN`, which `@jarenjs/core/series` turns into a
+ * refusal naming the local time.
+ *
+ * An unknown zone name is a refusal naming it, never a quiet UTC, and
+ * no call reads the host's own zone.
+ *
+ * @param {{ zones?: number }} [options] - `zones`: how many zones'
+ *   formatters stay resident (default `ZONE_CACHE_LIMIT`)
+ * @returns {import('@jarenjs/core/series').ZoneProvider}
+ * @example
+ * const provider = createIntlZoneProvider();
+ * resolveClock({ zone: 'Europe/Amsterdam', provider, disambiguation: 'later' });
+ * compileBuckets('P1M', { zone: 'Australia/Adelaide', provider });
+ */
+export function createIntlZoneProvider(options = undefined) {
+  const limit = options?.zones ?? ZONE_CACHE_LIMIT;
+  if (typeof limit !== 'number' || !Number.isInteger(limit) || limit <= 0)
+    throw new TypeError('zones is a positive whole number of resident zone formatters');
+  /** @type {import('@jarenjs/core/cache').BoundedCache<string, Intl.DateTimeFormat>} */
+  const formatters = createBoundedCache(limit);
+
+  /**
+   * @param {string} zone
+   * @returns {Intl.DateTimeFormat}
+   */
+  const formatterFor = (zone) => {
+    if (typeof zone !== 'string' || zone === '')
+      throw new TypeError('a zone is an IANA name, given explicitly');
+    return formatters.getOrCreate(zone, createFormatter);
+  };
+
+  /**
+   * @param {number} epoch
+   * @param {string} zone
+   */
+  function toParts(epoch, zone) {
+    const format = formatterFor(zone);
+    return readParts(format, checkInstant(epoch));
+  }
+
+  /**
+   * @param {any} parts
+   * @param {string} zone
+   * @param {string} [disambiguation]
+   * @returns {number}
+   */
+  function toEpoch(parts, zone, disambiguation = 'reject') {
+    const format = formatterFor(zone);
+    if (!DISAMBIGUATION.includes(disambiguation)) {
+      throw new TypeError(`disambiguation is ${
+        DISAMBIGUATION.map((d) => `'${d}'`).join(', ')}, not '${disambiguation}'`);
+    }
+    if (parts === null || typeof parts !== 'object')
+      throw new TypeError('a wall clock is a parts record');
+    const wanted = wantedWall(parts);
+    const guess = epochOfRFC3339Parts({ ...wanted, offset: 0 });
+    // a wall clock the platform cannot hold, or one so near its edge
+    // that a probe a day away would fall off it, names no instant
+    if (!Number.isFinite(guess) || Math.abs(guess) + DAY > RANGE)
+      return NaN;
+    const offsetAt = (at) => readParts(format, at).offset;
+
+    /** @type {number[]} */
+    const candidates = [];
+    const consider = (offset) => {
+      const at = guess - offset * MINUTE;
+      if (!candidates.includes(at))
+        candidates.push(at);
+    };
+    const first = offsetAt(guess);
+    consider(first);
+    consider(offsetAt(guess - first * MINUTE));
+    consider(offsetAt(guess - DAY));
+    consider(offsetAt(guess + DAY));
+
+    const verified = candidates.filter((at) => sameWall(readParts(format, at), wanted));
+    if (verified.length === 1)
+      return verified[0];
+    if (disambiguation === 'reject')
+      return NaN;
+    const choices = verified.length > 1 ? verified : candidates;
+    if (choices.length < 2)
+      return NaN;
+    return disambiguation === 'earlier' ? Math.min(...choices) : Math.max(...choices);
+  }
+
+  return Object.freeze({ toParts, toEpoch });
+}

package/src/ja.js

@@ -162,6 +162,8 @@ export const ja = {
   'contract/seq-regression': '操作 {op} のストリームが seq の順序に違反しました',
   'contract/stream-error': '操作 {op} のストリームはサーバーエラーで終了しました ({code})',
   'contract/heartbeat-missed': '操作 {op} のストリームが {ms} ミリ秒間沈黙しました',
+  'contract/slow-consumer': '操作 {op} のストリームは終了しました: 消費側が有界キューに追いつけませんでした',
+  'contract/reconnect-exhausted': '操作 {op} のストリームは {attempts} 回の試行後も再確立できませんでした（最後: {lastCode}）',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/ko.js

@@ -165,6 +165,8 @@ export const ko = {
   'contract/seq-regression': '작업 {op}의 스트림이 seq 순서를 위반했습니다',
   'contract/stream-error': '작업 {op}의 스트림이 서버 오류로 종료되었습니다 ({code})',
   'contract/heartbeat-missed': '작업 {op}의 스트림이 {ms}ms 동안 침묵했습니다',
+  'contract/slow-consumer': '작업 {op}의 스트림이 종료되었습니다: 소비자가 제한된 큐를 따라가지 못했습니다',
+  'contract/reconnect-exhausted': '작업 {op}의 스트림을 {attempts}회 시도 후에도 다시 연결하지 못했습니다 (마지막: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/nl.js

@@ -166,6 +166,8 @@ export const nl = {
   'contract/seq-regression': 'de stream van operatie {op} heeft de seq-volgorde geschonden',
   'contract/stream-error': 'de stream van operatie {op} is geëindigd met een serverfout ({code})',
   'contract/heartbeat-missed': 'de stream van operatie {op} is {ms} ms stil gebleven',
+  'contract/slow-consumer': 'de stream van operatie {op} is geëindigd: de afnemer bleef achter bij zijn begrensde wachtrij',
+  'contract/reconnect-exhausted': 'de stream van operatie {op} kon na {attempts} pogingen niet worden hersteld (laatste: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/pt.js

@@ -167,6 +167,8 @@ export const pt = {
   'contract/seq-regression': 'o fluxo da operação {op} violou a ordem de seus seq',
   'contract/stream-error': 'o fluxo da operação {op} terminou com um erro do servidor ({code})',
   'contract/heartbeat-missed': 'o fluxo da operação {op} ficou em silêncio por {ms} ms',
+  'contract/slow-consumer': 'o fluxo da operação {op} terminou: o consumidor ficou atrás da sua fila limitada',
+  'contract/reconnect-exhausted': 'o fluxo da operação {op} não pôde ser restabelecido após {attempts} tentativas (última: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/ru.js

@@ -185,6 +185,8 @@ export const ru = {
   'contract/seq-regression': 'поток операции {op} нарушил порядок своих seq',
   'contract/stream-error': 'поток операции {op} завершился ошибкой сервера ({code})',
   'contract/heartbeat-missed': 'поток операции {op} молчал {ms} мс',
+  'contract/slow-consumer': 'поток операции {op} завершён: потребитель отстал от своей ограниченной очереди',
+  'contract/reconnect-exhausted': 'поток операции {op} не удалось восстановить после {attempts} попыток (последняя: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/tr.js

@@ -164,6 +164,8 @@ export const tr = {
   'contract/seq-regression': '{op} işleminin akışı seq sırasını ihlal etti',
   'contract/stream-error': '{op} işleminin akışı bir sunucu hatasıyla sona erdi ({code})',
   'contract/heartbeat-missed': '{op} işleminin akışı {ms} ms boyunca sessiz kaldı',
+  'contract/slow-consumer': '{op} işleminin akışı sona erdi: tüketici sınırlı kuyruğunun gerisinde kaldı',
+  'contract/reconnect-exhausted': '{op} işleminin akışı {attempts} denemeden sonra yeniden kurulamadı (son: {lastCode})',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and

package/src/zh-tw.js

@@ -165,6 +165,8 @@ export const zhTW = {
   'contract/seq-regression': '操作 {op} 的串流違反了其 seq 順序',
   'contract/stream-error': '操作 {op} 的串流以伺服器錯誤結束({code})',
   'contract/heartbeat-missed': '操作 {op} 的串流沉默了 {ms} 毫秒',
+  'contract/slow-consumer': '操作 {op} 的串流已結束：消費端落後於其有界佇列',
+  'contract/reconnect-exhausted': '操作 {op} 的串流在 {attempts} 次嘗試後仍無法重新建立（最後：{lastCode}）',
   //#endregion
 
   //#region calendar language (the date names, relative phrasing and