@cyc-seattle/platform 1.50.0 → 1.52.0

package/README.md

@@ -101,20 +101,20 @@ deployer needs first.
 authenticates with Workload Identity Federation and stores no credentials. Each job runs in a
 GitHub environment that holds its identity and state bucket:
 
-| Event                      | Jobs, in order                                                                                 |
-| -------------------------- | ---------------------------------------------------------------------------------------------- |
-| Pull request               | `ci`                                                                                           |
-| Merge queue                | `ci`, then `dev`: `mise run deploy` as `deploy-dev`, then `mise run integration`; `dev-passed` |
-| Push to `main`             | `prod-preview`, then `prod`, which waits for the `maintainers` approval                        |
-| Run by hand, from a branch | `ci`, then `dev`                                                                               |
-| Run by hand, from `main`   | `prod-preview`, then `prod`                                                                    |
-
-Dev is shared, so only the merge queue deploys to it (#69, #80). PRs queued together deploy and
-test as one batch: each queued PR's run skips dev when a newer PR is queued behind it, and the newest
-tests them all. The queue requires `dev-passed`, so a batch merges only once its dev deploy and the
-integration tests pass, and `main` gets the exact commit the queue tested, in one push. If the
-newest PR fails, the queue drops it and the rest of the batch deploys without it. A queued PR of only docs or CI skips `dev`. To try a
-branch on dev before queueing it, run `gh workflow run pull-request.yml --ref <branch>`.
+| Event                      | Jobs, in order                                                          |
+| -------------------------- | ----------------------------------------------------------------------- |
+| Pull request               | `ci`                                                                    |
+| Merge queue                | `ci`, then `dev`: `mise run deploy` as `deploy-dev`; `dev-passed`       |
+| Push to `main`             | `prod-preview`, then `prod`, which waits for the `maintainers` approval |
+| Run by hand, from a branch | `ci`, then `dev`                                                        |
+| Run by hand, from `main`   | `prod-preview`, then `prod`                                             |
+
+Dev is shared, so only the merge queue deploys to it (#69, #80). PRs queued together deploy as
+one batch: each queued PR's run skips dev when a newer PR is queued behind it, and the newest
+deploys them all. The queue requires `dev-passed`, so a batch merges only once its dev deploy passes, and `main` gets the exact commit the queue tested, in one push. If the
+newest PR fails, the queue drops it and the rest of the batch deploys without it. A queued PR of only docs or CI skips `dev`. The queue
+doesn't run the integration tests (#161); a run by hand does. To try a
+branch on dev and test it before queueing it, run `gh workflow run pull-request.yml --ref <branch>`.
 
 `prod-preview` runs `mise run preview` as `deploy-runner` and writes the diff to the job summary.
 `prod` runs `mise run deploy` on the same commit once approved. It runs only when the preview shows

package/dist/planning/bonus.d.ts

@@ -1,10 +1,12 @@
 import type { Context } from "./context.ts";
-import type { Id } from "./types.ts";
+import { type OfferingTerms } from "./terms.ts";
+import type { BonusSummary } from "./types.ts";
 /**
- * Records each bonus owner's `bonus_rate` × its products' net for the year, above zero, after the
- * pools or before them. Every base is worked out before any bonus is booked, so one bonus never
- * counts in another's base. Each bonus is divided among the owned offerings by revenue, with the
- * year's payroll tax on it, and neither is counted in MTDC. Returns each position's bonus, by
- * position key.
+ * Records each bonus owner's `bonus_rate` × its products' net in each term, above zero, after the
+ * pools or before them. A term's loss doesn't lower another term's bonus. Offerings in no term, and
+ * anything not on an offering, make one more base, for the year. Every base is worked out before any
+ * bonus is booked, so one bonus never counts in another's base. Each bonus is divided among that
+ * base's offerings by revenue, with the year's payroll tax on it, and neither is counted in MTDC.
+ * Returns each bonus, by owner and term.
  */
-export declare function bookBonuses(ctx: Context): Map<Id, number>;
+export declare function bookBonuses(ctx: Context, terms: OfferingTerms): BonusSummary[];

package/dist/planning/bonus.js

@@ -1,77 +1,99 @@
 import { revenue } from "./measures.js";
+import { compareTerms } from "./terms.js";
 /**
- * Records each bonus owner's `bonus_rate` × its products' net for the year, above zero, after the
- * pools or before them. Every base is worked out before any bonus is booked, so one bonus never
- * counts in another's base. Each bonus is divided among the owned offerings by revenue, with the
- * year's payroll tax on it, and neither is counted in MTDC. Returns each position's bonus, by
- * position key.
+ * Records each bonus owner's `bonus_rate` × its products' net in each term, above zero, after the
+ * pools or before them. A term's loss doesn't lower another term's bonus. Offerings in no term, and
+ * anything not on an offering, make one more base, for the year. Every base is worked out before any
+ * bonus is booked, so one bonus never counts in another's base. Each bonus is divided among that
+ * base's offerings by revenue, with the year's payroll tax on it, and neither is counted in MTDC.
+ * Returns each bonus, by owner and term.
  */
-export function bookBonuses(ctx) {
-    const bonuses = ctx.data.plan_bonus_owners.map((owner) => ({ owner, base: baseOf(ctx, owner) }));
+export function bookBonuses(ctx, terms) {
+    const bonuses = ctx.data.plan_bonus_owners.map((owner) => ({ owner, bases: basesOf(ctx, owner, terms) }));
     const taxRate = ctx.rates?.payroll_tax_rate ?? 0;
     const taxAccount = taxRate > 0 && bonuses.length > 0 ? ctx.costAccount("payroll_tax") : undefined;
-    const byPosition = new Map();
-    for (const { owner, base } of bonuses) {
-        const bonus = owner.bonus_rate * Math.max(0, base.net);
-        if (bonus === 0)
-            continue;
-        const weights = new Map();
-        for (const key of base.offeringKeys) {
-            const r = revenue(ctx, key);
-            if (r > 0)
-                weights.set(key, r);
-        }
-        if (weights.size === 0) {
-            if (base.offeringKeys.length === 0) {
-                ctx.warn("bonus_without_offerings", `${owner.role_name}'s bonus has no offerings this year to charge it to, so it's left out`, owner.key);
-                continue;
-            }
-            // Its net came from elsewhere, such as revenue booked on a product, so its offerings share it evenly.
-            ctx.warn("bonus_without_revenue", `${owner.role_name}'s offerings have no revenue of their own, so its bonus is split evenly among them`, owner.key);
-            for (const key of base.offeringKeys)
-                weights.set(key, 1);
-        }
-        const total = [...weights.values()].reduce((t, w) => t + w, 0);
-        if (owner.position_key != null) {
-            byPosition.set(owner.position_key, (byPosition.get(owner.position_key) ?? 0) + bonus);
-        }
-        for (const [key, w] of weights) {
-            const amount = (bonus * w) / total;
-            ctx.book({
-                cost_center_type: "offering",
-                cost_center_key: key,
-                account_id: owner.account_id,
-                function: ctx.functionFor(owner.account_id, null, "offering"),
-                amount,
-                line_key: `bonus:${owner.key}`,
-                line_name: `Bonus: ${owner.role_name}`,
-                explanation: `${owner.role_name}: ${owner.bonus_rate} × net of its products`,
-                stage: "bonus",
-                mtdc_share: 0,
-            });
-            if (taxAccount === undefined)
-                continue;
-            ctx.book({
-                cost_center_type: "offering",
-                cost_center_key: key,
-                account_id: taxAccount,
-                function: ctx.functionFor(owner.account_id, null, "offering"),
-                amount: amount * taxRate,
-                line_key: `bonus_payroll_tax:${owner.key}`,
-                line_name: `Payroll tax on bonus: ${owner.role_name}`,
-                explanation: `${taxRate} × ${owner.role_name}'s bonus`,
-                stage: "bonus",
-                mtdc_share: 0,
+    const summaries = [];
+    for (const { owner, bases } of bonuses) {
+        const area = areaOf(ctx, owner);
+        for (const base of bases) {
+            const bonus = owner.bonus_rate * Math.max(0, base.net);
+            const booked = bonus === 0 ? 0 : bookBonus(ctx, owner, base, bonus, taxRate, taxAccount);
+            summaries.push({
+                bonus_owner_key: owner.key,
+                role_name: owner.role_name,
+                position_key: owner.position_key ?? null,
+                program_area_id: area,
+                term_key: base.term?.key ?? null,
+                bonus_rate: owner.bonus_rate,
+                net_cents: Math.round(base.net),
+                bonus_cents: Math.round(booked),
             });
         }
     }
-    return byPosition;
+    return summaries;
+}
+/** Books one term's bonus on its offerings, by revenue. Returns what it booked. */
+function bookBonus(ctx, owner, base, bonus, taxRate, taxAccount) {
+    const weights = new Map();
+    for (const key of base.offeringKeys) {
+        const r = revenue(ctx, key);
+        if (r > 0)
+            weights.set(key, r);
+    }
+    if (weights.size === 0) {
+        if (base.offeringKeys.length === 0) {
+            ctx.warn("bonus_without_offerings", `${owner.role_name}'s bonus has no offerings this year to charge it to, so it's left out`, owner.key);
+            return 0;
+        }
+        // Its net came from elsewhere, such as revenue booked on a product, so its offerings share it evenly.
+        ctx.warn("bonus_without_revenue", `${owner.role_name}'s offerings have no revenue of their own, so its bonus is split evenly among them`, owner.key);
+        for (const key of base.offeringKeys)
+            weights.set(key, 1);
+    }
+    const total = [...weights.values()].reduce((t, w) => t + w, 0);
+    for (const [key, w] of weights) {
+        const amount = (bonus * w) / total;
+        ctx.book({
+            cost_center_type: "offering",
+            cost_center_key: key,
+            account_id: owner.account_id,
+            function: ctx.functionFor(owner.account_id, null, "offering"),
+            amount,
+            line_key: `bonus:${owner.key}`,
+            line_name: `Bonus: ${owner.role_name}`,
+            explanation: `${owner.role_name}: ${owner.bonus_rate} × net of its products ${base.term === null ? "in no term" : `in ${base.term.name}`}`,
+            stage: "bonus",
+            mtdc_share: 0,
+        });
+        if (taxAccount === undefined)
+            continue;
+        ctx.book({
+            cost_center_type: "offering",
+            cost_center_key: key,
+            account_id: taxAccount,
+            function: ctx.functionFor(owner.account_id, null, "offering"),
+            amount: amount * taxRate,
+            line_key: `bonus_payroll_tax:${owner.key}`,
+            line_name: `Payroll tax on bonus: ${owner.role_name}`,
+            explanation: `${taxRate} × ${owner.role_name}'s bonus`,
+            stage: "bonus",
+            mtdc_share: 0,
+        });
+    }
+    return bonus;
+}
+/** The program area of all the owner's products, or null when they're in more than one or none. */
+function areaOf(ctx, owner) {
+    const areas = new Set(ctx.data.plan_bonus_owner_products
+        .filter((row) => row.bonus_owner_id === owner.id)
+        .map((row) => ctx.products.get(row.product_id)?.program_area_id ?? null));
+    return areas.size === 1 ? ([...areas][0] ?? null) : null;
 }
 /**
- * The owner's products' net for the year, and their offerings. An area plan's bonus counts only that
- * area's products, and warns about any other.
+ * The owner's products' net in each term they have an offering in, with those offerings, in term
+ * order and then no term. An area plan's bonus counts only that area's products, and warns about any other.
  */
-function baseOf(ctx, owner) {
+function basesOf(ctx, owner, terms) {
     const plan = ctx.planOfVersion.get(owner.version_id);
     const products = new Set();
     for (const row of ctx.data.plan_bonus_owner_products) {
@@ -84,21 +106,37 @@ function baseOf(ctx, owner) {
         }
         products.add(row.product_id);
     }
-    const offeringKeys = new Set(ctx.data.plan_offerings.filter((o) => products.has(o.product_id)).map((o) => o.key));
+    const bases = new Map();
+    const baseFor = (term) => {
+        const base = bases.get(term?.key ?? null) ?? { term, net: 0, offeringKeys: [] };
+        bases.set(term?.key ?? null, base);
+        return base;
+    };
+    const owned = new Set();
+    for (const o of ctx.data.plan_offerings) {
+        if (!products.has(o.product_id))
+            continue;
+        owned.add(o.key);
+        baseFor(terms.get(o.key) ?? null).offeringKeys.push(o.key);
+    }
     const afterPools = (owner.basis ?? "after_shared_costs") === "after_shared_costs";
-    let net = 0;
     for (const e of ctx.entries) {
         if (e.stage === "bonus" || (!afterPools && e.stage === "pool") || e.cost_center_key == null)
             continue;
-        const owned = (e.cost_center_type === "offering" && offeringKeys.has(e.cost_center_key)) ||
-            (e.cost_center_type === "product" && products.has(e.cost_center_key));
-        if (!owned)
+        let term;
+        if (e.cost_center_type === "offering" && owned.has(e.cost_center_key)) {
+            term = terms.get(e.cost_center_key) ?? null;
+        }
+        else if (e.cost_center_type === "product" && products.has(e.cost_center_key)) {
+            term = null;
+        }
+        else
             continue;
         const type = ctx.accountType(e.account_id);
         if (type === "revenue")
-            net += e.amount;
+            baseFor(term).net += e.amount;
         else if (type === "expense")
-            net -= e.amount;
+            baseFor(term).net -= e.amount;
     }
-    return { net, offeringKeys: [...offeringKeys] };
+    return [...bases.values()].sort((a, b) => compareTerms(a.term, b.term));
 }

package/dist/planning/engine.js

@@ -8,6 +8,7 @@ import { bookPayrollTax } from "./payroll.js";
 import { allocatePools } from "./pools.js";
 import { bookRevenue, countDays } from "./revenue.js";
 import { bookSalaries } from "./salaried.js";
+import { compareTerms, offeringTerms } from "./terms.js";
 import { enrollmentOf, round2, Staffing } from "./staffing.js";
 /**
  * Calculates the plan year's P&L from a plan's rows. The steps run in the order
@@ -18,6 +19,7 @@ export function computePlan(data) {
     for (const o of data.plan_offerings)
         ctx.enrollment.set(o.id, enrollmentOf(o));
     checkAreas(ctx);
+    const terms = offeringTerms(ctx);
     const { activities, coaching, doubleBooked } = new Staffing(ctx).run(scheduleActivities(ctx));
     countDays(ctx, activities);
     bookRevenue(ctx);
@@ -30,15 +32,22 @@ export function computePlan(data) {
     bookPayrollTax(ctx);
     const mtdcByOffering = new Map(ctx.data.plan_offerings.map((o) => [o.key, mtdc(ctx, o.key)]));
     allocatePools(ctx);
-    const bonuses = bookBonuses(ctx);
+    const bonuses = bookBonuses(ctx, terms);
+    const bonusByPosition = new Map();
+    for (const b of bonuses) {
+        if (b.position_key == null)
+            continue;
+        bonusByPosition.set(b.position_key, (bonusByPosition.get(b.position_key) ?? 0) + b.bonus_cents);
+    }
     const lines = sumLines(ctx);
     const organization = organizationTotals(ctx, lines);
     return {
         lines,
-        pnl: summarize(ctx, lines, mtdcByOffering),
+        pnl: summarize(ctx, lines, mtdcByOffering, terms),
         organization,
         activities,
-        positions: summarizePositions(ctx, coaching, charged, bonuses, doubleBooked),
+        positions: summarizePositions(ctx, coaching, charged, bonusByPosition, doubleBooked),
+        bonuses,
         capital: rankCapital(ctx, lines, organization),
         warnings: ctx.warnings,
     };
@@ -173,8 +182,8 @@ function sumLines(ctx) {
     })
         .filter((l) => l.amount_cents !== 0);
 }
-/** Each plan-year offering's P&L, then each product's, then each program area's. */
-function summarize(ctx, lines, mtdcByOffering) {
+/** Each plan-year offering's P&L, then each product's, then each program area's, then each area's terms. */
+function summarize(ctx, lines, mtdcByOffering, terms) {
     const pnl = (level, key, own, counts) => {
         const byAccount = new Map();
         let revenue = 0;
@@ -231,24 +240,38 @@ function summarize(ctx, lines, mtdcByOffering) {
     for (const l of lines)
         if (l.cost_center_type === "program_area" && l.cost_center_key !== null)
             areaIds.add(l.cost_center_key);
-    const areaPnl = [...areaIds].sort().map((id) => {
+    const areaPnl = [];
+    const termPnl = [];
+    for (const id of [...areaIds].sort()) {
         const own = offeringPnl.filter((s) => {
             const product = ctx.offeringsByKey.get(s.key)?.product_id;
             return product !== undefined && ctx.products.get(product)?.program_area_id === id;
         });
-        const keys = new Set(own.map((s) => s.key));
         const products = new Set(own.map((s) => ctx.offeringsByKey.get(s.key)?.product_id));
-        const add = (field) => own.reduce((t, s) => t + s[field], 0);
-        return pnl("program_area", id, lines.filter((l) => (l.cost_center_type === "offering" && l.cost_center_key !== null && keys.has(l.cost_center_key)) ||
-            (l.cost_center_type === "product" && products.has(l.cost_center_key ?? undefined)) ||
-            (l.cost_center_type === "program_area" && l.cost_center_key === id)), {
-            mtdc_cents: add("mtdc_cents"),
-            enrollment: add("enrollment"),
-            days: add("days"),
-            sailor_days: add("sailor_days"),
-        });
-    });
-    return [...offeringPnl, ...productPnl, ...areaPnl];
+        // Costs left on the area or a product, because it had no offerings to divide them among, are in no term.
+        const rollup = (level, offerings, leftovers) => {
+            const keys = new Set(offerings.map((s) => s.key));
+            const add = (field) => offerings.reduce((t, s) => t + s[field], 0);
+            return pnl(level, id, lines.filter((l) => (l.cost_center_type === "offering" && l.cost_center_key !== null && keys.has(l.cost_center_key)) ||
+                (leftovers && l.cost_center_type === "product" && products.has(l.cost_center_key ?? undefined)) ||
+                (leftovers && l.cost_center_type === "program_area" && l.cost_center_key === id)), {
+                mtdc_cents: add("mtdc_cents"),
+                enrollment: add("enrollment"),
+                days: add("days"),
+                sailor_days: add("sailor_days"),
+            });
+        };
+        areaPnl.push(rollup("program_area", own, true));
+        const termOf = (s) => terms.get(s.key) ?? null;
+        const areaTerms = [...new Map(own.map((s) => [termOf(s)?.key, termOf(s)])).values()].filter((t) => t !== null);
+        for (const term of [...areaTerms.sort(compareTerms), null]) {
+            const inTerm = own.filter((s) => termOf(s)?.key === term?.key);
+            const row = { ...rollup("program_area_term", inTerm, term === null), term_key: term?.key ?? null };
+            if (inTerm.length > 0 || row.by_account.length > 0)
+                termPnl.push(row);
+        }
+    }
+    return [...offeringPnl, ...productPnl, ...areaPnl, ...termPnl];
 }
 function divide(totals, by) {
     if (by <= 0)

package/dist/planning/lines.js

@@ -79,7 +79,7 @@ export function bookBudgetLines(ctx, booker) {
             line_key: `budget:${line.key}`,
             line_name: line.name,
             explanation: line.name,
-            mtdc_share: line.excluded_from_mtdc ? 0 : 1,
+            mtdc_share: line.in_mtdc ? 1 : 0,
         });
     }
 }

package/dist/planning/revenue.js

@@ -51,7 +51,7 @@ export function bookRevenue(ctx) {
         for (const charge of ctx.data.plan_revenue_charges) {
             if (!(charge.product_kinds ?? []).includes(product.kind))
                 continue;
-            book(charge.account_id, total * charge.rate, `charge:${charge.key}`, charge.name, `${charge.name}: ${charge.rate} × revenue`, charge.excluded_from_mtdc ? 0 : 1);
+            book(charge.account_id, total * charge.rate, `charge:${charge.key}`, charge.name, `${charge.name}: ${charge.rate} × revenue`, charge.in_mtdc ? 1 : 0);
         }
     }
 }

package/dist/planning/terms.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "./context.ts";
+import type { Id, PlanTerm } from "./types.ts";
+/** Each offering's term, by offering key, in no particular order. Null for an offering in none. */
+export type OfferingTerms = Map<Id, PlanTerm | null>;
+/**
+ * Finds each offering's term in the plan's terms. An offering whose term isn't there, such as one deleted
+ * from the Operations Plan, is in none, with a warning.
+ */
+export declare function offeringTerms(ctx: Context): OfferingTerms;
+/** Orders terms by their first days, then names, with no term (null) last. */
+export declare function compareTerms(a: PlanTerm | null, b: PlanTerm | null): number;

package/dist/planning/terms.js

@@ -0,0 +1,22 @@
+/**
+ * Finds each offering's term in the plan's terms. An offering whose term isn't there, such as one deleted
+ * from the Operations Plan, is in none, with a warning.
+ */
+export function offeringTerms(ctx) {
+    const terms = new Map((ctx.data.plan_terms ?? []).map((t) => [t.key, t]));
+    const byOffering = new Map();
+    for (const o of ctx.data.plan_offerings) {
+        const term = o.term_key == null ? null : (terms.get(o.term_key) ?? null);
+        if (o.term_key != null && term === null) {
+            ctx.warn("unknown_term", `${o.name} is in a term the Operations Plan doesn't have, so it counts as in no term`, o.key);
+        }
+        byOffering.set(o.key, term);
+    }
+    return byOffering;
+}
+/** Orders terms by their first days, then names, with no term (null) last. */
+export function compareTerms(a, b) {
+    if (a === null || b === null)
+        return a === b ? 0 : a === null ? 1 : -1;
+    return a.starts_on.localeCompare(b.starts_on) || a.name.localeCompare(b.name) || a.key.localeCompare(b.key);
+}

package/dist/planning/types.d.ts

@@ -192,8 +192,8 @@ export interface PlanBudgetLine extends Versioned {
     cost_center_key: Id | null;
     amount_cents: number;
     fiscal_year: number;
-    /** Set for a cost 2 CFR 200.1 leaves out of MTDC, such as equipment or participant support. */
-    excluded_from_mtdc: boolean;
+    /** Whether it counts toward MTDC; cleared for a cost 2 CFR 200.1 leaves out, such as equipment or participant support. */
+    in_mtdc: boolean;
     note: string | null;
 }
 /**
@@ -274,7 +274,8 @@ export interface PlanRevenueCharge extends Versioned {
     product_kinds: ProductKind[] | null;
     /** A revenue account adds revenue; an expense account adds a cost. */
     account_id: Id;
-    excluded_from_mtdc: boolean;
+    /** Whether it counts toward MTDC; cleared for one 2 CFR 200.1 leaves out, such as scholarships. */
+    in_mtdc: boolean;
     note: string | null;
 }
 /** A day the organization is closed, such as Labor Day. */
@@ -349,9 +350,12 @@ export interface Totals {
 }
 /** One offering's P&L for the plan year, or a product's or program area's, which adds up its offerings. */
 export interface Pnl extends Totals {
-    level: "offering" | "product" | "program_area";
+    /** `program_area_term` is a program area's offerings in one term, or in none. */
+    level: "offering" | "product" | "program_area" | "program_area_term";
     /** An offering key, a product id, or a program area id. */
     key: Id;
+    /** A `program_area_term`'s `plan_terms` key, null for its offerings in no term. Only that level has one. */
+    term_key?: Id | null;
     /** Each account's total, revenue and expense alike. */
     by_account: {
         account_id: Id;
@@ -447,10 +451,26 @@ export interface PositionSummary {
     /** Dates it's on two or more groups at once. */
     double_booked_dates: number;
 }
+/** A bonus owner's bonus for one term, or on its offerings in no term for the year. */
+export interface BonusSummary {
+    bonus_owner_key: Id;
+    role_name: string;
+    position_key: Id | null;
+    /** The program area of all the owner's products, or null when they're in more than one. */
+    program_area_id: Id | null;
+    /** A `plan_terms` key, or null for its offerings in no term. */
+    term_key: Id | null;
+    bonus_rate: number;
+    /** The net the bonus is figured on, which can be below zero. */
+    net_cents: number;
+    bonus_cents: number;
+}
 export interface EngineOutput {
     lines: CostLine[];
-    /** Each offering's P&L, then each product's, then each program area's. */
+    /** Each offering's P&L, then each product's, then each program area's, then each area's terms. */
     pnl: Pnl[];
+    /** Each bonus owner's bonus in each term it has offerings in, then in no term. */
+    bonuses: BonusSummary[];
     organization: OrganizationTotals;
     activities: ComputedActivity[];
     /** Each salaried position's pay for the year. */

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
 /** Every collection, for `createDirectus<Schema>()`. */
 export interface Schema {
     accounts: Accounts[];
+    announcements: Announcements[];
     assets: Assets[];
     audit_findings: AuditFindings[];
     boat_classes: BoatClasses[];
@@ -26,6 +27,7 @@ export interface Schema {
     group_policies: GroupPolicies[];
     groups: Groups[];
     households: Households[];
+    links: Links[];
     medical_profiles: MedicalProfiles[];
     offerings: Offerings[];
     organization_cost_accounts: OrganizationCostAccounts[];
@@ -46,6 +48,7 @@ export interface Schema {
     plan_pools: PlanPools[];
     plan_programs: PlanPrograms[];
     plan_rates: PlanRates[];
+    plan_result_bonuses: PlanResultBonuses[];
     plan_result_capital: PlanResultCapital[];
     plan_result_lines: PlanResultLines[];
     plan_result_pnl: PlanResultPnl[];
@@ -113,6 +116,14 @@ export interface Accounts {
     /** Kept for history, and closed to new lines. */
     retired: boolean;
 }
+/** What Sail Team's home page shows, newest first. */
+export interface Announcements {
+    id: string;
+    title: string;
+    body: string;
+    /** The date the home page shows. Newest comes first. */
+    published_on: string;
+}
 /** Each boat, motor and piece of equipment CSC owns: sailboats, powerboats such as the coach boats, motors, and others such as trailers. Planning counts the boats of each class CSC has on each day. */
 export interface Assets {
     id: string;
@@ -445,6 +456,24 @@ export interface Households {
     share_contact: boolean | null;
     date_created: string | null;
 }
+/** The Links page in Sail Team. Drag the rows to change their order. */
+export interface Links {
+    id: string;
+    title: string;
+    /** The page's address, starting with https://. */
+    url: string;
+    /** A line under the title, if it needs one. */
+    note: string | null;
+    sort: number | null;
+    /** The page's own title, read from the page when the link is saved. */
+    preview_title: string | null;
+    /** The page's own summary, read from the page when the link is saved. */
+    preview_description: string | null;
+    /** The address of the page's own picture, read from the page when the link is saved. */
+    preview_image: string | null;
+    /** When the page was last read. Empty if it couldn't be read: save the link again to retry. */
+    previewed_at: string | null;
+}
 /** A person's medical information, kept apart from People so only some staff see it. */
 export interface MedicalProfiles {
     id: string;
@@ -652,8 +681,8 @@ export interface PlanBudgetLines {
     /** In cents: 12500 is $125.00. */
     amount_cents: number;
     fiscal_year: number;
-    /** Set for a cost left out of modified total direct costs (MTDC), such as equipment. */
-    excluded_from_mtdc: boolean;
+    /** Counts toward modified total direct costs (MTDC). Clear it for a cost 2 CFR 200.1 leaves out, such as equipment. */
+    in_mtdc: boolean;
     note: string | null;
 }
 /** Something lasting CSC means to buy, ranked with the most needed first. */
@@ -768,6 +797,29 @@ export interface PlanRates {
     /** In cents: 12500 is $125.00. */
     mileage_rate_cents: number | null;
 }
+/** Each bonus in a Financial Plan, for each term, and for the offerings in no term on the year. A draft's are worked out again a moment after each change to it, and a saved one's when it's saved, and then never change. */
+export interface PlanResultBonuses {
+    id: string;
+    /** The bonus's role, such as Director. */
+    name: string;
+    term_key: string | null;
+    /** The term it's paid on. Empty for the offerings in no term, such as Adult Learn to Sail, whose bonus is worked out on the year. */
+    term_name: string | null;
+    /** The term's first day, which puts the terms in order. */
+    term_starts_on: string | null;
+    /** A share of the net. 0.05 means 5%. */
+    bonus_rate: string;
+    /** The net of its products in the term, which the bonus is figured on. In cents: 12500 is $125.00. */
+    net_cents: number;
+    /** Its rate × the net, or nothing when the net is a loss. In cents: 12500 is $125.00. */
+    bonus_cents: number;
+    bonus_owner_key: string;
+    program_area_key: string | null;
+    /** The Financial Plan these results are for. */
+    version_set_id: string | VersionSets;
+    /** The plan in the Financial Plan that pays the bonus. */
+    version_set_member_id: string | VersionSetMembers | null;
+}
 /** The capital list in rank order, in a Financial Plan, with what the year's money covers. A draft's are worked out again a moment after each change to it, and a saved one's when it's saved, and then never change. */
 export interface PlanResultCapital {
     id: string;
@@ -807,7 +859,7 @@ export interface PlanResultLines {
 /** A Financial Plan's P&L for each offering, product, and program area. A draft's are worked out again a moment after each change to it, and a saved one's when it's saved, and then never change. */
 export interface PlanResultPnl {
     id: string;
-    level: "offering" | "product" | "program_area";
+    level: "offering" | "product" | "program_area" | "program_area_term";
     subject_key: string;
     name: string;
     /** In cents: 12500 is $125.00. */
@@ -825,6 +877,11 @@ export interface PlanResultPnl {
     version_set_id: string | VersionSets;
     /** The plan in the Financial Plan that holds what it's charged to. */
     version_set_member_id: string | VersionSetMembers | null;
+    term_key: string | null;
+    /** For a program area by term, the term. Empty for its offerings in no term, such as Adult Learn to Sail. */
+    term_name: string | null;
+    /** The term's first day, which puts the terms in order. */
+    term_starts_on: string | null;
 }
 /** Each salaried position's pay for the year, in a Financial Plan. A draft's are worked out again a moment after each change to it, and a saved one's when it's saved, and then never change. */
 export interface PlanResultPositions {
@@ -908,8 +965,8 @@ export interface PlanRevenueCharges {
     product_kinds: ("program" | "charter" | "storage_lease" | "merchandise" | "event_hosting" | "other")[] | null;
     /** A revenue account adds revenue, such as card fees families pay. An expense account adds a cost. */
     account_id: string | Accounts;
-    /** Set for a charge 2 CFR 200.1 leaves out of MTDC, such as scholarships. */
-    excluded_from_mtdc: boolean;
+    /** Counts toward MTDC. Clear it for a charge 2 CFR 200.1 leaves out, such as scholarships. */
+    in_mtdc: boolean;
     note: string | null;
 }
 /** Hours of a salaried position booked to a product. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyc-seattle/platform",
-  "version": "1.50.0",
+  "version": "1.52.0",
   "description": "Pulumi components for CYC's shared Google Cloud platform: WebService, the platform outputs reader, and the stacks that build the platform",
   "author": "CYC Community Sailing Center",
   "license": "Apache-2.0",