@aglyn/aglyn 1.0.0-beta.269 → 1.0.0-beta.271

package/src/lib/app-utils/append-only-history.js

@@ -0,0 +1,73 @@
+/**
+ * @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.
+ */ /**
+ * APPEND-ONLY HISTORY (AGL-3959).
+ *
+ * Work that bills — Site Care minutes and extra time, and the flat-quoted
+ * project invoice after it (AGL-3970) — keeps one dated row per thing that
+ * happened: a minute entry, a timer start, an approval, a charge, an email,
+ * a correction. Nothing is overwritten. A fix is a new row that says what it
+ * was before, what it is now, who changed it and why, so the record a person
+ * can be shown is the whole record.
+ *
+ * Each row carries two tellings of the same fact: `summary`, written for the
+ * owner in plain words (it is what their statement lists), and the
+ * structured `before` / `after` / `stripe` a staff member or the
+ * reconciliation reads. This module is the row's shape and its rules; the
+ * write — always a `create`, in the same batch as the change it records — is
+ * `@aglyn/tenant-data-admin/server/append-only-history-write`.
+ */ /** The longest reason or summary a row keeps. */ export const HISTORY_TEXT_MAX = 500;
+/** A trimmed, bounded reason, or null when blank. */ export function cleanHistoryReason(reason) {
+    const text = typeof reason === 'string' ? reason.trim().slice(0, HISTORY_TEXT_MAX) : '';
+    return text ? text : null;
+}
+/**
+ * The reason a correction must carry, or an error to show. Every change to
+ * something already recorded goes through this, so "why" is never optional
+ * where it matters.
+ */ export function requireHistoryReason(reason) {
+    const cleaned = cleanHistoryReason(reason);
+    return cleaned ? {
+        ok: true,
+        reason: cleaned
+    } : {
+        ok: false,
+        error: 'Say why — a reason is required.'
+    };
+}
+/** A row from its parts, every field present so a reader never guesses. */ export function historyRow(input) {
+    var _input_by_uid, _input_by_email, _input_summary, _input_reason, _input_before, _input_after, _input_stripe, _input_subjectId;
+    return {
+        atMs: Math.floor(input.atMs),
+        byUid: (_input_by_uid = input.by.uid) != null ? _input_by_uid : null,
+        byEmail: (_input_by_email = input.by.email) != null ? _input_by_email : null,
+        kind: input.kind,
+        summary: String((_input_summary = input.summary) != null ? _input_summary : '').trim().slice(0, HISTORY_TEXT_MAX),
+        reason: cleanHistoryReason((_input_reason = input.reason) != null ? _input_reason : null),
+        before: (_input_before = input.before) != null ? _input_before : null,
+        after: (_input_after = input.after) != null ? _input_after : null,
+        stripe: (_input_stripe = input.stripe) != null ? _input_stripe : null,
+        subjectId: (_input_subjectId = input.subjectId) != null ? _input_subjectId : null
+    };
+}
+/** Rows oldest first, ties kept in the order they were read. */ export function sortHistoryRows(rows) {
+    return rows.map((row, index)=>({
+            row,
+            index
+        })).sort((a, b)=>a.row.atMs - b.row.atMs || a.index - b.index).map(({ row })=>row);
+}
+
+//# sourceMappingURL=append-only-history.js.map

package/src/lib/app-utils/append-only-history.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/append-only-history.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 * APPEND-ONLY HISTORY (AGL-3959).\n *\n * Work that bills — Site Care minutes and extra time, and the flat-quoted\n * project invoice after it (AGL-3970) — keeps one dated row per thing that\n * happened: a minute entry, a timer start, an approval, a charge, an email,\n * a correction. Nothing is overwritten. A fix is a new row that says what it\n * was before, what it is now, who changed it and why, so the record a person\n * can be shown is the whole record.\n *\n * Each row carries two tellings of the same fact: `summary`, written for the\n * owner in plain words (it is what their statement lists), and the\n * structured `before` / `after` / `stripe` a staff member or the\n * reconciliation reads. This module is the row's shape and its rules; the\n * write — always a `create`, in the same batch as the change it records — is\n * `@aglyn/tenant-data-admin/server/append-only-history-write`.\n */\n\n/** The longest reason or summary a row keeps. */\nexport const HISTORY_TEXT_MAX = 500\n\n/** The Stripe object a row's money movement names. */\nexport interface HistoryStripeRef {\n  /** `invoiceitem`, `credit_note`, `refund`, `invoice`. */\n  object: string\n  id: string\n  /** Whole cents the object moved, when it moved money. */\n  amountCents?: number\n}\n\n/** One row. */\nexport interface AppendOnlyHistoryRow {\n  /** When it happened, epoch ms. */\n  atMs: number\n  /** Who did it; null when nobody did (a scheduled check). */\n  byUid: string | null\n  byEmail: string | null\n  /** What kind of thing happened, `noun.verb`: `minutes.corrected`. */\n  kind: string\n  /** What happened, in plain words an owner can read. */\n  summary: string\n  /** Why; required on every correction. */\n  reason: string | null\n  before: Readonly<Record<string, unknown>> | null\n  after: Readonly<Record<string, unknown>> | null\n  stripe: HistoryStripeRef | null\n  /** The record the row belongs to, when the history is shared by many. */\n  subjectId: string | null\n}\n\nexport interface HistoryRowInput {\n  atMs: number\n  by: { uid: string | null; email: string | null }\n  kind: string\n  summary: string\n  reason?: string | null\n  before?: Readonly<Record<string, unknown>> | null\n  after?: Readonly<Record<string, unknown>> | null\n  stripe?: HistoryStripeRef | null\n  subjectId?: string | null\n}\n\n/** A trimmed, bounded reason, or null when blank. */\nexport function cleanHistoryReason(reason: unknown): string | null {\n  const text = typeof reason === 'string' ? reason.trim().slice(0, HISTORY_TEXT_MAX) : ''\n  return text ? text : null\n}\n\n/**\n * The reason a correction must carry, or an error to show. Every change to\n * something already recorded goes through this, so \"why\" is never optional\n * where it matters.\n */\nexport function requireHistoryReason(\n  reason: unknown,\n): { ok: true; reason: string } | { ok: false; error: string } {\n  const cleaned = cleanHistoryReason(reason)\n  return cleaned ? { ok: true, reason: cleaned } : { ok: false, error: 'Say why — a reason is required.' }\n}\n\n/** A row from its parts, every field present so a reader never guesses. */\nexport function historyRow(input: HistoryRowInput): AppendOnlyHistoryRow {\n  return {\n    atMs: Math.floor(input.atMs),\n    byUid: input.by.uid ?? null,\n    byEmail: input.by.email ?? null,\n    kind: input.kind,\n    summary: String(input.summary ?? '').trim().slice(0, HISTORY_TEXT_MAX),\n    reason: cleanHistoryReason(input.reason ?? null),\n    before: input.before ?? null,\n    after: input.after ?? null,\n    stripe: input.stripe ?? null,\n    subjectId: input.subjectId ?? null,\n  }\n}\n\n/** Rows oldest first, ties kept in the order they were read. */\nexport function sortHistoryRows<Row extends Pick<AppendOnlyHistoryRow, 'atMs'>>(\n  rows: readonly Row[],\n): Row[] {\n  return rows\n    .map((row, index) => ({ row, index }))\n    .sort((a, b) => a.row.atMs - b.row.atMs || a.index - b.index)\n    .map(({ row }) => row)\n}\n"],"names":["HISTORY_TEXT_MAX","cleanHistoryReason","reason","text","trim","slice","requireHistoryReason","cleaned","ok","error","historyRow","input","atMs","Math","floor","byUid","by","uid","byEmail","email","kind","summary","String","before","after","stripe","subjectId","sortHistoryRows","rows","map","row","index","sort","a","b"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;CAgBC,GAED,+CAA+C,GAC/C,OAAO,MAAMA,mBAAmB,IAAG;AA2CnC,mDAAmD,GACnD,OAAO,SAASC,mBAAmBC,MAAe;IAChD,MAAMC,OAAO,OAAOD,WAAW,WAAWA,OAAOE,IAAI,GAAGC,KAAK,CAAC,GAAGL,oBAAoB;IACrF,OAAOG,OAAOA,OAAO;AACvB;AAEA;;;;CAIC,GACD,OAAO,SAASG,qBACdJ,MAAe;IAEf,MAAMK,UAAUN,mBAAmBC;IACnC,OAAOK,UAAU;QAAEC,IAAI;QAAMN,QAAQK;IAAQ,IAAI;QAAEC,IAAI;QAAOC,OAAO;IAAkC;AACzG;AAEA,yEAAyE,GACzE,OAAO,SAASC,WAAWC,KAAsB;QAGtCA,eACEA,iBAEOA,gBACWA,eACnBA,eACDA,cACCA,eACGA;IAVb,OAAO;QACLC,MAAMC,KAAKC,KAAK,CAACH,MAAMC,IAAI;QAC3BG,KAAK,GAAEJ,gBAAAA,MAAMK,EAAE,CAACC,GAAG,YAAZN,gBAAgB;QACvBO,OAAO,GAAEP,kBAAAA,MAAMK,EAAE,CAACG,KAAK,YAAdR,kBAAkB;QAC3BS,MAAMT,MAAMS,IAAI;QAChBC,SAASC,QAAOX,iBAAAA,MAAMU,OAAO,YAAbV,iBAAiB,IAAIP,IAAI,GAAGC,KAAK,CAAC,GAAGL;QACrDE,QAAQD,oBAAmBU,gBAAAA,MAAMT,MAAM,YAAZS,gBAAgB;QAC3CY,MAAM,GAAEZ,gBAAAA,MAAMY,MAAM,YAAZZ,gBAAgB;QACxBa,KAAK,GAAEb,eAAAA,MAAMa,KAAK,YAAXb,eAAe;QACtBc,MAAM,GAAEd,gBAAAA,MAAMc,MAAM,YAAZd,gBAAgB;QACxBe,SAAS,GAAEf,mBAAAA,MAAMe,SAAS,YAAff,mBAAmB;IAChC;AACF;AAEA,8DAA8D,GAC9D,OAAO,SAASgB,gBACdC,IAAoB;IAEpB,OAAOA,KACJC,GAAG,CAAC,CAACC,KAAKC,QAAW,CAAA;YAAED;YAAKC;QAAM,CAAA,GAClCC,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEH,GAAG,CAAClB,IAAI,GAAGsB,EAAEJ,GAAG,CAAClB,IAAI,IAAIqB,EAAEF,KAAK,GAAGG,EAAEH,KAAK,EAC3DF,GAAG,CAAC,CAAC,EAAEC,GAAG,EAAE,GAAKA;AACtB"}

package/src/lib/app-utils/bundle-intent.d.ts

@@ -0,0 +1,186 @@
+/**
+ * @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.
+ */
+/**
+ * THE ADD-ONS A PLAN SELLS, AND THE BUNDLE A LINK ASKS FOR (AGL-3955).
+ *
+ * One list of add-on kinds and one parser for the add-ons a link, an upgrade
+ * proposal or a staff dialog names, so the Billing card, the bundle checkout
+ * link, the hand-off proposal (AGL-3956) and `/api/billing/checkout` agree on
+ * what `addons=siteCare,ai,extraHost:2` means.
+ *
+ * The kinds are `OrgSeatAddons`' keys: what `resolvePurchasedAddons` counts,
+ * what the webhook mirrors from Stripe, and what `/api/billing/addons` sells.
+ * The prices and ceilings here are the ones `billing-addons.ts` (server)
+ * re-exports, so a kind the link can preselect is always a kind the
+ * checkout can price.
+ *
+ * A link is typed by a person and passed through hops nobody controls, so
+ * the parser never throws and never guesses: an unknown token is dropped and
+ * reported, so the page can say so in one line instead of failing.
+ */
+import type { AiTierId, OrgPlan, OrgSeatAddons } from '../foundation/definitions/org-billing.types';
+import { resolveOrgEntitlements } from './plan-entitlements';
+/** An add-on kind: a key of `org.seatAddons`. */
+export type AddonKind = keyof Required<OrgSeatAddons>;
+/**
+ * Every add-on kind Billing sells, in the order the Billing card lists them.
+ * `/api/billing/addons`, the webhook's price map and the native add-ons
+ * screen all read this list.
+ */
+export declare const ADDON_KINDS: readonly AddonKind[];
+/** The org-wide 0/1 kinds: one purchase covers the workspace. */
+export declare const TOGGLE_ADDON_KIND_LIST: readonly AddonKind[];
+export declare function isAddonKind(value: unknown): value is AddonKind;
+/**
+ * Monthly USD per unit for an add-on on a plan (yearly prices are ×12 of
+ * this); null when the plan doesn't sell the kind. Single pricing source
+ * of truth: `PLAN_PRICING`, the three flat add-on constants and `AI_TIERS`
+ * (`tier` as `addonPriceId` reads it; absent, the tier a plan-named purchase
+ * means, `defaultAiTierForPlan`, AGL-3965).
+ */
+export declare function addonUnitUsd(kind: AddonKind, plan: OrgPlan, tier?: AiTierId | null): number | null;
+/**
+ * Max purchasable quantity per kind, from a purchases-free entitlement
+ * resolution (plan defaults + staff overrides only) so the ceiling does not
+ * drift as the org buys: seat/dataset kinds stop at the plan's hard max,
+ * hosts/registers use flat ceilings, the Event Calendar, Aglyn AI and Site
+ * Care are 0/1 toggles. POS registers additionally require the `pos`
+ * feature, and Site Care a plan that sells it (`planSellsSiteCare`), which is
+ * why the plan travels with the baseline.
+ *
+ * One definition for every reader: `/api/billing/addons` asks how many the
+ * org may buy on its plan, a plan change asks how many of what it bought the
+ * new plan can deliver, and a bundle link asks how many it may preselect.
+ */
+export declare function addonMaxForBaseline(kind: AddonKind, baseline: ReturnType<typeof resolveOrgEntitlements>, plan: OrgPlan): number;
+/** The ceiling a PLAN would impose on an add-on kind, purchases excluded. */
+export declare function addonMaxForPlan(kind: AddonKind, plan: OrgPlan): number;
+/** Whether a plan sells an add-on at all: priced, with a ceiling above zero. */
+export declare function planSellsAddon(kind: AddonKind, plan: OrgPlan): boolean;
+/** Quantities by kind, absent kinds meaning none. */
+export type BundleAddons = Partial<Record<AddonKind, number>>;
+/**
+ * What a link writes for each kind. `ai` and `extraHost` are the words the
+ * account owner chose (AGL-3955); the rest follow the same shape.
+ */
+export declare const BUNDLE_ADDON_TOKENS: Record<AddonKind, string>;
+/** One add-on a token names, with the Aglyn AI tier when it names one. */
+interface ParsedToken {
+    kind: AddonKind;
+    quantity: number;
+    tier?: AiTierId;
+}
+/**
+ * THE `ai:<tier>` TOKENS (AGL-3965).
+ *
+ * Aglyn AI is a tier chosen on its own, on any paid plan: `ai:boost` adds
+ * Aglyn AI Boost. The words are the tier ids, lower-cased as every token is,
+ * and resolve through `parseAiTierAddonKey`, the one spelling of the
+ * `ai:<tier>` key. A bare `ai` (or `ai:1`) still means "add it" and sells
+ * the plan's default tier (`defaultAiTierForPlan`). An unknown tier is
+ * dropped with the notice like any other unknown add-on, never read as
+ * "add whichever tier": that would sell a tier nobody chose.
+ */
+export declare const AI_ADDON_TIER_TOKENS: Readonly<Record<string, AiTierId>>;
+export declare function resolveAiAddonTier(tier: string): ParsedToken | null;
+export interface ParsedBundleAddons {
+    addons: BundleAddons;
+    /** The tokens nothing understood, as they were written. */
+    dropped: string[];
+    /** The Aglyn AI tier an `ai:<tier>` token named (AGL-3965), if any. */
+    aiTier?: AiTierId;
+}
+/**
+ * Read the add-ons a link, a proposal or a request names.
+ *
+ * Accepts the link form (`"siteCare,ai,extraHost:2"`), a list of tokens, or a
+ * map of kind → quantity or flag (`{ siteCare: true, hosts: 2 }`, the shape
+ * the native staff screens post from their toggles). Never throws: anything
+ * it cannot read is reported in `dropped` and left out.
+ */
+export declare function parseBundleAddons(input: unknown): ParsedBundleAddons;
+export interface FittedBundleAddons {
+    addons: BundleAddons;
+    /** Kinds the plan does not sell, dropped. */
+    notSold: AddonKind[];
+}
+/**
+ * The add-ons a plan can actually carry: kinds it does not sell are dropped,
+ * quantities are held to its ceiling. What a link preselects on one plan is
+ * re-fitted when the owner picks another, so the checkout is never asked for
+ * something it would refuse.
+ */
+export declare function fitBundleAddonsToPlan(addons: BundleAddons | null | undefined, plan: OrgPlan): FittedBundleAddons;
+/**
+ * The add-ons as the link writes them: `siteCare,ai:boost,extraHost:2`.
+ * Aglyn AI is written with its tier when one is named (AGL-3965), as bare
+ * `ai` otherwise.
+ */
+export declare function bundleAddonsParam(addons: BundleAddons | null | undefined, aiTier?: AiTierId | null): string;
+/** Whether any add-on is asked for. */
+export declare function hasBundleAddons(addons: BundleAddons | null | undefined): boolean;
+/**
+ * How each kind is named to a customer, singular. Aglyn AI carries its tier
+ * when one is named: "Aglyn AI Boost" (AGL-3965).
+ */
+export declare function bundleAddonLabel(kind: AddonKind, brand?: string, aiTier?: AiTierId | null): string;
+/** "Site Care", "2 × Extra site", "Aglyn AI Boost". */
+export declare function describeBundleAddon(kind: AddonKind, quantity: number, brand?: string, aiTier?: AiTierId | null): string;
+/** The longest coupon code a link carries. Stripe codes are far shorter. */
+export declare const BUNDLE_COUPON_MAX = 64;
+/**
+ * A promotion code as a link carries it, or undefined. Only the characters
+ * Stripe allows in a customer-facing code; anything else is not a code
+ * somebody was handed, and is dropped rather than sent to Stripe.
+ *
+ * The code is only APPLIED here. Codes are minted on the staff Coupons page,
+ * which audits them; nothing on this path creates one.
+ */
+export declare function normalizeBundleCoupon(raw: unknown): string | undefined;
+/**
+ * A domain name as a bundle carries it — lower-cased, no scheme, no path —
+ * or undefined. Whether it is for sale and at what price is the registrar's
+ * answer, re-checked at purchase; this only refuses what cannot be a name.
+ */
+export declare function normalizeBundleDomain(raw: unknown): string | undefined;
+/** "$15.99". */
+export declare function formatBundleCents(cents: number): string;
+/**
+ * The domain line a bundle shows (AGL-3955): "example.com — $15.99 first
+ * year, renews yearly at $15.99". The price is the registrar's at the moment
+ * the link was minted; the purchase re-checks it.
+ */
+export declare function bundleDomainLine(domain: {
+    name: string;
+    firstYearCents: number;
+    renewalCents: number;
+}): string;
+/**
+ * The bundle in one line, for an email, a dialog or a snackbar:
+ * "Starter with Site Care and Aglyn AI, billed yearly, code BOOTH25".
+ */
+export declare function describeBundle(bundle: {
+    plan: OrgPlan;
+    addons?: BundleAddons | null;
+    interval?: 'month' | 'year' | null;
+    coupon?: string | null;
+    /** The Aglyn AI tier, named with the AI add-on (AGL-3965). */
+    aiTier?: AiTierId | null;
+}, options?: {
+    brand?: string;
+}): string;
+export {};

package/src/lib/app-utils/bundle-intent.js

@@ -0,0 +1,386 @@
+/**
+ * @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.
+ */ /**
+ * THE ADD-ONS A PLAN SELLS, AND THE BUNDLE A LINK ASKS FOR (AGL-3955).
+ *
+ * One list of add-on kinds and one parser for the add-ons a link, an upgrade
+ * proposal or a staff dialog names, so the Billing card, the bundle checkout
+ * link, the hand-off proposal (AGL-3956) and `/api/billing/checkout` agree on
+ * what `addons=siteCare,ai,extraHost:2` means.
+ *
+ * The kinds are `OrgSeatAddons`' keys: what `resolvePurchasedAddons` counts,
+ * what the webhook mirrors from Stripe, and what `/api/billing/addons` sells.
+ * The prices and ceilings here are the ones `billing-addons.ts` (server)
+ * re-exports, so a kind the link can preselect is always a kind the
+ * checkout can price.
+ *
+ * A link is typed by a person and passed through hops nobody controls, so
+ * the parser never throws and never guesses: an unknown token is dropped and
+ * reported, so the page can say so in one line instead of failing.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { AI_TIER_IDS, AI_TIERS, aiAddonName, aiTierAddonKey, aiTierName, defaultAiTierForPlan, EVENT_CALENDAR_ADDON_MONTHLY_USD, EXTRA_HOSTS_ADDON_MAX, PLAN_LABELS, parseAiTierAddonKey, PLAN_PRICING, planSellsAiTiers, planSellsSiteCare, POS_REGISTER_ADDON_MONTHLY_USD, POS_REGISTERS_ADDON_MAX, resolveOrgEntitlements, SITE_CARE_ADDON_MONTHLY_USD, UNLIMITED } from "./plan-entitlements.js";
+/**
+ * Every add-on kind Billing sells, in the order the Billing card lists them.
+ * `/api/billing/addons`, the webhook's price map and the native add-ons
+ * screen all read this list.
+ */ export const ADDON_KINDS = [
+    'managers',
+    'members',
+    'datasets',
+    'hosts',
+    'posRegisters',
+    'eventCalendar',
+    'aiAddon',
+    'siteCare'
+];
+/** The org-wide 0/1 kinds: one purchase covers the workspace. */ export const TOGGLE_ADDON_KIND_LIST = [
+    'eventCalendar',
+    'aiAddon',
+    'siteCare'
+];
+export function isAddonKind(value) {
+    return typeof value === 'string' && ADDON_KINDS.includes(value);
+}
+/**
+ * Monthly USD per unit for an add-on on a plan (yearly prices are ×12 of
+ * this); null when the plan doesn't sell the kind. Single pricing source
+ * of truth: `PLAN_PRICING`, the three flat add-on constants and `AI_TIERS`
+ * (`tier` as `addonPriceId` reads it; absent, the tier a plan-named purchase
+ * means, `defaultAiTierForPlan`, AGL-3965).
+ */ export function addonUnitUsd(kind, plan, tier) {
+    const pricing = PLAN_PRICING[plan];
+    switch(kind){
+        case 'managers':
+            return pricing.extraSeatMonthlyUsd;
+        case 'members':
+            return pricing.extraCollaboratorMonthlyUsd;
+        case 'datasets':
+            return pricing.extraDatasetMonthlyUsd;
+        case 'hosts':
+            return pricing.extraHostMonthlyUsd;
+        case 'posRegisters':
+            return POS_REGISTER_ADDON_MONTHLY_USD;
+        case 'eventCalendar':
+            return EVENT_CALENDAR_ADDON_MONTHLY_USD;
+        case 'aiAddon':
+            {
+                const chosen = planSellsAiTiers(plan) ? tier != null ? tier : defaultAiTierForPlan(plan) : null;
+                return chosen ? AI_TIERS[chosen].monthlyUsd : null;
+            }
+        case 'siteCare':
+            return SITE_CARE_ADDON_MONTHLY_USD;
+    }
+}
+/**
+ * Max purchasable quantity per kind, from a purchases-free entitlement
+ * resolution (plan defaults + staff overrides only) so the ceiling does not
+ * drift as the org buys: seat/dataset kinds stop at the plan's hard max,
+ * hosts/registers use flat ceilings, the Event Calendar, Aglyn AI and Site
+ * Care are 0/1 toggles. POS registers additionally require the `pos`
+ * feature, and Site Care a plan that sells it (`planSellsSiteCare`), which is
+ * why the plan travels with the baseline.
+ *
+ * One definition for every reader: `/api/billing/addons` asks how many the
+ * org may buy on its plan, a plan change asks how many of what it bought the
+ * new plan can deliver, and a bundle link asks how many it may preselect.
+ */ export function addonMaxForBaseline(kind, baseline, plan) {
+    const bounded = (included, max)=>Number.isFinite(max) ? Math.max(0, max - included) : EXTRA_HOSTS_ADDON_MAX;
+    switch(kind){
+        case 'managers':
+            return bounded(baseline.managersPerOrg, baseline.maxManagersPerOrg);
+        case 'members':
+            return bounded(baseline.membersPerHost, baseline.maxMembersPerHost);
+        case 'datasets':
+            return bounded(baseline.datasetsPerOrg, baseline.maxDatasetsPerOrg);
+        case 'hosts':
+            return baseline.hostLimit === UNLIMITED ? 0 : EXTRA_HOSTS_ADDON_MAX;
+        case 'posRegisters':
+            return baseline.features.pos ? POS_REGISTERS_ADDON_MAX : 0;
+        case 'eventCalendar':
+            return 1;
+        case 'aiAddon':
+            // Org-wide like the Event Calendar: one purchase, of one tier, on any
+            // plan that sells tiers (AGL-3965) — not Free, not Enterprise.
+            return planSellsAiTiers(plan) ? 1 : 0;
+        case 'siteCare':
+            // Flat-priced, so the price map cannot say "not sold here" the way it
+            // does for Aglyn AI. This ceiling is the rule that keeps Free (no
+            // subscription) and Enterprise (quoted per deal) from buying it.
+            return planSellsSiteCare(plan) ? 1 : 0;
+    }
+}
+/** The ceiling a PLAN would impose on an add-on kind, purchases excluded. */ export function addonMaxForPlan(kind, plan) {
+    return addonMaxForBaseline(kind, resolveOrgEntitlements({
+        plan
+    }), plan);
+}
+/** Whether a plan sells an add-on at all: priced, with a ceiling above zero. */ export function planSellsAddon(kind, plan) {
+    return addonUnitUsd(kind, plan) != null && addonMaxForPlan(kind, plan) > 0;
+}
+/**
+ * What a link writes for each kind. `ai` and `extraHost` are the words the
+ * account owner chose (AGL-3955); the rest follow the same shape.
+ */ export const BUNDLE_ADDON_TOKENS = {
+    managers: 'extraSeat',
+    members: 'extraMember',
+    datasets: 'extraDataset',
+    hosts: 'extraHost',
+    posRegisters: 'posRegister',
+    eventCalendar: 'eventCalendar',
+    aiAddon: 'ai',
+    siteCare: 'siteCare'
+};
+/**
+ * Every spelling the parser accepts, lower-cased: the written token, the
+ * stored kind, and the plurals a person types.
+ */ const TOKEN_KINDS = (()=>{
+    const map = {};
+    const add = (kind, ...words)=>{
+        for (const word of [
+            kind,
+            BUNDLE_ADDON_TOKENS[kind],
+            ...words
+        ]){
+            map[word.toLowerCase()] = kind;
+        }
+    };
+    add('managers', 'extraSeats', 'seats', 'managerSeats');
+    add('members', 'extraMembers', 'collaborators', 'collaboratorSeats');
+    add('datasets', 'extraDatasets');
+    add('hosts', 'extraHosts', 'extraSite', 'extraSites', 'sites');
+    add('posRegisters', 'registers', 'register');
+    add('eventCalendar', 'events', 'calendar');
+    add('aiAddon', 'aglynAi');
+    add('siteCare', 'site-care', 'site_care', 'care');
+    return map;
+})();
+/** The most of a quantity kind a link may ask for, before the plan's ceiling. */ const MAX_LINK_QUANTITY = 999;
+/**
+ * THE `ai:<tier>` TOKENS (AGL-3965).
+ *
+ * Aglyn AI is a tier chosen on its own, on any paid plan: `ai:boost` adds
+ * Aglyn AI Boost. The words are the tier ids, lower-cased as every token is,
+ * and resolve through `parseAiTierAddonKey`, the one spelling of the
+ * `ai:<tier>` key. A bare `ai` (or `ai:1`) still means "add it" and sells
+ * the plan's default tier (`defaultAiTierForPlan`). An unknown tier is
+ * dropped with the notice like any other unknown add-on, never read as
+ * "add whichever tier": that would sell a tier nobody chose.
+ */ export const AI_ADDON_TIER_TOKENS = Object.freeze(Object.fromEntries(AI_TIER_IDS.map((tier)=>[
+        tier.toLowerCase(),
+        tier
+    ])));
+export function resolveAiAddonTier(tier) {
+    const word = tier.trim().toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(AI_ADDON_TIER_TOKENS, word)) return null;
+    const parsed = parseAiTierAddonKey(aiTierAddonKey(AI_ADDON_TIER_TOKENS[word]));
+    return parsed ? {
+        kind: 'aiAddon',
+        quantity: 1,
+        tier: parsed
+    } : null;
+}
+/** One token, `kind` or `kind:quantity`, or null when nothing understands it. */ function parseToken(raw) {
+    const token = raw.trim();
+    if (!token) return null;
+    const [name, ...rest] = token.split(':');
+    const kind = TOKEN_KINDS[name.trim().toLowerCase()];
+    if (!kind) return null;
+    const value = rest.join(':').trim();
+    if (!value) return {
+        kind,
+        quantity: 1
+    };
+    if (/^\d+$/.test(value)) {
+        const quantity = Math.min(MAX_LINK_QUANTITY, Number(value));
+        if (quantity < 1) return null;
+        return {
+            kind,
+            quantity: TOGGLE_ADDON_KIND_LIST.includes(kind) ? 1 : quantity
+        };
+    }
+    return kind === 'aiAddon' ? resolveAiAddonTier(value) : null;
+}
+/**
+ * Read the add-ons a link, a proposal or a request names.
+ *
+ * Accepts the link form (`"siteCare,ai,extraHost:2"`), a list of tokens, or a
+ * map of kind → quantity or flag (`{ siteCare: true, hosts: 2 }`, the shape
+ * the native staff screens post from their toggles). Never throws: anything
+ * it cannot read is reported in `dropped` and left out.
+ */ export function parseBundleAddons(input) {
+    const addons = {};
+    const dropped = [];
+    let aiTier;
+    const take = (parsed, raw)=>{
+        var _addons_parsed_kind;
+        if (!parsed) {
+            if (raw.trim()) dropped.push(raw.trim().slice(0, 40));
+            return;
+        }
+        addons[parsed.kind] = Math.max((_addons_parsed_kind = addons[parsed.kind]) != null ? _addons_parsed_kind : 0, parsed.quantity);
+        // The first tier named wins: one workspace holds one tier.
+        if (parsed.tier && !aiTier) aiTier = parsed.tier;
+    };
+    if (typeof input === 'string') {
+        for (const raw of input.split(/[,\s]+/))take(parseToken(raw), raw);
+    } else if (Array.isArray(input)) {
+        for (const raw of input){
+            if (typeof raw === 'string') take(parseToken(raw), raw);
+        }
+    } else if (input && typeof input === 'object') {
+        for (const [name, value] of Object.entries(input)){
+            const off = value === false || value === 0 || value === null || value === undefined || value === '' || value === 'false' || value === '0';
+            if (off) continue;
+            const quantity = value === true || value === 'true' ? '' : typeof value === 'number' || typeof value === 'string' ? String(value) : '';
+            take(parseToken(quantity ? `${name}:${quantity}` : name), name);
+        }
+    }
+    return _extends({
+        addons,
+        dropped
+    }, aiTier ? {
+        aiTier
+    } : {});
+}
+/**
+ * The add-ons a plan can actually carry: kinds it does not sell are dropped,
+ * quantities are held to its ceiling. What a link preselects on one plan is
+ * re-fitted when the owner picks another, so the checkout is never asked for
+ * something it would refuse.
+ */ export function fitBundleAddonsToPlan(addons, plan) {
+    const fitted = {};
+    const notSold = [];
+    for (const kind of ADDON_KINDS){
+        var _ref;
+        const wanted = Math.floor(Number((_ref = addons == null ? void 0 : addons[kind]) != null ? _ref : 0));
+        if (!(wanted > 0)) continue;
+        if (!planSellsAddon(kind, plan)) {
+            notSold.push(kind);
+            continue;
+        }
+        fitted[kind] = Math.min(wanted, addonMaxForPlan(kind, plan));
+    }
+    return {
+        addons: fitted,
+        notSold
+    };
+}
+/**
+ * The add-ons as the link writes them: `siteCare,ai:boost,extraHost:2`.
+ * Aglyn AI is written with its tier when one is named (AGL-3965), as bare
+ * `ai` otherwise.
+ */ export function bundleAddonsParam(addons, aiTier) {
+    return ADDON_KINDS.filter((kind)=>{
+        var _ref;
+        return ((_ref = addons == null ? void 0 : addons[kind]) != null ? _ref : 0) > 0;
+    }).map((kind)=>{
+        var _ref;
+        if (kind === 'aiAddon' && aiTier) return aiTierAddonKey(aiTier);
+        const quantity = (_ref = addons == null ? void 0 : addons[kind]) != null ? _ref : 0;
+        return quantity > 1 ? `${BUNDLE_ADDON_TOKENS[kind]}:${quantity}` : BUNDLE_ADDON_TOKENS[kind];
+    }).join(',');
+}
+/** Whether any add-on is asked for. */ export function hasBundleAddons(addons) {
+    return ADDON_KINDS.some((kind)=>{
+        var _ref;
+        return ((_ref = addons == null ? void 0 : addons[kind]) != null ? _ref : 0) > 0;
+    });
+}
+/**
+ * How each kind is named to a customer, singular. Aglyn AI carries its tier
+ * when one is named: "Aglyn AI Boost" (AGL-3965).
+ */ export function bundleAddonLabel(kind, brand, aiTier) {
+    switch(kind){
+        case 'managers':
+            return 'Extra manager seat';
+        case 'members':
+            return 'Extra collaborator seat';
+        case 'datasets':
+            return 'Extra dataset';
+        case 'hosts':
+            return 'Extra site';
+        case 'posRegisters':
+            return 'POS register';
+        case 'eventCalendar':
+            return 'Event Calendar';
+        case 'aiAddon':
+            return aiTier ? aiTierName(aiTier, brand) : aiAddonName(brand);
+        case 'siteCare':
+            return 'Site Care';
+    }
+}
+/** "Site Care", "2 × Extra site", "Aglyn AI Boost". */ export function describeBundleAddon(kind, quantity, brand, aiTier) {
+    const label = bundleAddonLabel(kind, brand, aiTier);
+    return quantity > 1 ? `${quantity} × ${label}` : label;
+}
+/** The longest coupon code a link carries. Stripe codes are far shorter. */ export const BUNDLE_COUPON_MAX = 64;
+/**
+ * A promotion code as a link carries it, or undefined. Only the characters
+ * Stripe allows in a customer-facing code; anything else is not a code
+ * somebody was handed, and is dropped rather than sent to Stripe.
+ *
+ * The code is only APPLIED here. Codes are minted on the staff Coupons page,
+ * which audits them; nothing on this path creates one.
+ */ export function normalizeBundleCoupon(raw) {
+    if (typeof raw !== 'string') return undefined;
+    const code = raw.trim();
+    if (!code || code.length > BUNDLE_COUPON_MAX) return undefined;
+    return /^[A-Za-z0-9_-]+$/.test(code) ? code : undefined;
+}
+/**
+ * A domain name as a bundle carries it — lower-cased, no scheme, no path —
+ * or undefined. Whether it is for sale and at what price is the registrar's
+ * answer, re-checked at purchase; this only refuses what cannot be a name.
+ */ export function normalizeBundleDomain(raw) {
+    if (typeof raw !== 'string') return undefined;
+    const name = raw.trim().toLowerCase().replace(/^https?:\/\//, '').replace(/\/.*$/, '').replace(/\.$/, '');
+    if (!name || name.length > 253) return undefined;
+    const labels = name.split('.');
+    if (labels.length < 2) return undefined;
+    const ok = labels.every((label)=>/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+    return ok && /^[a-z]{2,63}$/.test(labels[labels.length - 1]) ? name : undefined;
+}
+/** "$15.99". */ export function formatBundleCents(cents) {
+    return `$${(Math.max(0, Math.round(cents)) / 100).toFixed(2)}`;
+}
+/**
+ * The domain line a bundle shows (AGL-3955): "example.com — $15.99 first
+ * year, renews yearly at $15.99". The price is the registrar's at the moment
+ * the link was minted; the purchase re-checks it.
+ */ export function bundleDomainLine(domain) {
+    return `${domain.name} — ${formatBundleCents(domain.firstYearCents)} first year, ` + `renews yearly at ${formatBundleCents(domain.renewalCents)}`;
+}
+/**
+ * The bundle in one line, for an email, a dialog or a snackbar:
+ * "Starter with Site Care and Aglyn AI, billed yearly, code BOOTH25".
+ */ export function describeBundle(bundle, options = {}) {
+    var _PLAN_LABELS_bundle_plan;
+    const parts = ADDON_KINDS.filter((kind)=>{
+        var _ref;
+        var _bundle_addons;
+        return ((_ref = (_bundle_addons = bundle.addons) == null ? void 0 : _bundle_addons[kind]) != null ? _ref : 0) > 0;
+    }).map((kind)=>{
+        var _ref;
+        var _bundle_addons;
+        return describeBundleAddon(kind, (_ref = (_bundle_addons = bundle.addons) == null ? void 0 : _bundle_addons[kind]) != null ? _ref : 0, options.brand, bundle.aiTier);
+    });
+    const addons = parts.length === 0 ? '' : parts.length === 1 ? ` with ${parts[0]}` : ` with ${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
+    const interval = bundle.interval === 'year' ? ', billed yearly' : bundle.interval === 'month' ? ', billed monthly' : '';
+    const coupon = bundle.coupon ? `, code ${bundle.coupon}` : '';
+    return `${(_PLAN_LABELS_bundle_plan = PLAN_LABELS[bundle.plan]) != null ? _PLAN_LABELS_bundle_plan : bundle.plan}${addons}${interval}${coupon}`;
+}
+
+//# sourceMappingURL=bundle-intent.js.map