@hanzo/rooms 0.1.0

package/dist/lib/models.js

@@ -0,0 +1,106 @@
+/**
+ * What a provider and a model are CALLED — the few naming rules the rooms draw
+ * with. The catalogue itself (prices, contexts, the serving list) is the host's.
+ */
+import { getOrgAndSlug } from './path.js';
+export { canonicalOrg, getOrgAndSlug, modelPagePath } from './path.js';
+// Map org slug → display name
+export const ORG_DISPLAY_NAMES = {
+    hanzo: 'Hanzo',
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    google: 'Google',
+    'meta-llama': 'Meta',
+    'x-ai': 'xAI',
+    mistralai: 'Mistral',
+    deepseek: 'DeepSeek',
+    qwen: 'Qwen',
+    nvidia: 'NVIDIA',
+    'z-ai': 'Z.ai',
+    'arcee-ai': 'Arcee AI',
+    minimax: 'Minimax',
+    allenai: 'Allen AI',
+    nousresearch: 'Nous Research',
+    liquid: 'Liquid AI',
+    moonshotai: 'Moonshot AI',
+    amazon: 'Amazon',
+    perplexity: 'Perplexity',
+    baidu: 'Baidu',
+    cohere: 'Cohere',
+    'bytedance-seed': 'ByteDance Seed',
+    openrouter: 'OpenRouter',
+    microsoft: 'Microsoft',
+    inflection: 'Inflection',
+    sao10k: 'Sao10K',
+    'aion-labs': 'Aion Labs',
+    thedrummer: 'TheDrummer',
+    stepfun: 'StepFun',
+    relace: 'Relace',
+    morph: 'Morph',
+    inception: 'Inception',
+    neversleep: 'NeverSleep',
+    upstage: 'Upstage',
+    writer: 'Writer',
+    xiaomi: 'Xiaomi',
+    'nex-agi': 'Nex-AGI',
+    essentialai: 'EssentialAI',
+    'prime-intellect': 'Prime Intellect',
+    deepcogito: 'DeepCogito',
+    kwaipilot: 'KwaiPilot',
+    'ibm-granite': 'IBM Granite',
+    alibaba: 'Alibaba',
+    opengvlab: 'OpenGVLab',
+    meituan: 'Meituan',
+    ai21: 'AI21',
+    bytedance: 'ByteDance',
+    switchpoint: 'Switchpoint',
+    cognitivecomputations: 'Cognitive Computations',
+    tencent: 'Tencent',
+    tngtech: 'TNG Tech',
+    eleutherai: 'EleutherAI',
+    alfredpros: 'AlfredPros',
+    raifle: 'Raifle',
+    'anthracite-org': 'Anthracite',
+    alpindale: 'Alpindale',
+    mancer: 'Mancer',
+    undi95: 'Undi95',
+    gryphe: 'Gryphe',
+    meta: 'Meta',
+    inclusionai: 'inclusionAI',
+    thinkingmachines: 'Thinking Machines',
+    rekaai: 'Reka AI',
+    sakana: 'Sakana AI',
+    perceptron: 'Perceptron',
+};
+export function orgDisplayName(org) {
+    if (!org)
+        return 'Hanzo';
+    return ORG_DISPLAY_NAMES[org] ?? org;
+}
+/**
+ * What a model is CALLED, as against the id it answers to.
+ *
+ * Two things the catalog does that a reader should not have to:
+ *
+ *   it names the house families by their slug — `name` is `"enso"`, the same
+ *   string as `id` — so the card would read "enso" twice, once in prose type
+ *   and once in mono. Title-case the slug and the card reads "Enso Flash" over
+ *   `enso-flash`, which is a name over an address.
+ *
+ *   it prefixes third-party names with the lab — `"DeepSeek: DeepSeek V4 Pro"`,
+ *   `"SpaceXAI: Grok 4.5"`. The lab is already the group the row sits in and
+ *   the namespace on the id beside it, so the prefix is the third telling.
+ *
+ * It lived on /models as a private helper while the table, the tile and the lab
+ * index all needed it, which is how the same model could read three ways on one
+ * page.
+ */
+export function modelName(model) {
+    if (model.name && model.name !== model.id) {
+        return model.name.replace(/^[A-Za-z0-9.\-() ]{1,18}:\s+/, '');
+    }
+    return getOrgAndSlug(model.id)
+        .slug.split('-')
+        .map((word) => (word ? word[0].toUpperCase() + word.slice(1) : word))
+        .join(' ');
+}

package/dist/lib/org.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The organization settings area's reads and writes, each on the API that owns it.
+ *
+ *   the org row            GET    /v1/iam/organizations/admin/<org>
+ *   delete the org         DELETE /v1/iam/organizations/admin/<org>
+ *   found a team org       POST   /v1/iam/organizations {owner: admin, name, displayName}
+ *   business address       GET|PUT /v1/settings/organization (cloud's per-org config)
+ *   your keys              GET|POST|DELETE /v1/account/keys (minted by IAM on you, shown once)
+ *   the org's keys         GET    /v1/iam/keys?owner=<org>, DELETE /v1/iam/keys/<org>/<name>
+ *   payment methods        GET    /v1/billing/methods
+ *   invoices               GET    /v1/billing/invoices
+ *
+ * The name, the logo, the members and the invitations are lib/hanzo/team.ts's,
+ * and the plan and balance are lib/hanzo/tier.ts's. Nothing here decides who may
+ * do what: every request carries the reader's bearer and organization (`scope`),
+ * the server answers, and a refusal comes back as the server's own sentence.
+ */
+/** A refusal, with the status it came under and the server's words. */
+export declare class Refusal extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/** The words of any failure, for a toast or a line under a control. */
+export declare const say: (e: unknown) => string;
+/** The org row as IAM answers it. Every org row is filed under the reserved `admin` owner. */
+export interface OrgRow {
+    name: string;
+    displayName: string;
+    websiteUrl?: string;
+    isPersonal?: boolean;
+    avatar?: string;
+}
+export declare const readOrg: (org: string) => Promise<OrgRow>;
+/** Deletes the org row. IAM decides who may; there is no undo. */
+export declare const deleteOrg: (org: string) => Promise<unknown>;
+/**
+ * Creates an organization the reader owns: cloud's `POST /v1/account/orgs
+ * {name}`, the one create every surface uses. Cloud files the row in IAM and
+ * records the verified creator as its owner through IAM's membership API.
+ * Answers the new organization's handle; a refusal is what the reader is shown.
+ */
+export declare const createOrg: (name: string) => Promise<string>;
+/** The handle an org is addressed by, from the name a person typed. */
+export declare function slug(name: string): string;
+export interface Address {
+    line1: string;
+    line2: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+}
+export declare const EMPTY_ADDRESS: Address;
+export declare function readAddress(): Promise<Address>;
+/**
+ * Stores the address and answers what was stored. The document is written
+ * whole, so the rest of it is read first and carried: a save of the address
+ * never drops a field somebody else kept beside it.
+ */
+export declare function saveAddress(next: Address): Promise<Address>;
+export type KeyType = 'secret' | 'publishable';
+/** One of the reader's own keys in the acting org. A secret key's value is never listed. */
+export interface OwnKey {
+    type: KeyType;
+    prefix?: string;
+    /** The whole value, for a publishable key only: it is public by construction. */
+    key?: string;
+    createdAt?: string;
+}
+export declare function ownKeys(): Promise<OwnKey[]>;
+/** Mints the reader's key of `type`, replacing the one they held, and answers it — once. */
+export declare function mintKey(type: KeyType): Promise<string>;
+export declare const revokeOwnKey: (type: KeyType) => Promise<unknown>;
+/** One of the org's keys, as IAM lists them: the secret half never leaves IAM. */
+export interface OrgKey {
+    owner: string;
+    name: string;
+    displayName?: string;
+    user?: string;
+    scope?: string;
+    state?: string;
+    createdTime?: string;
+}
+export declare function orgKeys(org: string): Promise<OrgKey[]>;
+export declare const revokeKey: (k: Pick<OrgKey, 'owner' | 'name'>) => Promise<unknown>;
+/** A card on file, as billing lists it. */
+export interface Method {
+    id: string;
+    brand?: string;
+    last4?: string;
+    expMonth?: number;
+    expYear?: number;
+    isDefault?: boolean;
+}
+export declare function methods(): Promise<Method[]>;
+/** An invoice, amounts in whole cents. */
+export interface Invoice {
+    id: string;
+    numberStr?: string;
+    status?: string;
+    amountDue: number;
+    amountPaid?: number;
+    currency?: string;
+    createdAt?: string;
+    paidAt?: string;
+}
+export declare function invoices(): Promise<Invoice[]>;
+/** Whole cents as money: `$1,234.56`. */
+export declare function cents(n: number, currency?: string): string;

package/dist/lib/org.js

@@ -0,0 +1,140 @@
+/**
+ * The organization settings area's reads and writes, each on the API that owns it.
+ *
+ *   the org row            GET    /v1/iam/organizations/admin/<org>
+ *   delete the org         DELETE /v1/iam/organizations/admin/<org>
+ *   found a team org       POST   /v1/iam/organizations {owner: admin, name, displayName}
+ *   business address       GET|PUT /v1/settings/organization (cloud's per-org config)
+ *   your keys              GET|POST|DELETE /v1/account/keys (minted by IAM on you, shown once)
+ *   the org's keys         GET    /v1/iam/keys?owner=<org>, DELETE /v1/iam/keys/<org>/<name>
+ *   payment methods        GET    /v1/billing/methods
+ *   invoices               GET    /v1/billing/invoices
+ *
+ * The name, the logo, the members and the invitations are lib/hanzo/team.ts's,
+ * and the plan and balance are lib/hanzo/tier.ts's. Nothing here decides who may
+ * do what: every request carries the reader's bearer and organization (`scope`),
+ * the server answers, and a refusal comes back as the server's own sentence.
+ */
+import { scope } from './session.js';
+import { api } from './api.js';
+import { list } from './list.js';
+/** A refusal, with the status it came under and the server's words. */
+export class Refusal extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+/** IAM's code for "not yours to do", said as a sentence. */
+const UNAUTHORIZED = /^auth:Unauthorized operation$|^forbidden$/i;
+const NOT_YOURS = 'Your role in this organization does not allow this.';
+/** One request as the signed-in reader, in the organization this browser works in. */
+async function ask(path, init = {}) {
+    const res = await fetch(`${api()}${path}`, {
+        method: init.method ?? 'GET',
+        headers: {
+            ...scope(),
+            ...(init.json === undefined ? null : { 'Content-Type': 'application/json' }),
+        },
+        body: init.json === undefined ? undefined : JSON.stringify(init.json),
+    });
+    let body = null;
+    try {
+        body = await res.json();
+    }
+    catch {
+        // An empty or HTML body carries nothing worth showing.
+    }
+    const said = (body ?? {});
+    if (res.status === 401)
+        throw new Refusal(401, 'Your session expired. Sign in again.');
+    if (!res.ok || said.status === 'error') {
+        const words = said.detail || said.msg || said.error || said.message || '';
+        const status = res.ok ? 400 : res.status;
+        throw new Refusal(status, UNAUTHORIZED.test(words) || (status === 403 && !words) ? NOT_YOURS : words || `The server answered ${res.status}.`);
+    }
+    return body;
+}
+const enc = encodeURIComponent;
+/** The words of any failure, for a toast or a line under a control. */
+export const say = (e) => (e instanceof Error && e.message ? e.message : 'That did not go through.');
+export const readOrg = (org) => ask(`/v1/iam/organizations/admin/${enc(org)}`);
+/** Deletes the org row. IAM decides who may; there is no undo. */
+export const deleteOrg = (org) => ask(`/v1/iam/organizations/admin/${enc(org)}`, { method: 'DELETE' });
+/**
+ * Creates an organization the reader owns: cloud's `POST /v1/account/orgs
+ * {name}`, the one create every surface uses. Cloud files the row in IAM and
+ * records the verified creator as its owner through IAM's membership API.
+ * Answers the new organization's handle; a refusal is what the reader is shown.
+ */
+export const createOrg = async (name) => {
+    const made = await ask('/v1/account/orgs', { method: 'POST', json: { name } });
+    if (!made?.org)
+        throw new Refusal(502, 'The organization was not created. Try again.');
+    return made.org;
+};
+/** The handle an org is addressed by, from the name a person typed. */
+export function slug(name) {
+    return name
+        .normalize('NFKD')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 39)
+        .replace(/-+$/, '');
+}
+export const EMPTY_ADDRESS = { line1: '', line2: '', city: '', state: '', postalCode: '', country: '' };
+/** Where cloud keeps an org's own settings: one document per (org, product). */
+const PROFILE = '/v1/settings/organization';
+const text = (v) => (typeof v === 'string' ? v : '');
+function addressOf(config) {
+    const a = (config?.address ?? {});
+    return {
+        line1: text(a.line1),
+        line2: text(a.line2),
+        city: text(a.city),
+        state: text(a.state),
+        postalCode: text(a.postalCode),
+        country: text(a.country),
+    };
+}
+export async function readAddress() {
+    return addressOf((await ask(PROFILE)).config);
+}
+/**
+ * Stores the address and answers what was stored. The document is written
+ * whole, so the rest of it is read first and carried: a save of the address
+ * never drops a field somebody else kept beside it.
+ */
+export async function saveAddress(next) {
+    const held = (await ask(PROFILE)).config ?? {};
+    const stored = await ask(PROFILE, { method: 'PUT', json: { config: { ...held, address: next } } });
+    return addressOf(stored.config);
+}
+export async function ownKeys() {
+    return list((await ask('/v1/account/keys')).keys);
+}
+/** Mints the reader's key of `type`, replacing the one they held, and answers it — once. */
+export async function mintKey(type) {
+    const made = await ask('/v1/account/keys', { method: 'POST', json: { type } });
+    if (!made?.key)
+        throw new Refusal(502, 'IAM answered without a key.');
+    return made.key;
+}
+export const revokeOwnKey = (type) => ask(`/v1/account/keys?type=${type}`, { method: 'DELETE' });
+export async function orgKeys(org) {
+    return list((await ask(`/v1/iam/keys?owner=${enc(org)}`)).keys);
+}
+export const revokeKey = (k) => ask(`/v1/iam/keys/${enc(k.owner)}/${enc(k.name)}`, { method: 'DELETE' });
+export async function methods() {
+    const got = await ask('/v1/billing/methods');
+    return list(Array.isArray(got) ? got : got?.data);
+}
+export async function invoices() {
+    return list((await ask('/v1/billing/invoices')).invoices);
+}
+/** Whole cents as money: `$1,234.56`. */
+export function cents(n, currency = 'usd') {
+    return new Intl.NumberFormat('en-US', { style: 'currency', currency: currency.toUpperCase() }).format(n / 100);
+}

package/dist/lib/path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Where a model's page lives. No imports, so a build script can ask too.
+ */
+export declare function getOrgAndSlug(modelId: string): {
+    org: string;
+    slug: string;
+};
+export declare function canonicalOrg(org?: string): string;
+export declare function modelPagePath(modelId: string): string;

package/dist/lib/path.js

@@ -0,0 +1,29 @@
+/**
+ * Where a model's page lives. No imports, so a build script can ask too.
+ */
+export function getOrgAndSlug(modelId) {
+    if (modelId.includes('/')) {
+        const [org, ...rest] = modelId.split('/');
+        return { org, slug: rest.join('/') };
+    }
+    return { org: 'hanzo', slug: modelId };
+}
+// Some labs reach the gateway under two namespaces — `meta-llama` and `meta`,
+// `bytedance-seed` and `bytedance` — and a leading `~` marks a latest-alias
+// namespace of a lab already present. Fold them onto one canonical org so the
+// catalogue heads one group per lab and that lab's page serves the union.
+// Mirrors ProviderMark's OF map, which folds the same aliases for the mark.
+const ORG_ALIASES = {
+    'meta-llama': 'meta',
+    'bytedance-seed': 'bytedance',
+};
+export function canonicalOrg(org) {
+    if (!org)
+        return 'hanzo';
+    const base = org.replace(/^~/, '');
+    return ORG_ALIASES[base] ?? base;
+}
+export function modelPagePath(modelId) {
+    const { org, slug } = getOrgAndSlug(modelId);
+    return `/models/${canonicalOrg(org)}/${slug}`;
+}

package/dist/lib/plans.d.ts

@@ -0,0 +1,193 @@
+/**
+ * The subscription catalog, in one place, for every pricing surface.
+ *
+ * THERE ARE TWO CATALOGS AND THEY ARE DIFFERENT PRODUCTS. Confusing them is
+ * what this module exists to prevent:
+ *
+ *   GET /v1/billing/plans   THIS ONE. commerce's subscription authority — the
+ *                           same rows that charge. 17 plans across categories
+ *                           personal/team/enterprise/world/social/dns, each
+ *                           with `features`. Bare ARRAY, `slug`, `price` in
+ *                           CENTS.
+ *   GET /v1/plans           Cloud VM tiers — vcpus, memoryGB, diskGB. 11 rows,
+ *                           NO `features` on any of them. Shaped `{plans:[…]}`.
+ *
+ * They collide on the words "pro" and "enterprise" and on nothing else: `pro`
+ * the subscription is $20/mo, `pro` the VM tier is $25/mo for 2 vCPU. Reading
+ * the VM catalog to render subscriptions is not a wrong number, it is a wrong
+ * product — and it crashed this page. The team/enterprise view filtered /v1/plans
+ * for `category === "enterprise"`, matched the $429 VM row, replaced the real
+ * Team/Enterprise cards with it, and handed a card `features: undefined`. The
+ * `.map()` over it took the whole pricing page down to "Something went wrong."
+ * for anyone who clicked the tab.
+ *
+ * So the catalog is named once, mapped once, and guarded once, here.
+ *
+ * A SuperAdmin edits these rows at admin.hanzo.ai (/v1/commerce/plans/entries),
+ * and every reader here follows: the build bakes the authority's answer into the
+ * pricing snapshot for the first paint, and the page replaces it with the live
+ * read. No price in this repo is typed; @hanzo/plans is read only for what the
+ * wire does not carry — a plan's name for a slug, and the Free row's models.
+ */
+/** A row exactly as GET /v1/billing/plans returns it. */
+export interface BillingPlan {
+    slug: string;
+    name: string;
+    description: string;
+    price: number | null;
+    priceAnnual?: number | null;
+    annualTotal?: number | null;
+    category: string;
+    features?: string[];
+    limits?: Record<string, number | null>;
+    popular?: boolean;
+    contactSales?: boolean;
+    perSeat?: boolean;
+    checkoutUrl?: string;
+    checkoutId?: string;
+}
+/** A plan as the pricing cards render it: dollars, and features always present. */
+export interface SubscriptionPlan {
+    id: string;
+    name: string;
+    description: string;
+    priceMonthly: number | null;
+    /** A year shown per month: what each month costs when a year is bought. */
+    priceAnnual?: number | null;
+    /** What a year charges, once, where the catalog sells a year: `annualTotal`. */
+    annualTotal?: number | null;
+    category: string;
+    popular?: boolean;
+    contactSales?: boolean;
+    pricePerUser?: boolean;
+    features: string[];
+    limits?: Record<string, number | null>;
+    payouts?: {
+        idleResalePercent: number;
+        description: string;
+    };
+    checkoutUrl?: string;
+    checkoutId?: string;
+}
+/**
+ * The checkout address, opened on a plan when one is named, and returning to
+ * `back` once the buyer has paid. Without `back` a paid buyer lands on the pay
+ * site's receipt with no way into what they bought.
+ *
+ * ONE writer for this address. It was spelled out in three places — the
+ * personal ladder, the business strip and the /account hand-off — and a plan id
+ * only selects the card a reader clicked if every writer spells the query the
+ * same way.
+ */
+export declare function checkoutUrl(id?: string, back?: string): string;
+/**
+ * A page on the pay site, for the organization this browser works in.
+ *
+ * pay charges and reads the ledger it is named, and it can only offer the ones
+ * the token lists; which of them this workspace is in is a fact only this site
+ * holds. `?org=` carries it across, and pay honours it only while the token
+ * offers it. Call it at the moment of leaving: the organization lives in this
+ * browser and moves with the switcher.
+ */
+export declare function payPage(path?: string): string;
+/**
+ * The checkout a plan's CTA opens.
+ *
+ * A catalog row may carry its own link, and then that link wins; otherwise the
+ * id is the whole address. The id is also what `plan_clicked` reports, so the
+ * plan the event names and the plan the checkout opens cannot disagree.
+ */
+export declare function planCheckoutUrl(plan: SubscriptionPlan, back?: string): string;
+/** A subscription term. A month is what every catalog row charges by default. */
+export type Interval = "month" | "year";
+/**
+ * A checkout address for a term: a year adds `interval=year`, a month leaves the
+ * address as it is. pay reads the parameter; until it sells a year, its cart
+ * states the monthly charge, and the buyer reads that before paying. A relative
+ * address is read against the pay site, where every checkout is.
+ */
+export declare function term(href: string, interval: Interval): string;
+/**
+ * The cart for `seats` of a per-seat plan, for a term, charged to `org` and
+ * returning to `back` once paid. `quantity` is the seat count checkout sells.
+ */
+export declare function cartUrl(plan: string, seats: number, interval: Interval, org: string, back: string): string;
+/** The plans in one category, live — or null when commerce did not answer. */
+export declare function loadPlans(category: string): Promise<SubscriptionPlan[] | null>;
+/** The plans in one category as the build last read them. */
+export declare function fallbackPlans(category: string): SubscriptionPlan[];
+/**
+ * Every row the authority serves, in catalog order: painted from the snapshot,
+ * replaced by the live read. This is how an edit made at admin.hanzo.ai reaches
+ * a reader with no build in between.
+ */
+export declare function useCatalog(): SubscriptionPlan[];
+/** The row an organization runs on, priced. */
+export interface OrgPlan {
+    plan: SubscriptionPlan | null;
+    /** The monthly price as money. An em dash until a row resolves — never a guess. */
+    price: string;
+}
+/**
+ * Which plan an organization runs on, and what it costs. A plan is a
+ * subscription with usage limits; it mints no credit, so nothing here says it does.
+ *
+ * ONE ANSWER FOR TWO SURFACES. /pricing states the offer and the workspace gate
+ * asks a member to buy it; those were two readings of one row, each with its own
+ * copy of "the first personal row that charges" and its own money formatter. A
+ * marketing page and a subscribe screen quoting different numbers for the same
+ * plan is the failure that costs a sale, and it needs only for one of the two
+ * copies to be edited.
+ *
+ * It is the FIRST ROW THAT CHARGES in a category: `personal` is the plan a
+ * personal organization runs on, `team` the per-seat plan a team organization
+ * runs on, whatever commerce currently prices each at. Neither surface holds the
+ * figure, so neither can be wrong on its own.
+ *
+ * Painted from the snapshot and replaced by the live catalog, which is the
+ * contract every reader in this module keeps.
+ */
+export declare function usePlan(category?: string): OrgPlan;
+/**
+ * A category's rows a reader can buy on their own, in catalog order: the
+ * personal ladder from Free up, or the Team plan. Rows sold through a
+ * conversation are left out. Painted from the snapshot, replaced by the catalog.
+ */
+export declare function usePlans(category: string): SubscriptionPlan[];
+/** A row priced the way every surface writes it. */
+export declare function priced(plan: SubscriptionPlan | null): OrgPlan;
+/** Money as a sentence says it: whole dollars bare, anything else to the cent — $20, $16.67. */
+export declare const money: (n: number) => string;
+/**
+ * What one term of a plan charges, in dollars, or null where the catalog sells
+ * no such term. A month is `priceMonthly`. A year is the total the catalog
+ * states, or twelve of `priceAnnual` where it states only the monthly figure.
+ */
+export declare function charge(plan: SubscriptionPlan, interval: Interval): number | null;
+/**
+ * A term's price as a button quotes it — "$20/month", "$200/year" — or null.
+ * A year is quoted as the total where the catalog states one, and otherwise as
+ * the monthly figure the catalog does state, never as a total derived here.
+ */
+export declare function quote(plan: SubscriptionPlan, interval: Interval): string | null;
+/** What a year saves against twelve months, as a whole percent: 1 − year ÷ (12 × month). Null where it saves nothing. */
+export declare function saving(plan: SubscriptionPlan): number | null;
+/** Whether the Free plan runs a model: one its row names, or any `:free` route. */
+export declare function onFree(model: string): boolean;
+/**
+ * The catalog's own name for a plan slug — "max-20x" reads as "Max 20x" —
+ * or null where the slug is empty or the catalog does not carry it.
+ *
+ * Read off the published package: a plan's name does not move between a build and the next release the way
+ * its price can, so the bundled copy is not a stale answer here the way it
+ * would be for money. A reader of `GET /v1/billing/tier`'s `plan` field
+ * needs a name and nothing else, so no live fetch is spent proving what the
+ * package already states.
+ */
+export declare function planName(slug: string | null | undefined): string | null;
+/**
+ * A usage rate as money. A sub-dollar rate needs at least two decimals to read as
+ * a price at all — 0.1 is $0.10, not $0.1 — while keeping the precision the
+ * catalog states, so $0.015/1K vectors does not round away to a cent.
+ */
+export declare function formatUsageRate(v: number): string;