@cyc-seattle/platform 1.49.0 → 1.51.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/context.d.ts

@@ -18,7 +18,7 @@ export interface Entry {
     line_name: string;
     explanation: string;
     stage: Stage;
-    /** How much of the amount MTDC counts: 0 when excluded, a fraction for a mix of rented and owned RIBs. */
+    /** How much of the amount MTDC counts: 1, or 0 when it leaves MTDC, such as a boat charter. */
     mtdc_share: number;
     /** Whether it's wages, which payroll tax is charged on. */
     wages: boolean;

package/dist/planning/context.js

@@ -1,7 +1,6 @@
 /** The warnings about what the blocks are given, or when they run. The rest are about the data. */
 const ALLOCATION_WARNINGS = new Set([
     "over_inventory_boats",
-    "over_inventory_resource",
     "over_capacity",
     "unallocated_activity",
     "closed_date",
@@ -12,9 +11,9 @@ const COST_TYPES = {
     coach_wages: "coach wages",
     salaries: "salaries",
     payroll_tax: "payroll tax",
-    ribs: "RIBs",
+    ribs: "coach boats",
     boat_maintenance: "boat maintenance",
-    resources: "resources",
+    resources: "boat charters",
     travel: "travel",
     cogs: "cost of goods sold",
 };

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/staffing.d.ts

@@ -43,9 +43,17 @@ export declare class Staffing {
      * Boats count the ones sailors bring.
      */
     private checkCapacity;
+    /** Books a cost on a block, split among its activities by their offerings' sailors. */
+    private book;
     /**
-     * Warns when the organization's boats of one class, or a resource such as RIBs, are given to more
-     * blocks at once on a date than it has. Boats sailors bring don't count.
+     * Charges each boat class's charter rate once a day, for the most of its boats chartered at once
+     * that day, shared among the blocks that charter them by how many each does. A charter is a rental,
+     * so it's left out of MTDC (2 CFR 200.1).
+     */
+    private bookCharters;
+    /**
+     * Warns when more of the organization's boats of one class are given to blocks at once on a date
+     * than it has that day on the asset list. Boats it charters, or sailors bring, don't count.
      */
     private checkInventory;
     /**
@@ -53,7 +61,7 @@ export declare class Staffing {
      * both. Returns each position's double-booked hours and dates.
      */
     private checkDoubleBooked;
-    /** Costs every block's staff, RIBs, boats and resources, and checks them against the limits. */
+    /** Costs every block's staff and boats, and checks them against the limits. */
     run(scheduled: ScheduledActivity[]): {
         activities: ComputedActivity[];
         coaching: SalariedCoaching[];

package/dist/planning/staffing.js

@@ -61,7 +61,6 @@ export class Staffing {
     blocks(scheduled) {
         const { data } = this.ctx;
         const staff = groupBy(data.plan_block_staff, (r) => r.block_id);
-        const resources = groupBy(data.plan_block_resources, (r) => r.block_id);
         const boats = groupBy(data.plan_block_boats, (r) => r.block_id);
         const rows = new Map(data.plan_activity_blocks.map((b) => [b.id, b]));
         const members = new Map();
@@ -103,7 +102,6 @@ export class Staffing {
                     Math.max(0, ...list.map((a) => a.stored.putaway_minutes ?? 0)),
                 on_water_minutes: set.length > 0 ? Math.max(...set) : sailingMinutes,
                 staff: staff.get(id) ?? [],
-                resources: resources.get(id) ?? [],
                 boats: boats.get(id) ?? [],
                 shares: new Map(list.map((a) => [a, share(a)])),
             });
@@ -171,12 +169,13 @@ export class Staffing {
         const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
         let seats = 0;
         for (const b of block.boats) {
-            const perBoat = classes.get(b.boat_class_id)?.sailors_per_boat;
-            if (perBoat == null || perBoat <= 0) {
-                this.warnOnce("no_sailors_per_boat", `${classes.get(b.boat_class_id)?.name ?? b.boat_class_id} has no sailors per boat. Add it to check that the boats hold every sailor`, b.boat_class_id, scope);
+            // A coach boat's class takes 0, without a warning.
+            const perBoat = classes.get(b.boat_class_id)?.max_capacity;
+            if (perBoat == null) {
+                this.warnOnce("no_max_capacity", `${classes.get(b.boat_class_id)?.name ?? b.boat_class_id} has no max capacity. Add it to check that the boats hold every sailor`, b.boat_class_id, scope);
                 continue;
             }
-            seats += (b.count + (b.sailor_owned ?? 0)) * perBoat;
+            seats += (b.count + (b.chartered ?? 0) + (b.sailor_owned ?? 0)) * perBoat;
         }
         if (sailors > seats) {
             ctx.warn("over_capacity", seats === 0
@@ -184,28 +183,79 @@ export class Staffing {
                 : `${has} ${countOf(sailors, "sailor")}, but the boats hold only ${seats}`, block.row.key, scope);
         }
     }
+    /** Books a cost on a block, split among its activities by their offerings' sailors. */
+    book(block, account, amount, line, name, explanation, mtdcShare = 1, wages = false) {
+        if (amount === 0 || account === undefined)
+            return;
+        for (const [a, share] of block.shares) {
+            this.ctx.book({
+                cost_center_type: "offering",
+                cost_center_key: a.offering.key,
+                account_id: account,
+                function: this.ctx.functionFor(account, null, "offering"),
+                amount: amount * share,
+                line_key: `${line}:${a.offering.key}`,
+                line_name: name,
+                explanation,
+                mtdc_share: mtdcShare,
+                wages,
+            });
+        }
+    }
+    /**
+     * Charges each boat class's charter rate once a day, for the most of its boats chartered at once
+     * that day, shared among the blocks that charter them by how many each does. A charter is a rental,
+     * so it's left out of MTDC (2 CFR 200.1).
+     */
+    bookCharters(blocks) {
+        const { ctx } = this;
+        const rates = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r]));
+        const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
+        for (const list of groupBy(blocks, (b) => b.row.date).values()) {
+            const chartered = list.flatMap((block) => block.boats.flatMap((b) => ((b.chartered ?? 0) > 0 ? [{ block, id: b.boat_class_id, n: b.chartered }] : [])));
+            for (const [id, uses] of groupBy(chartered, (c) => c.id)) {
+                const name = classes.get(id)?.name ?? id;
+                const rate = rates.get(id)?.charter_per_day_cents;
+                if (rate == null) {
+                    for (const { block } of uses) {
+                        this.warnOnce("no_charter_rate", `${block.row.name} charters ${pluralOf(name)}, but the Operations Plan has no charter rate for them, so they cost nothing`, id, { version_id: block.row.version_id, date: block.row.date });
+                    }
+                    continue;
+                }
+                const day = mostAtOnce(uses).total * rate;
+                const total = sum(uses.map((u) => u.n));
+                for (const { block, n } of uses) {
+                    this.book(block, ctx.costAccount("resources"), (day * n) / total, `charters:${id}`, `Boat charters: ${name}`, "The most boats of the class chartered at once that day × the class's charter rate", 0);
+                }
+            }
+        }
+    }
     /**
-     * Warns when the organization's boats of one class, or a resource such as RIBs, are given to more
-     * blocks at once on a date than it has. Boats sailors bring don't count.
+     * Warns when more of the organization's boats of one class are given to blocks at once on a date
+     * than it has that day on the asset list. Boats it charters, or sailors bring, don't count.
      */
     checkInventory(blocks) {
         const { ctx } = this;
         const dates = groupBy(blocks, (b) => b.row.date);
         const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
-        const fleet = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r.quantity]));
-        const resources = new Map(ctx.data.plan_resources.map((r) => [r.key, r]));
+        const assets = new Map(ctx.data.assets.map((a) => [a.id, a]));
+        const boats = ctx.data.boats.flatMap((b) => {
+            const asset = assets.get(b.asset_id);
+            return asset === undefined ? [] : [{ asset, boat_class_id: b.boat_class_id }];
+        });
         const organization = ctx.data.organization.name;
         for (const [date, list] of dates) {
+            const has = (a) => (a.acquired_on == null || a.acquired_on <= date) && (a.disposed_on == null || date < a.disposed_on);
             const check = (code, what, have, used) => {
-                if (have == null)
-                    return;
                 const out = list.flatMap((b) => (used(b) > 0 ? [{ block: b, n: used(b) }] : []));
                 const peak = mostAtOnce(out);
                 if (peak.total <= have)
                     return;
+                const only = have === 0 ? "none" : `only ${have}`;
+                const count = countOf(peak.total, what);
                 const message = peak.at.length === 1
-                    ? `${countOf(peak.total, what)} out at once for ${offeringsOf(peak.at[0].block)}, but ${organization} has only ${have}`
-                    : `${countOf(peak.total, what)} out at once, but ${organization} has only ${have}: ${listOf(peak.at.map(({ block, n }) => `${n} for ${offeringsOf(block)}`))}`;
+                    ? `${count} out at once for ${offeringsOf(peak.at[0].block)}, but ${organization} has ${only}`
+                    : `${count} out at once, but ${organization} has ${only}: ${listOf(peak.at.map(({ block, n }) => `${n} for ${offeringsOf(block)}`))}`;
                 for (const version of new Set(peak.at.map(({ block }) => block.row.version_id))) {
                     ctx.warn(code, message, what, {
                         version_id: version,
@@ -215,17 +265,8 @@ export class Staffing {
             };
             const classIds = new Set(list.flatMap((b) => b.boats.filter((x) => x.count > 0).map((x) => x.boat_class_id)));
             for (const id of classIds) {
-                if (fleet.get(id) == null) {
-                    for (const b of list.filter((x) => x.boats.some((y) => y.boat_class_id === id && y.count > 0))) {
-                        this.warnOnce("no_fleet_quantity", `The Operations Plan doesn't say how many ${pluralOf(classes.get(id)?.name ?? id)} ${organization} has. Add it to check that there are enough`, id, { version_id: b.row.version_id, date });
-                    }
-                }
-                check("over_inventory_boats", classes.get(id)?.name ?? id, fleet.get(id), (b) => sum(b.boats.filter((x) => x.boat_class_id === id).map((x) => x.count)));
-            }
-            const resourceKeys = new Set(list.flatMap((b) => b.resources.map((x) => x.resource_key)));
-            for (const key of resourceKeys) {
-                const resource = resources.get(key);
-                check("over_inventory_resource", resource?.name ?? key, resource?.quantity, (b) => sum(b.resources.filter((x) => x.resource_key === key).map((x) => x.quantity)));
+                const have = boats.filter((b) => b.boat_class_id === id && has(b.asset)).length;
+                check("over_inventory_boats", classes.get(id)?.name ?? id, have, (b) => sum(b.boats.filter((x) => x.boat_class_id === id).map((x) => x.count)));
             }
         }
     }
@@ -260,7 +301,7 @@ export class Staffing {
         }
         return result;
     }
-    /** Costs every block's staff, RIBs, boats and resources, and checks them against the limits. */
+    /** Costs every block's staff and boats, and checks them against the limits. */
     run(scheduled) {
         const { ctx } = this;
         const blocks = this.blocks(scheduled);
@@ -274,37 +315,14 @@ export class Staffing {
         const coaching = [];
         const levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
         const positions = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
-        const resources = new Map(ctx.data.plan_resources.map((r) => [r.key, r]));
         const boatClasses = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
         const boatRates = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r]));
-        const ribKind = ctx.data.rib_resource_kind_id;
         const given = new Map();
         for (const block of byDate(blocks)) {
             const scope = { version_id: block.row.version_id, date: block.row.date };
             const paidHours = block.paid_minutes / 60;
             const waterHours = block.on_water_minutes / 60;
-            // Each cost is split among the block's activities by their offerings' sailors.
-            const book = (type, amount, line, name, explanation, mtdcShare = 1) => {
-                if (amount === 0)
-                    return;
-                const account = ctx.costAccount(type);
-                if (account === undefined)
-                    return;
-                for (const [a, share] of block.shares) {
-                    ctx.book({
-                        cost_center_type: "offering",
-                        cost_center_key: a.offering.key,
-                        account_id: account,
-                        function: ctx.functionFor(account, null, "offering"),
-                        amount: amount * share,
-                        line_key: `${line}:${a.offering.key}`,
-                        line_name: name,
-                        explanation,
-                        mtdc_share: mtdcShare,
-                        wages: type === "coach_wages",
-                    });
-                }
-            };
+            const book = (type, amount, line, name, explanation) => this.book(block, ctx.costAccount(type), amount, line, name, explanation, 1, type === "coach_wages");
             let wages = 0;
             for (const s of block.staff) {
                 if (s.count <= 0)
@@ -350,32 +368,20 @@ export class Staffing {
                     wages += s.count * paidHours * (level.hourly_rate_cents ?? 0);
             }
             book("coach_wages", wages, "coach_wages", "Coach wages", "Staff × paid hours × each one's hourly rate");
-            let ribs = 0;
-            for (const use of block.resources) {
-                const resource = resources.get(use.resource_key);
-                if (resource === undefined) {
-                    this.warnOnce("unknown_resource", `${block.row.name} uses resource ${use.resource_key}, which isn't in the plan`, use.resource_key, scope);
-                    continue;
-                }
-                const rib = ribKind != null && resource.resource_kind_id === ribKind;
-                if (rib)
-                    ribs += use.quantity;
-                const hours = use.hours ?? (rib ? waterHours : paidHours);
-                const cost = use.quantity * (hours * hourlyCost(resource) + (resource.cost_per_day_cents ?? 0));
-                book(rib ? "ribs" : "resources", cost, rib ? "ribs" : `resource:${resource.key}`, rib ? "RIBs" : resource.name, `${resource.name}: quantity × hours × hourly cost, plus a day rate`, resource.excluded_from_mtdc ? 0 : 1);
-            }
             for (const b of block.boats) {
                 const rate = boatRates.get(b.boat_class_id);
                 if (rate === undefined || b.count <= 0 || waterHours <= 0)
                     continue;
-                book("boat_maintenance", b.count * waterHours * rate.maintenance_per_boat_hour_cents, `boats:${b.boat_class_id}`, `Boat maintenance: ${boatClasses.get(b.boat_class_id)?.name ?? "boats"}`, "The organization's boats × on-water hours × the class's maintenance rate");
+                const boatClass = boatClasses.get(b.boat_class_id);
+                this.book(block, boatClass?.account_id ?? ctx.costAccount("boat_maintenance"), b.count * waterHours * (rate.maintenance_per_boat_hour_cents + (rate.fuel_per_hour_cents ?? 0)), `boats:${b.boat_class_id}`, `Boats: ${boatClass?.name ?? "boats"}`, "The organization's boats × on-water hours × the class's fuel and upkeep");
             }
             const coaches = sum(block.staff.map((s) => s.count));
-            const boats = sum(block.boats.map((b) => b.count));
+            const boats = sum(block.boats.map((b) => b.count + (b.chartered ?? 0)));
             for (const [a, share] of block.shares) {
-                given.set(a, { coaches: coaches * share, ribs: ribs * share, boats: boats * share });
+                given.set(a, { coaches: coaches * share, boats: boats * share });
             }
         }
+        this.bookCharters(byDate(blocks));
         this.bookTrips(blocks, scheduled);
         return {
             coaching,
@@ -391,7 +397,6 @@ export class Staffing {
                 on_water_minutes: a.on_water_minutes,
                 uses_boats: a.uses_boats,
                 coaches: given.get(a)?.coaches ?? 0,
-                ribs: given.get(a)?.ribs ?? 0,
                 boats: given.get(a)?.boats ?? 0,
                 block_id: blocks.has(a.stored.block_id ?? "") ? a.stored.block_id : null,
             })),
@@ -508,9 +513,6 @@ function extraCoachMinutes(list) {
     }
     return minutes;
 }
-function hourlyCost(r) {
-    return (r.cost_per_hour_cents ?? 0) + (r.fuel_per_hour_cents ?? 0) + (r.maintenance_per_hour_cents ?? 0);
-}
 export function round2(n) {
     return Math.round(n * 100) / 100;
 }

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

@@ -52,12 +52,27 @@ export interface QualificationCover {
 export interface BoatClass {
     id: Id;
     name: string;
-    sailors_per_boat: number | null;
+    /** The most sailors one boat can safely take. */
+    max_capacity: number | null;
     footprint_sq_ft: number | null;
+    /** Where its own boats' fuel and upkeep are booked; empty for the boat maintenance cost type's. */
+    account_id?: Id | null;
 }
-export interface ResourceKind {
+/** Something the organization owns: a sailboat, a powerboat, a motor, or other equipment. */
+export interface Asset {
     id: Id;
-    name: string;
+    kind: "sailboat" | "powerboat" | "motor" | "other";
+    name: string | null;
+    /** The day the organization got it, or expects to; empty counts it from the start. */
+    acquired_on: DateString | null;
+    /** The day it stopped being the organization's; empty while it still is. */
+    disposed_on: DateString | null;
+}
+/** A sailboat or powerboat asset's class. */
+export interface Boat {
+    id: Id;
+    asset_id: Id;
+    boat_class_id: Id;
 }
 export interface Organization {
     id: Id;
@@ -134,7 +149,7 @@ export interface PlanActivity extends Versioned {
     /** The block it's staffed in, if any. */
     block_id: Id | null;
 }
-/** Activities on one date that share their staff, RIBs and boats. */
+/** Activities on one date that share their staff and boats. */
 export interface PlanActivityBlock extends Versioned {
     date: DateString;
     name: string;
@@ -150,21 +165,13 @@ export interface PlanBlockStaff extends Versioned {
     /** How a salaried position is paid for the block: out of its salary (the default), or by the hour at its own rate. */
     pay: "salary" | "hourly" | null;
 }
-/** A resource on a block, such as RIBs. */
-export interface PlanBlockResource extends Versioned {
-    block_id: Id;
-    /** A `plan_resources` key. */
-    resource_key: Id;
-    quantity: number;
-    /** Hours each is used; empty for the block's time on the water (RIBs) or its paid time (the rest). */
-    hours: number | null;
-}
-/** Boats of one class on a block: the organization's, and the ones sailors bring. */
+/** Boats of one class on a block: the organization's, the ones it charters, and the ones sailors bring. */
 export interface PlanBlockBoats extends Versioned {
     block_id: Id;
     boat_class_id: Id;
     count: number;
     sailor_owned: number | null;
+    chartered?: number | null;
 }
 export interface PlanLaborLine extends Versioned {
     name: string;
@@ -231,22 +238,15 @@ export interface PlanSalariedBooking extends Versioned {
     kind: "management";
     hours: number;
 }
-export interface PlanResource extends Versioned {
-    resource_kind_id: Id;
-    name: string;
-    quantity: number | null;
-    cost_per_hour_cents: number | null;
-    cost_per_day_cents: number | null;
-    fuel_per_hour_cents: number | null;
-    maintenance_per_hour_cents: number | null;
-    /** Set for a rental, whose cost leaves MTDC. */
-    excluded_from_mtdc: boolean;
-}
+/** A boat class's rates for the year. */
 export interface PlanBoatRate extends Versioned {
     boat_class_id: Id;
+    /** Upkeep for each hour one of the organization's boats of the class is on the water. */
     maintenance_per_boat_hour_cents: number;
-    /** How many boats of the class the organization has. */
-    quantity: number | null;
+    /** Fuel for each hour one is on the water. */
+    fuel_per_hour_cents?: number | null;
+    /** What one costs to charter for a day. */
+    charter_per_day_cents?: number | null;
 }
 /** A group of shared costs, such as G&A, divided among all of the plan's offerings by MTDC. */
 export interface PlanPool extends Versioned {
@@ -294,15 +294,15 @@ export interface PlanData {
     fiscal_year: number;
     organization: Organization;
     organization_cost_accounts: OrganizationCostAccount[];
-    /** The resource kind whose `plan_resources` price RIB hours. */
-    rib_resource_kind_id: Id | null;
     products: Product[];
     program_areas: ProgramArea[];
     accounts: Account[];
     qualifications: Qualification[];
     qualification_covers: QualificationCover[];
     boat_classes: BoatClass[];
-    resource_kinds: ResourceKind[];
+    /** The asset list, with its boats, which the engine counts by class on each day. */
+    assets: Asset[];
+    boats: Boat[];
     /** The plans and versions being calculated, so the engine can tell which plan each offering is in. */
     plans: Plan[];
     plan_versions: PlanVersion[];
@@ -312,7 +312,6 @@ export interface PlanData {
     plan_activities: PlanActivity[];
     plan_activity_blocks: PlanActivityBlock[];
     plan_block_staff: PlanBlockStaff[];
-    plan_block_resources: PlanBlockResource[];
     plan_block_boats: PlanBlockBoats[];
     plan_labor_lines: PlanLaborLine[];
     plan_budget_lines: PlanBudgetLine[];
@@ -321,7 +320,6 @@ export interface PlanData {
     plan_staff_levels: PlanStaffLevel[];
     plan_salaried_positions: PlanSalariedPosition[];
     plan_salaried_bookings: PlanSalariedBooking[];
-    plan_resources: PlanResource[];
     plan_boat_rates: PlanBoatRate[];
     plan_pools: PlanPool[];
     plan_bonus_owners: PlanBonusOwner[];
@@ -351,9 +349,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;
@@ -378,9 +379,8 @@ export interface ComputedActivity {
     paid_minutes: number;
     on_water_minutes: number;
     uses_boats: boolean;
-    /** Its share of its block's staff, RIBs and boats, by its sailors. */
+    /** Its share of its block's staff and boats, the organization's and chartered, by its sailors. */
     coaches: number;
-    ribs: number;
     boats: number;
     block_id: Id | null;
 }
@@ -450,10 +450,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,8 @@
 /** Every collection, for `createDirectus<Schema>()`. */
 export interface Schema {
     accounts: Accounts[];
+    announcements: Announcements[];
+    assets: Assets[];
     audit_findings: AuditFindings[];
     boat_classes: BoatClasses[];
     boats: Boats[];
@@ -25,6 +27,7 @@ export interface Schema {
     group_policies: GroupPolicies[];
     groups: Groups[];
     households: Households[];
+    links: Links[];
     medical_profiles: MedicalProfiles[];
     offerings: Offerings[];
     organization_cost_accounts: OrganizationCostAccounts[];
@@ -33,7 +36,6 @@ export interface Schema {
     plan_activities: PlanActivities[];
     plan_activity_blocks: PlanActivityBlocks[];
     plan_block_boats: PlanBlockBoats[];
-    plan_block_resources: PlanBlockResources[];
     plan_block_staff: PlanBlockStaff[];
     plan_boat_rates: PlanBoatRates[];
     plan_bonus_owner_products: PlanBonusOwnerProducts[];
@@ -46,7 +48,7 @@ export interface Schema {
     plan_pools: PlanPools[];
     plan_programs: PlanPrograms[];
     plan_rates: PlanRates[];
-    plan_resources: PlanResources[];
+    plan_result_bonuses: PlanResultBonuses[];
     plan_result_capital: PlanResultCapital[];
     plan_result_lines: PlanResultLines[];
     plan_result_pnl: PlanResultPnl[];
@@ -70,7 +72,6 @@ export interface Schema {
     qualification_covers: QualificationCovers[];
     qualifications: Qualifications[];
     registrations: Registrations[];
-    resource_kinds: ResourceKinds[];
     schools: Schools[];
     sync_leases: SyncLeases[];
     sync_runs: SyncRuns[];
@@ -115,6 +116,39 @@ 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;
+    /** A sailboat or powerboat also needs a row in Boats. Directus can't check that, so keep them matching. */
+    kind: "sailboat" | "powerboat" | "motor" | "other";
+    /** Its name, if it has one, such as Scooter or the van. */
+    name: string | null;
+    /** This asset's boat details, if it is a sailboat or powerboat. */
+    boats: (string | Boats)[];
+    /** Who made it, such as Zodiac or Yamaha. */
+    make: string | null;
+    /** Its model. A boat's model is its boat class, in Boats. */
+    model: string | null;
+    /** The number that identifies it: a boat's hull number (HIN), a vehicle's VIN, or a serial number. */
+    identifier: string | null;
+    /** The state registration number, such as WN 1234 AB, if it has one. */
+    registration_number: string | null;
+    /** Its book value, as in QuickBooks account 1500. In cents: 12500 is $125.00. */
+    value_cents: number | null;
+    /** The day CSC got it, or expects to. Planning counts it from this day; empty counts it from the start. */
+    acquired_on: string | null;
+    /** The day CSC sold, scrapped, or gave it away. Planning stops counting it on this day. Empty while CSC still has it. */
+    disposed_on: string | null;
+    note: string | null;
+}
 /** Something a sync noticed but didn't fix. A dismissed finding stays dismissed on later runs. */
 export interface AuditFindings {
     id: string;
@@ -133,28 +167,22 @@ export interface AuditFindings {
 export interface BoatClasses {
     id: string;
     name: string;
-    sailors_per_boat: number;
+    /** The most sailors one boat can safely take, such as 4 in an FJ. 0 for a coach boat. */
+    max_capacity: number;
     /** Dry-storage area one boat takes. */
     footprint_sq_ft: string | null;
+    /** Where the fuel and upkeep of CSC's own boats of the class are booked, such as Coach boats for a RIB. Empty books them to boat maintenance. */
+    account_id: string | Accounts | null;
 }
-/** Each boat CSC owns, for planning the year. Sailors' own boats aren't listed here. */
+/** A boat's own details, sail or power: its class and sail number. Sailors' own boats aren't listed here. */
 export interface Boats {
     id: string;
+    /** The asset this boat is. Its kind must be Sailboat or Powerboat. */
+    asset_id: string | Assets;
+    /** Such as Opti, 420, or RIB. */
     boat_class_id: string | BoatClasses;
-    /** The boat's name, if it has one. */
-    name: string | null;
+    /** A sailboat's, if it has one. */
     sail_number: string | null;
-    /** The hull identification number on the transom, if it's known. */
-    hull_number: string | null;
-    /** What the boat is worth. In cents: 12500 is $125.00. */
-    value_cents: number | null;
-    /** The day CSC got the boat. */
-    acquired_on: string | null;
-    /** The day the boat first sailed in a program. */
-    in_service_on: string | null;
-    /** The day CSC stopped using the boat. Empty while it's still in use. */
-    retired_on: string | null;
-    note: string | null;
 }
 /** An offering of a program that plans and Clubspot both point to, such as "J-Pod · fall practices" or "Summer camp · week 3". Each Financial Plan sets its own price, schedule, and size for it, and Clubspot's offerings are linked to it. */
 export interface CatalogOfferings {
@@ -428,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;
@@ -558,20 +604,8 @@ export interface PlanBlockBoats {
     count: number;
     /** How many boats sailors bring. They cost nothing and don't count against the organization's. */
     sailor_owned: number | null;
-}
-/** RIBs and other equipment a block uses. */
-export interface PlanBlockResources {
-    id: string;
-    /** The version this row belongs to. */
-    version_id: string | PlanVersions;
-    /** Stays the same across versions. Copy it where another row asks for this one's Key. */
-    key: string;
-    block_id: string | PlanActivityBlocks;
-    /** The resource it uses: copy the Key from a resource in the Operations Plan. */
-    resource_key: string;
-    quantity: string;
-    /** Hours each is used. Leave it empty for the block's time on the water (RIBs) or its paid time (other equipment). */
-    hours: string | null;
+    /** How many boats of the class the block charters. They cost the class's charter rate for each day, and don't count against the organization's. */
+    chartered: number | null;
 }
 /** Who coaches a block: a number of staff at one staff level, or a salaried position. */
 export interface PlanBlockStaff {
@@ -598,10 +632,12 @@ export interface PlanBoatRates {
     /** Stays the same across versions. Copy it where another row asks for this one's Key. */
     key: string;
     boat_class_id: string | BoatClasses;
-    /** In cents: 12500 is $125.00. */
+    /** Upkeep for each hour one of CSC's boats of the class is on the water. In cents: 12500 is $125.00. */
     maintenance_per_boat_hour_cents: number;
-    /** How many boats of the class the organization has. */
-    quantity: number | null;
+    /** Fuel for each hour one of CSC's boats of the class is on the water. In cents: 12500 is $125.00. */
+    fuel_per_hour_cents: number | null;
+    /** What one boat of the class costs to charter for a day. In cents: 12500 is $125.00. */
+    charter_per_day_cents: number | null;
 }
 /** The products a bonus owner owns. */
 export interface PlanBonusOwnerProducts {
@@ -760,29 +796,29 @@ export interface PlanRates {
     lodging_per_night_cents: number | null;
     /** In cents: 12500 is $125.00. */
     mileage_rate_cents: number | null;
-    /** The kind of resource whose cost prices coach boat (RIB) hours. */
-    rib_resource_kind_id: string | ResourceKinds | null;
 }
-/** Equipment programs share, such as coach boats, and what an hour or a day of it costs. */
-export interface PlanResources {
+/** 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 version this row belongs to. */
-    version_id: string | PlanVersions;
-    /** Stays the same across versions. Copy it where another row asks for this one's Key. */
-    key: string;
-    resource_kind_id: string | ResourceKinds;
+    /** The bonus's role, such as Director. */
     name: string;
-    quantity: number | null;
-    /** In cents: 12500 is $125.00. */
-    cost_per_hour_cents: number | null;
-    /** In cents: 12500 is $125.00. */
-    cost_per_day_cents: number | null;
-    /** In cents: 12500 is $125.00. */
-    fuel_per_hour_cents: number | null;
-    /** In cents: 12500 is $125.00. */
-    maintenance_per_hour_cents: number | null;
-    /** Set for a rental, whose cost is left out of modified total direct costs (MTDC). */
-    excluded_from_mtdc: boolean;
+    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 {
@@ -823,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. */
@@ -841,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 {
@@ -1121,11 +1162,6 @@ export interface Registrations {
     status: "confirmed" | "waitlist" | "cancelled";
     clubspot_entry_id: string | ClubspotRegistrationEntries;
 }
-/** A kind of shared resource, such as RIB or trailer. */
-export interface ResourceKinds {
-    id: string;
-    name: string;
-}
 /** The schools a sailor can sail for, which families pick from. A school's other names match what families typed on their Clubspot forms. */
 export interface Schools {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyc-seattle/platform",
-  "version": "1.49.0",
+  "version": "1.51.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",