@burdenoff/fe-libs 2026.1024.2 → 2026.1024.4

package/dist/shared/assistant/avatar/live/liveAvatarMinutesView.d.ts

@@ -0,0 +1,127 @@
+import { AvatarCopy } from '../useAvatarCopy';
+import { LiveAvatarSnapshot } from './liveAvatarController';
+/** At most this many credits left read as running low (DESIGN 3.10: 1 or 2). */
+export declare const LIVE_AVATAR_MINUTES_LOW = 2;
+/**
+ * The app's plans page (each app mounts billing at `/billing`), routed with the panel's navigator: the page the shared upgrade prompt
+ * opens by default (`UpgradePromptModal`'s `upgradePath`), so a plan with more avatar credits is bought as any plan is (plans page,
+ * checkout, activation), and the tab checks again when the person comes back.
+ */
+export declare const LIVE_AVATAR_MINUTES_PLANS_PATH = "/billing/plans";
+/** What the host's `minutesPurchase.access()` answers. */
+export interface LiveAvatarMinutesPurchaseAccess {
+    /** This person may buy a plan for the workspace's organization (the host's billing check, `billing:create` on its billing account). */
+    readonly canPurchase: boolean;
+}
+/** ★ BOFF-9446: the host's way to tell whether this person may buy a plan. fe-libs cannot import billing, so the host passes it. */
+export interface LiveAvatarMinutesPurchase {
+    /** Asked only where "See plans" could be offered (a plan with more credits exists), and once per workspace's credits answer. */
+    readonly access: () => Promise<LiveAvatarMinutesPurchaseAccess>;
+}
+/** What the tab knows of the host's answer. */
+export type LiveAvatarMinutesAccessState = 
+/** No host option, or no navigator to route with: a person who has run out is told to ask their billing administrator. */
+{
+    readonly status: 'absent';
+}
+/** Not answered yet: nothing is offered until it is. */
+ | {
+    readonly status: 'asking';
+}
+/** The question failed, or its answer could not be read: nothing is offered. */
+ | {
+    readonly status: 'failed';
+} | {
+    readonly status: 'answered';
+    readonly access: LiveAvatarMinutesPurchaseAccess;
+};
+export type LiveAvatarMinutesState = 
+/** At least `LIVE_AVATAR_MINUTES_LOW + 1` credits left. */
+'available'
+/** 1 or 2 credits left. */
+ | 'low'
+/** The credits left are held by another person's running session in the workspace. */
+ | 'in-use'
+/** M23: the credits left are held by this person's own session on another device, which keeps running. */
+ | 'in-use-self'
+/** None left: the workspace's, this person's free credits (`minutesReason`), or the zero-session limit. */
+ | 'exhausted'
+/** The workspace has no avatar credits at all (`NOT_INCLUDED`). */
+ | 'not-included'
+/** The credits could not be checked; Turn on is the retry. */
+ | 'unavailable'
+/** A credits refusal's time runs (the controller's Retry-After lock): the status line says what and when. */
+ | 'waiting'
+/** The check after a plan purchase is running. */
+ | 'checking-purchase'
+/** On: being started, running (its time left), or ending. */
+ | 'in-session'
+/** Credits are in play, but there is nothing to say about them now. */
+ | 'quiet';
+export type LiveAvatarMinutesAction = 
+/** Opens the app's plans page (`LIVE_AVATAR_MINUTES_PLANS_PATH`). */
+'see-plans'
+/** Asks the credits again, for free (`refreshMinutes`). */
+ | 'check-again'
+/** Runs the bounded check after a purchase again (`checkMinutesPurchase`). */
+ | 'check-purchase-again';
+/** The action that opens billing: offered only with the host's `canPurchase`, and only while a plan with more credits exists. */
+export declare const LIVE_AVATAR_MINUTES_BUY_ACTIONS: ReadonlySet<LiveAvatarMinutesAction>;
+export interface LiveAvatarMinutesView {
+    readonly state: LiveAvatarMinutesState;
+    /** The sentence that says the state; null when the status line already says it (the server's last credits refusal), or there is none. */
+    readonly headline: string | null;
+    /** What follows it: the balance's details, or what a person who has run out can do about it. */
+    readonly details: readonly string[];
+    readonly action: LiveAvatarMinutesAction | null;
+    /** Turn on cannot start the avatar for its credits, and no refusal's time runs: Turn on and the stage's Confirm wait. */
+    readonly blocksStart: boolean;
+    /** The host's purchase access matters here: a state a plan lifts, a plan with more credits exists, nothing else wrong. */
+    readonly wantsAccess: boolean;
+    /** For the region's one polite live region, said when it first appears: never a ticking value. Null: nothing to announce. */
+    readonly announcement: string | null;
+    /** The voice stage's words (it offers no action): the state, and the warning when they run low. */
+    readonly stageLines: readonly string[];
+    /** W, the seconds of "How avatar credits are counted"; null when the answer gave none the client could read. */
+    readonly staleSeconds: number | null;
+}
+export interface LiveAvatarMinutesInput {
+    readonly snapshot: LiveAvatarSnapshot;
+    readonly access: LiveAvatarMinutesAccessState;
+    /**
+     * How the last check after a purchase ended, while no newer credits answer came (the tab follows it): `seen`, the credits rose;
+     * `not-seen`, they did not. Absent: no check ended since the last answer.
+     */
+    readonly purchaseOutcome?: 'seen' | 'not-seen' | null;
+    /**
+     * The answer a "Check again" waited for has come, and no newer answer since (the tab follows it): what it says is announced. That
+     * includes a refusal that stands: the status line shows it in the same words as before, so nothing else reads it again.
+     */
+    readonly rechecked?: boolean;
+    /** Wall-clock ms: a refusal's time, and the session's time left. */
+    readonly now: number;
+}
+/**
+ * ★★★ Whether the credits are in play at all: the server sent a block, a session has its own length (D'), a purchase is being checked,
+ * a session ended for its credits, or a credits refusal is shown. False with every answer before `enforce`: then nothing changes.
+ */
+export declare function liveAvatarMinutesActive(snapshot: LiveAvatarSnapshot): boolean;
+/**
+ * Whether Turn on (and the stage's Confirm) waits for the credits: off, no refusal's time running (that lock is the controller's, and
+ * says when), and a credits answer that says none are left for this person, or the server's last refusal for none left while there is a
+ * credits answer that a quiet question renews (the controller asks one after the refusal; "Check again" asks another). With no credits
+ * answer at all no quiet question is asked (the controller asks only once the server has sent credits), so a refusal holds nothing back:
+ * Turn on is the retry, and asks the server again. The same reading as `liveAvatarAskState`'s `no-minutes`, at the wall-clock time
+ * `now`; the controller's `confirm` reads the credits answer alone (and sends no start while it says in use either).
+ */
+export declare function liveAvatarMinutesBlockStart(snapshot: LiveAvatarSnapshot, now: number): boolean;
+/**
+ * Whether the credits say none are left for this person, with no clock: the newest of the server's last credits refusal (one a newer
+ * answer would have settled) and the credits answer decides, and only while there is a credits answer at all. `liveAvatarAskState`'s
+ * `no-minutes` and `liveAvatarMinutesBlockStart` both read it.
+ */
+export declare function liveAvatarMinutesHoldStart(snapshot: LiveAvatarSnapshot): boolean;
+/**
+ * ★★ BOFF-9446: the credits view for this snapshot, or null when the credits are not in play (`liveAvatarMinutesActive`): INERT.
+ */
+export declare function liveAvatarMinutesView(input: LiveAvatarMinutesInput, copy: AvatarCopy): LiveAvatarMinutesView | null;

package/dist/shared/assistant/avatar/live/liveAvatarMinutesView.js

@@ -0,0 +1,168 @@
+import { avatarMinutesRefusal as e } from "./avatarSessionClient.js";
+//#region src/shared/assistant/avatar/live/liveAvatarMinutesView.ts
+var t = 2, n = "/billing/plans", r = new Set(["see-plans"]), i = new Set([
+	"minutes-exhausted",
+	"minutes-in-use",
+	"minutes-in-use-self",
+	"minutes-unavailable"
+]), a = "minutes-exhausted", o = new Set([
+	"minutes-exhausted",
+	"minutes-in-use",
+	"minutes-in-use-self"
+]), s = (e) => e.phase === "starting" || e.phase === "connecting" || e.phase === "ready" || e.phase === "ending";
+function c(e) {
+	return e.problem !== null && i.has(e.problem);
+}
+function l(e) {
+	return e.offered && (e.minutes !== null || e.sessionEndsAt !== null || e.purchase === "checking" || e.notice === "minutes-ended" || c(e));
+}
+function u(e, t) {
+	return s(e) || e.retryAt !== null && e.retryAt > t ? !1 : d(e);
+}
+function d(t) {
+	return t.minutes === null ? !1 : (t.problem !== null && o.has(t.problem) ? t.problem : e(t.minutes)?.problem ?? null) === a;
+}
+var f = {
+	details: [],
+	action: null,
+	wantsAccess: !1
+};
+function p(e, t, n, r) {
+	if (e?.balance?.morePlanCreditsAvailable !== !0) return f;
+	let i = r ? {
+		...f,
+		wantsAccess: !0
+	} : {
+		details: [n.minutes.askAdmin],
+		action: null,
+		wantsAccess: !0
+	};
+	switch (t.status) {
+		case "absent": return {
+			...i,
+			wantsAccess: !1
+		};
+		case "asking":
+		case "failed": return {
+			...f,
+			wantsAccess: !0
+		};
+		case "answered": return t.access.canPurchase ? {
+			details: [],
+			action: "see-plans",
+			wantsAccess: !0
+		} : i;
+	}
+}
+function m(e, t, n) {
+	let r = [];
+	return n && r.push(t.minutes.low), r.push(t.minutes.shared), r.push(e.freeMinutesPerMonth > 0 ? t.minutes.freePerMonth(e.freeMinutesPerMonth) : t.minutes.noFree), e.planMinutesPerMonth > 0 && r.push(t.minutes.planPerMonth(e.planMinutesPerMonth)), r.push(t.minutes.resetsOn(e.resetsAt)), r;
+}
+function h(t, n) {
+	let { snapshot: r, access: a, now: o } = t;
+	if (!l(r)) return null;
+	let { minutes: c } = r, d = c?.balance ?? null, h = {
+		state: "quiet",
+		headline: null,
+		details: [],
+		action: null,
+		blocksStart: !1,
+		wantsAccess: !1,
+		announcement: null,
+		stageLines: [],
+		staleSeconds: c?.staleSeconds ?? null
+	};
+	if (s(r)) {
+		let e = r.phase === "ready" && !r.closing && r.sessionEndsAt !== null ? r.sessionEndsAt - o : 0;
+		if (e <= 0) return {
+			...h,
+			state: "in-session"
+		};
+		let t = Math.ceil(e / 6e4), i = n.minutes.sessionLeft(t);
+		return {
+			...h,
+			state: "in-session",
+			headline: i,
+			announcement: t <= 1 ? i : null
+		};
+	}
+	let g = u(r, o), { problem: _ } = r, v = _ !== null && i.has(_) ? _ : null, y = _ !== null && v === null;
+	if (r.purchase === "checking") {
+		let e = n.minutes.checkingPlan;
+		return {
+			...h,
+			state: "checking-purchase",
+			headline: e,
+			blocksStart: g,
+			announcement: e,
+			stageLines: [e]
+		};
+	}
+	if (v !== null && r.retryAt !== null && r.retryAt > o) return {
+		...h,
+		state: "waiting"
+	};
+	let b = e(c), x = v ?? b?.problem ?? (c?.state === "UNAVAILABLE" ? "minutes-unavailable" : null), S = v === null ? b?.minutesReason ?? null : r.minutesReason, C = x === null ? null : n.problem(x, {
+		minutesReason: S,
+		minutesResetsAt: d?.resetsAt ?? null
+	}), w = v === null ? C : null, T = (e, n) => t.rechecked === !0 && e.announcement === null && n !== null ? {
+		...e,
+		announcement: n
+	} : e, E = (e) => t.purchaseOutcome === "seen" ? {
+		...e,
+		announcement: e.headline
+	} : t.purchaseOutcome === "not-seen" ? {
+		...e,
+		details: [n.minutes.assignPlan, ...e.details],
+		action: "check-purchase-again",
+		announcement: n.minutes.assignPlan
+	} : e, D = w === null ? [] : [w];
+	switch (x) {
+		case "minutes-exhausted": {
+			let e = S === "FREE_CEILING" && d !== null ? [...d.personFreeCeiling === null ? [] : [n.minutes.freePerPerson(d.personFreeCeiling)], n.minutes.resetsOn(d.resetsAt)] : [], t = S === "ZERO_SESSION_LIMIT" || y ? f : p(c, a, n, !1), r = c !== null && t.action === null && !t.wantsAccess && b === null && S !== "ZERO_SESSION_LIMIT";
+			return T(E({
+				...h,
+				state: S === "NOT_INCLUDED" ? "not-included" : "exhausted",
+				headline: w,
+				details: [...e, ...t.details],
+				action: r ? "check-again" : t.action,
+				blocksStart: g,
+				wantsAccess: t.wantsAccess,
+				stageLines: D
+			}), C);
+		}
+		case "minutes-in-use":
+		case "minutes-in-use-self": return T({
+			...h,
+			state: x === "minutes-in-use-self" ? "in-use-self" : "in-use",
+			headline: w,
+			blocksStart: g,
+			stageLines: D
+		}, C);
+		case "minutes-unavailable": return T({
+			...h,
+			state: "unavailable",
+			headline: w,
+			blocksStart: g,
+			stageLines: D
+		}, C);
+		default: break;
+	}
+	if (c === null || d === null) return {
+		...h,
+		blocksStart: g
+	};
+	let O = d.availableMinutes, k = O <= 2, A = n.minutes.left(O), j = k && !y ? p(c, a, n, !0) : f;
+	return T(E({
+		...h,
+		state: k ? "low" : "available",
+		headline: A,
+		details: [...m(d, n, k), ...j.details],
+		action: j.action,
+		blocksStart: g,
+		wantsAccess: j.wantsAccess,
+		stageLines: k ? [A, n.minutes.low] : [A]
+	}), A);
+}
+//#endregion
+export { r as LIVE_AVATAR_MINUTES_BUY_ACTIONS, t as LIVE_AVATAR_MINUTES_LOW, n as LIVE_AVATAR_MINUTES_PLANS_PATH, l as liveAvatarMinutesActive, u as liveAvatarMinutesBlockStart, d as liveAvatarMinutesHoldStart, h as liveAvatarMinutesView };

package/dist/shared/assistant/avatar/live/liveAvatarStatus.d.ts

@@ -11,6 +11,9 @@ import { LiveAvatarSnapshot } from './liveAvatarController';
  *  - `locked`: off after a "not now" refusal that said when (`retryAt`), until that time (`now`, wall-clock ms): Turn on waits for it
  *    (critic m11). From that time on it is `off`, even while the snapshot still carries the time: the timer that clears it runs late
  *    after a system sleep (BOFF-9333 UI-11);
+ *  - `no-minutes` (★ BOFF-9446): off, and Turn on cannot start it for avatar credits: the credits answer says none are left for this
+ *    person, or the server's last credits refusal said so while there is a credits answer (with none, Turn on is the retry:
+ *    `liveAvatarMinutesBlockStart`);
  *  - `off`: off, or being set up (checking, choosing).
  * A device voice (no hosted voice to animate) is not predicted here: the route says so per reply, and the tab's
  * status line already explains it (`needs-hosted-voice`).

package/dist/shared/assistant/avatar/live/liveAvatarStatus.js

@@ -1,21 +1,24 @@
+import { liveAvatarMinutesHoldStart as e } from "./liveAvatarMinutesView.js";
 //#region src/shared/assistant/avatar/live/liveAvatarStatus.ts
-function e(e, t = Date.now()) {
-	switch (e.phase) {
-		case "ready": return e.closing ? "ending" : e.audioBlocked ? "sound-blocked" : "ready";
+function t(t, n = Date.now()) {
+	switch (t.phase) {
+		case "ready": return t.closing ? "ending" : t.audioBlocked ? "sound-blocked" : "ready";
 		case "starting":
 		case "connecting": return "starting";
 		case "ending": return "ending";
-		default: return e.retryAt !== null && e.retryAt > t ? "locked" : "off";
+		default: return t.retryAt !== null && t.retryAt > n ? "locked" : e(t) ? "no-minutes" : "off";
 	}
 }
-function t(e, t, n = Date.now()) {
+function n(e, t, n = Date.now()) {
 	if (e.problem === "playback-blocked" && e.audioBlocked) return null;
 	let r = e.voiceLive;
 	if (e.problem !== null) {
 		let i = e.retryAt, a = i !== null && i > n, o = t.problem(e.problem, {
 			voiceLive: r,
 			timed: a,
-			budgetScope: e.budgetScope
+			budgetScope: e.budgetScope,
+			minutesReason: e.minutesReason,
+			minutesResetsAt: e.minutes?.balance?.resetsAt ?? null
 		});
 		return a ? `${o} ${t.availableAgain(t.retryTime(i, n))}` : o;
 	}
@@ -24,8 +27,9 @@ function t(e, t, n = Date.now()) {
 		case "interrupted": return t.stateInterrupted;
 		case "voice-only": return r ? t.stateVoiceOnly : t.stateVoiceOnlyNoVoice;
 		case "time-limit": return r ? t.stateTimeLimit : t.stateTimeLimitNoVoice;
+		case "minutes-ended": return r ? t.minutes.ended : t.minutes.endedNoVoice;
 		default: return null;
 	}
 }
 //#endregion
-export { e as liveAvatarAskState, t as liveAvatarStatusText };
+export { t as liveAvatarAskState, n as liveAvatarStatusText };

package/dist/shared/assistant/avatar/useAvatarCopy.d.ts

@@ -1,12 +1,23 @@
 import { AvatarAskBlocker } from '../ui/avatar/avatarAskGate';
 import { VoiceStartBlocker } from '../ui/voice/voiceStartGate';
-import { AvatarBudgetScope } from './live/avatarSessionClient';
+import { AvatarBudgetScope, AvatarMinutesReason } from './live/avatarSessionClient';
 /** What the person can be told went wrong; the adapter maps server codes onto these. */
 export type AvatarProblem = 'unavailable' | 'not-ready' | 'already-running' | 'capacity' | 'rate-limited' | 'paused'
 /** The avatar time allowed for now (a credit cap) is used up; the server says when it comes back, and whose it is (`budgetScope`). */
  | 'budget-exhausted' | 'start-timeout' | 'provider'
 /** The avatar vendor's balance is at its floor: nobody's fault, it affects everyone, and no time is said for it. */
- | 'provider-out-of-credits' | 'connection' | 'needs-hosted-voice' | 'unsupported-browser' | 'playback-blocked';
+ | 'provider-out-of-credits' | 'connection' | 'needs-hosted-voice' | 'unsupported-browser' | 'playback-blocked'
+/**
+ * ★ BOFF-9446: no avatar credits are left for this person (the server's reason, when it gave one, is on the snapshot): the workspace's
+ * are used up, their free ones for the month are, the workspace has none at all (`NOT_INCLUDED`), or the zero-session limit.
+ */
+ | 'minutes-exhausted'
+/** ★ BOFF-9446: the workspace's credits left are held by another person's running session. Never a reason to buy. */
+ | 'minutes-in-use'
+/** ★ BOFF-9446 (M23): the credits left are held by this person's own session on another device, which keeps running. Never a buy. */
+ | 'minutes-in-use-self'
+/** ★ BOFF-9446: the credits could not be checked; a start is the retry. */
+ | 'minutes-unavailable';
 export interface AvatarCopy {
     toggle: string;
     toggleHint: string;
@@ -115,6 +126,8 @@ export interface AvatarCopy {
      * (`budget-exhausted` only; BOFF-9333).
      */
     problem: (problem: AvatarProblem, options?: AvatarProblemOptions) => string;
+    /** ★ BOFF-9446: the avatar minutes, in the Avatar tab and on the voice stage. */
+    minutes: AvatarMinutesCopy;
 }
 export interface AvatarProblemOptions {
     /** A voice conversation is live (the default: the voice stage is shown only during one). */
@@ -123,10 +136,122 @@ export interface AvatarProblemOptions {
     readonly timed?: boolean;
     /** With `budget-exhausted`, whose budget is used up. Absent or null: the server named none, and the general line is said. */
     readonly budgetScope?: AvatarBudgetScope | null;
+    /** ★ BOFF-9446: with `minutes-exhausted`, why none are left (the snapshot's `minutesReason`): each reason has its own words. */
+    readonly minutesReason?: AvatarMinutesReason | null;
+    /** ★ BOFF-9446: with `minutes-exhausted` and no reason, when the credits come back (UTC epoch ms); absent or null: no date is said. */
+    readonly minutesResetsAt?: number | null;
+}
+/**
+ * ★ BOFF-9446: the avatar credits' words (1 credit = 1 minute of avatar time; the credits are the workspace's). Count-neutral: every
+ * count follows a label. Every date is a UTC date (`formatAvatarMinutesDate`), and says so.
+ */
+export interface AvatarMinutesCopy {
+    /** The balance: "Avatar credits left: 12". */
+    left: (count: number) => string;
+    /** The balance is the workspace's, shared by everyone in it. */
+    shared: string;
+    /** The workspace's free credits each month (F > 0). */
+    freePerMonth: (count: number) => string;
+    /** F = 0. */
+    noFree: string;
+    /** The credits the workspace's plans give each month (P > 0). */
+    planPerMonth: (count: number) => string;
+    /** The UTC date the free and plan credits reset on. */
+    resetsOn: (resetsAt: number) => string;
+    /** The free credits one person may use each month, across workspaces (the per-person ceiling), said once they are used. */
+    freePerPerson: (count: number) => string;
+    /** 1 or 2 credits left. */
+    low: string;
+    /** The running session's time left, in whole minutes, rounded up: "Minutes left in this session: about 1". */
+    sessionLeft: (count: number) => string;
+    /** The buy action, for a person who may buy, when a plan with more credits exists: opens the app's plans page. */
+    seePlans: string;
+    /** Said instead to a person who cannot buy, when a plan with more credits exists. */
+    askAdmin: string;
+    /** Asks the credits again, for free (a refusal the latest answer does not explain). */
+    checkAgain: string;
+    /** "Check again", while its answer is on its way. */
+    checking: string;
+    /** The bounded check after a plan purchase is running. */
+    checkingPlan: string;
+    /** That check ended without the credits rising: the new plan is not assigned to this workspace yet. */
+    assignPlan: string;
+    /** The session ended because the credits it had ran out (D' was its length); voice continues. */
+    ended: string;
+    /** The same, with no voice conversation live. */
+    endedNoVoice: string;
+    /** "How avatar credits are counted": the control that shows the text. */
+    howCountedTitle: string;
+    /** Its sentences (`AVATAR_MINUTES_HOW_COUNTED`), with W in seconds: the server's `staleSeconds`, or null when it sent none. */
+    howCounted: (staleSeconds: number | null) => readonly string[];
 }
+/** One line of "How avatar credits are counted": its key and its English. */
+export interface AvatarMinutesCountedLine {
+    readonly key: string;
+    readonly fallback: string;
+}
+/**
+ * ★★★ The operator approved this English copy on 2026-10-24 (BOFF-9446, DESIGN 3.10, "How avatar credits are counted").
+ * R4 requires legal review of the refund rule before any customer is charged. The approved words use credits
+ * (1 credit = 1 minute of avatar time, M12), word for word (`avatarMinutesCopy.test.ts` pins them), and the Avatar tab shows them
+ * only once the server sends credits (`enforce`).
+ *
+ * ★★ D-23: its translations are a native speaker's, or reviewed by one, before any customer reads them; never machine-translated. (The
+ * consent is the other text under that rule.)
+ *
+ * ONE table, so approved words change in one place: the copy reads it (`AvatarMinutesCopy.howCounted`), and so does the manifest
+ * (`ASSISTANT_I18N_COMPUTED_COPY`). `lost` carries W, the server's `staleSeconds` (`{{seconds}}`); `lostNoFigure` stands in only for an
+ * answer whose W the client could not read.
+ */
+export declare const AVATAR_MINUTES_HOW_COUNTED: {
+    readonly title: {
+        readonly key: "avatar.minutes.howCounted.title";
+        readonly fallback: "How avatar credits are counted";
+    };
+    readonly unit: {
+        readonly key: "avatar.minutes.howCounted.unit";
+        readonly fallback: "1 credit = 1 minute of avatar time.";
+    };
+    readonly start: {
+        readonly key: "avatar.minutes.howCounted.start";
+        readonly fallback: "Counting starts once you and the avatar are both connected. Waiting for the avatar and starts that fail are free.";
+    };
+    readonly rounding: {
+        readonly key: "avatar.minutes.howCounted.rounding";
+        readonly fallback: "Each started minute uses one avatar credit. For example, a 2-minute-10-second session uses 3 credits.";
+    };
+    readonly drops: {
+        readonly key: "avatar.minutes.howCounted.drops";
+        readonly fallback: "Short connection drops that don't end the session count as part of it, like a phone call.";
+    };
+    readonly lost: {
+        readonly key: "avatar.minutes.howCounted.lost";
+        readonly fallback: "If the connection is lost, counting stops at the last moment we saw you both connected, minus a {{seconds}}-second safety margin.";
+    };
+    readonly lostNoFigure: {
+        readonly key: "avatar.minutes.howCounted.lostNoFigure";
+        readonly fallback: "If the connection is lost, counting stops at the last moment we saw you both connected, minus a safety margin.";
+    };
+    readonly ourEnd: {
+        readonly key: "avatar.minutes.howCounted.ourEnd";
+        readonly fallback: "If we stop the session because of a problem or maintenance on our side, or the avatar fails, the unfinished minute is free.";
+    };
+    readonly support: {
+        readonly key: "avatar.minutes.howCounted.support";
+        readonly fallback: "If something looks wrong, contact support: we credit the whole session back.";
+    };
+};
 /**
  * `at` as the reader's locale writes a time, with the date when `at` is not on `now`'s day (a daily limit comes back tomorrow).
  * ★ An unknown or malformed locale tag makes `Intl.DateTimeFormat` throw a RangeError: English stands in rather than losing the line.
  */
 export declare function formatAvatarRetryTime(at: number, now: number, locale: string | undefined): string;
+/**
+ * ★ BOFF-9446: a reset instant (UTC epoch ms) as the UTC date it falls on, in the reader's locale. The credits' months are UTC months, so
+ * "They come back on 1 Nov (UTC)" reads the same in every time zone: local time is never used, here or anywhere a credits date is shown.
+ * ★ An unknown or malformed locale tag falls back to English, as `formatAvatarRetryTime`.
+ */
+export declare function formatAvatarMinutesDate(at: number, locale: string | undefined): string;
+/** ★ BOFF-9446: a whole count of credits, minutes or seconds, in the reader's locale's digits; English for a tag it cannot read. */
+export declare function formatAvatarCount(count: number, locale: string | undefined): string;
 export declare function useAvatarCopy(): AvatarCopy;