@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/billing/ai-overage-standing.js

@@ -0,0 +1,215 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * A WORKSPACE'S OVERAGE STANDING (AGL-3011) — the pure half.
+ *
+ * AI credits past a plan's included band are sold on every paid plan. What
+ * bounds them is not one number but four facts about the workspace, and this
+ * module is the one derivation of all four: whether a card can be charged,
+ * whether accrual is paused, how much overage this month may reach, and how
+ * much may be outstanding at once.
+ *
+ * Nothing here reads Firestore, calls Stripe or knows what a month cost.
+ * `ai-overage-ledger.ts` holds the documents and `ai-overage-charge.ts` the
+ * charging; the gate and the staff card both resolve their figures here, so
+ * the ceiling a customer is refused at is the ceiling the card displays.
+ *
+ * ## The bound, stated once
+ *
+ * A workspace may leave at most `AI_OVERAGE_UNPAID_LIMIT_USD` of overage
+ * unpaid. That is enforced by REFUSING, not by charging — the gate compares
+ * what a month accrued against what it paid, inside the reservation
+ * transaction, every request. So the bound holds when a charge is late, when
+ * Stripe is down, and when the charge path never ran at all. Charging at
+ * `AI_OVERAGE_THRESHOLD_USD` exists to keep a workspace working, by settling
+ * the balance before it reaches the bound; it is not what makes the bound
+ * true.
+ */ import { resolveAssistOverageCapUsd } from "@aglyn/aglyn/app-utils/assist-credits";
+/**
+ * The unbilled overage at which the card on file is charged.
+ *
+ * Fifty times Stripe's minimum charge, so no charge is refused for being too
+ * small; low enough that what is outstanding between charges stays near the
+ * bound below; high enough that per-invoice fees stay a few percent.
+ */ export const AI_OVERAGE_THRESHOLD_USD = 25;
+/**
+ * The most overage a workspace may have accrued and not paid for.
+ *
+ * Twice the threshold, so one charge in flight plus one accruing is inside
+ * it, and a workspace doing ordinary work never meets it. Meeting it means
+ * the charges are not settling, and that is exactly when accrual must stop.
+ */ export const AI_OVERAGE_UNPAID_LIMIT_USD = 50;
+/**
+ * The monthly ceiling, by step. It rises one step for each later calendar
+ * month in which the workspace paid an invoice with a real charge.
+ *
+ * Months, not invoices: every paid workspace pays an invoice the moment it
+ * subscribes, and threshold invoices can arrive several times a day, so
+ * counting invoices would reach the top step in an afternoon. Counting
+ * months takes at least two, which covers much of the window in which a
+ * stolen card is reported.
+ */ export const AI_OVERAGE_CEILING_LADDER_USD = [
+    50,
+    150,
+    500
+];
+/** The top index of the ladder; `step` is clamped to it. */ export const AI_OVERAGE_MAX_STEP = AI_OVERAGE_CEILING_LADDER_USD.length - 1;
+/**
+ * The smallest amount worth an invoice — Stripe's own minimum charge. A
+ * close-out remainder under it is carried, not billed: an invoice that
+ * cannot be paid is a document that dunning chases forever.
+ */ export const AI_OVERAGE_MIN_CHARGE_USD = 0.5;
+/** Bounds on a ceiling staff may write by hand, the customer ceiling's. */ export const AI_OVERAGE_STAFF_CEILING_MIN_USD = 1;
+export const AI_OVERAGE_STAFF_CEILING_MAX_USD = 100000;
+/** The standing of a workspace nothing has written a document for. */ export const EMPTY_AI_OVERAGE_STANDING = {
+    paymentMethodType: undefined,
+    firstPaidMonth: null,
+    qualifyingMonths: [],
+    staffOverride: null,
+    pause: null,
+    lastDisputeAt: null
+};
+/** How many qualifying months the document keeps. */ export const AI_OVERAGE_QUALIFYING_MONTHS_KEPT = 12;
+const MONTH = /^\d{4}-\d{2}$/;
+function readString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function readInstant(value) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+    // A Firestore Timestamp, as the Admin SDK hands one back.
+    const toDate = value == null ? void 0 : value.toDate;
+    if (typeof toDate === 'function') {
+        const date = toDate.call(value);
+        return date instanceof Date && !Number.isNaN(date.getTime()) ? date.toISOString() : null;
+    }
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value.toISOString();
+    }
+    return null;
+}
+const PAUSE_REASONS = [
+    'charge_failed',
+    'past_due',
+    'dispute',
+    'staff'
+];
+/**
+ * Reads the stored document into the shape above, strictly.
+ *
+ * Strictly, because every field here decides whether a workspace may spend
+ * money: a string `"true"` that read as a boolean, or a `NaN` ceiling that
+ * every comparison passes, is a guard that is not there. Anything that does
+ * not narrow is the empty standing's value for that field — which is the
+ * conservative answer in each case except the card, where the deliberate
+ * answer is "nobody has looked".
+ */ export function readAiOverageStanding(data) {
+    var _readString, _readString1;
+    if (!data || typeof data !== 'object') return EMPTY_AI_OVERAGE_STANDING;
+    const rawType = data['paymentMethodType'];
+    const paymentMethodType = rawType === undefined ? undefined : typeof rawType === 'string' && rawType.trim() ? rawType.trim() : null;
+    const firstPaidMonth = readString(data['firstPaidMonth']);
+    const months = Array.isArray(data['qualifyingMonths']) ? data['qualifyingMonths'].filter((month)=>typeof month === 'string' && MONTH.test(month)).filter((month, index, all)=>all.indexOf(month) === index).sort() : [];
+    const override = data['staffOverride'];
+    const ceilingUsd = Number(override == null ? void 0 : override['ceilingUsd']);
+    const staffOverride = override && Number.isFinite(ceilingUsd) && ceilingUsd > 0 ? {
+        ceilingUsd,
+        reason: (_readString = readString(override['reason'])) != null ? _readString : '',
+        setBy: (_readString1 = readString(override['setBy'])) != null ? _readString1 : '',
+        setAt: readInstant(override['setAt']),
+        expiresAt: readInstant(override['expiresAt'])
+    } : null;
+    const rawPause = data['pause'];
+    const pauseReason = readString(rawPause == null ? void 0 : rawPause['reason']);
+    const pause = rawPause && pauseReason && PAUSE_REASONS.includes(pauseReason) ? {
+        reason: pauseReason,
+        invoiceId: readString(rawPause['invoiceId']),
+        since: readInstant(rawPause['since'])
+    } : null;
+    return {
+        paymentMethodType,
+        firstPaidMonth: firstPaidMonth && MONTH.test(firstPaidMonth) ? firstPaidMonth : null,
+        qualifyingMonths: months,
+        staffOverride,
+        pause,
+        lastDisputeAt: readInstant(data['lastDisputeAt'])
+    };
+}
+/**
+ * The workspace's step on the ladder — one per qualifying month, clamped.
+ *
+ * Derived rather than stored, so a stored `step` cannot disagree with the
+ * months it was supposed to have been derived from. The document carries a
+ * mirrored copy for readers that want one figure, and this is what writes it.
+ */ export function aiOverageStep(standing) {
+    return Math.min(AI_OVERAGE_MAX_STEP, standing.qualifyingMonths.length);
+}
+/** Is a staff override still standing at this instant? */ export function aiOverageOverrideApplies(override, now) {
+    if (!override) return false;
+    if (!override.expiresAt) return true;
+    const expires = Date.parse(override.expiresAt);
+    // An unparseable expiry expires the override rather than extending it: a
+    // ceiling that was meant to end and cannot say when must not outlive its
+    // reason because a timestamp did not read back.
+    if (!Number.isFinite(expires)) return false;
+    return now.getTime() < expires;
+}
+/**
+ * Aglyn's own ceiling on this month's overage, in retail dollars.
+ *
+ * The staff override when one stands, and the ladder otherwise. This is the
+ * platform's limit; the customer's own `capUsd` is a separate figure and the
+ * lower of the two binds — see `aiOverageEffectiveCeilingUsd`.
+ */ export function aiOverageStandingCeilingUsd(standing, now) {
+    if (aiOverageOverrideApplies(standing.staffOverride, now)) {
+        return standing.staffOverride.ceilingUsd;
+    }
+    return AI_OVERAGE_CEILING_LADDER_USD[aiOverageStep(standing)];
+}
+/**
+ * The ceiling that actually binds: the lower of the workspace's own and
+ * Aglyn's. For display and for staff; the gate consults the two separately,
+ * because the customer's ceiling and the platform's need different words.
+ */ export function aiOverageEffectiveCeilingUsd(org, standing, now) {
+    const own = resolveAssistOverageCapUsd(org);
+    const ours = aiOverageStandingCeilingUsd(standing, now);
+    return own === null ? ours : Math.min(own, ours);
+}
+/**
+ * Whether a card is the default payment method, as far as anyone has looked.
+ *
+ * `undefined` when nobody has, and callers must handle that third answer
+ * rather than coercing it — see `paymentMethodType`.
+ */ export function aiOverageCardOnFile(standing) {
+    if (standing.paymentMethodType === undefined) return undefined;
+    return standing.paymentMethodType === 'card';
+}
+/**
+ * The month a qualifying step is recorded under, from a paid invoice.
+ *
+ * `null` when the payment is not evidence that money moved or that time has
+ * passed: an invoice marked paid out of band is a staff action, a zero
+ * payment is a credit, and the first paid month is the baseline the ladder
+ * counts FROM rather than a step on it.
+ */ export function aiOverageQualifyingMonth(standing, payment) {
+    if (!MONTH.test(payment.month)) return null;
+    if (payment.paidOutOfBand) return null;
+    if (!(payment.amountPaidCents > 0)) return null;
+    if (!standing.firstPaidMonth) return null;
+    if (!(payment.month > standing.firstPaidMonth)) return null;
+    return payment.month;
+}
+
+//# sourceMappingURL=ai-overage-standing.js.map

package/src/lib/billing/ai-overage-standing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/billing/ai-overage-standing.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A WORKSPACE'S OVERAGE STANDING (AGL-3011) — the pure half.\n *\n * AI credits past a plan's included band are sold on every paid plan. What\n * bounds them is not one number but four facts about the workspace, and this\n * module is the one derivation of all four: whether a card can be charged,\n * whether accrual is paused, how much overage this month may reach, and how\n * much may be outstanding at once.\n *\n * Nothing here reads Firestore, calls Stripe or knows what a month cost.\n * `ai-overage-ledger.ts` holds the documents and `ai-overage-charge.ts` the\n * charging; the gate and the staff card both resolve their figures here, so\n * the ceiling a customer is refused at is the ceiling the card displays.\n *\n * ## The bound, stated once\n *\n * A workspace may leave at most `AI_OVERAGE_UNPAID_LIMIT_USD` of overage\n * unpaid. That is enforced by REFUSING, not by charging — the gate compares\n * what a month accrued against what it paid, inside the reservation\n * transaction, every request. So the bound holds when a charge is late, when\n * Stripe is down, and when the charge path never ran at all. Charging at\n * `AI_OVERAGE_THRESHOLD_USD` exists to keep a workspace working, by settling\n * the balance before it reaches the bound; it is not what makes the bound\n * true.\n */\n\nimport { resolveAssistOverageCapUsd } from '@aglyn/aglyn/app-utils/assist-credits'\nimport type { AglynOrgBilling } from '@aglyn/aglyn/foundation/definitions/org-billing.types'\n\n/** The billing fields of an org, as every resolver in this folder takes it. */\nexport type AiOverageOrg = Partial<AglynOrgBilling> | null | undefined\n\n/**\n * The unbilled overage at which the card on file is charged.\n *\n * Fifty times Stripe's minimum charge, so no charge is refused for being too\n * small; low enough that what is outstanding between charges stays near the\n * bound below; high enough that per-invoice fees stay a few percent.\n */\nexport const AI_OVERAGE_THRESHOLD_USD = 25\n\n/**\n * The most overage a workspace may have accrued and not paid for.\n *\n * Twice the threshold, so one charge in flight plus one accruing is inside\n * it, and a workspace doing ordinary work never meets it. Meeting it means\n * the charges are not settling, and that is exactly when accrual must stop.\n */\nexport const AI_OVERAGE_UNPAID_LIMIT_USD = 50\n\n/**\n * The monthly ceiling, by step. It rises one step for each later calendar\n * month in which the workspace paid an invoice with a real charge.\n *\n * Months, not invoices: every paid workspace pays an invoice the moment it\n * subscribes, and threshold invoices can arrive several times a day, so\n * counting invoices would reach the top step in an afternoon. Counting\n * months takes at least two, which covers much of the window in which a\n * stolen card is reported.\n */\nexport const AI_OVERAGE_CEILING_LADDER_USD = [50, 150, 500] as const\n\n/** The top index of the ladder; `step` is clamped to it. */\nexport const AI_OVERAGE_MAX_STEP = AI_OVERAGE_CEILING_LADDER_USD.length - 1\n\n/**\n * The smallest amount worth an invoice — Stripe's own minimum charge. A\n * close-out remainder under it is carried, not billed: an invoice that\n * cannot be paid is a document that dunning chases forever.\n */\nexport const AI_OVERAGE_MIN_CHARGE_USD = 0.5\n\n/** Bounds on a ceiling staff may write by hand, the customer ceiling's. */\nexport const AI_OVERAGE_STAFF_CEILING_MIN_USD = 1\nexport const AI_OVERAGE_STAFF_CEILING_MAX_USD = 100_000\n\n/** Why overage is paused. Each one is payment trust dropping, differently. */\nexport type AiOveragePauseReason =\n  | 'charge_failed'\n  | 'past_due'\n  | 'dispute'\n  | 'staff'\n\n/** A staff ceiling that outranks the ladder. */\nexport interface AiOverageStaffOverride {\n  ceilingUsd: number\n  reason: string\n  setBy: string\n  setAt: string | null\n  /** ISO instant, or `null` to stand until staff clear it. */\n  expiresAt: string | null\n}\n\n/** Accrual stopped, and why. */\nexport interface AiOveragePause {\n  reason: AiOveragePauseReason\n  /** The invoice that failed, when a charge is what stopped it. */\n  invoiceId: string | null\n  since: string | null\n}\n\n/**\n * `orgs/{orgId}/aiBilling/standing`, normalized.\n *\n * Written only by the server, read by the gate on every request past the\n * band. The Firestore rules deny every client write and allow the same reads\n * as `aiAllotments`.\n */\nexport interface AiOverageStanding {\n  /**\n   * The workspace's default payment method type, `null` when it has none,\n   * and `undefined` when nobody has looked yet.\n   *\n   * THREE states, not two, and the third is the important one. A workspace\n   * that has been paying for a year has no standing document until something\n   * writes one, and reading that absence as \"no card\" would refuse a paying\n   * customer's work over a document we never wrote. So \"never observed\"\n   * declines to answer the card question and lets the other guards bind —\n   * the unpaid bound does not rest on the card check, which is why it can\n   * afford to abstain. A pre-cutover backfill is what turns `undefined` into\n   * a real answer for existing workspaces.\n   */\n  paymentMethodType: string | null | undefined\n  /** The first month (`YYYY-MM`) an invoice of this workspace's was paid. */\n  firstPaidMonth: string | null\n  /**\n   * Later months with a paid invoice, ascending, the most recent 12 kept. A\n   * month is dropped again if an AI charge of that month was still unpaid\n   * when the month ended.\n   */\n  qualifyingMonths: string[]\n  staffOverride: AiOverageStaffOverride | null\n  pause: AiOveragePause | null\n  lastDisputeAt: string | null\n}\n\n/** The standing of a workspace nothing has written a document for. */\nexport const EMPTY_AI_OVERAGE_STANDING: AiOverageStanding = {\n  paymentMethodType: undefined,\n  firstPaidMonth: null,\n  qualifyingMonths: [],\n  staffOverride: null,\n  pause: null,\n  lastDisputeAt: null,\n}\n\n/** How many qualifying months the document keeps. */\nexport const AI_OVERAGE_QUALIFYING_MONTHS_KEPT = 12\n\nconst MONTH = /^\\d{4}-\\d{2}$/\n\nfunction readString(value: unknown): string | null {\n  return typeof value === 'string' && value.trim() ? value.trim() : null\n}\n\nfunction readInstant(value: unknown): string | null {\n  if (typeof value === 'string' && value.trim()) return value.trim()\n  // A Firestore Timestamp, as the Admin SDK hands one back.\n  const toDate = (value as { toDate?: () => Date } | null)?.toDate\n  if (typeof toDate === 'function') {\n    const date = toDate.call(value)\n    return date instanceof Date && !Number.isNaN(date.getTime())\n      ? date.toISOString()\n      : null\n  }\n  if (value instanceof Date && !Number.isNaN(value.getTime())) {\n    return value.toISOString()\n  }\n  return null\n}\n\nconst PAUSE_REASONS: readonly AiOveragePauseReason[] = [\n  'charge_failed',\n  'past_due',\n  'dispute',\n  'staff',\n]\n\n/**\n * Reads the stored document into the shape above, strictly.\n *\n * Strictly, because every field here decides whether a workspace may spend\n * money: a string `\"true\"` that read as a boolean, or a `NaN` ceiling that\n * every comparison passes, is a guard that is not there. Anything that does\n * not narrow is the empty standing's value for that field — which is the\n * conservative answer in each case except the card, where the deliberate\n * answer is \"nobody has looked\".\n */\nexport function readAiOverageStanding(\n  data: Record<string, unknown> | null | undefined,\n): AiOverageStanding {\n  if (!data || typeof data !== 'object') return EMPTY_AI_OVERAGE_STANDING\n  const rawType = data['paymentMethodType']\n  const paymentMethodType =\n    rawType === undefined\n      ? undefined\n      : typeof rawType === 'string' && rawType.trim()\n        ? rawType.trim()\n        : null\n  const firstPaidMonth = readString(data['firstPaidMonth'])\n  const months = Array.isArray(data['qualifyingMonths'])\n    ? (data['qualifyingMonths'] as unknown[])\n        .filter((month): month is string => typeof month === 'string' && MONTH.test(month))\n        .filter((month, index, all) => all.indexOf(month) === index)\n        .sort()\n    : []\n  const override = data['staffOverride'] as Record<string, unknown> | null | undefined\n  const ceilingUsd = Number(override?.['ceilingUsd'])\n  const staffOverride: AiOverageStaffOverride | null =\n    override && Number.isFinite(ceilingUsd) && ceilingUsd > 0\n      ? {\n          ceilingUsd,\n          reason: readString(override['reason']) ?? '',\n          setBy: readString(override['setBy']) ?? '',\n          setAt: readInstant(override['setAt']),\n          expiresAt: readInstant(override['expiresAt']),\n        }\n      : null\n  const rawPause = data['pause'] as Record<string, unknown> | null | undefined\n  const pauseReason = readString(rawPause?.['reason']) as AiOveragePauseReason | null\n  const pause: AiOveragePause | null =\n    rawPause && pauseReason && PAUSE_REASONS.includes(pauseReason)\n      ? {\n          reason: pauseReason,\n          invoiceId: readString(rawPause['invoiceId']),\n          since: readInstant(rawPause['since']),\n        }\n      : null\n  return {\n    paymentMethodType,\n    firstPaidMonth: firstPaidMonth && MONTH.test(firstPaidMonth) ? firstPaidMonth : null,\n    qualifyingMonths: months,\n    staffOverride,\n    pause,\n    lastDisputeAt: readInstant(data['lastDisputeAt']),\n  }\n}\n\n/**\n * The workspace's step on the ladder — one per qualifying month, clamped.\n *\n * Derived rather than stored, so a stored `step` cannot disagree with the\n * months it was supposed to have been derived from. The document carries a\n * mirrored copy for readers that want one figure, and this is what writes it.\n */\nexport function aiOverageStep(standing: AiOverageStanding): number {\n  return Math.min(AI_OVERAGE_MAX_STEP, standing.qualifyingMonths.length)\n}\n\n/** Is a staff override still standing at this instant? */\nexport function aiOverageOverrideApplies(\n  override: AiOverageStaffOverride | null,\n  now: Date,\n): boolean {\n  if (!override) return false\n  if (!override.expiresAt) return true\n  const expires = Date.parse(override.expiresAt)\n  // An unparseable expiry expires the override rather than extending it: a\n  // ceiling that was meant to end and cannot say when must not outlive its\n  // reason because a timestamp did not read back.\n  if (!Number.isFinite(expires)) return false\n  return now.getTime() < expires\n}\n\n/**\n * Aglyn's own ceiling on this month's overage, in retail dollars.\n *\n * The staff override when one stands, and the ladder otherwise. This is the\n * platform's limit; the customer's own `capUsd` is a separate figure and the\n * lower of the two binds — see `aiOverageEffectiveCeilingUsd`.\n */\nexport function aiOverageStandingCeilingUsd(\n  standing: AiOverageStanding,\n  now: Date,\n): number {\n  if (aiOverageOverrideApplies(standing.staffOverride, now)) {\n    return standing.staffOverride!.ceilingUsd\n  }\n  return AI_OVERAGE_CEILING_LADDER_USD[aiOverageStep(standing)]\n}\n\n/**\n * The ceiling that actually binds: the lower of the workspace's own and\n * Aglyn's. For display and for staff; the gate consults the two separately,\n * because the customer's ceiling and the platform's need different words.\n */\nexport function aiOverageEffectiveCeilingUsd(\n  org: AiOverageOrg,\n  standing: AiOverageStanding,\n  now: Date,\n): number {\n  const own = resolveAssistOverageCapUsd(org)\n  const ours = aiOverageStandingCeilingUsd(standing, now)\n  return own === null ? ours : Math.min(own, ours)\n}\n\n/**\n * Whether a card is the default payment method, as far as anyone has looked.\n *\n * `undefined` when nobody has, and callers must handle that third answer\n * rather than coercing it — see `paymentMethodType`.\n */\nexport function aiOverageCardOnFile(\n  standing: AiOverageStanding,\n): boolean | undefined {\n  if (standing.paymentMethodType === undefined) return undefined\n  return standing.paymentMethodType === 'card'\n}\n\n/**\n * The month a qualifying step is recorded under, from a paid invoice.\n *\n * `null` when the payment is not evidence that money moved or that time has\n * passed: an invoice marked paid out of band is a staff action, a zero\n * payment is a credit, and the first paid month is the baseline the ladder\n * counts FROM rather than a step on it.\n */\nexport function aiOverageQualifyingMonth(\n  standing: AiOverageStanding,\n  payment: { month: string; amountPaidCents: number; paidOutOfBand: boolean },\n): string | null {\n  if (!MONTH.test(payment.month)) return null\n  if (payment.paidOutOfBand) return null\n  if (!(payment.amountPaidCents > 0)) return null\n  if (!standing.firstPaidMonth) return null\n  if (!(payment.month > standing.firstPaidMonth)) return null\n  return payment.month\n}\n"],"names":["resolveAssistOverageCapUsd","AI_OVERAGE_THRESHOLD_USD","AI_OVERAGE_UNPAID_LIMIT_USD","AI_OVERAGE_CEILING_LADDER_USD","AI_OVERAGE_MAX_STEP","length","AI_OVERAGE_MIN_CHARGE_USD","AI_OVERAGE_STAFF_CEILING_MIN_USD","AI_OVERAGE_STAFF_CEILING_MAX_USD","EMPTY_AI_OVERAGE_STANDING","paymentMethodType","undefined","firstPaidMonth","qualifyingMonths","staffOverride","pause","lastDisputeAt","AI_OVERAGE_QUALIFYING_MONTHS_KEPT","MONTH","readString","value","trim","readInstant","toDate","date","call","Date","Number","isNaN","getTime","toISOString","PAUSE_REASONS","readAiOverageStanding","data","rawType","months","Array","isArray","filter","month","test","index","all","indexOf","sort","override","ceilingUsd","isFinite","reason","setBy","setAt","expiresAt","rawPause","pauseReason","includes","invoiceId","since","aiOverageStep","standing","Math","min","aiOverageOverrideApplies","now","expires","parse","aiOverageStandingCeilingUsd","aiOverageEffectiveCeilingUsd","org","own","ours","aiOverageCardOnFile","aiOverageQualifyingMonth","payment","paidOutOfBand","amountPaidCents"],"mappings":"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"}

package/src/lib/billing/ai-overage-trigger.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Charges the workspace's accrued overage if it has reached the threshold.
+ *
+ * Returns quietly on every "nothing to do" — before the cutover, no org
+ * document, no Stripe customer — because this is called after every metered
+ * turn and a thrown error on the ordinary path would fill the logs with the
+ * ordinary path.
+ */
+export declare function chargeAccruedAiOverage(firestore: FirebaseFirestore.Firestore, orgId: string, month: string, now?: Date): Promise<void>;
+/**
+ * The same, for a caller that has no Firestore handle of its own — the
+ * close-out sweep and the staff route, which run outside a metered turn.
+ */
+export declare function aiOverageFirestore(): FirebaseFirestore.Firestore;

package/src/lib/billing/ai-overage-trigger.js

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * WHAT A METERED TURN OWES THE CHARGE PATH (AGL-3011).
+ *
+ * The meter's two writers call this once their batch has committed. It reads
+ * what the charge needs — the org's plan and its Stripe customer — and hands
+ * it to `maybeChargeAiOverage`.
+ *
+ * ## Why the reads live here and not in the meter
+ *
+ * `assist-usage.ts` deliberately keeps the admin lib's `firebase-admin`
+ * module out of its import graph, so that every unit test touching a counter
+ * does not drag a cert credential, RTDB and AppCheck along with it. This
+ * module is loaded through a dynamic import from there, exactly as the
+ * allotment alerts are, so the meter's graph is unchanged and the cost of
+ * these reads is paid only on a turn that could produce a charge.
+ *
+ * ## Why the reads are affordable
+ *
+ * Nothing here runs before the cutover month — the caller checks that first,
+ * and so does `maybeChargeAiOverage`. Once charging is on, two reads on a
+ * metered turn sit beside a model call that costs orders of magnitude more.
+ *
+ * ## Why losing this is survivable
+ *
+ * It runs off the request's await path, so a killed process can drop it. The
+ * money is still bounded: the gate refuses at the unpaid limit whether or
+ * not a charge ever ran, the next turn tries again, and the reconcile sweep
+ * finishes anything left half-done.
+ */ import { firebaseAdmin, readOrgBilling } from "@aglyn/tenant-data-admin";
+import { maybeChargeAiOverage } from "./ai-overage-charge.js";
+import { aiOverageBillsByInvoice } from "./ai-overage-cutover.js";
+/**
+ * Charges the workspace's accrued overage if it has reached the threshold.
+ *
+ * Returns quietly on every "nothing to do" — before the cutover, no org
+ * document, no Stripe customer — because this is called after every metered
+ * turn and a thrown error on the ordinary path would fill the logs with the
+ * ordinary path.
+ */ export async function chargeAccruedAiOverage(firestore, orgId, month, now = new Date()) {
+    var _ref, _orgSnapshot_data;
+    if (!aiOverageBillsByInvoice(month)) return;
+    const orgSnapshot = await firestore.collection('orgs').doc(orgId).get();
+    if (!orgSnapshot.exists) return;
+    const billing = await readOrgBilling(orgId);
+    const stripeCustomerId = String((_ref = billing == null ? void 0 : billing.stripeCustomerId) != null ? _ref : '') || null;
+    await maybeChargeAiOverage(firestore, {
+        orgId,
+        org: (_orgSnapshot_data = orgSnapshot.data()) != null ? _orgSnapshot_data : {},
+        month,
+        stripeCustomerId,
+        now
+    });
+}
+/**
+ * The same, for a caller that has no Firestore handle of its own — the
+ * close-out sweep and the staff route, which run outside a metered turn.
+ */ export function aiOverageFirestore() {
+    return firebaseAdmin.app().firestore();
+}
+
+//# sourceMappingURL=ai-overage-trigger.js.map

package/src/lib/billing/ai-overage-trigger.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/billing/ai-overage-trigger.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * WHAT A METERED TURN OWES THE CHARGE PATH (AGL-3011).\n *\n * The meter's two writers call this once their batch has committed. It reads\n * what the charge needs — the org's plan and its Stripe customer — and hands\n * it to `maybeChargeAiOverage`.\n *\n * ## Why the reads live here and not in the meter\n *\n * `assist-usage.ts` deliberately keeps the admin lib's `firebase-admin`\n * module out of its import graph, so that every unit test touching a counter\n * does not drag a cert credential, RTDB and AppCheck along with it. This\n * module is loaded through a dynamic import from there, exactly as the\n * allotment alerts are, so the meter's graph is unchanged and the cost of\n * these reads is paid only on a turn that could produce a charge.\n *\n * ## Why the reads are affordable\n *\n * Nothing here runs before the cutover month — the caller checks that first,\n * and so does `maybeChargeAiOverage`. Once charging is on, two reads on a\n * metered turn sit beside a model call that costs orders of magnitude more.\n *\n * ## Why losing this is survivable\n *\n * It runs off the request's await path, so a killed process can drop it. The\n * money is still bounded: the gate refuses at the unpaid limit whether or\n * not a charge ever ran, the next turn tries again, and the reconcile sweep\n * finishes anything left half-done.\n */\n\nimport { firebaseAdmin, readOrgBilling } from '@aglyn/tenant-data-admin'\nimport { maybeChargeAiOverage } from './ai-overage-charge'\nimport { aiOverageBillsByInvoice } from './ai-overage-cutover'\n\n/**\n * Charges the workspace's accrued overage if it has reached the threshold.\n *\n * Returns quietly on every \"nothing to do\" — before the cutover, no org\n * document, no Stripe customer — because this is called after every metered\n * turn and a thrown error on the ordinary path would fill the logs with the\n * ordinary path.\n */\nexport async function chargeAccruedAiOverage(\n  firestore: FirebaseFirestore.Firestore,\n  orgId: string,\n  month: string,\n  now = new Date(),\n): Promise<void> {\n  if (!aiOverageBillsByInvoice(month)) return\n  const orgSnapshot = await firestore.collection('orgs').doc(orgId).get()\n  if (!orgSnapshot.exists) return\n  const billing = await readOrgBilling(orgId)\n  const stripeCustomerId = String(billing?.stripeCustomerId ?? '') || null\n  await maybeChargeAiOverage(firestore, {\n    orgId,\n    org: (orgSnapshot.data() ?? {}) as never,\n    month,\n    stripeCustomerId,\n    now,\n  })\n}\n\n/**\n * The same, for a caller that has no Firestore handle of its own — the\n * close-out sweep and the staff route, which run outside a metered turn.\n */\nexport function aiOverageFirestore(): FirebaseFirestore.Firestore {\n  return firebaseAdmin.app().firestore()\n}\n"],"names":["firebaseAdmin","readOrgBilling","maybeChargeAiOverage","aiOverageBillsByInvoice","chargeAccruedAiOverage","firestore","orgId","month","now","Date","orgSnapshot","collection","doc","get","exists","billing","stripeCustomerId","String","org","data","aiOverageFirestore","app"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GAED,SAASA,aAAa,EAAEC,cAAc,QAAQ,2BAA0B;AACxE,SAASC,oBAAoB,QAAQ,yBAAqB;AAC1D,SAASC,uBAAuB,QAAQ,0BAAsB;AAE9D;;;;;;;CAOC,GACD,OAAO,eAAeC,uBACpBC,SAAsC,EACtCC,KAAa,EACbC,KAAa,EACbC,MAAM,IAAIC,MAAM;cASRC;IAPR,IAAI,CAACP,wBAAwBI,QAAQ;IACrC,MAAMG,cAAc,MAAML,UAAUM,UAAU,CAAC,QAAQC,GAAG,CAACN,OAAOO,GAAG;IACrE,IAAI,CAACH,YAAYI,MAAM,EAAE;IACzB,MAAMC,UAAU,MAAMd,eAAeK;IACrC,MAAMU,mBAAmBC,eAAOF,2BAAAA,QAASC,gBAAgB,mBAAI,OAAO;IACpE,MAAMd,qBAAqBG,WAAW;QACpCC;QACAY,GAAG,GAAGR,oBAAAA,YAAYS,IAAI,cAAhBT,oBAAsB,CAAC;QAC7BH;QACAS;QACAR;IACF;AACF;AAEA;;;CAGC,GACD,OAAO,SAASY;IACd,OAAOpB,cAAcqB,GAAG,GAAGhB,SAAS;AACtC"}

package/src/lib/components/ai-allotment-editor.component.d.ts

@@ -0,0 +1,40 @@
+import { type AiAllotmentMode } from '../model/ai-allotments';
+export interface AiAllotmentValue {
+    credits: number | null;
+    mode: AiAllotmentMode;
+    models: string[] | null;
+}
+export interface AiAllotmentEditorProps {
+    open: boolean;
+    title: string;
+    /** One sentence under the title: whose allotment, and what it bounds. */
+    description?: string;
+    /** The allotment as it stands, or `null` for a new one. */
+    initial: AiAllotmentValue | null;
+    /** The models an allowlist may name, from the allotments route. */
+    models: ReadonlyArray<{
+        id: string;
+        label: string;
+    }>;
+    /** The org-wide restriction: models only, no credits and no mode. */
+    modelsOnly?: boolean;
+    /** The workspace's pool, for the note that an allotment never grants past it. */
+    poolLimit?: number | null;
+    busy?: boolean;
+    error?: string | null;
+    onClose: () => void;
+    onSave: (value: AiAllotmentValue) => void;
+    /** Offered when the allotment exists. */
+    onRemove?: () => void;
+}
+/**
+ * THE ALLOTMENT EDITOR (AGL-2942): credits a month, hard or soft, and an
+ * optional model allowlist — one dialog for a member, a collaborator, a
+ * site, a bulk selection and the org-wide restriction, so the four places a
+ * manager sets an allotment ask the same questions in the same words.
+ */
+export declare function AiAllotmentEditor(props: AiAllotmentEditorProps): import("react").JSX.Element;
+export declare namespace AiAllotmentEditor {
+    var displayName: string;
+}
+export default AiAllotmentEditor;

package/src/lib/components/ai-allotment-editor.component.js

@@ -0,0 +1,213 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Alert, Button, Checkbox, CircularProgress, Dialog, DialogActions, DialogContent, DialogTitle, FormControlLabel, FormGroup, FormHelperText, FormLabel, Radio, RadioGroup, Stack, TextField, Typography } from "@mui/material";
+import { useEffect, useState } from "react";
+import { AI_ALLOTMENT_MAX_CREDITS } from "../model/ai-allotments.js";
+/**
+ * THE ALLOTMENT EDITOR (AGL-2942): credits a month, hard or soft, and an
+ * optional model allowlist — one dialog for a member, a collaborator, a
+ * site, a bulk selection and the org-wide restriction, so the four places a
+ * manager sets an allotment ask the same questions in the same words.
+ */ export function AiAllotmentEditor(props) {
+    var _ref, _ref1, _ref2;
+    const { open, initial, models, modelsOnly, poolLimit, busy, error } = props;
+    const [credits, setCredits] = useState('');
+    const [mode, setMode] = useState('hard');
+    const [allowed, setAllowed] = useState([]);
+    const [invalid, setInvalid] = useState(null);
+    // Reset from the allotment each time the dialog opens, keyed on the open
+    // flag and the values rather than on the object's identity.
+    const initialCredits = (_ref = initial == null ? void 0 : initial.credits) != null ? _ref : null;
+    const initialMode = (_ref1 = initial == null ? void 0 : initial.mode) != null ? _ref1 : 'hard';
+    const initialModels = ((_ref2 = initial == null ? void 0 : initial.models) != null ? _ref2 : []).join('\n');
+    useEffect(()=>{
+        if (!open) return;
+        setCredits(initialCredits === null ? '' : String(initialCredits));
+        setMode(initialMode);
+        setAllowed(initialModels ? initialModels.split('\n') : []);
+        setInvalid(null);
+    }, [
+        open,
+        initialCredits,
+        initialMode,
+        initialModels
+    ]);
+    const parsedCredits = credits.trim() === '' ? null : Number(credits);
+    const save = ()=>{
+        if (!modelsOnly) {
+            if (parsedCredits !== null && (!Number.isInteger(parsedCredits) || parsedCredits < 1 || parsedCredits > AI_ALLOTMENT_MAX_CREDITS)) {
+                setInvalid('Enter a whole number of credits, 1 or more.');
+                return;
+            }
+            if (parsedCredits === null && !allowed.length) {
+                setInvalid('Set credits, choose models, or remove the allotment.');
+                return;
+            }
+        }
+        setInvalid(null);
+        props.onSave({
+            credits: modelsOnly ? null : parsedCredits,
+            mode,
+            models: allowed.length ? allowed : null
+        });
+    };
+    const toggle = (id)=>setAllowed((current)=>current.includes(id) ? current.filter((entry)=>entry !== id) : [
+                ...current,
+                id
+            ]);
+    return /*#__PURE__*/ _jsxs(Dialog, {
+        open: open,
+        onClose: busy ? undefined : props.onClose,
+        maxWidth: "xs",
+        fullWidth: true,
+        children: [
+            /*#__PURE__*/ _jsx(DialogTitle, {
+                children: props.title
+            }),
+            /*#__PURE__*/ _jsxs(DialogContent, {
+                sx: {
+                    display: 'flex',
+                    flexDirection: 'column',
+                    gap: 2,
+                    pt: 1
+                },
+                children: [
+                    props.description ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "body2",
+                        color: "text.secondary",
+                        children: props.description
+                    }) : null,
+                    modelsOnly ? null : /*#__PURE__*/ _jsxs(_Fragment, {
+                        children: [
+                            /*#__PURE__*/ _jsx(TextField, {
+                                label: "Credits a month",
+                                type: "number",
+                                size: "small",
+                                value: credits,
+                                onChange: (event)=>setCredits(event.target.value),
+                                disabled: busy,
+                                slotProps: {
+                                    htmlInput: {
+                                        min: 1,
+                                        step: 100
+                                    }
+                                },
+                                helperText: poolLimit && parsedCredits && parsedCredits > poolLimit ? `Larger than the workspace's ${poolLimit.toLocaleString()} credits — the workspace's pool still stops first.` : 'Counted from the first of the month (UTC). Leave empty to limit models only.'
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                children: [
+                                    /*#__PURE__*/ _jsx(FormLabel, {
+                                        id: "ai-allotment-mode",
+                                        children: 'At the allotment'
+                                    }),
+                                    /*#__PURE__*/ _jsxs(RadioGroup, {
+                                        "aria-labelledby": "ai-allotment-mode",
+                                        value: mode,
+                                        onChange: (event)=>setMode(event.target.value),
+                                        children: [
+                                            /*#__PURE__*/ _jsx(FormControlLabel, {
+                                                value: "hard",
+                                                control: /*#__PURE__*/ _jsx(Radio, {
+                                                    size: "small"
+                                                }),
+                                                disabled: busy,
+                                                label: "Stop AI requests (hard)"
+                                            }),
+                                            /*#__PURE__*/ _jsx(FormControlLabel, {
+                                                value: "soft",
+                                                control: /*#__PURE__*/ _jsx(Radio, {
+                                                    size: "small"
+                                                }),
+                                                disabled: busy,
+                                                label: "Keep going and alert at 80% and 100% (soft)"
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    models.length ? /*#__PURE__*/ _jsxs("div", {
+                        children: [
+                            /*#__PURE__*/ _jsx(FormLabel, {
+                                component: "legend",
+                                children: modelsOnly ? 'Models the organization may use' : 'Limit to these models (optional)'
+                            }),
+                            /*#__PURE__*/ _jsx(FormGroup, {
+                                children: models.map((model)=>/*#__PURE__*/ _jsx(FormControlLabel, {
+                                        control: /*#__PURE__*/ _jsx(Checkbox, {
+                                            size: "small",
+                                            checked: allowed.includes(model.id),
+                                            onChange: ()=>toggle(model.id),
+                                            disabled: busy
+                                        }),
+                                        label: model.label
+                                    }, model.id))
+                            }),
+                            /*#__PURE__*/ _jsx(FormHelperText, {
+                                children: modelsOnly ? 'None checked means no restriction. Auto keeps choosing among the checked models.' : 'None checked means every model the plan offers. Auto keeps choosing among the checked models.'
+                            })
+                        ]
+                    }) : null,
+                    invalid || error ? /*#__PURE__*/ _jsx(Alert, {
+                        severity: "error",
+                        children: invalid != null ? invalid : error
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(DialogActions, {
+                children: [
+                    props.onRemove ? /*#__PURE__*/ _jsx(Button, {
+                        color: "error",
+                        disabled: busy,
+                        onClick: props.onRemove,
+                        sx: {
+                            mr: 'auto'
+                        },
+                        children: modelsOnly ? 'Clear restriction' : 'Remove allotment'
+                    }) : null,
+                    /*#__PURE__*/ _jsx(Button, {
+                        disabled: busy,
+                        onClick: props.onClose,
+                        children: 'Cancel'
+                    }),
+                    /*#__PURE__*/ _jsx(Stack, {
+                        direction: "row",
+                        spacing: 1,
+                        sx: {
+                            alignItems: 'center'
+                        },
+                        children: /*#__PURE__*/ _jsx(Button, {
+                            variant: "contained",
+                            disabled: busy,
+                            onClick: save,
+                            startIcon: busy ? /*#__PURE__*/ _jsx(CircularProgress, {
+                                size: 16
+                            }) : undefined,
+                            children: busy ? 'Saving…' : 'Save'
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+AiAllotmentEditor.displayName = 'AiAllotmentEditor';
+export default AiAllotmentEditor;
+
+//# sourceMappingURL=ai-allotment-editor.component.js.map