@byokit/accounts 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 0.13.0 (2026-10-01)
+
+
+
+- Add portable, choose-once multi-account selection with most-room ordering, unknown room above exhausted, and secret-free candidate explanations. Auto and default fallback use subscription accounts only; an API key (billed per use) must be explicitly selected.
+- Export roomOf and roomWords, shared Auto conformance fixtures, and descriptive multi-account terms data.
+
 ## 0.12.0 (2026-09-30)
 
 

package/README.md

@@ -489,3 +489,65 @@ The common route follows Hermes's platform token host, three scopes and `axios/1
 with inference `claude-code/2.1.74 (external, cli)`, `x-app: cli`, bearer authorization, Messages version
 `2023-06-01` and betas `claude-code-20250219,oauth-2025-04-20`. The implementation is independent;
 [NOTICE](NOTICE) records the MIT protocol references.
+
+## Choosing between accounts
+
+The portable entry exports `chooseAccount`, `resolveSelection`, `roomOf`, `roomWords` and the structural
+`AccountLike`, `AccountPick`, `Room`, `Considered`, `RunSelection` and `Defaults` types. The host supplies its own
+account records and readings; these functions never read credentials, sign in, refresh, start a run or switch a
+running conversation. Resolve once before starting and keep the selected account for the whole run.
+
+```ts
+import { resolveSelection, roomOf, type AccountLike, type Defaults } from '@byokit/accounts';
+
+// Host-provided account, model and measurement accessors:
+declare const accounts: readonly AccountLike[];
+declare const defaults: Defaults;
+declare function windowsFor(account: AccountLike, demand: readonly string[]):
+  { usedPercent: number; kind: string; resetsAt?: number }[];
+declare function measuredAt(account: AccountLike): number | undefined;
+declare function modelsFor(account: AccountLike): { id: string; available: boolean }[];
+declare function startRunWith(account: AccountLike, model: string): void;
+
+const pick = resolveSelection(accounts, defaults, { account: 'auto', needs: ['provider/model'] },
+  (account, demand) => roomOf(windowsFor(account, demand), measuredAt(account), 'milliseconds'), Date.now(),
+  (account) => modelsFor(account));
+if (pick.ok) startRunWith(pick.account, pick.model);
+```
+
+Auto uses ready subscription accounts (including a rest whose deadline has elapsed). It ranks usable readings
+by most room, earlier refill, then list order; unknown readings follow; exhausted accounts refill first. A reading
+older than 24 hours counts as unknown. A numeric reading without a measurement time retains its room tier,
+with unknown age/confidence. Explicit account ids bypass state and billing filtering: the host must verify the
+selected account is ready before starting, and a failed explicit selection never falls back to another account.
+API key accounts (billed per use) are used only when explicitly selected by id or a ready default.
+
+`sel.model` and deduplicated `sel.needs` form the demand passed to the room reader. Supply `models` to verify
+every demanded model is available. Without it, the host owns model eligibility; `model` is the explicit or default
+model, or an empty string when neither is provided. With a model list, no available model returns `not_included`.
+Without a demand, selection stays within the default account's provider, or the first provider in list order.
+
+Each pick includes every account's `considered` row in list order. It holds only ids, exclusion/ranking codes,
+room figures, measurement age and confidence (`known`, `stale`, `unknown`); no names, emails, credential fields
+or engine messages are copied. The winning row's `reason` is the pick's `why`; other candidate reasons describe
+the deterministic comparison to the Auto winner. Excluded rows carry their first exclusion code. Account ids
+and model ids supplied by the host must themselves be secret-free. The generic returned `account` is the original
+host record: keep credentials outside that record before exposing the whole pick to UI or logs.
+
+`AccountLike.until`, `nowMs`, `Room.at`, `Room.resetsAt` and `Considered.age` use **milliseconds**.
+`roomOf(windows, at, resetUnit?)` accepts structural windows. Legacy reset **epoch seconds** are the default,
+converted by 1000 exactly once. For normalized `@byokit/usage` 0.2.0+ windows, pass `'milliseconds'` as the
+third argument; reset times then stay unchanged. A normalized usage `Room` also passes directly to the chooser.
+The optional `at` is always the original measurement time in epoch milliseconds.
+The current structural input contains `usedPercent`, `kind`, and optional `resetsAt`; hard-limit/model-scope and
+poll-health ingestion is a follow-up to the pending usage extension. Hosts must supply demand-filtered windows
+and authoritative eligibility rather than interpreting an unavailable quota reading as a fresh successful read.
+
+`Provider.multiAccount` gives a terms assessment, reason and source for multiple accounts of that service.
+A grey assessment records missing explicit documentation; it does not gate selection. `auto.terms`, `auto.*`,
+`room.*` and `pick.*` words are exported in `WORDS`.
+
+Identity and re-authentication stay with the host's canonical device store or engine. A provider account id
+scoped by member/provider proves identity; names and emails do not. The TypeScript identity fixture records
+wrong-account, duplicate identity, changed-email, absent-identity, removal/refresh and extension-field boundaries
+for runtime integration; the chooser consumes host-validated state and never adopts credentials itself.

package/dist/catalogue.d.ts

@@ -1,6 +1,12 @@
 export type Terms = 'allowed' | 'grey' | 'partner' | 'forbidden';
 /** How the person pays: their plan (`subscription`), or per-use charges to their account (`api`, never offered by default). */
 export type Billing = 'subscription' | 'api';
+/** Terms assessment for choosing between several accounts; descriptive, never an eligibility gate. */
+export type MultiAccountTerms = {
+    terms: Terms;
+    why: string;
+    source: string;
+};
 /** `callbackPort`: where the provider sends the browser back after its own sign-in page, fixed for the client Pi signs in as.
  *  `revoke`: where signing out ends the sign-in on the provider's side too, for the client `clientId`. */
 export type Provider = {
@@ -23,6 +29,7 @@ export type Provider = {
     hidden: boolean;
     why: string;
     source: string;
+    multiAccount: MultiAccountTerms;
 };
 export declare const PROVIDERS: Record<string, Provider>;
 export declare function provider(key: string): Provider;

package/dist/catalogue.json

@@ -14,7 +14,12 @@
         "terms": "grey",
         "hidden": false,
         "why": "Signs in through Codex's own sign-in. OpenAI documents it for Codex, not for other apps, and has endorsed one other app using it.",
-        "source": "https://developers.openai.com/codex/auth"
+        "source": "https://developers.openai.com/codex/auth",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://developers.openai.com/codex/auth"
+        }
     },
     "openrouter": {
         "pi": "openrouter",
@@ -27,7 +32,12 @@
         "terms": "allowed",
         "hidden": false,
         "why": "Documented sign-in for any app, no registration. Pay-as-you-go credits, not a subscription.",
-        "source": "https://openrouter.ai/docs/guides/overview/auth/oauth"
+        "source": "https://openrouter.ai/docs/guides/overview/auth/oauth",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://openrouter.ai/docs/guides/overview/auth/oauth"
+        }
     },
     "grok": {
         "pi": "xai",
@@ -40,7 +50,12 @@
         "terms": "partner",
         "hidden": true,
         "why": "xAI allows plan sign-in only in apps it has partnered with.",
-        "source": "https://x.ai/news/grok-opencode"
+        "source": "https://x.ai/news/grok-opencode",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://x.ai/news/grok-opencode"
+        }
     },
     "copilot": {
         "pi": "github-copilot",
@@ -53,7 +68,12 @@
         "terms": "partner",
         "hidden": true,
         "why": "GitHub allows Copilot sign-in only in apps it has partnered with; this uses VS Code's client.",
-        "source": "https://github.blog/changelog/2026-01-16-github-copilot-now-supports-opencode"
+        "source": "https://github.blog/changelog/2026-01-16-github-copilot-now-supports-opencode",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://github.blog/changelog/2026-01-16-github-copilot-now-supports-opencode"
+        }
     },
     "anthropic": {
         "pi": "anthropic",
@@ -69,7 +89,12 @@
         "label": "API key (billed per use)",
         "offer": false,
         "why": "The app passes an Anthropic API key explicitly. API key (billed per use), never a default or subscription fallback.",
-        "source": "https://platform.claude.com/docs/en/api/overview"
+        "source": "https://platform.claude.com/docs/en/api/overview",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://platform.claude.com/docs/en/api/overview"
+        }
     },
     "claude": {
         "pi": "byokit-claude-plan",
@@ -85,6 +110,11 @@
         "terms": "grey",
         "hidden": false,
         "why": "Anthropic prohibits third-party Claude.ai sign-in without approval; this route may stop working or lead to account restrictions.",
-        "source": "https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use"
+        "source": "https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use",
+        "multiAccount": {
+            "terms": "grey",
+            "why": "This source does not explicitly document choosing between several accounts of this service in another app.",
+            "source": "https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use"
+        }
     }
 }

package/dist/multi.d.ts

@@ -0,0 +1,77 @@
+export type SignInState = 'ready' | 'signing' | 'resting' | 'signed_out' | 'needs_again' | 'not_included';
+export type AccountLike = {
+    id: string;
+    provider: string;
+    name: string;
+    state: SignInState;
+    billing: 'subscription' | 'api';
+    until?: number;
+};
+export type RoomSpan = 'session' | 'week' | 'month' | 'tightest';
+/** Every time here is epoch milliseconds; `at` is the source measurement time, never its receipt time. */
+export type Room = {
+    left: number;
+    span: RoomSpan;
+    resetsAt?: number;
+    at?: number;
+} | {
+    left: 'unknown';
+    at?: number;
+};
+export type RunSelection = {
+    account: string | 'default' | 'auto';
+    model?: string;
+    needs?: string[];
+};
+export type Defaults = {
+    account?: string;
+    model?: string;
+    auto?: boolean;
+};
+export type PickWhy = 'chosen' | 'default' | 'first_ready' | 'only' | 'most_room' | 'earlier_reset' | 'list_order' | 'no_reading' | 'refills_first';
+export type Considered = {
+    id: string;
+    out?: 'state' | 'resting' | 'billing' | 'model' | 'provider';
+    until?: number;
+    missing?: string;
+    tier?: 'room' | 'unknown' | 'exhausted';
+    left: number | 'unknown';
+    span?: RoomSpan;
+    resetsAt?: number;
+    age: number | 'unknown';
+    confidence: 'known' | 'stale' | 'unknown';
+    reason: PickWhy | 'state' | 'resting' | 'billing' | 'model' | 'provider';
+};
+export type AccountPick<A extends AccountLike = AccountLike> = {
+    ok: true;
+    account: A;
+    model: string;
+    how: 'chosen' | 'default' | 'auto';
+    why: PickWhy;
+    reason: string;
+    considered: Considered[];
+} | {
+    ok: false;
+    code: 'none' | 'not_included' | 'unknown_account';
+    reason: string;
+    considered: Considered[];
+};
+type Models<A> = (a: A) => readonly {
+    id: string;
+    available: boolean;
+}[];
+/** Structural windows: legacy reset seconds by default; usage 0.2.0+ must pass milliseconds explicitly. */
+export declare function roomOf(windows: readonly {
+    usedPercent: number;
+    kind: string;
+    resetsAt?: number;
+}[], at?: number, resetUnit?: 'seconds' | 'milliseconds'): Room;
+export declare function roomWords(room: Room): string;
+/** Auto's winner only. Pure and portable; no timers, reads, refreshes or mid-run switching. */
+export declare function chooseAccount<A extends AccountLike>(accounts: readonly A[], room: (a: A) => Room, nowMs: number): {
+    account: A;
+    why: PickWhy;
+} | undefined;
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export declare function resolveSelection<A extends AccountLike>(accounts: readonly A[], defaults: Defaults, sel: RunSelection, room: (a: A, demand: readonly string[]) => Room, nowMs: number, models?: Models<A>): AccountPick<A>;
+export {};

package/dist/multi.js

@@ -0,0 +1,134 @@
+// Pure start-of-run selection. Callers own identities and credentials and keep the returned account for the run.
+import { clock, say } from "./words.js";
+const DAY_MS = 24 * 60 * 60 * 1000;
+const finite = (n) => typeof n === 'number' && Number.isFinite(n);
+const reset = (r) => r.resetsAt ?? Infinity;
+/** Structural windows: legacy reset seconds by default; usage 0.2.0+ must pass milliseconds explicitly. */
+export function roomOf(windows, at, resetUnit = 'seconds') {
+    const known = windows.filter((w) => finite(w.usedPercent));
+    if (!known.length)
+        return { left: 'unknown', ...(finite(at) ? { at } : {}) };
+    const w = known.reduce((a, b) => b.usedPercent > a.usedPercent ? b : a);
+    const span = w.kind === 'session' ? 'session' : w.kind === 'weekly' ? 'week' : w.kind === 'monthly' ? 'month' : 'tightest';
+    return { left: Math.max(0, Math.min(100, 100 - w.usedPercent)), span,
+        ...(finite(w.resetsAt) ? { resetsAt: w.resetsAt * (resetUnit === 'seconds' ? 1000 : 1) } : {}), ...(finite(at) ? { at } : {}) };
+}
+export function roomWords(room) {
+    return room.left === 'unknown' ? say('room.unknown') : say(`room.${room.span}`, { left: `${Math.round(room.left)}%` });
+}
+// One shared eligibility predicate for direct picks, Auto and all explanation rows. Room is read once per row.
+function consider(accounts, room, nowMs, demand = [], models, provider, named) {
+    return accounts.map((account) => {
+        const r = room(account);
+        const age = finite(r.at) ? Math.max(0, nowMs - r.at) : 'unknown';
+        const stale = typeof age === 'number' && age > DAY_MS;
+        const left = r.left === 'unknown' || !finite(r.left) || stale ? 'unknown' : Math.max(0, Math.min(100, r.left));
+        const row = { id: account.id, left, age,
+            confidence: stale ? 'stale' : left === 'unknown' || age === 'unknown' ? 'unknown' : 'known', reason: 'no_reading' };
+        if (r.left !== 'unknown') {
+            row.span = r.span;
+            if (finite(r.resetsAt))
+                row.resetsAt = r.resetsAt;
+        }
+        // Explicit ids bypass state and billing: the host verifies readiness before starting, never falls back.
+        if (account.id !== named) {
+            if (account.state === 'resting' && finite(account.until) && account.until > nowMs) {
+                row.out = 'resting';
+                row.until = account.until;
+            }
+            else if (account.state !== 'ready' && !(account.state === 'resting' && finite(account.until) && account.until <= nowMs))
+                row.out = 'state';
+            else if (account.billing !== 'subscription')
+                row.out = 'billing';
+        }
+        if (!row.out && demand.length && models) {
+            const available = models(account);
+            const missing = demand.find((id) => !available.some((m) => m.id === id && m.available));
+            if (missing !== undefined) {
+                row.out = 'model';
+                row.missing = missing;
+            }
+        }
+        if (!row.out && !demand.length && provider !== undefined && account.provider !== provider && account.id !== named)
+            row.out = 'provider';
+        if (row.out)
+            row.reason = row.out;
+        else
+            row.tier = left === 'unknown' ? 'unknown' : left > 0 || reset(row) <= nowMs ? 'room' : 'exhausted';
+        return { account, row };
+    });
+}
+const tierOrder = { room: 0, unknown: 1, exhausted: 2 };
+function compare(a, b) {
+    const tier = tierOrder[a.row.tier] - tierOrder[b.row.tier];
+    if (tier)
+        return tier;
+    if (a.row.tier === 'unknown')
+        return 0;
+    if (a.row.tier === 'room' && a.row.left !== b.row.left)
+        return Number(b.row.left) - Number(a.row.left);
+    // Avoid Infinity - Infinity (NaN); stable sort preserves list order for ties.
+    return reset(a.row) === reset(b.row) ? 0 : reset(a.row) < reset(b.row) ? -1 : 1;
+}
+function rankingReason(winner, next) {
+    if (winner.row.tier === 'unknown')
+        return 'no_reading';
+    if (winner.row.tier === 'exhausted')
+        return 'refills_first';
+    if (!next || next.row.tier !== 'room' || winner.row.left !== next.row.left)
+        return 'most_room';
+    return reset(winner.row) < reset(next.row) ? 'earlier_reset' : 'list_order';
+}
+function rank(rows) {
+    const ranked = rows.filter((c) => !c.row.out).sort(compare);
+    const winner = ranked[0];
+    if (!winner)
+        return undefined;
+    const why = ranked.length === 1 ? 'only' : rankingReason(winner, ranked[1]);
+    for (const c of ranked)
+        c.row.reason = c === winner ? why : rankingReason(winner, c);
+    return { account: winner.account, why, row: winner.row };
+}
+/** Auto's winner only. Pure and portable; no timers, reads, refreshes or mid-run switching. */
+export function chooseAccount(accounts, room, nowMs) {
+    const pick = rank(consider(accounts, room, nowMs));
+    return pick && { account: pick.account, why: pick.why };
+}
+/** Resolve once before starting. Without `models`, membership is host-validated and a missing model is ''. */
+export function resolveSelection(accounts, defaults, sel, room, nowMs, models) {
+    const demand = [...new Set([...(sel.model ? [sel.model] : []), ...(sel.needs ?? [])])];
+    const defaultAccount = accounts.find((a) => a.id === defaults.account);
+    const named = sel.account === 'default' ? defaultAccount?.state === 'ready' ? defaultAccount.id : undefined : sel.account === 'auto' ? undefined : sel.account;
+    const provider = defaultAccount?.provider ?? accounts[0]?.provider;
+    const rows = consider(accounts, (a) => room(a, demand), nowMs, demand, models, provider, named);
+    const considered = rows.map((c) => c.row);
+    const auto = rank(rows); // also fills explanations for every eligible row, even on explicit selection
+    if (named !== undefined) {
+        const chosen = rows.find((c) => c.account.id === named);
+        if (!chosen)
+            return { ok: false, code: 'unknown_account', reason: say('pick.unknownAccount'), considered };
+        if (chosen.row.out)
+            return { ok: false, code: 'not_included', reason: say('pick.out.model', { model: chosen.row.missing ?? '' }), considered };
+        return finish(chosen.account, chosen.row, sel.account === 'default' ? 'default' : 'chosen', sel.account === 'default' ? 'default' : 'chosen');
+    }
+    if (sel.account === 'default' && defaults.auto === false) {
+        const first = rows.find((c) => !c.row.out);
+        if (first)
+            return finish(first.account, first.row, 'default', 'first_ready');
+    }
+    else if (auto)
+        return finish(auto.account, auto.row, 'auto', auto.why);
+    return { ok: false, code: 'none', reason: say('auto.none', { provider: provider ?? '' }), considered };
+    function finish(account, row, how, why) {
+        const available = models?.(account).filter((m) => m.available);
+        const model = sel.model ?? (defaults.model && (!available || available.some((m) => m.id === defaults.model)) ? defaults.model : available?.[0]?.id) ?? '';
+        if (models && !model)
+            return { ok: false, code: 'not_included', reason: say('pick.noModel'), considered };
+        row.reason = why;
+        const slots = { name: account.name, provider: account.provider };
+        const reason = how !== 'auto' ? say(`pick.why.${why}`, slots) : row.tier === 'unknown' ? say('auto.unknown', slots) : row.tier === 'exhausted' ?
+            say(finite(row.resetsAt) ? 'auto.refills' : 'auto.refillsNoTime', { ...slots, time: finite(row.resetsAt) ? clock(row.resetsAt) : '' }) :
+            say('auto.room', { ...slots, room: roomWords({ left: Number(row.left), span: row.span ?? 'tightest' }) });
+        return { ok: true, account, model, how, why, reason, considered };
+    }
+}

package/dist/portable.d.ts

@@ -1,5 +1,5 @@
 export { Accounts, planOf, portable, type AccountsOptions, type ClaudePlanAsk, type AnthropicAccountAsk, type AuthHost, type Loopback, type Member, type Platform, type SignIn, type Status } from './accounts.ts';
-export { PROVIDERS, offered, provider, type Billing, type Provider, type Terms } from './catalogue.ts';
+export { PROVIDERS, offered, provider, type Billing, type MultiAccountTerms, type Provider, type Terms } from './catalogue.ts';
 export { PORTABLE, claims, credentialOf, devicePoll, deviceStart, portableEngine, type EngineOptions, type Poll } from './engine.ts';
 export { REST_MS, classify, classifyFailure, type Failure, type Kind } from './limits.ts';
 export { IncompleteError, ResponseError, isFunctionCall, limitResponse, respond, sseReader, type Ask, type ResponseFunctionCall, type ResponseInputItem, type ResponseOutputItem, type ResponseOutputMessage, type ResponseReasoning, type ResponseResult, type ResponseStreamEvent, type ResponseText, type ResponseTextFormat, type ResponseTool, type ResponseToolChoice } from './responses.ts';
@@ -8,3 +8,4 @@ export { WORDS, billingWords, callbackPage, clock, failure, say, signInError, ty
 export { chatgptPlan, UnsupportedAccountError, type ChatGPTPlanAccount, type ChatGPTPlanSession } from './chatgpt-plan.ts';
 export { anthropic, anthropicSseReader, AnthropicIncompleteError, type AnthropicAsk, type AnthropicCacheControl, type AnthropicContent, type AnthropicImage, type AnthropicMessage, type AnthropicOptions, type AnthropicRequest, type AnthropicResponse, type AnthropicResult, type AnthropicStreamEvent, type AnthropicText, type AnthropicThinking, type AnthropicTool, type AnthropicToolChoice, type AnthropicToolUse, type AnthropicUsage } from './anthropic.ts';
 export { ClaudePlanExpiredError, ClaudePlanPlatformError, claudeAuthorization, claudeCode, type ClaudePlanOptions } from './claude-plan.ts';
+export { chooseAccount, resolveSelection, roomOf, roomWords, type AccountLike, type AccountPick, type Considered, type Defaults, type PickWhy, type Room, type RoomSpan, type RunSelection, type SignInState } from './multi.ts';

package/dist/portable.js

@@ -10,3 +10,4 @@ export { WORDS, billingWords, callbackPage, clock, failure, say, signInError } f
 export { chatgptPlan, UnsupportedAccountError } from "./chatgpt-plan.js";
 export { anthropic, anthropicSseReader, AnthropicIncompleteError } from "./anthropic.js";
 export { ClaudePlanExpiredError, ClaudePlanPlatformError, claudeAuthorization, claudeCode } from "./claude-plan.js";
+export { chooseAccount, resolveSelection, roomOf, roomWords } from "./multi.js";

package/dist/words.json

@@ -1,5 +1,5 @@
 {
-    "signIn.opening": "Opening {name}…",
+    "signIn.opening": "Opening {name}\u2026",
     "signIn.waitingUrl": "Sign in on the {name} page that just opened.",
     "signIn.waitingCode": "On the {name} page, type this code: {code}",
     "signIn.pasteHint": "Having trouble? Copy the address from the browser and paste it here.",
@@ -12,7 +12,7 @@
     "signIn.busy": "Something else on this computer is signing in to {name}. Try again in a minute.",
     "signIn.failed": "{name} didn't finish the sign-in. Tap Sign in with {name} to try again.",
     "status.ready": "{name} is connected.",
-    "status.signing": "Signing in to {name}…",
+    "status.signing": "Signing in to {name}\u2026",
     "status.resting": "{name} is resting until {until}.",
     "status.busy": "{name} is busy right now.",
     "status.signedOut": "{name} isn't signed in yet.",
@@ -25,5 +25,37 @@
     "callback.declined": "No problem. Nothing was changed. You can go back to {app}.",
     "callback.failed": "{error} Go back to {app}.",
     "callback.nearly": "Nearly there. Go back to {app} to finish.",
-    "callback.outOfDate": "This sign-in page is out of date. Go back to {app} and tap Sign in with {name} again."
+    "callback.outOfDate": "This sign-in page is out of date. Go back to {app} and tap Sign in with {name} again.",
+    "auto.terms": "Auto may use either of a provider's accounts.",
+    "auto.room": "Right now that's {name}: {room}",
+    "auto.unknown": "Right now that's {name} (no recent reading)",
+    "auto.refills": "All {provider} accounts are out of room until {time}. {name} refills first.",
+    "auto.refillsNoTime": "All {provider} accounts are out of room. {name} refills first.",
+    "auto.none": "No signed-in {provider} account.",
+    "room.unknown": "Room left unknown",
+    "room.session": "{left} left this session",
+    "room.week": "{left} left this week",
+    "room.month": "{left} left this month",
+    "room.tightest": "{left} left for now",
+    "pick.out.state": "Not signed in right now",
+    "pick.out.resting": "Taking a break until {time}",
+    "pick.out.billing": "Billed per use, so used only when you choose it",
+    "pick.out.model": "Doesn't include {model}",
+    "pick.out.provider": "A different service",
+    "pick.out.bound": "This conversation uses another account",
+    "pick.unknownAccount": "That account is no longer in your list.",
+    "pick.noModel": "That account doesn't include a model for this run.",
+    "pick.why.chosen": "You chose {name}.",
+    "pick.why.default": "{name} is your default.",
+    "pick.why.first_ready": "Your default isn't ready, so {name}, the first ready account.",
+    "pick.why.only": "{name} is the only account that can take this.",
+    "pick.why.most_room": "{name} has the most room left.",
+    "pick.why.earlier_reset": "{name} has as much room left and refills sooner.",
+    "pick.why.list_order": "{name} is tied for room and comes first in your list.",
+    "pick.why.no_reading": "No account has a recent reading, so {name}, first in your list.",
+    "pick.why.refills_first": "All accounts are out of room; {name} refills first.",
+    "pick.age": "Read {ago} ago",
+    "pick.ageUnknown": "Reading time unknown",
+    "ago.minutes": "{n} minutes",
+    "ago.hours": "{n} hours"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/accounts",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Sign in with the AI plan you already pay for, into your app's own store.",
   "license": "Apache-2.0",
   "type": "module",