hanzio 2.2.0 → 3.1.0

package/dist/iso/languages.d.ts

@@ -0,0 +1,195 @@
+/** ISO 639-1 two-letter language codes (lowercase) with English names. */
+export declare const languageNames: {
+    readonly aa: "Afar";
+    readonly ab: "Abkhazian";
+    readonly ae: "Avestan";
+    readonly af: "Afrikaans";
+    readonly ak: "Akan";
+    readonly am: "Amharic";
+    readonly an: "Aragonese";
+    readonly ar: "Arabic";
+    readonly as: "Assamese";
+    readonly av: "Avaric";
+    readonly ay: "Aymara";
+    readonly az: "Azerbaijani";
+    readonly ba: "Bashkir";
+    readonly be: "Belarusian";
+    readonly bg: "Bulgarian";
+    readonly bi: "Bislama";
+    readonly bm: "Bambara";
+    readonly bn: "Bangla";
+    readonly bo: "Tibetan";
+    readonly br: "Breton";
+    readonly bs: "Bosnian";
+    readonly ca: "Catalan";
+    readonly ce: "Chechen";
+    readonly ch: "Chamorro";
+    readonly co: "Corsican";
+    readonly cr: "Cree";
+    readonly cs: "Czech";
+    readonly cu: "Church Slavic";
+    readonly cv: "Chuvash";
+    readonly cy: "Welsh";
+    readonly da: "Danish";
+    readonly de: "German";
+    readonly dv: "Dhivehi";
+    readonly dz: "Dzongkha";
+    readonly ee: "Ewe";
+    readonly el: "Greek";
+    readonly en: "English";
+    readonly eo: "Esperanto";
+    readonly es: "Spanish";
+    readonly et: "Estonian";
+    readonly eu: "Basque";
+    readonly fa: "Persian";
+    readonly ff: "Fula";
+    readonly fi: "Finnish";
+    readonly fj: "Fijian";
+    readonly fo: "Faroese";
+    readonly fr: "French";
+    readonly fy: "Western Frisian";
+    readonly ga: "Irish";
+    readonly gd: "Scottish Gaelic";
+    readonly gl: "Galician";
+    readonly gn: "Guarani";
+    readonly gu: "Gujarati";
+    readonly gv: "Manx";
+    readonly ha: "Hausa";
+    readonly he: "Hebrew";
+    readonly hi: "Hindi";
+    readonly ho: "Hiri Motu";
+    readonly hr: "Croatian";
+    readonly ht: "Haitian Creole";
+    readonly hu: "Hungarian";
+    readonly hy: "Armenian";
+    readonly hz: "Herero";
+    readonly ia: "Interlingua";
+    readonly id: "Indonesian";
+    readonly ie: "Interlingue";
+    readonly ig: "Igbo";
+    readonly ii: "Liangshan Yi";
+    readonly ik: "Inupiaq";
+    readonly io: "Ido";
+    readonly is: "Icelandic";
+    readonly it: "Italian";
+    readonly iu: "Inuktitut";
+    readonly ja: "Japanese";
+    readonly jv: "Javanese";
+    readonly ka: "Georgian";
+    readonly kg: "Kongo";
+    readonly ki: "Kikuyu";
+    readonly kj: "Kuanyama";
+    readonly kk: "Kazakh";
+    readonly kl: "Kalaallisut";
+    readonly km: "Khmer";
+    readonly kn: "Kannada";
+    readonly ko: "Korean";
+    readonly kr: "Kanuri";
+    readonly ks: "Kashmiri";
+    readonly ku: "Kurdish";
+    readonly kv: "Komi";
+    readonly kw: "Cornish";
+    readonly ky: "Kyrgyz";
+    readonly la: "Latin";
+    readonly lb: "Luxembourgish";
+    readonly lg: "Ganda";
+    readonly li: "Limburgish";
+    readonly ln: "Lingala";
+    readonly lo: "Lao";
+    readonly lt: "Lithuanian";
+    readonly lu: "Luba-Katanga";
+    readonly lv: "Latvian";
+    readonly mg: "Malagasy";
+    readonly mh: "Marshallese";
+    readonly mi: "Māori";
+    readonly mk: "Macedonian";
+    readonly ml: "Malayalam";
+    readonly mn: "Mongolian";
+    readonly mr: "Marathi";
+    readonly ms: "Malay";
+    readonly mt: "Maltese";
+    readonly my: "Burmese";
+    readonly na: "Nauru";
+    readonly nb: "Norwegian Bokmål";
+    readonly nd: "North Ndebele";
+    readonly ne: "Nepali";
+    readonly ng: "Ndonga";
+    readonly nl: "Dutch";
+    readonly nn: "Norwegian Nynorsk";
+    readonly no: "Norwegian";
+    readonly nr: "South Ndebele";
+    readonly nv: "Navajo";
+    readonly ny: "Nyanja";
+    readonly oc: "Occitan";
+    readonly oj: "Ojibwa";
+    readonly om: "Oromo";
+    readonly or: "Odia";
+    readonly os: "Ossetic";
+    readonly pa: "Punjabi";
+    readonly pi: "Pali";
+    readonly pl: "Polish";
+    readonly ps: "Pashto";
+    readonly pt: "Portuguese";
+    readonly qu: "Quechua";
+    readonly rm: "Romansh";
+    readonly rn: "Rundi";
+    readonly ro: "Romanian";
+    readonly ru: "Russian";
+    readonly rw: "Kinyarwanda";
+    readonly sa: "Sanskrit";
+    readonly sc: "Sardinian";
+    readonly sd: "Sindhi";
+    readonly se: "North Sámi";
+    readonly sg: "Sango";
+    readonly si: "Sinhala";
+    readonly sk: "Slovak";
+    readonly sl: "Slovenian";
+    readonly sm: "Samoan";
+    readonly sn: "Shona";
+    readonly so: "Somali";
+    readonly sq: "Albanian";
+    readonly sr: "Serbian";
+    readonly ss: "Swati";
+    readonly st: "Southern Sotho";
+    readonly su: "Sundanese";
+    readonly sv: "Swedish";
+    readonly sw: "Swahili";
+    readonly ta: "Tamil";
+    readonly te: "Telugu";
+    readonly tg: "Tajik";
+    readonly th: "Thai";
+    readonly ti: "Tigrinya";
+    readonly tk: "Turkmen";
+    readonly tl: "Tagalog";
+    readonly tn: "Tswana";
+    readonly to: "Tongan";
+    readonly tr: "Turkish";
+    readonly ts: "Tsonga";
+    readonly tt: "Tatar";
+    readonly tw: "Twi";
+    readonly ty: "Tahitian";
+    readonly ug: "Uyghur";
+    readonly uk: "Ukrainian";
+    readonly ur: "Urdu";
+    readonly uz: "Uzbek";
+    readonly ve: "Venda";
+    readonly vi: "Vietnamese";
+    readonly vo: "Volapük";
+    readonly wa: "Walloon";
+    readonly wo: "Wolof";
+    readonly xh: "Xhosa";
+    readonly yi: "Yiddish";
+    readonly yo: "Yoruba";
+    readonly za: "Zhuang";
+    readonly zh: "Chinese";
+    readonly zu: "Zulu";
+};
+export type LanguageCode = keyof typeof languageNames;
+export declare const languageCodes: readonly ("aa" | "ab" | "ae" | "af" | "ak" | "am" | "an" | "ar" | "as" | "av" | "ay" | "az" | "ba" | "be" | "bg" | "bi" | "bm" | "bn" | "bo" | "br" | "bs" | "ca" | "ce" | "ch" | "co" | "cr" | "cs" | "cu" | "cv" | "cy" | "da" | "de" | "dv" | "dz" | "ee" | "el" | "en" | "eo" | "es" | "et" | "eu" | "fa" | "ff" | "fi" | "fj" | "fo" | "fr" | "fy" | "ga" | "gd" | "gl" | "gn" | "gu" | "gv" | "ha" | "he" | "hi" | "ho" | "hr" | "ht" | "hu" | "hy" | "hz" | "ia" | "id" | "ie" | "ig" | "ii" | "ik" | "io" | "is" | "it" | "iu" | "ja" | "jv" | "ka" | "kg" | "ki" | "kj" | "kk" | "kl" | "km" | "kn" | "ko" | "kr" | "ks" | "ku" | "kv" | "kw" | "ky" | "la" | "lb" | "lg" | "li" | "ln" | "lo" | "lt" | "lu" | "lv" | "mg" | "mh" | "mi" | "mk" | "ml" | "mn" | "mr" | "ms" | "mt" | "my" | "na" | "nb" | "nd" | "ne" | "ng" | "nl" | "nn" | "no" | "nr" | "nv" | "ny" | "oc" | "oj" | "om" | "or" | "os" | "pa" | "pi" | "pl" | "ps" | "pt" | "qu" | "rm" | "rn" | "ro" | "ru" | "rw" | "sa" | "sc" | "sd" | "se" | "sg" | "si" | "sk" | "sl" | "sm" | "sn" | "so" | "sq" | "sr" | "ss" | "st" | "su" | "sv" | "sw" | "ta" | "te" | "tg" | "th" | "ti" | "tk" | "tl" | "tn" | "to" | "tr" | "ts" | "tt" | "tw" | "ty" | "ug" | "uk" | "ur" | "uz" | "ve" | "vi" | "vo" | "wa" | "wo" | "xh" | "yi" | "yo" | "za" | "zh" | "zu")[];
+export declare function isLanguageCode(value: unknown): value is LanguageCode;
+/**
+ * The ISO 639-1 language of a BCP-47-ish tag (`'en-GB'`, `'da_DK'`), or
+ * `null` when it has none. Map tags your app treats as one language (`'no'`
+ * and `'nn'` to `'nb'`, say) before or after.
+ */
+export declare function matchLanguageCode(tag: string | null | undefined): LanguageCode | null;

package/dist/iso/phone-language.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A default language from an E.164 number's calling code (`+45…` → `'da'`),
+ * or `null` when the number is missing, too short, or its code is unmapped.
+ */
+export declare function languageFromE164PhoneNumber(phoneNumber: string | null | undefined): "da" | "de" | "en" | "es" | "fr" | "it" | "nb" | "nl" | "pt" | "sv" | null;

package/dist/promise/index.d.ts

@@ -79,6 +79,37 @@ export declare function pMap<T, R>(items: Iterable<T>, fn: (item: T, index: numb
     concurrency?: number;
     signal?: AbortSignal;
 }): Promise<R[]>;
+export type TaskPool = {
+    /** Queues `task`; it starts once a slot is free. */
+    run<T>(task: () => Promise<T>): Promise<T>;
+    /** Resolves once every queued and active task has settled; rejects with the first failure. */
+    drain(): Promise<void>;
+    /** Throws the abort reason or the first failure, if any. */
+    throwIfFailed(): void;
+};
+/**
+ * A bounded pool for work that arrives over time, such as a crawl that queues
+ * pages as it discovers them (`pMap` needs the whole list up front).
+ *
+ * The first failure, or an abort, discards queued tasks and rejects later
+ * `run` calls; `drain` waits for active tasks to settle before rejecting with
+ * it. Pass the same `signal` to the tasks' IO so an abort interrupts them too.
+ * `stopOnError: false` keeps the pool running when a task fails, for callers
+ * that retry or fall back per task.
+ *
+ * A `run` promise that is never awaited does not cause an unhandled rejection;
+ * `drain` still reports its failure.
+ *
+ * @example
+ * const pool = createTaskPool({ concurrency: 4, signal })
+ * for await (const page of discoverPages(signal)) void pool.run(() => scrape(page, signal))
+ * await pool.drain()
+ */
+export declare function createTaskPool(options: {
+    concurrency: number;
+    signal?: AbortSignal;
+    stopOnError?: boolean;
+}): TaskPool;
 /** Starts a clock; call the returned function to read elapsed ms. */
 export declare function startTimer(): () => number;
 /** Runs `fn` and reports how long it took (throws pass through). */

package/dist/redis/client.d.ts

@@ -0,0 +1,49 @@
+import type { RedisClient, RedisOptions } from 'bun';
+export type RedisRole = 'client' | 'subscriber';
+export type RedisErrorContext = {
+    role: RedisRole;
+    stage: 'close' | 'subscribe' | 'resubscribe' | 'unsubscribe' | 'handler';
+    channel?: string;
+};
+export type ManagedRedisOptions = {
+    /** Read when a connection is created, so a secret store can resolve it lazily. */
+    url: string | (() => string);
+    /** Every failure, for logging, metrics and error tracking. Defaults to `console.error`. */
+    onError?: (error: unknown, context: RedisErrorContext) => void;
+    /** Builds each connection. Defaults to `new Bun.RedisClient(url, options)`. */
+    createClient?: (url: string, options: RedisOptions) => RedisClient;
+};
+export type RedisMessageHandler = (message: string, channel: string) => void;
+export type ManagedRedis = {
+    /** The shared command connection, created on first use. */
+    getClient(): RedisClient;
+    /**
+     * Subscribes `handler` to `channel` on the shared subscriber connection.
+     * Channels are ref-counted: Redis sees one `SUBSCRIBE` however many handlers
+     * share it, and the returned function unsubscribes when the last one leaves.
+     */
+    subscribe(channel: string, handler: RedisMessageHandler): Promise<() => Promise<void>>;
+    isConnected(): boolean;
+    getStats(): {
+        channelCount: number;
+        channels: string[];
+        isConnected: boolean;
+        isSubscriberConnected: boolean;
+    };
+    /** Closes both connections. Errors from the shutdown itself are not reported. */
+    close(): void;
+};
+/**
+ * A command connection plus one shared subscriber connection for a Bun
+ * server. Both reconnect on their own, and subscriptions come back after a
+ * reconnect.
+ *
+ * @example
+ * export const redis = createManagedRedis({
+ *   url: () => getSecret('REDIS_URL'),
+ *   onError: (error, context) => captureException(error, 'redis', context)
+ * })
+ * await redis.getClient().set('key', 'value')
+ * const unsubscribe = await redis.subscribe('events', (message) => handle(message))
+ */
+export declare function createManagedRedis(options: ManagedRedisOptions): ManagedRedis;

package/dist/redis/concurrency-limit.d.ts

@@ -0,0 +1,63 @@
+import { type RedisSend } from './lua-script';
+export type ConcurrencyLimitStage = 'slot' | 'start';
+export type RedisConcurrencyLimitOptions = {
+    key: string;
+    max: number;
+    slotTtlMs: number;
+    send: RedisSend;
+    maxStartsPerSecond?: number;
+    failOpenAfterMs?: number;
+    commandTimeoutMs?: number;
+    /** Receives throttled warnings. Defaults to `console`. */
+    logger?: Pick<Console, 'warn'>;
+    /** Called when a caller starts queueing; the returned function runs once it stops. */
+    onWait?: (stage: ConcurrencyLimitStage) => (() => void) | void;
+};
+export type RedisConcurrencyLimit = {
+    <T>(run: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    tripCooldown: (retryAfterMs: number) => Promise<void>;
+    /** Callers in this process waiting for a slot or a start, e.g. for a gauge. */
+    queueDepth: () => number;
+    /** Drop this limiter's timers. See `createRedisConcurrencyLimit`. */
+    dispose: () => void;
+};
+/**
+ * Redis semaphore shared by every process. Returns `withLimit(run)` - at most
+ * `max` callbacks in flight for `key`.
+ *
+ * A held slot is heartbeated for as long as `run` lasts, so `slotTtlMs` is a
+ * crash-detection window rather than a run budget: slots leaked by a killed pod
+ * free themselves within one TTL, while slow-but-alive work keeps its slot.
+ *
+ * `maxStartsPerSecond` is a separate sliding 1s window of *starts*. Use it when
+ * the provider quota is requests-per-second (Cloudflare Quick Actions) so
+ * in-flight concurrency can sit higher than the start rate.
+ *
+ * `tripCooldown` writes a shared pause from an upstream `Retry-After` so every
+ * process backs off together instead of stampeding into 429s.
+ *
+ * Waiters inside one process queue locally and are handed to Redis in a single
+ * batched call, so a pod with hundreds of callers costs the same Redis traffic
+ * as one with a handful.
+ *
+ * When Redis itself is unreachable for `failOpenAfterMs` the limiter gives up
+ * and runs uncapped. Callers guard a third-party quota; degrading to the
+ * provider's own rate limit beats hanging every caller until Redis returns.
+ * That verdict is shared per limiter: once tripped, later calls degrade
+ * immediately while a background probe watches for Redis to come back.
+ *
+ * `onWait` and `queueDepth` feed metrics. A limiter minted per tenant or per
+ * customer host should report under a shared pool label rather than its key,
+ * or every key ever touched leaves a permanent series. Call `dispose()` when
+ * such a limiter is discarded, and unregister any gauge reading `queueDepth`.
+ *
+ * @example
+ * const withLimit = createRedisConcurrencyLimit({
+ *   key: 'openai',
+ *   max: 20,
+ *   slotTtlMs: 30_000,
+ *   send: (command, args) => redis.getClient().send(command, args)
+ * })
+ * const reply = await withLimit(() => openai.chat(request), signal)
+ */
+export declare function createRedisConcurrencyLimit(input: RedisConcurrencyLimitOptions): RedisConcurrencyLimit;

package/dist/redis/index.d.ts

@@ -0,0 +1,3 @@
+export { createManagedRedis, type ManagedRedis, type ManagedRedisOptions, type RedisErrorContext, type RedisMessageHandler, type RedisRole } from './client';
+export { type ConcurrencyLimitStage, createRedisConcurrencyLimit, type RedisConcurrencyLimit, type RedisConcurrencyLimitOptions } from './concurrency-limit';
+export { createLuaScript, type RedisSend } from './lua-script';

package/dist/redis/lua-script.d.ts

@@ -0,0 +1,13 @@
+/** One raw Redis command, e.g. `(command, args) => redis.getClient().send(command, args)`. */
+export type RedisSend = (command: string, args: string[]) => Promise<unknown>;
+/**
+ * Ship a Lua script by SHA instead of resending its source on every call.
+ *
+ * Redis forgets its script cache on restart and on `SCRIPT FLUSH`, so a
+ * `NOSCRIPT` reply falls back to an inline `EVAL` (which repopulates the cache)
+ * and drops the stale digest.
+ *
+ * The digest is cached per instance rather than per module so each limiter -
+ * and each test fake - owns its own cache.
+ */
+export declare function createLuaScript(send: RedisSend, source: string): (keys: string[], args: string[]) => Promise<unknown>;

package/dist/secrets/infisical-identity-file.d.ts

@@ -0,0 +1,12 @@
+import type { EnvironmentVariables } from './environment';
+/**
+ * Machine identity (Universal Auth) credentials kept in a private file for every
+ * process on this machine, for example by agentgate, which syncs one identity to
+ * all of a user's machines. `INFISICAL_UNIVERSAL_AUTH_FILE` overrides the default
+ * `~/.infisical/universal-auth.json`. Only credentials for `siteUrl`'s instance are
+ * returned, so a secret is never sent to another Infisical instance.
+ */
+export declare function readInfisicalIdentityFile(env: EnvironmentVariables | undefined, siteUrl: string): Promise<{
+    clientId: string;
+    clientSecret: string;
+} | undefined>;

package/dist/src/api-wrapper/connection-auth.js

@@ -0,0 +1,82 @@
+import {
+  raceAbort2
+} from "../../index-6f2w90pp.js";
+
+// src/api-wrapper/connection-auth.ts
+import { createHmac, randomBytes } from "node:crypto";
+class ConnectionAuthCache {
+  maxEntries;
+  key = randomBytes(32);
+  entries = new Map;
+  constructor(maxEntries = 1000) {
+    this.maxEntries = maxEntries;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  clear() {
+    for (const entry of this.entries.values())
+      entry.token = undefined;
+    this.entries.clear();
+  }
+  prune(protectedEntry) {
+    for (const [connectionId, entry] of this.entries) {
+      if (this.entries.size <= this.maxEntries)
+        break;
+      if (entry.pending || entry === protectedEntry)
+        continue;
+      entry.token = undefined;
+      this.entries.delete(connectionId);
+    }
+  }
+  bind(input) {
+    const identity = createHmac("sha256", this.key).update(JSON.stringify(input.authInputs)).digest("hex");
+    let entry = this.entries.get(input.connectionId);
+    if (!entry || entry.identity !== identity) {
+      if (entry)
+        entry.token = undefined;
+      entry = { identity };
+    }
+    this.entries.delete(input.connectionId);
+    this.entries.set(input.connectionId, entry);
+    this.prune(entry);
+    const state = entry;
+    const get = (options) => {
+      if (options?.signal?.aborted) {
+        return Promise.reject(options.signal.reason);
+      }
+      if (this.entries.get(input.connectionId) === state) {
+        this.entries.delete(input.connectionId);
+        this.entries.set(input.connectionId, state);
+      }
+      if (state.pending)
+        return raceAbort2(state.pending, options?.signal);
+      if (!options?.fresh && state.token && state.token.expiresAt - Date.now() > input.refreshMarginMs) {
+        return Promise.resolve(state.token);
+      }
+      state.token = undefined;
+      const pending = input.exchange().then((token) => {
+        if (this.entries.get(input.connectionId) === state) {
+          state.token = token;
+        }
+        return token;
+      }).finally(() => {
+        if (state.pending === pending)
+          state.pending = undefined;
+        this.prune();
+      });
+      state.pending = pending;
+      return raceAbort2(pending, options?.signal);
+    };
+    return {
+      get,
+      reject(token) {
+        if (state.token === token)
+          state.token = undefined;
+      }
+    };
+  }
+}
+export {
+  ConnectionAuthCache
+};

package/dist/src/api-wrapper/index.js

@@ -28,7 +28,7 @@ import {
   paginate2,
   otelMiddleware2,
   defineEndpoint2
-} from "../../index-zbj9s3s3.js";
+} from "../../index-2kz392vw.js";
 export {
   ActionError2 as ActionError,
   ApiError2 as ApiError,

package/dist/src/cli/index.js

@@ -0,0 +1,10 @@
+import {
+  CliError2,
+  defineCommand2,
+  defineCli2
+} from "../../index-6ragggbs.js";
+export {
+  CliError2 as CliError,
+  defineCli2 as defineCli,
+  defineCommand2 as defineCommand
+};

package/dist/src/format/index.js

@@ -1,6 +1,6 @@
 import {
   stableStringify2
-} from "../../index-kj1phgrx.js";
+} from "../../index-29mmh343.js";
 
 // src/format/index.ts
 var MAX_CACHED_FORMATTERS = 100;
@@ -44,6 +44,9 @@ function formatCurrency(amount, currency, locale, options) {
     currency
   });
 }
+function formatPrice(amount, currency, locale) {
+  return formatCurrency(amount, currency, locale, Number.isInteger(amount) ? { minimumFractionDigits: 0, maximumFractionDigits: 0 } : undefined);
+}
 function formatCompactNumber(value, locale) {
   return formatNumber(value, locale, { notation: "compact" });
 }
@@ -173,12 +176,68 @@ function formatDateRange(start, end, locale, options = {}) {
   const to = new Date(toTime(end));
   return typeof format.formatRange === "function" ? format.formatRange(from, to) : `${format.format(from)} – ${format.format(to)}`;
 }
+var DATE_PRESETS = {
+  "DD/MM/YYYY": { day: "2-digit", month: "2-digit", year: "numeric" },
+  "DD/MM/YYYY HH:mm": {
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  },
+  "HH:mm": { hour: "2-digit", minute: "2-digit", hourCycle: "h23" },
+  ddd: { weekday: "short" },
+  "D MMM": { day: "numeric", month: "short" },
+  "D MMM YYYY": { day: "numeric", month: "short", year: "numeric" },
+  "dddd, MMMM D": { weekday: "long", day: "numeric", month: "long" },
+  "MMMM YYYY": { month: "long", year: "numeric" }
+};
+function formatDate(date, preset, locale) {
+  return getDateTimeFormat(locale, DATE_PRESETS[preset]).format(toTime(date));
+}
+function formatDateTime(date, locale) {
+  return getDateTimeFormat(locale, {
+    dateStyle: "medium",
+    timeStyle: "short"
+  }).format(toTime(date));
+}
+function dayOffset(date, now) {
+  const start = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+  return Math.round((start(date) - start(now)) / DAY_MS);
+}
+var relativeDay = (offset, locale) => getRelativeTimeFormat(locale, { numeric: "auto" }).format(offset, "day");
+function formatCompactTime(date, locale, options = {}) {
+  const value = new Date(toTime(date));
+  if (Number.isNaN(value.getTime()))
+    return "";
+  const now = new Date(toTime(options.now ?? Date.now()));
+  const offset = dayOffset(value, now);
+  if (offset === 0)
+    return formatDate(value, "HH:mm", locale);
+  if (offset === -1)
+    return relativeDay(-1, locale);
+  const sameYear = value.getFullYear() === now.getFullYear();
+  return formatDate(value, sameYear ? "D MMM" : "D MMM YYYY", locale);
+}
+function formatDayDivider(date, locale, options = {}) {
+  const value = new Date(toTime(date));
+  if (Number.isNaN(value.getTime()))
+    return "";
+  const now = new Date(toTime(options.now ?? Date.now()));
+  const offset = dayOffset(value, now);
+  if (offset === 0 || offset === -1)
+    return relativeDay(offset, locale);
+  const sameYear = value.getFullYear() === now.getFullYear();
+  return formatDate(value, sameYear ? "dddd, MMMM D" : "D MMM YYYY", locale);
+}
 function formatList(items, locale, options) {
   if (typeof Intl.ListFormat !== "function") {
     return items.join(options?.style === "narrow" ? " " : ", ");
   }
   return getListFormat(locale, options).format(items);
 }
+var EM_DASH = "—";
 function formatCappedCount(count, max = 99) {
   if (!(count > 0))
     return "0";
@@ -188,17 +247,34 @@ function pluralize(count, forms, locale) {
   const form = forms[getPluralRules(locale).select(count)] ?? forms.other;
   return form.replaceAll("{count}", formatNumber(count, locale));
 }
+function withLocale(getLocale) {
+  return {
+    formatDate: (date, preset) => formatDate(date, preset, getLocale()),
+    formatDateTime: (date) => formatDateTime(date, getLocale()),
+    formatCompactTime: (date) => formatCompactTime(date, getLocale()),
+    formatDayDivider: (date) => formatDayDivider(date, getLocale()),
+    formatRelativeTime: (date, options) => formatRelativeTime(date, getLocale(), options),
+    formatNumber: (value, options) => formatNumber(value, getLocale(), options),
+    formatPrice: (amount, currency) => formatPrice(amount, currency, getLocale())
+  };
+}
 export {
+  EM_DASH,
   formatBytes,
   formatCappedCount,
   formatClockDuration,
   formatCompactNumber,
+  formatCompactTime,
   formatCurrency,
+  formatDate,
   formatDateRange,
+  formatDateTime,
+  formatDayDivider,
   formatDuration,
   formatList,
   formatNumber,
   formatPercent,
+  formatPrice,
   formatRelativeTime,
   formatWait,
   getDateTimeFormat,
@@ -207,5 +283,6 @@ export {
   getPluralRules,
   getRelativeTimeFormat,
   pluralize,
-  splitDuration
+  splitDuration,
+  withLocale
 };

package/dist/src/format/phone.js

@@ -0,0 +1,21 @@
+// src/format/phone.ts
+import {
+  isSupportedCountry,
+  parsePhoneNumberFromString
+} from "libphonenumber-js";
+function formatPhone(value, country) {
+  const raw = value?.trim() ?? "";
+  if (!raw)
+    return "";
+  const region = country && isSupportedCountry(country) ? country : undefined;
+  const parsed = parsePhoneNumberFromString(raw, region ? { defaultCountry: region } : undefined);
+  if (!parsed)
+    return raw;
+  if (region && parsed.country === region && parsed.isValid()) {
+    return parsed.formatNational();
+  }
+  return parsed.formatInternational();
+}
+export {
+  formatPhone
+};