@pipeline-builder/api-core 5.2.3 → 5.2.4

package/lib/types/quota-catalog.d.ts

@@ -0,0 +1,247 @@
+/**
+ * The quota-type display catalog, as DATA ONLY — what a quota is CALLED and how
+ * its number is RENDERED, for every `QuotaType`.
+ *
+ * Dependency-free and env-free so the browser imports it directly
+ * (`@pipeline-builder/api-core/quota-catalog`). Its only import is a type, which
+ * is erased at compile time, so nothing of the server graph reaches the bundle.
+ *
+ * WHY IT EXISTS. The same facts were spelled in six places: this package's
+ * `QUOTA_TYPE_LABELS`, and five independent maps in the frontend — the pressure
+ * banner's labels, the quotas page's `QUOTA_META`, the org home's `QUOTA_LABELS`,
+ * the billing usage card's `QUOTA_LABELS` (with its own byte flag), and the
+ * add-on grid's `PACK_UNITS`. Each knew a subset, each could drift, and adding a
+ * quota type meant finding all six. `PACK_UNITS` had exactly one member, so the
+ * add-on grid rendered a GB step for storage and a bare pack count for
+ * everything else — not a decision anyone revisited, just the one entry somebody
+ * needed at the time.
+ *
+ * Add a quota type here and every surface renders it: `Record<QuotaType, …>`
+ * makes the compiler demand the entry, so none of the six can be forgotten
+ * again.
+ *
+ * EVERY display fact lives here, including the plural label. A first draft kept
+ * plurals in a frontend helper with a `Record<string, string>` and a fallback to
+ * the singular — which would have rendered a new quota type's plural wrongly and
+ * silently, reproducing the exact partial-map trap this file removes. A fact
+ * split across two packages is a fact that drifts.
+ */
+import type { QuotaType } from './common.js';
+/** How a quota's usage is learned: incremented as it happens, or read on demand. */
+export type QuotaObservation = 
+/** The platform increments a counter as the work happens. */
+'metered'
+/** Nothing increments: the figure is read from the system of record. */
+ | 'measured';
+/** Whether a quota refills on the period or persists until something changes. */
+export type QuotaAccrual = 
+/** A per-period rate: reserved on use, zeroed at the period boundary. */
+'flow'
+/** A level that stays until the tenant frees it. No reset, no forecast. */
+ | 'stock';
+/** How a raw quota number should be rendered. */
+export type QuotaRender = 
+/** A plain integer — "4 / 10". */
+'count'
+/** A byte count — render with `formatBytes` ("18.4 GB"), never raw. */
+ | 'bytes';
+/** What a surface needs to know to show one quota type. */
+export interface QuotaTypeMeta {
+    /**
+     * SINGULAR human label — the one spelling every 429 body, notification and
+     * dashboard uses ("API call quota reached …").
+     */
+    label: string;
+    /**
+     * PLURAL label, for surfaces that list dimensions rather than address one
+     * ("API calls" on a usage card, against "API call quota reached" in a 429).
+     *
+     * REQUIRED, and here rather than in the frontend, because the first draft put
+     * it in a `Record<string, string>` helper that fell back to the singular when
+     * a type was missing — so a new quota type would have rendered "Build minute"
+     * in plural contexts, wrongly and silently. That is the same partial-map trap
+     * this catalog exists to remove, and `Record<QuotaType, …>` closes it only if
+     * every display fact lives here.
+     */
+    labelPlural: string;
+    /** How to render a raw value for this type. */
+    render: QuotaRender;
+    /**
+     * Whether this quota REFILLS on the period, or persists until the tenant
+     * changes something.
+     *
+     * This is the single most load-bearing semantic difference between quota
+     * types and nothing could read it before: a surface had to know, by hand,
+     * that "resets in 2 days" is true of `apiCalls` and false of `storageBytes`.
+     * Getting it wrong is not cosmetic — the quotas page told an organization its
+     * registry storage would reset, which is the opposite of the one thing it
+     * needs to understand about storage.
+     *
+     * - `flow` — a per-period rate, reserved on create/build and zeroed at the
+     *   boundary. Hitting it is temporary and the account self-heals. The period is
+     *   PER TYPE rather than global: `QUOTA_RESET_DAYS` (3 days) for every flow but
+     *   `cpuCredits`, which is monthly. Read it through `quotaPeriodDays` and never
+     *   assume the global — a forecast or a "resets in N days" line computed
+     *   against the wrong window is wrong by a factor of ten for credits.
+     * - `stock` — a level, not a rate. It stays where it is until bytes are freed
+     *   or rows are deleted, so a reset date, a "resets in N days" line and a
+     *   burn-rate forecast are all meaningless for it. `storageBytes` is measured;
+     *   the resource-count caps are counted at create time and decremented on
+     *   delete; `listings` counts active publications.
+     *
+     * The {@link QuotaTypeMeta.description} wording follows from this ("this
+     * period" against "currently"), and a test holds the two in agreement.
+     */
+    accrual: QuotaAccrual;
+    /**
+     * How usage is OBSERVED — which is a different question from whether the
+     * quota refills, and the two do not line up.
+     *
+     * - `metered` — the platform INCREMENTS a counter as the work happens. Every
+     *   quota but one, including the create-time counts that are stocks
+     *   (`dashboards`, `listings`, …).
+     * - `measured` — nothing increments anything; the figure is READ from the
+     *   system of record on demand. `storageBytes` only: the registry walks its
+     *   own catalog, which is why it is "the one quota nothing increments".
+     *
+     * It decides which code path may legitimately notify about a quota. A storage
+     * notice arriving from the increment path could only be a bug, and a
+     * `listings` notice arriving from a sweep likewise — conflating this with
+     * {@link accrual} would have silenced every create-time count quota, because
+     * those are stocks that are nonetheless metered.
+     */
+    observed: QuotaObservation;
+    /**
+     * What this counter actually counts, in one short phrase — the answer to "am I
+     * spending this one?".
+     *
+     * REQUIRED, and a display FACT rather than page copy, which is the call a
+     * first pass got wrong by judging the field's name instead of its content. It
+     * had been left in a frontend `Record<DisplayedQuotaType, string>` on the
+     * reasoning that descriptions are a page's own voice. They are not: each of
+     * these answers a question whose answer is the same on every surface, and two
+     * surfaces disagreeing is a bug, not a difference in tone. Two of the five
+     * local copies had already drifted — `automationCalls` omitted personal
+     * access keys (so a PAT holder read the page and concluded they were spending
+     * `apiCalls`), and `plugins`/`pipelines` were phrased as stocks.
+     *
+     * The test is whether `docs/quotas.md` and this string can legitimately
+     * differ. For these, no. For a tier's positioning line ("Starter tier") or the
+     * quotas page's pooling explanation, yes — those stay in the page, exactly as
+     * `TIER_META` already splits a tier's label from its sales copy.
+     *
+     * Phrasing follows the SEMANTICS in {@link QuotaType}'s own documentation, not
+     * a house style: "this period" for the per-period flows, "currently" for the
+     * create-time counts that decrement on delete, and neither for the measured
+     * storage total.
+     */
+    description: string;
+    /**
+     * The unit an ADD-ON PACK of this quota is typed in, and the divisor from the
+     * raw grant to that unit — so a +10 GB storage pack offers a GB step rather
+     * than a pack count.
+     *
+     * Absent means "type pack counts", which is right where the quota has no
+     * natural unit: "1 pack of API calls" reads better than "25000 calls". The
+     * step itself is always derived from the bundle's own `grants`, never from a
+     * constant here, because a grant is env-overridable.
+     */
+    packUnit?: {
+        name: string;
+        per: number;
+    };
+}
+/**
+ * Display metadata for every quota type. Labels are the canonical ones — the
+ * strings here are user-facing and are relied on by 429 bodies and notices, so
+ * they change only deliberately.
+ */
+export declare const QUOTA_CATALOG: Readonly<Record<QuotaType, QuotaTypeMeta>>;
+/**
+ * Consumables that are NOT quota types but render beside them — same label,
+ * same bar, same card.
+ *
+ * `seats` is the only one: it is a STOCK (how many people may be on the
+ * account) rather than a per-period flow, so it is deliberately outside
+ * `QuotaType` and is sourced separately from the quota rollup. But the billing
+ * usage card draws it in the same list, and before this entry existed that one
+ * row carried its own inline "Seats" label while the five beside it came from
+ * the catalog — the precise split-fact drift this file exists to remove.
+ *
+ * Keep this for things rendered AS a consumable. It is not a back door for
+ * quota types: a real quota belongs in {@link QUOTA_CATALOG}, where
+ * `Record<QuotaType, …>` forces the entry.
+ */
+export declare const NON_QUOTA_CONSUMABLE_CATALOG: Readonly<Record<string, QuotaTypeMeta>>;
+/**
+ * This type's singular label, or the raw key for a value outside the catalog.
+ *
+ * The accessors take `string` because the quota type often arrives from the wire
+ * (a 429 body, a quota response) where an unknown value must render as something
+ * rather than crash a page. The `QuotaType` overload is for internal callers: it
+ * makes a typo a compile error instead of a key rendered as a label.
+ */
+export declare function quotaLabel(type: QuotaType): string;
+export declare function quotaLabel(type: string): string;
+/** This type's PLURAL label, or the raw key for a value outside the catalog. */
+export declare function quotaLabelPlural(type: QuotaType): string;
+export declare function quotaLabelPlural(type: string): string;
+/**
+ * How to render this type's values. `count` for anything the catalog does not
+ * know, so an unfamiliar wire value renders as a plain number.
+ *
+ * Read THIS rather than asking "is it bytes?". A boolean helper degrades
+ * silently the moment {@link QuotaRender} grows a third member — a new mode
+ * would simply render as a count, with nothing failing — whereas a caller that
+ * switches on this value exhaustively stops compiling until it handles the new
+ * mode. That is the whole point of the catalog, applied to its own accessors.
+ */
+export declare function quotaRender(type: QuotaType): QuotaRender;
+export declare function quotaRender(type: string): QuotaRender;
+/**
+ * A byte count as a human amount — `1.5 GB`, `512 MB`, `0 B`.
+ *
+ * The ONE implementation: the frontend's `formatBytes` delegates here rather
+ * than keeping its own copy, so a storage figure reads identically in a quota
+ * notice, a 403 explanation and the dashboard. Binary units (1024), one decimal
+ * below 10 and rounded above, which is what the dashboard already rendered —
+ * this moved the algorithm, it did not change it.
+ */
+export declare function formatByteAmount(bytes: number): string;
+/**
+ * A raw quota value as the amount a HUMAN should read, per this type's
+ * {@link QuotaRender} — bytes as `25 GB`, counts grouped as `60,000`.
+ *
+ * For server-side copy (quota notices, audit reasons, 403 explanations), which
+ * is why it is here rather than in the frontend: a storage notice that
+ * interpolated the raw number would read "used all 26843545600 of its registry
+ * storage". The frontend has its own thin wrapper because it renders an
+ * unlimited (-1) limit as `∞`, which is a display choice no server copy makes
+ * (unlimited orgs are skipped before any copy is generated).
+ */
+export declare function formatQuotaAmount(type: string, value: number): string;
+/**
+ * How this quota's usage is observed: `metered` (incremented) or `measured`
+ * (read on demand). Unknown wire values read as `metered`, matching every
+ * quota but storage.
+ */
+export declare function quotaObservation(type: QuotaType): QuotaObservation;
+export declare function quotaObservation(type: string): QuotaObservation;
+/**
+ * Whether this quota refills on the period (`flow`) or persists (`stock`).
+ * Unknown wire values are treated as `flow`, matching every metered quota.
+ */
+export declare function quotaAccrual(type: QuotaType): QuotaAccrual;
+export declare function quotaAccrual(type: string): QuotaAccrual;
+/** What this type counts, or the empty string for a value outside the catalog. */
+export declare function quotaDescription(type: QuotaType): string;
+export declare function quotaDescription(type: string): string;
+/** The pack unit for this type, or `null` to type pack counts instead. */
+export declare function quotaPackUnit(type: QuotaType): {
+    name: string;
+    per: number;
+} | null;
+export declare function quotaPackUnit(type: string): {
+    name: string;
+    per: number;
+} | null;

package/lib/types/quota-catalog.js

@@ -0,0 +1,122 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+const GB = 1024 ** 3;
+/**
+ * Display metadata for every quota type. Labels are the canonical ones — the
+ * strings here are user-facing and are relied on by 429 bodies and notices, so
+ * they change only deliberately.
+ */
+export const QUOTA_CATALOG = {
+    // Per-period FLOWS — a creation rate, not a stock. Deleting the entity does
+    // not give the slot back (`decrement-on-delete` was considered and rejected),
+    // so the wording says "this period" to stop the stock reading.
+    plugins: { label: 'Plugin build', labelPlural: 'Plugins', render: 'count', accrual: 'flow', observed: 'metered', description: 'Plugin versions deployed this period' },
+    pipelines: { label: 'Pipeline creation', labelPlural: 'Pipelines', render: 'count', accrual: 'flow', observed: 'metered', description: 'Pipelines created this period' },
+    // The call budgets. WHICH ONE a request spends is decided by
+    // `meteredQuotaTypeFor`, never by the route: a service-account key, a PERSONAL
+    // ACCESS key (`token_use: 'api_key'`) or anything minted while holding one
+    // (`parentKeyId`) spends `automationCalls` INSTEAD of `apiCalls`.
+    apiCalls: { label: 'API call', labelPlural: 'API calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'Requests made by people in browser sessions this period' },
+    automationCalls: { label: 'Automation call', labelPlural: 'Automation calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'Requests made with service-account or personal access keys this period' },
+    aiCalls: { label: 'AI call', labelPlural: 'AI calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'AI generation invocations this period' },
+    // The one flow quota on a period of its OWN — a MONTH, where every other flow
+    // rolls on QUOTA_RESET_DAYS (3 days). Rendered as a COUNT and never as a
+    // duration: the unit is an abstract credit precisely so it cannot be misread as
+    // wall-clock ("11,250 build minutes" reads as 187 hours when it buys 125), and
+    // formatting it back into "187h 30m" would undo that. The wall-clock conversion
+    // belongs in the pre-build cost hint, where it explains rather than misleads.
+    cpuCredits: { label: 'CPU credit', labelPlural: 'CPU credits', render: 'count', accrual: 'flow', observed: 'metered', description: 'vCPU-minutes of build compute used this month', packUnit: { name: 'credits', per: 1 } },
+    // A MEASURED total, recomputed on demand rather than counted — the one quota
+    // that is neither a period flow nor a create-time count.
+    storageBytes: { label: 'Registry storage', labelPlural: 'Registry storage', render: 'bytes', accrual: 'stock', observed: 'measured', description: 'Registry storage currently in use', packUnit: { name: 'GB', per: GB } },
+    // Resource-count caps: counted at create time and DECREMENTED on delete, so
+    // these really are stocks and "this period" would be wrong.
+    dashboards: { label: 'Dashboard', labelPlural: 'Dashboards', render: 'count', accrual: 'stock', observed: 'metered', description: 'Dashboards currently defined' },
+    alertRules: { label: 'Alert rule', labelPlural: 'Alert rules', render: 'count', accrual: 'stock', observed: 'metered', description: 'Alert rules currently defined' },
+    alertDestinations: { label: 'Alert destination', labelPlural: 'Alert destinations', render: 'count', accrual: 'stock', observed: 'metered', description: 'Alert destinations currently defined' },
+    idpConfigs: { label: 'IdP configuration', labelPlural: 'IdP configurations', render: 'count', accrual: 'stock', observed: 'metered', description: 'Identity-provider configurations currently defined' },
+    listings: { label: 'Plugin listing', labelPlural: 'Plugin listings', render: 'count', accrual: 'stock', observed: 'metered', description: 'Active plugin listings you publish' },
+};
+/**
+ * Consumables that are NOT quota types but render beside them — same label,
+ * same bar, same card.
+ *
+ * `seats` is the only one: it is a STOCK (how many people may be on the
+ * account) rather than a per-period flow, so it is deliberately outside
+ * `QuotaType` and is sourced separately from the quota rollup. But the billing
+ * usage card draws it in the same list, and before this entry existed that one
+ * row carried its own inline "Seats" label while the five beside it came from
+ * the catalog — the precise split-fact drift this file exists to remove.
+ *
+ * Keep this for things rendered AS a consumable. It is not a back door for
+ * quota types: a real quota belongs in {@link QUOTA_CATALOG}, where
+ * `Record<QuotaType, …>` forces the entry.
+ */
+export const NON_QUOTA_CONSUMABLE_CATALOG = {
+    seats: { label: 'Seat', labelPlural: 'Seats', render: 'count', accrual: 'stock', observed: 'measured', description: 'Members this account may have' },
+};
+/**
+ * Every described consumable, widened for lookups by a value that came off the
+ * wire.
+ */
+const byKey = {
+    ...NON_QUOTA_CONSUMABLE_CATALOG,
+    ...QUOTA_CATALOG,
+};
+export function quotaLabel(type) {
+    return byKey[type]?.label ?? type;
+}
+export function quotaLabelPlural(type) {
+    return byKey[type]?.labelPlural ?? type;
+}
+export function quotaRender(type) {
+    return byKey[type]?.render ?? 'count';
+}
+const BYTE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+/**
+ * A byte count as a human amount — `1.5 GB`, `512 MB`, `0 B`.
+ *
+ * The ONE implementation: the frontend's `formatBytes` delegates here rather
+ * than keeping its own copy, so a storage figure reads identically in a quota
+ * notice, a 403 explanation and the dashboard. Binary units (1024), one decimal
+ * below 10 and rounded above, which is what the dashboard already rendered —
+ * this moved the algorithm, it did not change it.
+ */
+export function formatByteAmount(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return '0 B';
+    let value = bytes;
+    let i = 0;
+    while (value >= 1024 && i < BYTE_UNITS.length - 1) {
+        value /= 1024;
+        i++;
+    }
+    return value < 10 ? `${value.toFixed(1)} ${BYTE_UNITS[i]}` : `${Math.round(value)} ${BYTE_UNITS[i]}`;
+}
+/**
+ * A raw quota value as the amount a HUMAN should read, per this type's
+ * {@link QuotaRender} — bytes as `25 GB`, counts grouped as `60,000`.
+ *
+ * For server-side copy (quota notices, audit reasons, 403 explanations), which
+ * is why it is here rather than in the frontend: a storage notice that
+ * interpolated the raw number would read "used all 26843545600 of its registry
+ * storage". The frontend has its own thin wrapper because it renders an
+ * unlimited (-1) limit as `∞`, which is a display choice no server copy makes
+ * (unlimited orgs are skipped before any copy is generated).
+ */
+export function formatQuotaAmount(type, value) {
+    return quotaRender(type) === 'bytes' ? formatByteAmount(value) : value.toLocaleString('en-US');
+}
+export function quotaObservation(type) {
+    return byKey[type]?.observed ?? 'metered';
+}
+export function quotaAccrual(type) {
+    return byKey[type]?.accrual ?? 'flow';
+}
+export function quotaDescription(type) {
+    return byKey[type]?.description ?? '';
+}
+export function quotaPackUnit(type) {
+    return byKey[type]?.packUnit ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"quota-catalog.js","sourceRoot":"","sources":["../../src/types/quota-catalog.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA8JtC,MAAM,EAAE,GAAG,IAAI,IAAI,CAAC,CAAC;AAErB;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAA+C;IACvE,4EAA4E;IAC5E,8EAA8E;IAC9E,+DAA+D;IAC/D,OAAO,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,sCAAsC,EAAE;IACtK,SAAS,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,+BAA+B,EAAE;IACxK,6DAA6D;IAC7D,+EAA+E;IAC/E,2EAA2E;IAC3E,kEAAkE;IAClE,QAAQ,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,yDAAyD,EAAE;IACxL,eAAe,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,wEAAwE,EAAE;IAC5N,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,uCAAuC,EAAE;IACnK,8EAA8E;IAC9E,yEAAyE;IACzE,gFAAgF;IAChF,+EAA+E;IAC/E,gFAAgF;IAChF,8EAA8E;IAC9E,UAAU,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,+CAA+C,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE;IAC3N,6EAA6E;IAC7E,yDAAyD;IACzD,YAAY,EAAE,EAAE,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,mCAAmC,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE;IAC1N,4EAA4E;IAC5E,4DAA4D;IAC5D,UAAU,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,8BAA8B,EAAE;IAClK,UAAU,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,+BAA+B,EAAE;IACrK,iBAAiB,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,sCAAsC,EAAE;IACjM,UAAU,EAAE,EAAE,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,oDAAoD,EAAE;IACxM,QAAQ,EAAE,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,WAAW,EAAE,oCAAoC,EAAE;CACjL,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAA4C;IACnF,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,+BAA+B,EAAE;CACtJ,CAAC;AAEF;;;GAGG;AACH,MAAM,KAAK,GAA8C;IACvD,GAAG,4BAA4B;IAC/B,GAAG,aAAa;CACjB,CAAC;AAYF,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;AACpC,CAAC;AAKD,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,IAAI,IAAI,CAAC;AAC1C,CAAC;AAcD,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,IAAI,OAAO,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAU,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACvD,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,KAAK,IAAI,IAAI,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClD,KAAK,IAAI,IAAI,CAAC;QACd,CAAC,EAAE,CAAC;IACN,CAAC;IACD,OAAO,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;AACvG,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,KAAa;IAC3D,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;AACjG,CAAC;AASD,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,IAAI,SAAS,CAAC;AAC5C,CAAC;AAQD,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,IAAI,MAAM,CAAC;AACxC,CAAC;AAKD,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,WAAW,IAAI,EAAE,CAAC;AACxC,CAAC;AAKD,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,QAAQ,IAAI,IAAI,CAAC;AACvC,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\n/**\n * The quota-type display catalog, as DATA ONLY — what a quota is CALLED and how\n * its number is RENDERED, for every `QuotaType`.\n *\n * Dependency-free and env-free so the browser imports it directly\n * (`@pipeline-builder/api-core/quota-catalog`). Its only import is a type, which\n * is erased at compile time, so nothing of the server graph reaches the bundle.\n *\n * WHY IT EXISTS. The same facts were spelled in six places: this package's\n * `QUOTA_TYPE_LABELS`, and five independent maps in the frontend — the pressure\n * banner's labels, the quotas page's `QUOTA_META`, the org home's `QUOTA_LABELS`,\n * the billing usage card's `QUOTA_LABELS` (with its own byte flag), and the\n * add-on grid's `PACK_UNITS`. Each knew a subset, each could drift, and adding a\n * quota type meant finding all six. `PACK_UNITS` had exactly one member, so the\n * add-on grid rendered a GB step for storage and a bare pack count for\n * everything else — not a decision anyone revisited, just the one entry somebody\n * needed at the time.\n *\n * Add a quota type here and every surface renders it: `Record<QuotaType, …>`\n * makes the compiler demand the entry, so none of the six can be forgotten\n * again.\n *\n * EVERY display fact lives here, including the plural label. A first draft kept\n * plurals in a frontend helper with a `Record<string, string>` and a fallback to\n * the singular — which would have rendered a new quota type's plural wrongly and\n * silently, reproducing the exact partial-map trap this file removes. A fact\n * split across two packages is a fact that drifts.\n */\n\nimport type { QuotaType } from './common.js';\n\n/** How a quota's usage is learned: incremented as it happens, or read on demand. */\nexport type QuotaObservation =\n  /** The platform increments a counter as the work happens. */\n  | 'metered'\n  /** Nothing increments: the figure is read from the system of record. */\n  | 'measured';\n\n/** Whether a quota refills on the period or persists until something changes. */\nexport type QuotaAccrual =\n  /** A per-period rate: reserved on use, zeroed at the period boundary. */\n  | 'flow'\n  /** A level that stays until the tenant frees it. No reset, no forecast. */\n  | 'stock';\n\n/** How a raw quota number should be rendered. */\nexport type QuotaRender =\n  /** A plain integer — \"4 / 10\". */\n  | 'count'\n  /** A byte count — render with `formatBytes` (\"18.4 GB\"), never raw. */\n  | 'bytes';\n\n/** What a surface needs to know to show one quota type. */\nexport interface QuotaTypeMeta {\n  /**\n   * SINGULAR human label — the one spelling every 429 body, notification and\n   * dashboard uses (\"API call quota reached …\").\n   */\n  label: string;\n  /**\n   * PLURAL label, for surfaces that list dimensions rather than address one\n   * (\"API calls\" on a usage card, against \"API call quota reached\" in a 429).\n   *\n   * REQUIRED, and here rather than in the frontend, because the first draft put\n   * it in a `Record<string, string>` helper that fell back to the singular when\n   * a type was missing — so a new quota type would have rendered \"Build minute\"\n   * in plural contexts, wrongly and silently. That is the same partial-map trap\n   * this catalog exists to remove, and `Record<QuotaType, …>` closes it only if\n   * every display fact lives here.\n   */\n  labelPlural: string;\n  /** How to render a raw value for this type. */\n  render: QuotaRender;\n  /**\n   * Whether this quota REFILLS on the period, or persists until the tenant\n   * changes something.\n   *\n   * This is the single most load-bearing semantic difference between quota\n   * types and nothing could read it before: a surface had to know, by hand,\n   * that \"resets in 2 days\" is true of `apiCalls` and false of `storageBytes`.\n   * Getting it wrong is not cosmetic — the quotas page told an organization its\n   * registry storage would reset, which is the opposite of the one thing it\n   * needs to understand about storage.\n   *\n   * - `flow` — a per-period rate, reserved on create/build and zeroed at the\n   *   boundary. Hitting it is temporary and the account self-heals. The period is\n   *   PER TYPE rather than global: `QUOTA_RESET_DAYS` (3 days) for every flow but\n   *   `cpuCredits`, which is monthly. Read it through `quotaPeriodDays` and never\n   *   assume the global — a forecast or a \"resets in N days\" line computed\n   *   against the wrong window is wrong by a factor of ten for credits.\n   * - `stock` — a level, not a rate. It stays where it is until bytes are freed\n   *   or rows are deleted, so a reset date, a \"resets in N days\" line and a\n   *   burn-rate forecast are all meaningless for it. `storageBytes` is measured;\n   *   the resource-count caps are counted at create time and decremented on\n   *   delete; `listings` counts active publications.\n   *\n   * The {@link QuotaTypeMeta.description} wording follows from this (\"this\n   * period\" against \"currently\"), and a test holds the two in agreement.\n   */\n  accrual: QuotaAccrual;\n  /**\n   * How usage is OBSERVED — which is a different question from whether the\n   * quota refills, and the two do not line up.\n   *\n   * - `metered` — the platform INCREMENTS a counter as the work happens. Every\n   *   quota but one, including the create-time counts that are stocks\n   *   (`dashboards`, `listings`, …).\n   * - `measured` — nothing increments anything; the figure is READ from the\n   *   system of record on demand. `storageBytes` only: the registry walks its\n   *   own catalog, which is why it is \"the one quota nothing increments\".\n   *\n   * It decides which code path may legitimately notify about a quota. A storage\n   * notice arriving from the increment path could only be a bug, and a\n   * `listings` notice arriving from a sweep likewise — conflating this with\n   * {@link accrual} would have silenced every create-time count quota, because\n   * those are stocks that are nonetheless metered.\n   */\n  observed: QuotaObservation;\n  /**\n   * What this counter actually counts, in one short phrase — the answer to \"am I\n   * spending this one?\".\n   *\n   * REQUIRED, and a display FACT rather than page copy, which is the call a\n   * first pass got wrong by judging the field's name instead of its content. It\n   * had been left in a frontend `Record<DisplayedQuotaType, string>` on the\n   * reasoning that descriptions are a page's own voice. They are not: each of\n   * these answers a question whose answer is the same on every surface, and two\n   * surfaces disagreeing is a bug, not a difference in tone. Two of the five\n   * local copies had already drifted — `automationCalls` omitted personal\n   * access keys (so a PAT holder read the page and concluded they were spending\n   * `apiCalls`), and `plugins`/`pipelines` were phrased as stocks.\n   *\n   * The test is whether `docs/quotas.md` and this string can legitimately\n   * differ. For these, no. For a tier's positioning line (\"Starter tier\") or the\n   * quotas page's pooling explanation, yes — those stay in the page, exactly as\n   * `TIER_META` already splits a tier's label from its sales copy.\n   *\n   * Phrasing follows the SEMANTICS in {@link QuotaType}'s own documentation, not\n   * a house style: \"this period\" for the per-period flows, \"currently\" for the\n   * create-time counts that decrement on delete, and neither for the measured\n   * storage total.\n   */\n  description: string;\n  /**\n   * The unit an ADD-ON PACK of this quota is typed in, and the divisor from the\n   * raw grant to that unit — so a +10 GB storage pack offers a GB step rather\n   * than a pack count.\n   *\n   * Absent means \"type pack counts\", which is right where the quota has no\n   * natural unit: \"1 pack of API calls\" reads better than \"25000 calls\". The\n   * step itself is always derived from the bundle's own `grants`, never from a\n   * constant here, because a grant is env-overridable.\n   */\n  packUnit?: { name: string; per: number };\n}\n\nconst GB = 1024 ** 3;\n\n/**\n * Display metadata for every quota type. Labels are the canonical ones — the\n * strings here are user-facing and are relied on by 429 bodies and notices, so\n * they change only deliberately.\n */\nexport const QUOTA_CATALOG: Readonly<Record<QuotaType, QuotaTypeMeta>> = {\n  // Per-period FLOWS — a creation rate, not a stock. Deleting the entity does\n  // not give the slot back (`decrement-on-delete` was considered and rejected),\n  // so the wording says \"this period\" to stop the stock reading.\n  plugins: { label: 'Plugin build', labelPlural: 'Plugins', render: 'count', accrual: 'flow', observed: 'metered', description: 'Plugin versions deployed this period' },\n  pipelines: { label: 'Pipeline creation', labelPlural: 'Pipelines', render: 'count', accrual: 'flow', observed: 'metered', description: 'Pipelines created this period' },\n  // The call budgets. WHICH ONE a request spends is decided by\n  // `meteredQuotaTypeFor`, never by the route: a service-account key, a PERSONAL\n  // ACCESS key (`token_use: 'api_key'`) or anything minted while holding one\n  // (`parentKeyId`) spends `automationCalls` INSTEAD of `apiCalls`.\n  apiCalls: { label: 'API call', labelPlural: 'API calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'Requests made by people in browser sessions this period' },\n  automationCalls: { label: 'Automation call', labelPlural: 'Automation calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'Requests made with service-account or personal access keys this period' },\n  aiCalls: { label: 'AI call', labelPlural: 'AI calls', render: 'count', accrual: 'flow', observed: 'metered', description: 'AI generation invocations this period' },\n  // The one flow quota on a period of its OWN — a MONTH, where every other flow\n  // rolls on QUOTA_RESET_DAYS (3 days). Rendered as a COUNT and never as a\n  // duration: the unit is an abstract credit precisely so it cannot be misread as\n  // wall-clock (\"11,250 build minutes\" reads as 187 hours when it buys 125), and\n  // formatting it back into \"187h 30m\" would undo that. The wall-clock conversion\n  // belongs in the pre-build cost hint, where it explains rather than misleads.\n  cpuCredits: { label: 'CPU credit', labelPlural: 'CPU credits', render: 'count', accrual: 'flow', observed: 'metered', description: 'vCPU-minutes of build compute used this month', packUnit: { name: 'credits', per: 1 } },\n  // A MEASURED total, recomputed on demand rather than counted — the one quota\n  // that is neither a period flow nor a create-time count.\n  storageBytes: { label: 'Registry storage', labelPlural: 'Registry storage', render: 'bytes', accrual: 'stock', observed: 'measured', description: 'Registry storage currently in use', packUnit: { name: 'GB', per: GB } },\n  // Resource-count caps: counted at create time and DECREMENTED on delete, so\n  // these really are stocks and \"this period\" would be wrong.\n  dashboards: { label: 'Dashboard', labelPlural: 'Dashboards', render: 'count', accrual: 'stock', observed: 'metered', description: 'Dashboards currently defined' },\n  alertRules: { label: 'Alert rule', labelPlural: 'Alert rules', render: 'count', accrual: 'stock', observed: 'metered', description: 'Alert rules currently defined' },\n  alertDestinations: { label: 'Alert destination', labelPlural: 'Alert destinations', render: 'count', accrual: 'stock', observed: 'metered', description: 'Alert destinations currently defined' },\n  idpConfigs: { label: 'IdP configuration', labelPlural: 'IdP configurations', render: 'count', accrual: 'stock', observed: 'metered', description: 'Identity-provider configurations currently defined' },\n  listings: { label: 'Plugin listing', labelPlural: 'Plugin listings', render: 'count', accrual: 'stock', observed: 'metered', description: 'Active plugin listings you publish' },\n};\n\n/**\n * Consumables that are NOT quota types but render beside them — same label,\n * same bar, same card.\n *\n * `seats` is the only one: it is a STOCK (how many people may be on the\n * account) rather than a per-period flow, so it is deliberately outside\n * `QuotaType` and is sourced separately from the quota rollup. But the billing\n * usage card draws it in the same list, and before this entry existed that one\n * row carried its own inline \"Seats\" label while the five beside it came from\n * the catalog — the precise split-fact drift this file exists to remove.\n *\n * Keep this for things rendered AS a consumable. It is not a back door for\n * quota types: a real quota belongs in {@link QUOTA_CATALOG}, where\n * `Record<QuotaType, …>` forces the entry.\n */\nexport const NON_QUOTA_CONSUMABLE_CATALOG: Readonly<Record<string, QuotaTypeMeta>> = {\n  seats: { label: 'Seat', labelPlural: 'Seats', render: 'count', accrual: 'stock', observed: 'measured', description: 'Members this account may have' },\n};\n\n/**\n * Every described consumable, widened for lookups by a value that came off the\n * wire.\n */\nconst byKey: Record<string, QuotaTypeMeta | undefined> = {\n  ...NON_QUOTA_CONSUMABLE_CATALOG,\n  ...QUOTA_CATALOG,\n};\n\n/**\n * This type's singular label, or the raw key for a value outside the catalog.\n *\n * The accessors take `string` because the quota type often arrives from the wire\n * (a 429 body, a quota response) where an unknown value must render as something\n * rather than crash a page. The `QuotaType` overload is for internal callers: it\n * makes a typo a compile error instead of a key rendered as a label.\n */\nexport function quotaLabel(type: QuotaType): string;\nexport function quotaLabel(type: string): string;\nexport function quotaLabel(type: string): string {\n  return byKey[type]?.label ?? type;\n}\n\n/** This type's PLURAL label, or the raw key for a value outside the catalog. */\nexport function quotaLabelPlural(type: QuotaType): string;\nexport function quotaLabelPlural(type: string): string;\nexport function quotaLabelPlural(type: string): string {\n  return byKey[type]?.labelPlural ?? type;\n}\n\n/**\n * How to render this type's values. `count` for anything the catalog does not\n * know, so an unfamiliar wire value renders as a plain number.\n *\n * Read THIS rather than asking \"is it bytes?\". A boolean helper degrades\n * silently the moment {@link QuotaRender} grows a third member — a new mode\n * would simply render as a count, with nothing failing — whereas a caller that\n * switches on this value exhaustively stops compiling until it handles the new\n * mode. That is the whole point of the catalog, applied to its own accessors.\n */\nexport function quotaRender(type: QuotaType): QuotaRender;\nexport function quotaRender(type: string): QuotaRender;\nexport function quotaRender(type: string): QuotaRender {\n  return byKey[type]?.render ?? 'count';\n}\n\nconst BYTE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB'] as const;\n\n/**\n * A byte count as a human amount — `1.5 GB`, `512 MB`, `0 B`.\n *\n * The ONE implementation: the frontend's `formatBytes` delegates here rather\n * than keeping its own copy, so a storage figure reads identically in a quota\n * notice, a 403 explanation and the dashboard. Binary units (1024), one decimal\n * below 10 and rounded above, which is what the dashboard already rendered —\n * this moved the algorithm, it did not change it.\n */\nexport function formatByteAmount(bytes: number): string {\n  if (!Number.isFinite(bytes) || bytes < 0) return '0 B';\n  let value = bytes;\n  let i = 0;\n  while (value >= 1024 && i < BYTE_UNITS.length - 1) {\n    value /= 1024;\n    i++;\n  }\n  return value < 10 ? `${value.toFixed(1)} ${BYTE_UNITS[i]}` : `${Math.round(value)} ${BYTE_UNITS[i]}`;\n}\n\n/**\n * A raw quota value as the amount a HUMAN should read, per this type's\n * {@link QuotaRender} — bytes as `25 GB`, counts grouped as `60,000`.\n *\n * For server-side copy (quota notices, audit reasons, 403 explanations), which\n * is why it is here rather than in the frontend: a storage notice that\n * interpolated the raw number would read \"used all 26843545600 of its registry\n * storage\". The frontend has its own thin wrapper because it renders an\n * unlimited (-1) limit as `∞`, which is a display choice no server copy makes\n * (unlimited orgs are skipped before any copy is generated).\n */\nexport function formatQuotaAmount(type: string, value: number): string {\n  return quotaRender(type) === 'bytes' ? formatByteAmount(value) : value.toLocaleString('en-US');\n}\n\n/**\n * How this quota's usage is observed: `metered` (incremented) or `measured`\n * (read on demand). Unknown wire values read as `metered`, matching every\n * quota but storage.\n */\nexport function quotaObservation(type: QuotaType): QuotaObservation;\nexport function quotaObservation(type: string): QuotaObservation;\nexport function quotaObservation(type: string): QuotaObservation {\n  return byKey[type]?.observed ?? 'metered';\n}\n\n/**\n * Whether this quota refills on the period (`flow`) or persists (`stock`).\n * Unknown wire values are treated as `flow`, matching every metered quota.\n */\nexport function quotaAccrual(type: QuotaType): QuotaAccrual;\nexport function quotaAccrual(type: string): QuotaAccrual;\nexport function quotaAccrual(type: string): QuotaAccrual {\n  return byKey[type]?.accrual ?? 'flow';\n}\n\n/** What this type counts, or the empty string for a value outside the catalog. */\nexport function quotaDescription(type: QuotaType): string;\nexport function quotaDescription(type: string): string;\nexport function quotaDescription(type: string): string {\n  return byKey[type]?.description ?? '';\n}\n\n/** The pack unit for this type, or `null` to type pack counts instead. */\nexport function quotaPackUnit(type: QuotaType): { name: string; per: number } | null;\nexport function quotaPackUnit(type: string): { name: string; per: number } | null;\nexport function quotaPackUnit(type: string): { name: string; per: number } | null {\n  return byKey[type]?.packUnit ?? null;\n}\n"]}

package/lib/types/quota-tiers.d.ts

@@ -1,3 +1,4 @@
+import type { QuotaType } from './common.js';
 /** Available quota tier identifiers.
  *
  * `unlimited` is a special tier: every quota is `-1` (uncapped) and it includes
@@ -10,6 +11,12 @@ export interface QuotaTierLimits {
     plugins: number;
     pipelines: number;
     apiCalls: number;
+    /**
+     * Metered API calls made by ORG SERVICE ACCOUNTS (automation), counted
+     * instead of `apiCalls` so pipelines can't starve the org's people. See
+     * {@link AUTOMATION_CALLS_SIZING} for how the defaults are derived.
+     */
+    automationCalls: number;
     aiCalls: number;
     /**
      * Aggregate registry storage cap in BYTES. Counted across every repo
@@ -18,6 +25,23 @@ export interface QuotaTierLimits {
      * `push` scope when the org's measured usage exceeds the limit.
      */
     storageBytes: number;
+    /**
+     * vCPU-MINUTES of plugin-build compute per MONTH — the one quota on a period
+     * of its own (every other flow quota rolls on `QUOTA_RESET_DAYS`, 3 days).
+     *
+     * Derived from the `plugins` cap rather than guessed: `plugins x 10` builds a
+     * month, at a flat 30 wall-minutes a build and 1.5 vCPU of buildkitd, so
+     * `credits = builds x 45`. The flat per-build figure is deliberate — scaling
+     * BOTH the build count and the per-build cost by tier made credits
+     * superlinear in tier on the strength of an unmeasured claim, and it made a
+     * pack's credit grant tier-dependent, which the catalogue's grant shape cannot
+     * express.
+     *
+     * This is the first dimension with genuine per-unit marginal cost: every other
+     * quota is a rate limit protecting shared infrastructure, this one is compute
+     * the platform pays for. See `docs/plans/cpu-credits.md`.
+     */
+    cpuCredits: number;
     /** Count-quotas on the user-editable feature tables added to close per-org
      *  DoS via spam. -1 means unlimited. */
     dashboards: number;
@@ -86,6 +110,78 @@ export interface QuotaTierPreset {
     label: string;
     limits: QuotaTierLimits;
 }
+/**
+ * How the `automationCalls` defaults are sized — written down so the next
+ * person to touch them argues with the arithmetic, not with the numbers.
+ *
+ * Every call an org's automation keys make in one pipeline RUN, itemized (the
+ * earlier sizing counted only the plugin lookups and hand-waved the rest as
+ * "×2"):
+ *
+ *   plugin lookups            12   one per plugin step (self-mutating pipeline)
+ *   synth                      1   the synth step fetching the pipeline config
+ *   runtime check              1   the pre-deploy runtime-check call
+ *   security-report upload     1   the scan step posting its report
+ *   registry register          1   pipeline-register stamping the deployed version
+ *   reporting ingest batches  12   the event forwarder posts ~one batch per action
+ *                             --
+ *                             28   calls per run
+ *
+ * Per default period (`QUOTA_RESET_DAYS`, 3 days) one active pipeline running
+ * hourly makes 28 × 24 × 3 = 2,016 calls. An org keeps far more pipelines alive
+ * than it CREATES in a period (`pipelines` is a creation rate), so active
+ * pipelines are taken as 4× the tier's `pipelines`. On top sits a per-ORG
+ * constant that does not scale with pipelines: the ingest-health heartbeat
+ * (≤ 1/minute → 1,440/day → 4,320/period). The sum gets 25% headroom (retries,
+ * registry pushes, ad-hoc CI scripts on keys) and rounds UP to the next 10,000:
+ *
+ *   developer   2×4×2016 + 4320 =  20,448 × 1.25 =  25,560 →  30,000
+ *   pro         5×4×2016 + 4320 =  44,640 × 1.25 =  55,800 →  60,000
+ *   team       10×4×2016 + 4320 =  84,960 × 1.25 = 106,200 → 110,000
+ *   business   20×4×2016 + 4320 = 165,600 × 1.25 = 207,000 → 210,000
+ *   enterprise 30×4×2016 + 4320 = 246,240 × 1.25 = 307,800 → 310,000
+ *
+ * {@link automationCallsFor} computes exactly this, and the tier tests hold the
+ * table to it. Over the cap the 429 is SOFT for a band ({@link quotaGracePct}):
+ * a self-mutating pipeline that hard-stopped at 100% stayed stopped until the
+ * period reset, up to 3 days. The limits are PER PERIOD: an operator who
+ * lengthens `QUOTA_RESET_DAYS` should scale `QUOTA_TIER_<TIER>_AUTOMATION_CALLS`
+ * by the same factor.
+ */
+export declare const AUTOMATION_CALLS_SIZING: {
+    readonly callsPerRun: {
+        readonly pluginLookups: 12;
+        readonly synth: 1;
+        readonly runtimeCheck: 1;
+        readonly securityReportUpload: 1;
+        readonly registryRegister: 1;
+        readonly ingestBatches: 12;
+    };
+    readonly runsPerDay: 24;
+    readonly activePipelinesPerCreation: 4;
+    /** Ingest-health heartbeats per org per day (≤ one a minute). */
+    readonly heartbeatsPerDay: 1440;
+    /** Multiplier on the itemized total. */
+    readonly headroom: 1.25;
+    /** Defaults round UP to a multiple of this. */
+    readonly roundTo: 10000;
+};
+/** The {@link AUTOMATION_CALLS_SIZING} formula for a tier creating `pipelines` per period. */
+export declare function automationCallsFor(pipelines: number, periodDays?: number): number;
+/** The soft band for `quotaType` in percent, or 0 for a type that stops hard. */
+export declare function quotaGracePct(quotaType: string): number;
+/**
+ * The limit enforcement actually binds on for `quotaType`: the nominal limit,
+ * plus the type's {@link quotaGracePct} band where it has one. Unlimited (-1)
+ * and zero ("none") limits are returned unchanged — a 0 cap is a deliberate
+ * refusal, not a budget to overrun.
+ *
+ * {@link QUOTA_GRACE_PCT} decides WHETHER a type has a band; `gracePct` only
+ * sizes it. So an explicit percentage passed for an unbanded type still yields
+ * the nominal limit, rather than quietly granting a band the type is not meant
+ * to have.
+ */
+export declare function enforcedQuotaLimit(quotaType: string, limit: number, gracePct?: number): number;
 export declare const QUOTA_TIERS: Record<QuotaTier, QuotaTierPreset>;
 /** All valid tier names (incl. `unlimited`). Used for validation of a *stored*
  *  tier — `unlimited` is a valid value even though it's never offered for sale. */
@@ -136,4 +232,26 @@ export declare function getTierLimits(tier: string): QuotaTierLimits;
  */
 export declare const QUOTA_RESET_DAYS: number;
 /** The next quota reset: local midnight `days` from `now`. */
+/**
+ * The `cpuCredits` period, in days. A MONTH rather than the global three-day
+ * window, because build demand is bursty in a way API traffic is not: a full
+ * catalogue rebuild is a day's work that arrives on one day, and a three-day
+ * window refuses it while the account holds most of a month's budget unspent.
+ */
+export declare const CPU_CREDITS_PERIOD_DAYS: number;
+/**
+ * The usage period for ONE quota type, in days.
+ *
+ * Every flow quota but `cpuCredits` rolls on the global {@link QUOTA_RESET_DAYS}.
+ * Credits are monthly, which makes the period a PER-TYPE fact — so anything that
+ * computes a reset date, a "resets in N days" line or a burn-rate forecast has
+ * to ask for the type's own period rather than reading the global constant. A
+ * forecast against the wrong window is wrong by a factor of ten.
+ *
+ * Stocks (`storageBytes` and the resource counts) have no period at all; this
+ * returns the global window for them because callers gate on
+ * `quotaAccrual(type) === 'stock'` before using it, and returning a figure is
+ * less disruptive than making every caller handle a null. Check the accrual.
+ */
+export declare function quotaPeriodDays(type: QuotaType): number;
 export declare function nextQuotaResetDate(days?: number, now?: Date): Date;