@50arms/ui 0.0.0-stage → 35.1.0

package/dist/lib/syntax/tokenize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenize.js","sources":["../../../src/lib/syntax/tokenize.ts"],"sourcesContent":["import { getGrammar } from \"./registry\";\nimport type { Grammar, Rule, Token, TokenizeContext, TokenType } from \"./types\";\n\n/**\n * The scanner. Walks a string left to right, trying each rule of the current\n * state at the current position, and emits a flat token list that covers the\n * whole input.\n *\n * TWO MECHANISMS, DELIBERATELY DISTINCT, because conflating them is what makes\n * hand-rolled highlighters unable to nest:\n *\n *   STATES (`push` / `pop`) are for a construct WITHIN one language — the body\n *   of a string, a block comment, the inside of a tag. Same grammar, different\n *   rules in force.\n *\n *   EMBEDDING (`embed` + `until`) hands a REGION to a different language\n *   entirely. The region is located first, tokenized by the inner grammar as if\n *   it were a document of its own, and spliced back in with every offset\n *   shifted. That indirection is what lets an embedded language have its own\n *   states, its own embeds, and even its own parser — which is how a fenced\n *   markdown block inside a Vue `<script>` block works without a single line of\n *   code that knows about that combination.\n */\n\n/** Nothing sensible can nest this deep; a grammar embedding itself would. */\nconst MAX_DEPTH = 12;\n\n/**\n * Tokenizes `source` as `language`. An unknown or missing language yields one\n * `text` token spanning the input — never an error, never an empty result. A\n * code block labelled with a language nobody implemented still has to be\n * readable, and an editor still has to be editable.\n */\nexport function tokenize(source: string, language: string | null | undefined): Token[] {\n  return run(source, getGrammar(language), 0, 0);\n}\n\nfunction run(source: string, grammar: Grammar | undefined, offset: number, depth: number): Token[] {\n  if (!source) return [];\n  if (!grammar || depth > MAX_DEPTH) {\n    return [{ start: offset, end: offset + source.length, type: \"text\", lang: grammar?.name ?? \"text\" }];\n  }\n\n  if (grammar.tokenize) {\n    const ctx: TokenizeContext = {\n      sub: (inner, lang, at) => run(inner, getGrammar(lang), at, depth + 1),\n    };\n    return shift(grammar.tokenize(source, ctx), offset);\n  }\n\n  return scan(source, grammar, offset, depth);\n}\n\n/** Re-bases a token list produced against a substring. */\nfunction shift(tokens: Token[], offset: number): Token[] {\n  if (offset === 0) return tokens;\n  return tokens.map((t) => ({ ...t, start: t.start + offset, end: t.end + offset }));\n}\n\nfunction scan(source: string, grammar: Grammar, offset: number, depth: number): Token[] {\n  const out: Token[] = [];\n  const stack: string[] = [\"root\"];\n  let pos = 0;\n\n  /* Unmatched characters accumulate rather than emitting one token each: a\n     token per character would make a 200kB file 200k objects, and the merge in\n     `emit` also makes the output canonical, which is what lets tests compare\n     token lists directly. */\n  let textFrom = 0;\n\n  const flushText = () => {\n    if (pos > textFrom) emit(out, offset + textFrom, offset + pos, \"text\", grammar.name);\n    textFrom = pos;\n  };\n\n  while (pos < source.length) {\n    const state = stack[stack.length - 1];\n    const rules = grammar.states[state] ?? [];\n    let matched = false;\n\n    for (let i = 0; i < rules.length; i++) {\n      const rule = rules[i];\n      rule.match.lastIndex = pos;\n      const m = rule.match.exec(source);\n      if (!m || m.index !== pos) continue;\n\n      if (m[0].length === 0) {\n        /* A zero-width match would spin forever. Loud, with the address, is the\n           only useful behaviour — this is always an authoring mistake. */\n        throw new Error(`${grammar.name}.${state}[${i}] matched empty at ${pos}`);\n      }\n\n      flushText();\n      emitMatch(out, m, rule, offset, grammar.name);\n      pos += m[0].length;\n\n      if (rule.embed) {\n        pos = embed(source, m, rule, out, grammar, offset, depth, pos);\n      } else if (rule.push) {\n        stack.push(rule.push);\n      } else if (rule.pop && stack.length > 1) {\n        stack.pop();\n      }\n\n      textFrom = pos;\n      matched = true;\n      break;\n    }\n\n    if (!matched) pos += 1;\n  }\n\n  pos = source.length;\n  flushText();\n  return out;\n}\n\n/**\n * Runs an embedded region and returns the position after it.\n *\n * The terminator is located BEFORE the inner grammar sees anything. Letting the\n * inner grammar scan until something happens to stop it is how a `</script>`\n * inside a JavaScript string ends the block early — the region's extent is the\n * OUTER language's business, and only the outer language can decide it.\n */\nfunction embed(\n  source: string,\n  match: RegExpExecArray,\n  rule: Rule,\n  out: Token[],\n  grammar: Grammar,\n  offset: number,\n  depth: number,\n  from: number,\n): number {\n  const language = typeof rule.embed === \"function\" ? rule.embed(match) : (rule.embed as string);\n\n  const until = rule.until!;\n  /* Searched, not sticky-tested: the terminator is somewhere ahead, and where\n     it is decides the region. `sticky` in the registry forced `y` on, so it is\n     rebuilt here as a plain search. */\n  const search = new RegExp(until.source, until.flags.replace(\"y\", \"\") + \"g\");\n  search.lastIndex = from;\n  const stop = search.exec(source);\n\n  const bodyEnd = stop ? stop.index : source.length;\n  const body = source.slice(from, bodyEnd);\n\n  if (body) {\n    const inner = run(body, getGrammar(language), offset + from, depth + 1);\n    for (const token of inner) out.push(token);\n  }\n\n  if (!stop) return source.length;\n\n  emit(out, offset + stop.index, offset + stop.index + stop[0].length, rule.untilToken ?? \"punctuation\", grammar.name);\n  return stop.index + stop[0].length;\n}\n\n/** Emits the parts of one rule match — whole-match, or per capture group. */\nfunction emitMatch(out: Token[], m: RegExpExecArray, rule: Rule, offset: number, lang: string): void {\n  const start = m.index;\n  const end = start + m[0].length;\n\n  if (rule.token) {\n    emit(out, offset + start, offset + end, rule.token, lang);\n    return;\n  }\n\n  if (rule.groups) {\n    const indices = m.indices;\n    let cursor = start;\n\n    for (let g = 0; g < rule.groups.length; g++) {\n      const span = indices?.[g + 1];\n      if (!span) continue;\n      /* Anything between the previous group and this one is real source text\n         and must still be emitted, or the coverage invariant breaks and the\n         editor overlay drifts out of alignment with its textarea. */\n      if (span[0] > cursor) emit(out, offset + cursor, offset + span[0], \"text\", lang);\n      emit(out, offset + span[0], offset + span[1], rule.groups[g] ?? \"text\", lang);\n      cursor = span[1];\n    }\n\n    if (cursor < end) emit(out, offset + cursor, offset + end, \"text\", lang);\n    return;\n  }\n\n  emit(out, offset + start, offset + end, \"text\", lang);\n}\n\n/** Appends, merging into the previous token when it is the same run. */\nfunction emit(out: Token[], start: number, end: number, type: TokenType, lang: string): void {\n  if (end <= start) return;\n  const last = out[out.length - 1];\n  if (last && last.end === start && last.type === type && last.lang === lang) {\n    last.end = end;\n    return;\n  }\n  out.push({ start, end, type, lang });\n}\n\n/**\n * Asserts what the whole design rests on: the tokens reproduce the source\n * exactly. Exported because it is used by every language's test rather than\n * re-derived in each one, and because a consumer building a grammar at runtime\n * should have the same check available.\n *\n * Returns a description of the first violation, or null when the list is sound.\n */\nexport function checkCoverage(source: string, tokens: Token[]): string | null {\n  let cursor = 0;\n  for (const t of tokens) {\n    if (t.start !== cursor) {\n      return t.start < cursor\n        ? `token at ${t.start} overlaps the previous one, which ended at ${cursor}`\n        : `gap in coverage from ${cursor} to ${t.start}`;\n    }\n    if (t.end <= t.start) return `empty or reversed token at ${t.start}`;\n    cursor = t.end;\n  }\n  if (cursor !== source.length) return `coverage stops at ${cursor} of ${source.length}`;\n  return null;\n}\n"],"names":["MAX_DEPTH","tokenize","source","language","run","getGrammar","grammar","offset","depth","ctx","inner","lang","at","shift","scan","tokens","out","stack","pos","textFrom","flushText","emit","state","rules","matched","i","rule","m","emitMatch","embed","match","from","until","search","stop","bodyEnd","body","token","start","end","indices","cursor","g","span","type","last","checkCoverage","t"],"mappings":"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"}

package/dist/lib/time/instant.js

@@ -0,0 +1,7 @@
+function e(t) {
+  return typeof t == "number" ? t : t instanceof Date ? t.getTime() : Date.parse(t);
+}
+export {
+  e as toEpochMs
+};
+//# sourceMappingURL=instant.js.map

package/dist/lib/time/instant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instant.js","sources":["../../../src/lib/time/instant.ts"],"sourcesContent":["/** A moment as epoch millis, from the three shapes a caller holds (ISO string, epoch millis, `Date`). `NaN` when it does not parse. The one parser the time layer shares. DX-4797. */\nexport function toEpochMs(when: string | number | Date): number {\n  return typeof when === \"number\" ? when : when instanceof Date ? when.getTime() : Date.parse(when);\n}\n"],"names":["toEpochMs","when"],"mappings":"AACO,SAASA,EAAUC,GAAsC;AAC9D,SAAO,OAAOA,KAAS,WAAWA,IAAOA,aAAgB,OAAOA,EAAK,QAAA,IAAY,KAAK,MAAMA,CAAI;AAClG;"}

package/dist/lib/time/plain.js

@@ -0,0 +1,83 @@
+function u(t, n) {
+  const r = /* @__PURE__ */ new Date(0);
+  return r.setUTCFullYear(t, n, 0), r.getUTCDate();
+}
+function y(t) {
+  return { year: t.getUTCFullYear(), month: t.getUTCMonth() + 1, day: t.getUTCDate() };
+}
+function c(t) {
+  const n = /* @__PURE__ */ new Date(0);
+  return n.setUTCFullYear(t.year, t.month - 1, t.day), n;
+}
+function i(t, n) {
+  const r = c(t);
+  return r.setUTCDate(r.getUTCDate() + n), y(r);
+}
+function D(t, n) {
+  const r = t.year * 12 + (t.month - 1) + n, e = Math.floor(r / 12), o = r % 12 + 1;
+  return { year: e, month: o, day: Math.min(t.day, u(e, o)) };
+}
+function g(t, n) {
+  return Math.round((c(n).getTime() - c(t).getTime()) / 864e5);
+}
+function h(t, n) {
+  return t.year !== n.year ? t.year - n.year : t.month !== n.month ? t.month - n.month : t.day - n.day;
+}
+function M(t, n) {
+  return h(t, n) === 0;
+}
+function m(t) {
+  return c(t).getUTCDay();
+}
+function s(t, n) {
+  const r = (m(t) - n + 7) % 7;
+  return i(t, -r);
+}
+function d(t) {
+  return { year: t.year, month: t.month, day: 1 };
+}
+function l(t) {
+  return { year: t.year, month: t.month, day: u(t.year, t.month) };
+}
+function T(t, n) {
+  const r = s(d(t), n), e = l(t), o = i(s(e, n), 6), f = [];
+  for (let a = r; h(a, o) <= 0; a = i(a, 1)) f.push(a);
+  return f;
+}
+function U(t, n) {
+  const r = s(t, n);
+  return Array.from({ length: 7 }, (e, o) => i(r, o));
+}
+function w(t) {
+  const n = /^(\d{4})-(\d{2})-(\d{2})$/.exec(t);
+  if (!n) throw new Error(`not an ISO date: ${JSON.stringify(t)} — expected YYYY-MM-DD`);
+  const r = Number(n[1]), e = Number(n[2]), o = Number(n[3]);
+  if (e < 1 || e > 12) throw new Error(`month out of range in ${t}`);
+  if (o < 1 || o > u(r, e))
+    throw new Error(`${t} is not a real date — ${r}-${e} has ${u(r, e)} days`);
+  return { year: r, month: e, day: o };
+}
+function C(t) {
+  return { ...t, hour: 0, minute: 0, second: 0, millisecond: 0 };
+}
+function Y(t, n, r = 0) {
+  return { ...t, hour: n, minute: r, second: 0, millisecond: 0 };
+}
+export {
+  i as addDays,
+  D as addMonths,
+  C as atMidnight,
+  Y as atTime,
+  h as comparePlainDate,
+  m as dayOfWeek,
+  g as daysBetween,
+  u as daysInMonth,
+  l as endOfMonth,
+  M as isSameDate,
+  T as monthGridDays,
+  w as parsePlainDate,
+  d as startOfMonth,
+  s as startOfWeek,
+  U as weekDays
+};
+//# sourceMappingURL=plain.js.map

package/dist/lib/time/plain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plain.js","sources":["../../../src/lib/time/plain.ts"],"sourcesContent":["import { isoDateString, type PlainDate, type PlainDateTime } from \"./types\";\n\n/* ============================================================================\n   CALENDAR ARITHMETIC — no zones, no instants, no offsets.\n\n   A month grid is a question about the calendar, not about time: which squares\n   does September have, which weekday does the 1st fall on, how many rows. None\n   of that depends on a zone, and none of it should reach for one. Keeping this\n   file zone-free is what stops a month grid quietly acquiring a dependency on\n   the viewer's location.\n\n   Every function here goes through UTC internally — NOT because these values\n   are UTC (they are not; they have no zone at all) but because UTC is the only\n   mode of `Date` with no transitions in it, so the arithmetic cannot be\n   disturbed by one. A local-mode `Date` doing the same work would lose an hour\n   twice a year and, at midnight-transition zones, land on the wrong DAY.\n   ========================================================================= */\n\n/** Days in `month` of `year`, leap years included. */\nexport function daysInMonth(year: number, month: number): number {\n  const d = new Date(0);\n  d.setUTCFullYear(year, month, 0);\n  return d.getUTCDate();\n}\n\nfunction fromUtc(d: Date): PlainDate {\n  return { year: d.getUTCFullYear(), month: d.getUTCMonth() + 1, day: d.getUTCDate() };\n}\n\nfunction toUtc(date: PlainDate): Date {\n  const d = new Date(0);\n  d.setUTCFullYear(date.year, date.month - 1, date.day);\n  return d;\n}\n\n/** `date` moved by `days`, which may be negative, rolling months and years. */\nexport function addDays(date: PlainDate, days: number): PlainDate {\n  const d = toUtc(date);\n  d.setUTCDate(d.getUTCDate() + days);\n  return fromUtc(d);\n}\n\n/**\n * `date` moved by `months`, clamping the day to the target month's length.\n *\n * CLAMPING, NOT ROLLING: one month after the 31st of January is the 28th or\n * 29th of February, never the 3rd of March. Rolling is what `Date.setMonth`\n * does natively and it is why \"next month\" buttons skip February.\n */\nexport function addMonths(date: PlainDate, months: number): PlainDate {\n  const total = date.year * 12 + (date.month - 1) + months;\n  const year = Math.floor(total / 12);\n  const month = (total % 12) + 1;\n  return { year, month, day: Math.min(date.day, daysInMonth(year, month)) };\n}\n\n/** Whole days from `a` to `b`; negative when `b` is earlier. */\nexport function daysBetween(a: PlainDate, b: PlainDate): number {\n  return Math.round((toUtc(b).getTime() - toUtc(a).getTime()) / 86_400_000);\n}\n\n/** Negative when `a` is earlier, 0 when equal, positive when later. */\nexport function comparePlainDate(a: PlainDate, b: PlainDate): number {\n  if (a.year !== b.year) return a.year - b.year;\n  if (a.month !== b.month) return a.month - b.month;\n  return a.day - b.day;\n}\n\nexport function isSameDate(a: PlainDate, b: PlainDate): boolean {\n  return comparePlainDate(a, b) === 0;\n}\n\n/** 0 = Sunday … 6 = Saturday, matching `Date.getUTCDay` and `Intl`'s weekday order. */\nexport function dayOfWeek(date: PlainDate): number {\n  return toUtc(date).getUTCDay();\n}\n\n/**\n * The first day of the week `date` falls in.\n *\n * `weekStartsOn` IS A PARAMETER WITH NO DEFAULT ANYWHERE UP THE STACK, because\n * there is no correct global answer: Sunday in the US and Japan, Monday across\n * Europe and by ISO 8601, Saturday in much of the Middle East. A component that\n * picks one silently is wrong for most of the world, so the calendar surfaces\n * it and this function simply obeys.\n */\nexport function startOfWeek(date: PlainDate, weekStartsOn: number): PlainDate {\n  const shift = (dayOfWeek(date) - weekStartsOn + 7) % 7;\n  return addDays(date, -shift);\n}\n\n/** The 1st of `date`'s month. */\nexport function startOfMonth(date: PlainDate): PlainDate {\n  return { year: date.year, month: date.month, day: 1 };\n}\n\n/** The last day of `date`'s month. */\nexport function endOfMonth(date: PlainDate): PlainDate {\n  return { year: date.year, month: date.month, day: daysInMonth(date.year, date.month) };\n}\n\n/**\n * Every day a month grid shows, INCLUDING the leading and trailing days that\n * belong to the neighbouring months.\n *\n * Always whole weeks, so the result is a multiple of seven and the grid never\n * has a ragged edge. The count varies — a 28-day February beginning on the\n * week's first day needs four rows, and a 31-day month beginning on its last\n * day needs six. Callers that assume six rows draw an empty one eleven months\n * a year; callers that assume five are simply wrong twice a year.\n */\nexport function monthGridDays(date: PlainDate, weekStartsOn: number): PlainDate[] {\n  const first = startOfWeek(startOfMonth(date), weekStartsOn);\n  const lastOfMonth = endOfMonth(date);\n  const last = addDays(startOfWeek(lastOfMonth, weekStartsOn), 6);\n  const out: PlainDate[] = [];\n  for (let d = first; comparePlainDate(d, last) <= 0; d = addDays(d, 1)) out.push(d);\n  return out;\n}\n\n/** The seven days of the week `date` falls in. */\nexport function weekDays(date: PlainDate, weekStartsOn: number): PlainDate[] {\n  const first = startOfWeek(date, weekStartsOn);\n  return Array.from({ length: 7 }, (_, i) => addDays(first, i));\n}\n\n/**\n * Parse `YYYY-MM-DD`.\n *\n * FAILS LOUDLY on anything else, including the shapes `Date` accepts and\n * silently reinterprets. `new Date(\"2026-2-30\")` yields the 2nd of March, which\n * is a data error becoming a rendered event on the wrong day with nothing\n * anywhere reporting a problem.\n */\nexport function parsePlainDate(iso: string): PlainDate {\n  const m = /^(\\d{4})-(\\d{2})-(\\d{2})$/.exec(iso);\n  if (!m) throw new Error(`not an ISO date: ${JSON.stringify(iso)} — expected YYYY-MM-DD`);\n  const year = Number(m[1]);\n  const month = Number(m[2]);\n  const day = Number(m[3]);\n  if (month < 1 || month > 12) throw new Error(`month out of range in ${iso}`);\n  if (day < 1 || day > daysInMonth(year, month)) {\n    throw new Error(`${iso} is not a real date — ${year}-${month} has ${daysInMonth(year, month)} days`);\n  }\n  return { year, month, day };\n}\n\nexport { isoDateString };\n\n/** A `PlainDateTime` at midnight on `date` — the wall reading, not an instant. */\nexport function atMidnight(date: PlainDate): PlainDateTime {\n  return { ...date, hour: 0, minute: 0, second: 0, millisecond: 0 };\n}\n\n/** A `PlainDateTime` at `hour`:`minute` on `date`. */\nexport function atTime(date: PlainDate, hour: number, minute = 0): PlainDateTime {\n  return { ...date, hour, minute, second: 0, millisecond: 0 };\n}\n"],"names":["daysInMonth","year","month","d","fromUtc","toUtc","date","addDays","days","addMonths","months","total","daysBetween","a","b","comparePlainDate","isSameDate","dayOfWeek","startOfWeek","weekStartsOn","shift","startOfMonth","endOfMonth","monthGridDays","first","lastOfMonth","last","out","weekDays","_","i","parsePlainDate","iso","m","day","atMidnight","atTime","hour","minute"],"mappings":"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"}

package/dist/lib/time/relativeAge.js

@@ -0,0 +1,20 @@
+import { numberFormat as d } from "../intl-cache.js";
+import { toEpochMs as M } from "./instant.js";
+function w(f, o, m, h = Date.now()) {
+  const t = d(m, {}).format, s = M(f);
+  if (Number.isNaN(s)) return o.unknown;
+  const e = Math.max(0, Math.round((h - s) / 1e3));
+  if (e < 45) return o.justNow;
+  const u = Math.round(e / 60);
+  if (u < 60) return o.minutesAgo(u, t(u));
+  const n = Math.round(e / 3600);
+  if (n < 24) return o.hoursAgo(n, t(n));
+  const r = Math.floor(n / 24), a = n % 24;
+  if (r < 7) return a > 0 ? o.daysHoursAgo(r, t(r), a, t(a)) : o.daysAgo(r, t(r));
+  const c = Math.round(r / 7);
+  return o.weeksAgo(c, t(c));
+}
+export {
+  w as relativeAge
+};
+//# sourceMappingURL=relativeAge.js.map

package/dist/lib/time/relativeAge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relativeAge.js","sources":["../../../src/lib/time/relativeAge.ts"],"sourcesContent":["/* ============================================================================\n   RELATIVE AGE — \"how long ago\", in the chat-transcript shape.\n\n   This is deliberately a THIRD implementation of \"time ago\" in the\n   danxbot/gpt-manager world, not a fourth copy of an existing one — neither\n   found an exact match:\n\n   - `views/demands/src/domain/format.ts`'s `relativeTime` stops at ONE unit\n     (\"4h ago\", never \"4h 12m ago\") and hands off to a calendar date past a\n     week, by deliberate design (\"9 weeks ago is arithmetic a reader has to\n     undo\").\n   - danxbot's own dashboard frontend (`frontend/src/lib/time.ts`)'s `ago` /\n     `agoShort` are `Intl.RelativeTimeFormat`-based and are ALSO single-unit\n     (\"2 hours ago\" / \"2h ago\").\n\n   The chat transcript wanted a two-unit form once the gap passes a day —\n   \"1d 6h ago\", not \"1d ago\" — matching the density of a real conversation\n   history (Claude Code's own transcript UI). Since no existing formatter in\n   either app produces that shape, it lives here, in `@50arms/ui`, so BOTH\n   consumers (`views/demands` and danxbot's own dashboard frontend) can share\n   one implementation instead of a fourth copy growing somewhere else.\n   ========================================================================= */\n\nimport type { RelativeAgeStrings } from \"../i18n/areas/formats\";\nimport { numberFormat } from \"../intl-cache\";\nimport { toEpochMs } from \"./instant\";\n\n/**\n * A moment's age in words (English shown; the words come from `strings`): \"just now\", \"4m ago\", \"4h ago\", \"1d 6h ago\",\n * \"2w ago\".\n *\n * Stays two-unit only in the day range (a message from earlier today reads\n * as \"6h ago\", not \"0d 6h ago\") — days-plus-hours is the one range where a\n * single unit throws away information a reader of a chat transcript actually\n * wants (\"this morning\" vs \"yesterday afternoon\" are different facts, and\n * \"1d ago\" collapses both). Beyond a week it drops to whole weeks, same as\n * every sibling formatter in this codebase — nobody needs \"9d ago\" instead\n * of \"1w 2d ago\", and nobody needs either instead of a calendar date, but a\n * chat message's hover row has no room for a calendar date, so weeks it is.\n *\n * `now` is the instant to measure against (default: the clock). `RelativeTime`'s shared ticker passes later instants to find\n * when this text next changes.\n */\nexport function relativeAge(when: string | number | Date, strings: RelativeAgeStrings, locale: string, now: number = Date.now()): string {\n  const fmt = numberFormat(locale, {}).format;\n  const at = toEpochMs(when);\n  if (Number.isNaN(at)) return strings.unknown;\n\n  const seconds = Math.max(0, Math.round((now - at) / 1000));\n  if (seconds < 45) return strings.justNow;\n\n  const totalMinutes = Math.round(seconds / 60);\n  if (totalMinutes < 60) return strings.minutesAgo(totalMinutes, fmt(totalMinutes));\n\n  /* One rounding pass on total hours, not two nested roundings (days, then a\n     remainder re-rounded to hours) — a second rounding on top of the first\n     is how a genuine 23h59m gap turns into \"1d 24h ago\". */\n  const totalHours = Math.round(seconds / 3600);\n  if (totalHours < 24) return strings.hoursAgo(totalHours, fmt(totalHours));\n\n  const days = Math.floor(totalHours / 24);\n  const hours = totalHours % 24;\n  if (days < 7) return hours > 0 ? strings.daysHoursAgo(days, fmt(days), hours, fmt(hours)) : strings.daysAgo(days, fmt(days));\n\n  const weeks = Math.round(days / 7);\n  return strings.weeksAgo(weeks, fmt(weeks));\n}\n"],"names":["relativeAge","when","strings","locale","now","fmt","numberFormat","at","toEpochMs","seconds","totalMinutes","totalHours","days","hours","weeks"],"mappings":";;AA2CO,SAASA,EAAYC,GAA8BC,GAA6BC,GAAgBC,IAAc,KAAK,OAAe;AACvI,QAAMC,IAAMC,EAAaH,GAAQ,CAAA,CAAE,EAAE,QAC/BI,IAAKC,EAAUP,CAAI;AACzB,MAAI,OAAO,MAAMM,CAAE,UAAUL,EAAQ;AAErC,QAAMO,IAAU,KAAK,IAAI,GAAG,KAAK,OAAOL,IAAMG,KAAM,GAAI,CAAC;AACzD,MAAIE,IAAU,GAAI,QAAOP,EAAQ;AAEjC,QAAMQ,IAAe,KAAK,MAAMD,IAAU,EAAE;AAC5C,MAAIC,IAAe,GAAI,QAAOR,EAAQ,WAAWQ,GAAcL,EAAIK,CAAY,CAAC;AAKhF,QAAMC,IAAa,KAAK,MAAMF,IAAU,IAAI;AAC5C,MAAIE,IAAa,GAAI,QAAOT,EAAQ,SAASS,GAAYN,EAAIM,CAAU,CAAC;AAExE,QAAMC,IAAO,KAAK,MAAMD,IAAa,EAAE,GACjCE,IAAQF,IAAa;AAC3B,MAAIC,IAAO,EAAG,QAAOC,IAAQ,IAAIX,EAAQ,aAAaU,GAAMP,EAAIO,CAAI,GAAGC,GAAOR,EAAIQ,CAAK,CAAC,IAAIX,EAAQ,QAAQU,GAAMP,EAAIO,CAAI,CAAC;AAE3H,QAAME,IAAQ,KAAK,MAAMF,IAAO,CAAC;AACjC,SAAOV,EAAQ,SAASY,GAAOT,EAAIS,CAAK,CAAC;AAC3C;"}

package/dist/lib/time/relativeClock.js

@@ -0,0 +1,59 @@
+const n = /* @__PURE__ */ new Set();
+let a;
+function b(e, t, o) {
+  const s = t(e, o);
+  let c = o, u = 1e3, r;
+  for (; ; ) {
+    const i = o + Math.min(u, 36e5);
+    if (t(e, i) !== s) {
+      r = i;
+      break;
+    }
+    if (c = i, u >= 36e5) break;
+    u *= 2;
+  }
+  if (r === void 0) return o + 36e5;
+  for (; r - c > 1; ) {
+    const i = Math.floor((c + r) / 2);
+    t(e, i) !== s ? r = i : c = i;
+  }
+  return r;
+}
+function d() {
+  a !== void 0 && clearTimeout(a), a = void 0;
+}
+function f() {
+  if (d(), n.size === 0 || document.visibilityState === "hidden") return;
+  let e = 1 / 0;
+  for (const { nextChangeAt: t } of n) e = Math.min(e, t);
+  a = setTimeout(m, Math.max(1, e - Date.now()));
+}
+function l(e) {
+  e.nextChangeAt = b(e.at, e.format, Date.now());
+}
+function m() {
+  const e = Date.now();
+  for (const t of [...n])
+    t.nextChangeAt > e || (t.onChange(), l(t));
+  f();
+}
+function h() {
+  if (document.visibilityState === "hidden") {
+    d();
+    return;
+  }
+  for (const e of [...n])
+    e.onChange(), l(e);
+  f();
+}
+function v(e, t, o) {
+  const s = { at: e, format: t, onChange: o, nextChangeAt: 0 };
+  return l(s), n.size === 0 && document.addEventListener("visibilitychange", h), n.add(s), f(), () => {
+    n.delete(s), n.size === 0 ? (d(), document.removeEventListener("visibilitychange", h)) : f();
+  };
+}
+export {
+  b as nextTextChangeAt,
+  v as subscribeRelativeClock
+};
+//# sourceMappingURL=relativeClock.js.map

package/dist/lib/time/relativeClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relativeClock.js","sources":["../../../src/lib/time/relativeClock.ts"],"sourcesContent":["/* ============================================================================\n   THE ONE CLIENT-SIDE CLOCK BEHIND EVERY LIVE RELATIVE TIME. DX-4797.\n\n   \"1 second ago\" must keep counting while the screen sits open. One timer serves\n   every mounted `RelativeTime` however many there are (a board of 200 tiles runs\n   ONE `setTimeout`, not 200), and it sleeps until the soonest moment any\n   subscriber's TEXT can change rather than ticking on a fixed beat, so a page of\n   hour-old times wakes once an hour.\n\n   THE WAKE TIME IS DERIVED FROM THE FORMAT, NOT ASSUMED. Each subscriber brings\n   its own `format(at, now)`, and a format's rounding is its own business (\"45s\"\n   flips `relativeAge` to minutes; `Intl` rounds a tie differently per sign).\n   Baking those marks in here would be a second, silently drifting copy of every\n   formatter. Instead the clock ASKS the format: it evaluates the text at later\n   instants (doubling forward until the text differs, then bisecting to the\n   millisecond) and sleeps to exactly that instant. The only assumption is that a\n   relative age's text does not change and then change back inside one probe\n   window: a count only grows as an age grows.\n\n   A hidden tab clears the timer and a return to visible re-reads everything:\n   browsers clamp hidden-tab timers, and a stale \"1 minute ago\" left on screen is\n   confidently wrong.\n   ========================================================================= */\n\n/** The text of a moment as of `now` (epoch ms). `relativeAge` is one. */\nexport type RelativeFormat = (at: string | number | Date, now?: number) => string;\n\nconst PROBE_START_MS = 1_000;\n/** No flip found this far ahead (a week-old \"1w ago\" is stable for days): look again after this long. */\nconst HORIZON_MS = 60 * 60 * 1000;\n\ninterface Subscriber {\n  readonly at: number;\n  readonly format: RelativeFormat;\n  readonly onChange: () => void;\n  /** Epoch ms at which `format(at)` next differs from what it reads now. */\n  nextChangeAt: number;\n}\n\nconst subscribers = new Set<Subscriber>();\nlet timer: ReturnType<typeof setTimeout> | undefined;\n\n/** The first instant after `now` at which `format(at, instant)` differs from `format(at, now)`, within `HORIZON_MS`. */\nexport function nextTextChangeAt(at: number, format: RelativeFormat, now: number): number {\n  const current = format(at, now);\n  let same = now;\n  let step = PROBE_START_MS;\n  let different: number | undefined;\n  for (;;) {\n    /* The last probe lands exactly on the horizon, so a flip anywhere inside it is found, never stepped over. */\n    const probe = now + Math.min(step, HORIZON_MS);\n    if (format(at, probe) !== current) {\n      different = probe;\n      break;\n    }\n    same = probe;\n    if (step >= HORIZON_MS) break;\n    step *= 2;\n  }\n  if (different === undefined) return now + HORIZON_MS;\n  while (different - same > 1) {\n    const middle = Math.floor((same + different) / 2);\n    if (format(at, middle) !== current) different = middle;\n    else same = middle;\n  }\n  return different;\n}\n\nfunction disarm(): void {\n  if (timer !== undefined) clearTimeout(timer);\n  timer = undefined;\n}\n\nfunction arm(): void {\n  disarm();\n  if (subscribers.size === 0 || document.visibilityState === \"hidden\") return;\n  let soonest = Infinity;\n  for (const { nextChangeAt } of subscribers) soonest = Math.min(soonest, nextChangeAt);\n  timer = setTimeout(wake, Math.max(1, soonest - Date.now()));\n}\n\nfunction reschedule(subscriber: Subscriber): void {\n  subscriber.nextChangeAt = nextTextChangeAt(subscriber.at, subscriber.format, Date.now());\n}\n\nfunction wake(): void {\n  const now = Date.now();\n  for (const subscriber of [...subscribers]) {\n    if (subscriber.nextChangeAt > now) continue;\n    subscriber.onChange();\n    reschedule(subscriber);\n  }\n  arm();\n}\n\nfunction onVisibilityChange(): void {\n  if (document.visibilityState === \"hidden\") {\n    disarm();\n    return;\n  }\n  for (const subscriber of [...subscribers]) {\n    subscriber.onChange();\n    reschedule(subscriber);\n  }\n  arm();\n}\n\n/** Calls `onChange` whenever `format(at)` may now read differently. Returns the unsubscribe. The last unsubscribe stops the timer. */\nexport function subscribeRelativeClock(at: number, format: RelativeFormat, onChange: () => void): () => void {\n  const subscriber: Subscriber = { at, format, onChange, nextChangeAt: 0 };\n  reschedule(subscriber);\n  if (subscribers.size === 0) document.addEventListener(\"visibilitychange\", onVisibilityChange);\n  subscribers.add(subscriber);\n  arm();\n  return () => {\n    subscribers.delete(subscriber);\n    if (subscribers.size === 0) {\n      disarm();\n      document.removeEventListener(\"visibilitychange\", onVisibilityChange);\n    } else {\n      arm();\n    }\n  };\n}\n\n/** Mounted subscribers right now; the tests pin that it returns to zero. */\nexport function relativeClockSubscriberCount(): number {\n  return subscribers.size;\n}\n"],"names":["subscribers","timer","nextTextChangeAt","at","format","now","current","same","step","different","probe","middle","disarm","arm","soonest","nextChangeAt","wake","reschedule","subscriber","onVisibilityChange","subscribeRelativeClock","onChange"],"mappings":"AAuCA,MAAMA,wBAAkB,IAAA;AACxB,IAAIC;AAGG,SAASC,EAAiBC,GAAYC,GAAwBC,GAAqB;AACxF,QAAMC,IAAUF,EAAOD,GAAIE,CAAG;AAC9B,MAAIE,IAAOF,GACPG,IAAO,KACPC;AACJ,aAAS;AAEP,UAAMC,IAAQL,IAAM,KAAK,IAAIG,GAAM,IAAU;AAC7C,QAAIJ,EAAOD,GAAIO,CAAK,MAAMJ,GAAS;AACjC,MAAAG,IAAYC;AACZ;AAAA,IACF;AAEA,QADAH,IAAOG,GACHF,KAAQ,KAAY;AACxB,IAAAA,KAAQ;AAAA,EACV;AACA,MAAIC,MAAc,OAAW,QAAOJ,IAAM;AAC1C,SAAOI,IAAYF,IAAO,KAAG;AAC3B,UAAMI,IAAS,KAAK,OAAOJ,IAAOE,KAAa,CAAC;AAChD,IAAIL,EAAOD,GAAIQ,CAAM,MAAML,IAASG,IAAYE,IAC3CJ,IAAOI;AAAA,EACd;AACA,SAAOF;AACT;AAEA,SAASG,IAAe;AACtB,EAAIX,MAAU,UAAW,aAAaA,CAAK,GAC3CA,IAAQ;AACV;AAEA,SAASY,IAAY;AAEnB,MADAD,EAAA,GACIZ,EAAY,SAAS,KAAK,SAAS,oBAAoB,SAAU;AACrE,MAAIc,IAAU;AACd,aAAW,EAAE,cAAAC,OAAkBf,OAAuB,KAAK,IAAIc,GAASC,CAAY;AACpF,EAAAd,IAAQ,WAAWe,GAAM,KAAK,IAAI,GAAGF,IAAU,KAAK,IAAA,CAAK,CAAC;AAC5D;AAEA,SAASG,EAAWC,GAA8B;AAChD,EAAAA,EAAW,eAAehB,EAAiBgB,EAAW,IAAIA,EAAW,QAAQ,KAAK,KAAK;AACzF;AAEA,SAASF,IAAa;AACpB,QAAMX,IAAM,KAAK,IAAA;AACjB,aAAWa,KAAc,CAAC,GAAGlB,CAAW;AACtC,IAAIkB,EAAW,eAAeb,MAC9Ba,EAAW,SAAA,GACXD,EAAWC,CAAU;AAEvB,EAAAL,EAAA;AACF;AAEA,SAASM,IAA2B;AAClC,MAAI,SAAS,oBAAoB,UAAU;AACzC,IAAAP,EAAA;AACA;AAAA,EACF;AACA,aAAWM,KAAc,CAAC,GAAGlB,CAAW;AACtC,IAAAkB,EAAW,SAAA,GACXD,EAAWC,CAAU;AAEvB,EAAAL,EAAA;AACF;AAGO,SAASO,EAAuBjB,GAAYC,GAAwBiB,GAAkC;AAC3G,QAAMH,IAAyB,EAAE,IAAAf,GAAI,QAAAC,GAAQ,UAAAiB,GAAU,cAAc,EAAA;AACrE,SAAAJ,EAAWC,CAAU,GACjBlB,EAAY,SAAS,KAAG,SAAS,iBAAiB,oBAAoBmB,CAAkB,GAC5FnB,EAAY,IAAIkB,CAAU,GAC1BL,EAAA,GACO,MAAM;AACX,IAAAb,EAAY,OAAOkB,CAAU,GACzBlB,EAAY,SAAS,KACvBY,EAAA,GACA,SAAS,oBAAoB,oBAAoBO,CAAkB,KAEnEN,EAAA;AAAA,EAEJ;AACF;"}

package/dist/lib/time/types.js

@@ -0,0 +1,23 @@
+import { pad as r } from "../pad.js";
+class $ extends Error {
+  constructor(t, o, e) {
+    super(
+      e === "gap" ? `${n(t)} does not exist in ${o} — the clock skipped it.` : `${n(t)} happens twice in ${o}.`
+    ), this.wall = t, this.zone = o, this.kind = e, this.name = "AmbiguousTimeError";
+  }
+  wall;
+  zone;
+  kind;
+}
+function n(i) {
+  return `${r(i.year, 4)}-${r(i.month)}-${r(i.day)}T${r(i.hour)}:${r(i.minute)}:${r(i.second)}.${r(i.millisecond, 3)}`;
+}
+function m(i) {
+  return `${r(i.year, 4)}-${r(i.month)}-${r(i.day)}`;
+}
+export {
+  $ as AmbiguousTimeError,
+  m as isoDateString,
+  n as isoDateTimeString
+};
+//# sourceMappingURL=types.js.map

package/dist/lib/time/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../src/lib/time/types.ts"],"sourcesContent":["/* ============================================================================\n   THE TIME LAYER'S VOCABULARY — deliberately `Temporal`'s, minus what we do\n   not need.\n\n   WHY WE HAVE OUR OWN AT ALL. `Temporal` is the right answer and it is not\n   available: Chrome 144+, Firefox 139+, Node 26+, and **Safari has not shipped\n   it in any stable version, desktop or iOS**. Every iOS browser is WebKit, so\n   \"modern browsers only\" does not rescue us — global support is ~69% and the\n   entire gap is Apple. The polyfill is 20.4 kB gzip and is a real option; it is\n   priced on the tracker (CAL-TIME) so reversing this decision is one sentence.\n\n   WHY THE SHAPES MIRROR `Temporal` ANYWAY. The day Safari ships it, the swap\n   should be mechanical rather than a rewrite. So `PlainDate` has `year` /\n   `month` / `day` with a ONE-BASED month, `PlainDateTime` extends it,\n   `Instant` is a fixed point on the timeline, and the disambiguation modes are\n   spelled exactly as `Temporal.ZonedDateTime.from` spells them. Anywhere a name\n   here differs from `Temporal`'s, that is a bug in this file.\n\n   WHAT IS DELIBERATELY ABSENT: calendars other than ISO 8601, nanosecond\n   precision, `Temporal.Duration`'s full field set, and any notion of a\n   `ZonedDateTime` object. A calendar needs an instant, a wall-clock reading, a\n   calendar day, and a way to move between them; carrying more would be carrying\n   a date library we did not choose to write.\n   ========================================================================= */\n\nimport { pad } from \"../pad\";\n\n/**\n * A point on the timeline, as milliseconds since the epoch.\n *\n * NOT a `Date`. A `Date` is a mutable object that prints itself in the host's\n * local zone, and every calendar bug in the survey behind this component\n * involved someone reading a `Date`'s local fields when they meant a specific\n * zone's. A number cannot be misread that way — it has no fields to read.\n */\nexport type Instant = number;\n\n/** An IANA time zone identifier, e.g. `\"America/New_York\"`. */\nexport type TimeZone = string;\n\n/**\n * A calendar day. No time, no zone, no offset — just which square on the wall.\n *\n * `month` IS ONE-BASED, matching `Temporal` and matching how every human writes\n * a date. `Date`'s zero-based month is the single most common off-by-one in\n * date code and it is not reproduced here.\n */\nexport interface PlainDate {\n  readonly year: number;\n  /** 1–12. */\n  readonly month: number;\n  /** 1–31. */\n  readonly day: number;\n}\n\n/**\n * A wall-clock reading. What a clock on the wall says, with no claim about\n * which wall.\n *\n * This is the type that makes the ambiguity explicit rather than accidental:\n * `2026-11-01T01:30` in New York happened TWICE, and `2026-03-08T02:30` never\n * happened at all. A `PlainDateTime` can represent both, which is precisely why\n * turning one into an `Instant` requires saying what to do about it.\n */\nexport interface PlainDateTime extends PlainDate {\n  /** 0–23. */\n  readonly hour: number;\n  /** 0–59. */\n  readonly minute: number;\n  /** 0–59. */\n  readonly second: number;\n  /** 0–999. */\n  readonly millisecond: number;\n}\n\n/**\n * How much to move, in CALENDAR units rather than elapsed time.\n *\n * THE DISTINCTION IS THE WHOLE POINT, and getting it wrong is the bug in every\n * library surveyed. \"One day later\" is not \"86,400,000 ms later\": across a\n * spring-forward boundary it is 23 hours, and across a fall-back it is 25. A\n * user dragging an event from Saturday to Sunday expects it to keep its\n * wall-clock time, so the move has to be expressed as `{ days: 1 }` and\n * resolved against the zone — never added as a number.\n *\n * `hours` and `minutes` ARE exact elapsed time, and that is correct: dragging\n * an event down by two hours means two hours of real duration.\n */\nexport interface CalendarDuration {\n  readonly days?: number;\n  readonly hours?: number;\n  readonly minutes?: number;\n}\n\n/**\n * What to do when a wall-clock reading does not name exactly one instant.\n *\n * Spelled as `Temporal.ZonedDateTime.from`'s option of the same name, with the\n * same meanings, so this is one more thing that becomes a deletion later.\n *\n * - `compatible` — what every other date library does, and the default.\n *   In a GAP (spring forward) move forward by the size of the gap; in an\n *   OVERLAP (fall back) take the first of the two.\n * - `earlier` / `later` — take that side explicitly.\n * - `reject` — throw. For a parser or an import, where a time that never\n *   existed is a fact about bad input rather than something to paper over.\n */\nexport type Disambiguation = \"compatible\" | \"earlier\" | \"later\" | \"reject\";\n\n/** Thrown by `reject` disambiguation, and never by anything else. */\nexport class AmbiguousTimeError extends Error {\n  constructor(\n    readonly wall: PlainDateTime,\n    readonly zone: TimeZone,\n    readonly kind: \"gap\" | \"overlap\",\n  ) {\n    super(\n      kind === \"gap\"\n        ? `${isoDateTimeString(wall)} does not exist in ${zone} — the clock skipped it.`\n        : `${isoDateTimeString(wall)} happens twice in ${zone}.`,\n    );\n    this.name = \"AmbiguousTimeError\";\n  }\n}\n\n/** `2026-03-08T02:30:00.000` — used in errors, and by the ISO helpers. */\nexport function isoDateTimeString(wall: PlainDateTime): string {\n  return (\n    `${pad(wall.year, 4)}-${pad(wall.month)}-${pad(wall.day)}` +\n    `T${pad(wall.hour)}:${pad(wall.minute)}:${pad(wall.second)}.${pad(wall.millisecond, 3)}`\n  );\n}\n\n/** `2026-03-08`. */\nexport function isoDateString(date: PlainDate): string {\n  return `${pad(date.year, 4)}-${pad(date.month)}-${pad(date.day)}`;\n}\n"],"names":["AmbiguousTimeError","wall","zone","kind","isoDateTimeString","pad","isoDateString","date"],"mappings":";AA8GO,MAAMA,UAA2B,MAAM;AAAA,EAC5C,YACWC,GACAC,GACAC,GACT;AACA;AAAA,MACEA,MAAS,QACL,GAAGC,EAAkBH,CAAI,CAAC,sBAAsBC,CAAI,6BACpD,GAAGE,EAAkBH,CAAI,CAAC,qBAAqBC,CAAI;AAAA,IAAA,GAPhD,KAAA,OAAAD,GACA,KAAA,OAAAC,GACA,KAAA,OAAAC,GAOT,KAAK,OAAO;AAAA,EACd;AAAA,EAVW;AAAA,EACA;AAAA,EACA;AASb;AAGO,SAASC,EAAkBH,GAA6B;AAC7D,SACE,GAAGI,EAAIJ,EAAK,MAAM,CAAC,CAAC,IAAII,EAAIJ,EAAK,KAAK,CAAC,IAAII,EAAIJ,EAAK,GAAG,CAAC,IACpDI,EAAIJ,EAAK,IAAI,CAAC,IAAII,EAAIJ,EAAK,MAAM,CAAC,IAAII,EAAIJ,EAAK,MAAM,CAAC,IAAII,EAAIJ,EAAK,aAAa,CAAC,CAAC;AAE1F;AAGO,SAASK,EAAcC,GAAyB;AACrD,SAAO,GAAGF,EAAIE,EAAK,MAAM,CAAC,CAAC,IAAIF,EAAIE,EAAK,KAAK,CAAC,IAAIF,EAAIE,EAAK,GAAG,CAAC;AACjE;"}

package/dist/lib/time/zone.js

@@ -0,0 +1,148 @@
+import { AmbiguousTimeError as p } from "./types.js";
+import { addDays as D } from "./plain.js";
+import { dateFormat as U } from "../intl-cache.js";
+const m = 36e5, M = 6e4;
+function F(t) {
+  return U("en-US", {
+    timeZone: t,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    /* `h23` EXPLICITLY, not `hour12: false`. Several ICU versions render
+       midnight as hour "24" under `hour12: false`, which parses as a valid
+       number and silently lands the reading on the wrong day. */
+    hourCycle: "h23"
+  });
+}
+function d(t, e) {
+  const n = F(t).formatToParts(new Date(e));
+  let r = 0, o = 1, i = 1, u = 0, s = 0, c = 0;
+  for (const f of n)
+    switch (f.type) {
+      case "year":
+        r = Number(f.value);
+        break;
+      case "month":
+        o = Number(f.value);
+        break;
+      case "day":
+        i = Number(f.value);
+        break;
+      case "hour":
+        u = Number(f.value);
+        break;
+      case "minute":
+        s = Number(f.value);
+        break;
+      case "second":
+        c = Number(f.value);
+        break;
+    }
+  const a = (e % 1e3 + 1e3) % 1e3;
+  return { year: r, month: o, day: i, hour: u, minute: s, second: c, millisecond: a };
+}
+function g(t) {
+  const e = /* @__PURE__ */ new Date(0);
+  return e.setUTCFullYear(t.year, t.month - 1, t.day), e.setUTCHours(t.hour, t.minute, t.second, t.millisecond), e.getTime();
+}
+function h(t, e) {
+  return g(d(t, e)) - e;
+}
+function v(t, e) {
+  return t.year === e.year && t.month === e.month && t.day === e.day && t.hour === e.hour && t.minute === e.minute && t.second === e.second && t.millisecond === e.millisecond;
+}
+function y(t, e) {
+  const n = g(e), r = h(t, n - 24 * m), o = h(t, n + 24 * m), i = [];
+  for (const u of r === o ? [r] : [r, o]) {
+    const s = n - u;
+    v(d(t, s), e) && i.push(s);
+  }
+  return i.sort((u, s) => u - s), i.filter((u, s) => s === 0 || u !== i[s - 1]);
+}
+function C(t, e, n = "compatible") {
+  const r = y(t, e);
+  if (r.length === 1) return r[0];
+  if (r.length > 1) {
+    if (n === "reject") throw new p(e, t, "overlap");
+    return n === "later" ? r[r.length - 1] : r[0];
+  }
+  if (n === "reject") throw new p(e, t, "gap");
+  const o = g(e), i = h(t, o - 24 * m), u = h(t, o + 24 * m), s = u - i, c = o - i, a = o - u;
+  return n === "earlier" ? Math.min(c, a) : s > 0 ? Math.max(c, a) : Math.min(c, a);
+}
+function x(t, e) {
+  const n = d(t, e);
+  return { year: n.year, month: n.month, day: n.day };
+}
+function l(t, e) {
+  const n = { ...e, hour: 0, minute: 0, second: 0, millisecond: 0 }, r = y(t, n);
+  if (r.length > 0) return r[0];
+  for (let o = 1; o <= 180; o++) {
+    const i = y(t, {
+      ...e,
+      hour: Math.floor(o / 60),
+      minute: o % 60,
+      second: 0,
+      millisecond: 0
+    });
+    if (i.length > 0) return i[0];
+  }
+  throw new Error(
+    `startOfDay: no instant exists in the first three hours of ${e.year}-${e.month}-${e.day} in ${t}`
+  );
+}
+function N(t) {
+  return D(t, 1);
+}
+function T(t, e) {
+  return l(t, N(e)) - l(t, e);
+}
+function $(t, e) {
+  return T(t, e) / m;
+}
+function w(t, e, n) {
+  const r = l(t, e);
+  return (n - r) / T(t, e);
+}
+function E(t, e, n) {
+  return l(t, e) + n * T(t, e);
+}
+function I(t, e, n, r = "compatible") {
+  const { days: o = 0, hours: i = 0, minutes: u = 0 } = n;
+  let s = e;
+  if (o !== 0) {
+    const c = d(t, e), a = /* @__PURE__ */ new Date(0);
+    a.setUTCFullYear(c.year, c.month - 1, c.day + o), s = C(
+      t,
+      {
+        year: a.getUTCFullYear(),
+        month: a.getUTCMonth() + 1,
+        day: a.getUTCDate(),
+        hour: c.hour,
+        minute: c.minute,
+        second: c.second,
+        millisecond: c.millisecond
+      },
+      r
+    );
+  }
+  return s + i * m + u * M;
+}
+export {
+  I as addDuration,
+  w as dayFraction,
+  T as dayLengthMs,
+  $ as hoursInDay,
+  E as instantAtFraction,
+  x as instantToPlainDate,
+  d as instantToPlainDateTime,
+  N as nextDay,
+  h as offsetAt,
+  C as plainDateTimeToInstant,
+  l as startOfDay,
+  g as wallAsUtcMs
+};
+//# sourceMappingURL=zone.js.map

package/dist/lib/time/zone.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone.js","sources":["../../../src/lib/time/zone.ts"],"sourcesContent":["import {\n  AmbiguousTimeError,\n  type Disambiguation,\n  type Instant,\n  type PlainDate,\n  type PlainDateTime,\n  type TimeZone,\n} from \"./types\";\nimport { addDays } from \"./plain\";\nimport { dateFormat } from \"@/lib/intl-cache\";\n\n/* ============================================================================\n   MOVING BETWEEN A WALL CLOCK AND THE TIMELINE.\n\n   Everything here rests on ONE primitive — `offsetAt(zone, instant)` — read out\n   of `Intl.DateTimeFormat`, which is the only IANA database a browser exposes.\n   Everything else is arithmetic on top of it, so there is exactly one place\n   where the rules of a zone enter this package.\n\n   THE RULE THIS FILE EXISTS TO ENFORCE: a day is not 24 hours. It is 23 in\n   New York on 2026-03-08, 25 on 2026-11-01, 23.5 in Lord Howe on 2026-10-04\n   (its shift is THIRTY MINUTES, so any branch on \"is the delta 3600000\" is\n   already wrong), and in Santiago on 2026-09-06 it is 23 hours that begin at\n   01:00 — `startOfDay` is NOT always midnight. Every one of those was measured\n   before this file was written, and all five are in the test corpus.\n\n   Kendo's scheduler crashed because two of its own methods disagreed about how\n   long a day was; Mozilla's calendar drew an event an hour out plus a phantom\n   row; react-big-calendar still shifts an entire week's columns because it\n   derives them by adding `n * 86400000`. The shape of all three is the same:\n   somewhere, a day was assumed.\n   ========================================================================= */\n\nconst HOUR_MS = 3_600_000;\nconst MINUTE_MS = 60_000;\n\nfunction formatterFor(zone: TimeZone): Intl.DateTimeFormat {\n  /* I18N-ALLOW: this formatter is zone ARITHMETIC, never display — the parts are read back as Latin digits, so the tag must not vary with the viewer's locale. */\n  return dateFormat(\"en-US\", {\n    timeZone: zone,\n    year: \"numeric\",\n    month: \"2-digit\",\n    day: \"2-digit\",\n    hour: \"2-digit\",\n    minute: \"2-digit\",\n    second: \"2-digit\",\n    /* `h23` EXPLICITLY, not `hour12: false`. Several ICU versions render\n       midnight as hour \"24\" under `hour12: false`, which parses as a valid\n       number and silently lands the reading on the wrong day. */\n    hourCycle: \"h23\",\n  });\n}\n\n/** The wall-clock reading in `zone` at `instant`. */\nexport function instantToPlainDateTime(zone: TimeZone, instant: Instant): PlainDateTime {\n  const parts = formatterFor(zone).formatToParts(new Date(instant));\n  let year = 0;\n  let month = 1;\n  let day = 1;\n  let hour = 0;\n  let minute = 0;\n  let second = 0;\n  for (const part of parts) {\n    switch (part.type) {\n      case \"year\":\n        year = Number(part.value);\n        break;\n      case \"month\":\n        month = Number(part.value);\n        break;\n      case \"day\":\n        day = Number(part.value);\n        break;\n      case \"hour\":\n        hour = Number(part.value);\n        break;\n      case \"minute\":\n        minute = Number(part.value);\n        break;\n      case \"second\":\n        second = Number(part.value);\n        break;\n    }\n  }\n  /* Sub-second precision passes straight through: every offset in the IANA\n     database since 1972 is a whole number of minutes, so a zone shift can never\n     move the millisecond field. */\n  const millisecond = ((instant % 1000) + 1000) % 1000;\n  return { year, month, day, hour, minute, second, millisecond };\n}\n\n/**\n * The same wall-clock fields, but as though they were UTC.\n *\n * `Date.UTC` is NOT used directly anywhere in this file: it maps years 0–99\n * onto 1900–1999, so a year-40 date silently becomes 1940. `setUTCFullYear` has\n * no such rule. The calendar will never render year 40, but a helper that is\n * wrong for an input it never receives is a trap left for whoever reuses it.\n */\nexport function wallAsUtcMs(wall: PlainDateTime): number {\n  const d = new Date(0);\n  d.setUTCFullYear(wall.year, wall.month - 1, wall.day);\n  d.setUTCHours(wall.hour, wall.minute, wall.second, wall.millisecond);\n  return d.getTime();\n}\n\n/**\n * `zone`'s offset from UTC at `instant`, in milliseconds. East is positive.\n *\n * THE ONE PRIMITIVE. Read by asking the browser what the wall clock says at\n * that instant and subtracting: if it is 07:00 UTC and the clock in New York\n * reads 02:00, the offset is −5 hours. No table, no parsing of a zone name, no\n * assumption that an offset is a whole number of hours — `Pacific/Chatham` sits\n * at +12:45, and `Asia/Kathmandu` at +5:45.\n */\nexport function offsetAt(zone: TimeZone, instant: Instant): number {\n  return wallAsUtcMs(instantToPlainDateTime(zone, instant)) - instant;\n}\n\nfunction sameWall(a: PlainDateTime, b: PlainDateTime): boolean {\n  return (\n    a.year === b.year &&\n    a.month === b.month &&\n    a.day === b.day &&\n    a.hour === b.hour &&\n    a.minute === b.minute &&\n    a.second === b.second &&\n    a.millisecond === b.millisecond\n  );\n}\n\n/**\n * Every instant at which `zone`'s clock reads exactly `wall` — zero, one, or\n * two of them, in ascending order.\n *\n * TWO CANDIDATES, BOTH VERIFIED, WHICH IS THE PART THAT IS EASY TO GET WRONG.\n * The naive method — take the offset at a guessed instant and subtract it — is\n * correct in the ordinary case and wrong at exactly the boundaries this\n * component exists to handle. So both plausible offsets are tried, and each\n * candidate is accepted ONLY if reading the clock back at it reproduces the\n * requested wall time. That round-trip is what distinguishes a real reading\n * from one the clock skipped.\n *\n *   two results → an OVERLAP; the clock struck this time twice (fall back)\n *   one result  → the ordinary case\n *   none        → a GAP; the clock never struck it at all (spring forward)\n */\nfunction instantsFor(zone: TimeZone, wall: PlainDateTime): Instant[] {\n  const asUtc = wallAsUtcMs(wall);\n  const offsetBefore = offsetAt(zone, asUtc - 24 * HOUR_MS);\n  const offsetAfter = offsetAt(zone, asUtc + 24 * HOUR_MS);\n\n  const found: Instant[] = [];\n  for (const offset of offsetBefore === offsetAfter ? [offsetBefore] : [offsetBefore, offsetAfter]) {\n    const candidate = asUtc - offset;\n    if (sameWall(instantToPlainDateTime(zone, candidate), wall)) found.push(candidate);\n  }\n  found.sort((a, b) => a - b);\n  /* A zone can in principle be sampled twice at the same offset either side of\n     a transition that returns to where it started; de-duplicate rather than\n     report one instant as two. */\n  return found.filter((t, i) => i === 0 || t !== found[i - 1]);\n}\n\n/**\n * The instant at which `zone`'s clock reads `wall`.\n *\n * See `Disambiguation` for what happens when that is not exactly one instant.\n * The default is `compatible`, which is what `Temporal` and every other date\n * library do, so the surprising cases are the ones you have to ask for.\n */\nexport function plainDateTimeToInstant(\n  zone: TimeZone,\n  wall: PlainDateTime,\n  disambiguation: Disambiguation = \"compatible\",\n): Instant {\n  const candidates = instantsFor(zone, wall);\n\n  if (candidates.length === 1) return candidates[0];\n\n  if (candidates.length > 1) {\n    /* OVERLAP — the hour ran twice. */\n    if (disambiguation === \"reject\") throw new AmbiguousTimeError(wall, zone, \"overlap\");\n    if (disambiguation === \"later\") return candidates[candidates.length - 1];\n    /* `compatible` takes the earlier, matching Temporal. */\n    return candidates[0];\n  }\n\n  /* GAP — the clock skipped this reading entirely. */\n  if (disambiguation === \"reject\") throw new AmbiguousTimeError(wall, zone, \"gap\");\n\n  const asUtc = wallAsUtcMs(wall);\n  const offsetBefore = offsetAt(zone, asUtc - 24 * HOUR_MS);\n  const offsetAfter = offsetAt(zone, asUtc + 24 * HOUR_MS);\n  const gap = offsetAfter - offsetBefore;\n\n  /* Both of these are real instants; they differ by the size of the gap. Using\n     the PRE-transition offset lands before the jump, the post-transition offset\n     lands after it. `compatible` shifts FORWARD by the gap — the same choice\n     Temporal makes, and the one that matches what a person means by \"07:30\" on\n     a morning when 07:30 did not happen. */\n  const earlier = asUtc - offsetBefore;\n  const later = asUtc - offsetAfter;\n  if (disambiguation === \"earlier\") return Math.min(earlier, later);\n  return gap > 0 ? Math.max(earlier, later) : Math.min(earlier, later);\n}\n\n/** The calendar day `instant` falls on, in `zone`. */\nexport function instantToPlainDate(zone: TimeZone, instant: Instant): PlainDate {\n  const wall = instantToPlainDateTime(zone, instant);\n  return { year: wall.year, month: wall.month, day: wall.day };\n}\n\n/**\n * The first instant of `date` in `zone`.\n *\n * NOT \"midnight\". In `America/Santiago` on 2026-09-06 the clock jumps from\n * 00:00 to 01:00, so the day's first instant reads 01:00 — and a grid that\n * assumes its own origin is midnight puts every event on that day an hour out.\n * `America/Havana` and `Asia/Beirut` do the same thing on their own dates.\n *\n * Implemented by asking for midnight and, when the clock skipped it, walking\n * forward a minute at a time until a reading exists. The walk is bounded: no\n * transition in the IANA database exceeds two hours, so 180 iterations cannot\n * be reached by real data, and the bound exists to fail loudly rather than spin\n * if that ever stops being true.\n */\nexport function startOfDay(zone: TimeZone, date: PlainDate): Instant {\n  const midnight: PlainDateTime = { ...date, hour: 0, minute: 0, second: 0, millisecond: 0 };\n  const exact = instantsFor(zone, midnight);\n  /* An OVERLAP at midnight means the day started twice; the day begins at the\n     first of them, not the second. */\n  if (exact.length > 0) return exact[0];\n\n  for (let minutes = 1; minutes <= 180; minutes++) {\n    const candidate = instantsFor(zone, {\n      ...date,\n      hour: Math.floor(minutes / 60),\n      minute: minutes % 60,\n      second: 0,\n      millisecond: 0,\n    });\n    if (candidate.length > 0) return candidate[0];\n  }\n  throw new Error(\n    `startOfDay: no instant exists in the first three hours of ${date.year}-${date.month}-${date.day} in ${zone}`,\n  );\n}\n\n/** The day after `date` on the calendar, ignoring zones entirely. */\nexport function nextDay(date: PlainDate): PlainDate {\n  return addDays(date, 1);\n}\n\n/**\n * How long `date` actually lasts in `zone`, in milliseconds.\n *\n * Measured as the distance between one day's first instant and the next day's,\n * which is true by construction for every case — 23 hours, 25 hours, the 30\n * minutes of Lord Howe, and a day that starts at 01:00 — with no special case\n * for any of them. That is the entire reason positions in the grid are a RATIO\n * of this number rather than `hour × rowHeight`.\n */\nexport function dayLengthMs(zone: TimeZone, date: PlainDate): number {\n  return startOfDay(zone, nextDay(date)) - startOfDay(zone, date);\n}\n\n/**\n * How many hours `date` lasts in `zone` — 23, 24, 25, or 23.5.\n *\n * Fractional by design. `Australia/Lord_Howe` shifts by thirty minutes, so a\n * signature returning an integer would be lying about a real zone, and any\n * caller branching on `=== 23` is already broken.\n */\nexport function hoursInDay(zone: TimeZone, date: PlainDate): number {\n  return dayLengthMs(zone, date) / HOUR_MS;\n}\n\n/**\n * Where `instant` sits within `date`, as a fraction from 0 to 1.\n *\n * THE LOAD-BEARING FUNCTION. A 23-hour day compresses and a 25-hour day\n * stretches with no branch anywhere, because the divisor is the day's real\n * length. Values outside 0–1 mean the instant is not on this day and are\n * returned rather than clamped — the layout core needs to know by how much in\n * order to clip a multi-day span.\n */\nexport function dayFraction(zone: TimeZone, date: PlainDate, instant: Instant): number {\n  const from = startOfDay(zone, date);\n  return (instant - from) / dayLengthMs(zone, date);\n}\n\n/**\n * The exact inverse of `dayFraction`.\n *\n * IT MUST BE EXACT, and that is not a stylistic preference. Rendering maps an\n * instant to a position and hit-testing maps a position back to an instant; if\n * the two disagree by even a rounding step, an event lands one slot away from\n * where it was dropped. FullCalendar's Australia selection bug is exactly this\n * pair drifting apart. `dayFraction(z, d, instantAtFraction(z, d, f)) === f`\n * for every zone in the corpus, and there is a test that says so.\n */\nexport function instantAtFraction(zone: TimeZone, date: PlainDate, fraction: number): Instant {\n  return startOfDay(zone, date) + fraction * dayLengthMs(zone, date);\n}\n\n/**\n * Move `instant` by a CALENDAR duration.\n *\n * Days are applied on the calendar and then re-anchored to the same wall-clock\n * time, so an event dragged from Saturday to Sunday across a transition keeps\n * reading 09:00 rather than becoming 08:00 or 10:00. Hours and minutes are\n * applied afterwards as exact elapsed time, because dragging an event down the\n * grid by two hours does mean two hours.\n *\n * ORDER MATTERS AND IS FIXED: days first, then time. The other order makes\n * \"one day and two hours later\" depend on which side of a transition the\n * intermediate value happened to land on.\n */\nexport function addDuration(\n  zone: TimeZone,\n  instant: Instant,\n  duration: { days?: number; hours?: number; minutes?: number },\n  disambiguation: Disambiguation = \"compatible\",\n): Instant {\n  const { days = 0, hours = 0, minutes = 0 } = duration;\n\n  let result = instant;\n  if (days !== 0) {\n    const wall = instantToPlainDateTime(zone, instant);\n    const shifted = new Date(0);\n    shifted.setUTCFullYear(wall.year, wall.month - 1, wall.day + days);\n    result = plainDateTimeToInstant(\n      zone,\n      {\n        year: shifted.getUTCFullYear(),\n        month: shifted.getUTCMonth() + 1,\n        day: shifted.getUTCDate(),\n        hour: wall.hour,\n        minute: wall.minute,\n        second: wall.second,\n        millisecond: wall.millisecond,\n      },\n      disambiguation,\n    );\n  }\n  return result + hours * HOUR_MS + minutes * MINUTE_MS;\n}\n"],"names":["HOUR_MS","MINUTE_MS","formatterFor","zone","dateFormat","instantToPlainDateTime","instant","parts","year","month","day","hour","minute","second","part","millisecond","wallAsUtcMs","wall","d","offsetAt","sameWall","a","b","instantsFor","asUtc","offsetBefore","offsetAfter","found","offset","candidate","t","i","plainDateTimeToInstant","disambiguation","candidates","AmbiguousTimeError","gap","earlier","later","instantToPlainDate","startOfDay","date","midnight","exact","minutes","nextDay","addDays","dayLengthMs","hoursInDay","dayFraction","from","instantAtFraction","fraction","addDuration","duration","days","hours","result","shifted"],"mappings":"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"}

package/dist/lib/use-controllable.js

@@ -0,0 +1,16 @@
+import { useState as a, useRef as i, useCallback as f } from "react";
+function d(e, o, r) {
+  const [l, u] = a(o), t = e !== void 0, n = i(r);
+  n.current = r;
+  const c = f(
+    (s) => {
+      t || u(s), n.current?.(s);
+    },
+    [t]
+  );
+  return [t ? e : l, c];
+}
+export {
+  d as useControllable
+};
+//# sourceMappingURL=use-controllable.js.map

package/dist/lib/use-controllable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-controllable.js","sources":["../../src/lib/use-controllable.ts"],"sourcesContent":["import { useCallback, useRef, useState } from \"react\";\n\n/**\n * One value that may be driven from outside or kept here.\n *\n * WHY IT IS SHARED RATHER THAN WRITTEN FOUR TIMES: `CodeEditor` has four of\n * these (text, wrap, view, expanded) and the subtle half is identical in all\n * four — a controlled instance must NEVER write its own state, or it renders\n * the consumer's value for one frame and its own for the next, which shows up\n * as a control that flickers back after every change.\n *\n * `controlled === undefined` decides, once per render, exactly as React's own\n * inputs do. Switching a prop from undefined to a value mid-life is a consumer\n * bug everywhere in React and is not defended against here.\n */\nexport function useControllable<T>(\n  controlled: T | undefined,\n  initial: T,\n  onChange?: (next: T) => void,\n): [T, (next: T) => void] {\n  const [internal, setInternal] = useState(initial);\n  const isControlled = controlled !== undefined;\n\n  /* The handler is read from a ref so `set` keeps a stable identity. Without\n     it every consumer passing an inline arrow re-creates `set` on each render,\n     which invalidates every memo below it — on a component whose child renders\n     a span per token, that is the difference between a keystroke costing one\n     re-render and costing several. */\n  const handler = useRef(onChange);\n  handler.current = onChange;\n\n  const set = useCallback(\n    (next: T) => {\n      if (!isControlled) setInternal(next);\n      handler.current?.(next);\n    },\n    [isControlled],\n  );\n\n  return [isControlled ? (controlled as T) : internal, set];\n}\n"],"names":["useControllable","controlled","initial","onChange","internal","setInternal","useState","isControlled","handler","useRef","set","useCallback","next"],"mappings":";AAeO,SAASA,EACdC,GACAC,GACAC,GACwB;AACxB,QAAM,CAACC,GAAUC,CAAW,IAAIC,EAASJ,CAAO,GAC1CK,IAAeN,MAAe,QAO9BO,IAAUC,EAAON,CAAQ;AAC/B,EAAAK,EAAQ,UAAUL;AAElB,QAAMO,IAAMC;AAAA,IACV,CAACC,MAAY;AACX,MAAKL,KAAcF,EAAYO,CAAI,GACnCJ,EAAQ,UAAUI,CAAI;AAAA,IACxB;AAAA,IACA,CAACL,CAAY;AAAA,EAAA;AAGf,SAAO,CAACA,IAAgBN,IAAmBG,GAAUM,CAAG;AAC1D;"}

package/dist/lib/use-fill-height.js

@@ -0,0 +1,49 @@
+import { useState as u, useLayoutEffect as f } from "react";
+import { nearestScrollAncestor as p } from "./dom/scroll-ancestor.js";
+const a = 200, c = (o) => p(o, { includeSelf: !1 });
+function h(o) {
+  const e = o.getBoundingClientRect(), r = c(o);
+  if (r === null) {
+    const s = o.ownerDocument.defaultView;
+    return o.ownerDocument.documentElement.clientHeight - (e.top + (s?.scrollY ?? 0));
+  }
+  const n = r.getBoundingClientRect(), l = parseFloat(getComputedStyle(r).borderTopWidth) || 0, i = e.top - n.top - l + r.scrollTop;
+  return r.clientHeight - i;
+}
+function d(o = !0) {
+  const [e, r] = u(null);
+  return f(() => {
+    if (e === null) return;
+    const n = () => {
+      if (!o) {
+        e.style.removeProperty("height");
+        return;
+      }
+      const s = h(e);
+      if (!(s >= a)) {
+        e.style.removeProperty("height");
+        return;
+      }
+      const t = `${Math.floor(s)}px`;
+      e.style.height !== t && (e.style.height = t);
+    };
+    if (n(), !o) return;
+    const l = e.ownerDocument.defaultView;
+    l?.addEventListener("resize", n);
+    const i = typeof ResizeObserver > "u" ? null : new ResizeObserver(n);
+    if (i) {
+      const s = c(e);
+      for (let t = e.parentElement; t && (i.observe(t), t !== s); t = t.parentElement)
+        ;
+      for (const t of e.parentElement?.children ?? [])
+        t !== e && i.observe(t);
+    }
+    return () => {
+      l?.removeEventListener("resize", n), i?.disconnect(), e.style.removeProperty("height");
+    };
+  }, [e, o]), r;
+}
+export {
+  d as useFillHeight
+};
+//# sourceMappingURL=use-fill-height.js.map

package/dist/lib/use-fill-height.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-fill-height.js","sources":["../../src/lib/use-fill-height.ts"],"sourcesContent":["import { useLayoutEffect, useState, type RefCallback } from \"react\";\nimport { nearestScrollAncestor } from \"./dom/scroll-ancestor\";\n\n/* ============================================================================\n   FILL THE REST OF THE SCREEN — the height CSS cannot compute.\n\n   THE DEFECT THIS EXISTS FOR, in the words it was reported in: \"the columns on\n   the kanban board should fill to the full remaining height of the page. No\n   scroll bar vertically. Only scroll vertically per column. Why is that not the\n   default out of the box?\"\n\n   IT WAS NOT THE DEFAULT BECAUSE NO ARRANGEMENT OF CLASSES CAN MAKE IT ONE. The\n   documented shape — `flex-1 min-h-0` chained from a bounded ancestor down to\n   the scroller — is correct, and it is correct only while EVERY element in that\n   chain cooperates. `flex-1` against a block parent is inert; `h-full` against a\n   parent with no definite height is `auto`; a percentage height resolves against\n   nothing. One ordinary page wrapper anywhere above — `<div className=\"flex\n   flex-col gap-10 py-10\">`, which is this package's own demo layout — and the\n   whole chain silently degrades to content sizing. Measured in the demo with\n   the fixture's own height removed: the board came out 473px tall, its lanes\n   scrolled nothing at all (`scrollHeight` 404 against `clientHeight` 404), and\n   the shell's content column took the overflow instead (1027 against 840).\n\n   So the component that needs the height has to ask for it, and CSS has no\n   question that means \"how far is it from my own top to the bottom of the box\n   that scrolls me\". That distance is what this measures.\n\n   THIS IS NOT THE ARITHMETIC `AppShell` BANS. Its header says: \"If a consumer is\n   doing viewport arithmetic against one of our tokens, this component has not\n   finished its job\" — and it is right, because `h-[calc(100dvh-var(--control-xl))]`\n   is a CACHED COPY of a fact the DOM already knows, wrong the moment the header\n   wraps or the token is retuned. Nothing is cached here. The number is read from\n   live boxes, re-read whenever any box above it changes size, and never written\n   by a consumer.\n\n   THE MEASUREMENT IS SCROLL-INDEPENDENT, and getting that wrong is a feedback\n   loop rather than an off-by-one. Taking `viewportHeight - rect.top` makes the\n   answer grow as the page scrolls down, which grows the element, which lengthens\n   the page. The offset is taken in the SCROLLPORT'S OWN CONTENT COORDINATES\n   instead — `rect.top - portRect.top - borderTop + port.scrollTop` — which does\n   not move when the scrollport scrolls, so the height is a fixed point.\n\n   WHAT IT DELIBERATELY DOES NOT DO. It never sets a height it cannot justify:\n   below `MIN_FILL` the property is removed and the element falls back to the\n   `flex-1`/content behaviour it had before, because a board 40px from the bottom\n   of a long document has no \"remaining height\" worth the name. And it writes\n   `height` only — pair it with `max-h-full` at the call site so a genuinely\n   bounded ancestor, which the caller may not know about, still wins.\n   ========================================================================= */\n\n/**\n * The smallest height worth forcing — a lane header plus something to put under\n * it. Below this the element is far enough down a long page that \"fill the rest\n * of the screen\" describes a sliver nobody asked for, and the unmeasured\n * behaviour is the better answer.\n */\nconst MIN_FILL = 200;\n\n/* The scrollport is the nearest ANCESTOR that scrolls (never the element itself), or null for the viewport.\n   `overflow: hidden` is not one: it is a clip box and often a content-sized one — a rounded card, a `Surface` —\n   and measuring against it would hand back its own content height. A real bounded one still wins through the\n   `max-h-full` the caller pairs with this. See `lib/dom/scroll-ancestor.ts`. */\nconst scrollportOf = (element: HTMLElement) => nearestScrollAncestor(element, { includeSelf: false });\n\n/**\n * Distance from the element's top to the bottom of the visible area of whatever\n * scrolls it — negative or tiny when it is below the fold.\n */\nfunction availableBelow(element: HTMLElement): number {\n  const rect = element.getBoundingClientRect();\n  const port = scrollportOf(element);\n  if (port === null) {\n    const view = element.ownerDocument.defaultView;\n    const root = element.ownerDocument.documentElement;\n    /* Document coordinates, for the same scroll-independence reason as below:\n       `rect.top` alone moves with the page. */\n    return root.clientHeight - (rect.top + (view?.scrollY ?? 0));\n  }\n  const portRect = port.getBoundingClientRect();\n  const borderTop = parseFloat(getComputedStyle(port).borderTopWidth) || 0;\n  const offsetInContent = rect.top - portRect.top - borderTop + port.scrollTop;\n  /* `clientHeight`, not the rect: it is the visible CONTENT box, so a horizontal\n     scrollbar along the bottom of the scrollport is already subtracted. */\n  return port.clientHeight - offsetInContent;\n}\n\n/**\n * Size an element to the space between its own top and the bottom of the box\n * that scrolls it, and keep it sized as the page changes around it.\n *\n * Returns a ref callback for the element. The height is written as inline style\n * rather than returned as state on purpose — a returned number would re-render\n * the subtree on every resize frame, and the value is only ever consumed by one\n * property on one element.\n *\n * ```tsx\n * const fillRef = useFillHeight(fill);\n * <div ref={fillRef} className=\"max-h-full …\" />\n * ```\n *\n * WHAT IT WATCHES, and why that list rather than a global observer. The number\n * changes when a box ABOVE the element changes size: the scrollport itself, an\n * ancestor between the two, or a sibling laid out before it. All three are\n * observed. The element itself is deliberately NOT observed — it is the thing\n * being written, and observing it is the loop.\n *\n * A sibling ADDED after mount is the known gap: the observer set is built once\n * per attach. In practice the content above a filling element is a page header,\n * not a live list, and a `key`ed remount covers the rest.\n */\nexport function useFillHeight(enabled = true): RefCallback<HTMLElement> {\n  /* State rather than a ref, so attaching the element re-runs the effect. A\n     ref callback alone gives no signal that the element arrived. */\n  const [element, setElement] = useState<HTMLElement | null>(null);\n\n  useLayoutEffect(() => {\n    if (element === null) return;\n\n    const apply = () => {\n      if (!enabled) {\n        element.style.removeProperty(\"height\");\n        return;\n      }\n      const available = availableBelow(element);\n      if (!(available >= MIN_FILL)) {\n        /* Includes the happy-dom case, where every rect is zero: nothing is\n           written and the element keeps exactly the behaviour it has without\n           this hook, which is what makes the unit suite meaningful. */\n        element.style.removeProperty(\"height\");\n        return;\n      }\n      /* FLOOR, NEVER ROUND. The element's own top is fractional far more often\n         than not — 282.33px on the demo page, from a font-relative gap — and\n         rounding UP puts the bottom edge a third of a pixel past the fold,\n         which is enough to give the scrollport back the scrollbar this exists\n         to remove. Losing a sub-pixel off the bottom of a lane costs nothing. */\n      // I18N-ALLOW: CSS length written to a style property\n      const next = `${Math.floor(available)}px`;\n      if (element.style.height !== next) element.style.height = next;\n    };\n\n    apply();\n    if (!enabled) return;\n\n    const view = element.ownerDocument.defaultView;\n    view?.addEventListener(\"resize\", apply);\n\n    /* Guarded: happy-dom has no `ResizeObserver`, and a missing one costs the\n       initial measurement above and nothing else. */\n    const observer =\n      typeof ResizeObserver === \"undefined\" ? null : new ResizeObserver(apply);\n    if (observer) {\n      const port = scrollportOf(element);\n      for (let parent = element.parentElement; parent; parent = parent.parentElement) {\n        observer.observe(parent);\n        if (parent === port) break;\n      }\n      for (const sibling of element.parentElement?.children ?? []) {\n        if (sibling !== element) observer.observe(sibling);\n      }\n    }\n\n    return () => {\n      view?.removeEventListener(\"resize\", apply);\n      observer?.disconnect();\n      element.style.removeProperty(\"height\");\n    };\n  }, [element, enabled]);\n\n  return setElement;\n}\n"],"names":["MIN_FILL","scrollportOf","element","nearestScrollAncestor","availableBelow","rect","port","view","portRect","borderTop","offsetInContent","useFillHeight","enabled","setElement","useState","useLayoutEffect","apply","available","next","observer","parent","sibling"],"mappings":";;AAwDA,MAAMA,IAAW,KAMXC,IAAe,CAACC,MAAyBC,EAAsBD,GAAS,EAAE,aAAa,IAAO;AAMpG,SAASE,EAAeF,GAA8B;AACpD,QAAMG,IAAOH,EAAQ,sBAAA,GACfI,IAAOL,EAAaC,CAAO;AACjC,MAAII,MAAS,MAAM;AACjB,UAAMC,IAAOL,EAAQ,cAAc;AAInC,WAHaA,EAAQ,cAAc,gBAGvB,gBAAgBG,EAAK,OAAOE,GAAM,WAAW;AAAA,EAC3D;AACA,QAAMC,IAAWF,EAAK,sBAAA,GAChBG,IAAY,WAAW,iBAAiBH,CAAI,EAAE,cAAc,KAAK,GACjEI,IAAkBL,EAAK,MAAMG,EAAS,MAAMC,IAAYH,EAAK;AAGnE,SAAOA,EAAK,eAAeI;AAC7B;AA0BO,SAASC,EAAcC,IAAU,IAAgC;AAGtE,QAAM,CAACV,GAASW,CAAU,IAAIC,EAA6B,IAAI;AAE/D,SAAAC,EAAgB,MAAM;AACpB,QAAIb,MAAY,KAAM;AAEtB,UAAMc,IAAQ,MAAM;AAClB,UAAI,CAACJ,GAAS;AACZ,QAAAV,EAAQ,MAAM,eAAe,QAAQ;AACrC;AAAA,MACF;AACA,YAAMe,IAAYb,EAAeF,CAAO;AACxC,UAAI,EAAEe,KAAajB,IAAW;AAI5B,QAAAE,EAAQ,MAAM,eAAe,QAAQ;AACrC;AAAA,MACF;AAOA,YAAMgB,IAAO,GAAG,KAAK,MAAMD,CAAS,CAAC;AACrC,MAAIf,EAAQ,MAAM,WAAWgB,MAAMhB,EAAQ,MAAM,SAASgB;AAAA,IAC5D;AAGA,QADAF,EAAA,GACI,CAACJ,EAAS;AAEd,UAAML,IAAOL,EAAQ,cAAc;AACnC,IAAAK,GAAM,iBAAiB,UAAUS,CAAK;AAItC,UAAMG,IACJ,OAAO,iBAAmB,MAAc,OAAO,IAAI,eAAeH,CAAK;AACzE,QAAIG,GAAU;AACZ,YAAMb,IAAOL,EAAaC,CAAO;AACjC,eAASkB,IAASlB,EAAQ,eAAekB,MACvCD,EAAS,QAAQC,CAAM,GACnBA,MAAWd,IAFgCc,IAASA,EAAO;AAE/D;AAEF,iBAAWC,KAAWnB,EAAQ,eAAe,YAAY,CAAA;AACvD,QAAImB,MAAYnB,KAASiB,EAAS,QAAQE,CAAO;AAAA,IAErD;AAEA,WAAO,MAAM;AACX,MAAAd,GAAM,oBAAoB,UAAUS,CAAK,GACzCG,GAAU,WAAA,GACVjB,EAAQ,MAAM,eAAe,QAAQ;AAAA,IACvC;AAAA,EACF,GAAG,CAACA,GAASU,CAAO,CAAC,GAEdC;AACT;"}

package/dist/lib/use-hydrated.js

@@ -0,0 +1,14 @@
+import { useSyncExternalStore as r } from "react";
+const t = () => () => {
+};
+function n() {
+  return r(
+    t,
+    () => !0,
+    () => !1
+  );
+}
+export {
+  n as useHydrated
+};
+//# sourceMappingURL=use-hydrated.js.map

package/dist/lib/use-hydrated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hydrated.js","sources":["../../src/lib/use-hydrated.ts"],"sourcesContent":["import { useSyncExternalStore } from \"react\";\n\nconst noSubscription = () => () => {};\n\n/**\n * DX-5411 / DX-5425 — false on a server and during hydration, true once the client has taken over.\n *\n * A prerendered page's first client render must draw exactly what the server drew, so anything that reads the browser\n * (a stored choice, a share sheet) or must not act before the bundle runs (a submit, a write to storage) waits on this.\n * A client render that is not hydrating (no server HTML underneath) is true from its first render.\n */\nexport function useHydrated(): boolean {\n  return useSyncExternalStore(\n    noSubscription,\n    () => true,\n    () => false,\n  );\n}\n"],"names":["noSubscription","useHydrated","useSyncExternalStore"],"mappings":";AAEA,MAAMA,IAAiB,MAAM,MAAM;AAAC;AAS7B,SAASC,IAAuB;AACrC,SAAOC;AAAA,IACLF;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,EAAA;AAEV;"}