@cyc-seattle/platform 1.20.1 → 1.22.0

package/dist/planning/activities.d.ts

@@ -6,6 +6,9 @@ export interface ScheduledActivity {
     trip: PlanTrip | null;
     stored: PlanActivity;
     date: string;
+    /** Minutes after midnight, or null when the activity has no times. */
+    start_minutes: number | null;
+    end_minutes: number | null;
     kind: ActivityKind;
     paid_minutes: number;
     on_water_minutes: number;

package/dist/planning/activities.js

@@ -5,6 +5,15 @@ import { minutesOf } from "./dates.js";
  */
 export function scheduleActivities(ctx) {
     const trips = new Map(ctx.data.plan_trips.map((t) => [t.id, t]));
+    const closed = new Map();
+    for (const c of ctx.data.plan_closed_dates ?? []) {
+        // The club's closed days are the Operations Plan's, not an area's.
+        if (ctx.planOfVersion.get(c.version_id)?.kind === "program_area") {
+            ctx.warn("closed_date_in_area_plan", `${c.name} is a closed day in a program area's plan, so it's ignored`, c.key);
+            continue;
+        }
+        closed.set(c.date, c.name);
+    }
     const result = [];
     for (const activity of ctx.data.plan_activities) {
         const offering = ctx.offeringsById.get(activity.offering_id);
@@ -14,15 +23,25 @@ export function scheduleActivities(ctx) {
         }
         if (!ctx.inYear(offering))
             continue;
-        const span = activity.start_time != null && activity.end_time != null
-            ? minutesOf(activity.end_time) - minutesOf(activity.start_time)
-            : 0;
+        const timed = activity.start_time != null && activity.end_time != null;
+        const start = timed ? minutesOf(activity.start_time) : null;
+        let end = timed ? minutesOf(activity.end_time) : null;
+        // An activity that ends before it starts runs past midnight.
+        if (start !== null && end !== null && end < start)
+            end += 24 * 60;
+        const span = start !== null && end !== null ? end - start : 0;
+        const closedFor = closed.get(activity.date);
+        if (closedFor !== undefined && activity.kind !== "travel") {
+            ctx.warn("closed_date", `${offering.name} has an activity on ${activity.date}, when the club is closed for ${closedFor}`, activity.key);
+        }
         const usesBoats = activity.kind !== "travel" && activity.uses_boats;
         result.push({
             offering,
             trip: activity.trip_id == null ? null : (trips.get(activity.trip_id) ?? null),
             stored: activity,
             date: activity.date,
+            start_minutes: start,
+            end_minutes: end,
             kind: activity.kind,
             paid_minutes: span + (activity.setup_minutes ?? 0) + (activity.putaway_minutes ?? 0),
             on_water_minutes: usesBoats ? (activity.on_water_minutes ?? span) : 0,

package/dist/planning/bonus.d.ts

@@ -1,6 +1,10 @@
 import type { Context } from "./context.ts";
+import type { Id } from "./types.ts";
 /**
- * Records each bonus owner's `bonus_rate × max(0, combined net)` for the plan year, after every pool.
- * It's divided among the owned products' offerings by revenue, and is never counted in MTDC.
+ * 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.
  */
-export declare function bookBonuses(ctx: Context): void;
+export declare function bookBonuses(ctx: Context): Map<Id, number>;

package/dist/planning/bonus.js

@@ -1,49 +1,105 @@
 import { revenue } from "./measures.js";
 /**
- * Records each bonus owner's `bonus_rate × max(0, combined net)` for the plan year, after every pool.
- * It's divided among the owned products' offerings by revenue, and is never counted in MTDC.
+ * 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.
  */
 export function bookBonuses(ctx) {
-    for (const owner of ctx.data.plan_bonus_owners) {
-        const products = new Set(ctx.data.plan_bonus_owner_products.filter((p) => p.bonus_owner_id === owner.id).map((p) => p.product_id));
-        const offeringKeys = new Set(ctx
-            .fyOfferings()
-            .filter((o) => products.has(o.product_id))
-            .map((o) => o.key));
-        let net = 0;
-        for (const e of ctx.entries) {
-            const owned = (e.cost_center_type === "offering" && e.cost_center_key != null && offeringKeys.has(e.cost_center_key)) ||
-                (e.cost_center_type === "product" && e.cost_center_key != null && products.has(e.cost_center_key));
-            if (!owned)
-                continue;
-            const type = ctx.accountType(e.account_id);
-            if (type === "revenue")
-                net += e.amount;
-            else if (type === "expense")
-                net -= e.amount;
-        }
-        const bonus = owner.bonus_rate * Math.max(0, net);
+    const bonuses = ctx.data.plan_bonus_owners.map((owner) => ({ owner, base: baseOf(ctx, owner) }));
+    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 offeringKeys) {
+        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: (bonus * w) / total,
+                amount,
                 line_key: `bonus:${owner.key}`,
-                explanation: `${owner.role_name}: ${owner.bonus_rate} × combined net of its products`,
+                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}`,
+                explanation: `${taxRate} × ${owner.role_name}'s bonus`,
                 stage: "bonus",
                 mtdc_share: 0,
             });
         }
     }
+    return byPosition;
+}
+/**
+ * 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.
+ */
+function baseOf(ctx, owner) {
+    const plan = ctx.planOfVersion.get(owner.version_id);
+    const products = new Set();
+    for (const row of ctx.data.plan_bonus_owner_products) {
+        if (row.bonus_owner_id !== owner.id)
+            continue;
+        const product = ctx.products.get(row.product_id);
+        if (plan?.kind === "program_area" && product?.program_area_id !== plan.program_area_id) {
+            ctx.warn("bonus_outside_area", `${owner.role_name}'s bonus names ${product?.name ?? row.product_id}, which isn't in its plan's program area, so it's left out`, owner.key);
+            continue;
+        }
+        products.add(row.product_id);
+    }
+    const offeringKeys = new Set(ctx
+        .fyOfferings()
+        .filter((o) => products.has(o.product_id))
+        .map((o) => 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)
+            continue;
+        const type = ctx.accountType(e.account_id);
+        if (type === "revenue")
+            net += e.amount;
+        else if (type === "expense")
+            net -= e.amount;
+    }
+    return { net, offeringKeys: [...offeringKeys] };
 }

package/dist/planning/engine.js

@@ -23,18 +23,19 @@ export function computePlan(data) {
     const booker = new CostCenterBooker(ctx);
     bookBudgetLines(ctx, booker);
     bookLaborLines(ctx, booker);
-    bookSalaries(ctx, coaching, booker);
+    const charged = bookSalaries(ctx, coaching, booker);
     booker.flush();
     bookPayrollTax(ctx);
     const mtdcByOffering = new Map(ctx.fyOfferings().map((o) => [o.key, mtdc(ctx, o.key)]));
     allocatePools(ctx);
-    bookBonuses(ctx);
+    const bonuses = bookBonuses(ctx);
     const lines = sumLines(ctx);
     return {
         lines,
         pnl: summarize(ctx, lines, mtdcByOffering),
         organization: organizationTotals(ctx, lines),
         activities,
+        positions: summarizePositions(ctx, coaching, charged, bonuses),
         warnings: ctx.warnings,
     };
 }
@@ -66,6 +67,41 @@ function checkAreas(ctx) {
         }
     }
 }
+/** Each salaried position's year: its salary, where its hours went, and its hourly wages and bonus. */
+function summarizePositions(ctx, coaching, charged, bonuses) {
+    const taxRate = ctx.rates?.payroll_tax_rate ?? 0;
+    const known = new Set(ctx.data.plan_salaried_positions.map((p) => p.key));
+    const named = [
+        ...coaching.map((c) => c.position_key),
+        ...ctx.data.plan_bonus_owners.flatMap((o) => (o.position_key == null ? [] : [o.position_key])),
+    ];
+    for (const key of new Set(named)) {
+        if (!known.has(key)) {
+            ctx.warn("unknown_position", `A block, offering or bonus names missing salaried position ${key}`, key);
+        }
+    }
+    return ctx.data.plan_salaried_positions.map((position) => {
+        const hourly = coaching.filter((c) => c.position_key === position.key && c.pay === "hourly");
+        const charges = charged.get(position.key);
+        const hourlyCents = hourly.reduce((t, c) => t + c.wages, 0);
+        const bonus = bonuses.get(position.key) ?? 0;
+        const total = position.annual_salary_cents + hourlyCents + bonus;
+        return {
+            position_key: position.key,
+            name: position.name,
+            salary_cents: position.annual_salary_cents,
+            salaried_coaching_hours: charges?.coaching_hours ?? 0,
+            salaried_coaching_cents: Math.round(charges?.coaching_cents ?? 0),
+            hourly_coaching_hours: hourly.reduce((t, c) => t + c.hours, 0),
+            hourly_coaching_cents: Math.round(hourlyCents),
+            booking_hours: charges?.booking_hours ?? 0,
+            booking_cents: Math.round(charges?.booking_cents ?? 0),
+            bonus_cents: Math.round(bonus),
+            total_pay_cents: Math.round(total),
+            payroll_tax_cents: Math.round(total * taxRate),
+        };
+    });
+}
 /**
  * The organization's year from every line. Capital is any line on an asset account; fundraising is
  * revenue and expense whose function is `fundraising`; everything else is operating.

package/dist/planning/salaried.d.ts

@@ -1,9 +1,17 @@
 import type { Context } from "./context.ts";
 import type { CostCenterBooker } from "./lines.ts";
 import type { SalariedCoaching } from "./staffing.ts";
+import type { Id } from "./types.ts";
+/** What a position's hours charged to programs, by position key, for its summary. */
+export interface PositionCharges {
+    coaching_hours: number;
+    coaching_cents: number;
+    booking_hours: number;
+    booking_cents: number;
+}
 /**
  * Charges each salaried position's salary: its coaching and management hours at its hourly
  * equivalent go to what they served, and the rest, including its `ga_share` off the top, goes to its
  * remainder pool, or the organization if it has none.
  */
-export declare function bookSalaries(ctx: Context, coaching: SalariedCoaching[], booker: CostCenterBooker): void;
+export declare function bookSalaries(ctx: Context, coaching: SalariedCoaching[], booker: CostCenterBooker): Map<Id, PositionCharges>;

package/dist/planning/salaried.js

@@ -4,18 +4,13 @@
  * remainder pool, or the organization if it has none.
  */
 export function bookSalaries(ctx, coaching, booker) {
+    const charged = new Map();
     if (ctx.data.plan_salaried_positions.length === 0)
-        return;
+        return charged;
     const account = ctx.costAccount("salaries");
     if (account === undefined)
-        return;
+        return charged;
     const pools = new Map(ctx.data.plan_pools.map((p) => [p.id, p]));
-    const known = new Set(ctx.data.plan_salaried_positions.map((p) => p.key));
-    for (const c of coaching) {
-        if (!known.has(c.position_key)) {
-            ctx.warn("unknown_position", `A block rule names missing salaried position ${c.position_key}`, c.position_key);
-        }
-    }
     for (const position of ctx.data.plan_salaried_positions) {
         const salary = position.annual_salary_cents;
         const rate = position.paid_hours_per_year != null && position.paid_hours_per_year > 0
@@ -23,7 +18,7 @@ export function bookSalaries(ctx, coaching, booker) {
             : null;
         const charges = [
             ...coaching
-                .filter((c) => c.position_key === position.key)
+                .filter((c) => c.position_key === position.key && c.pay === "salary")
                 .map((c) => ({
                 cost_center_type: "offering",
                 cost_center_key: c.offering_key,
@@ -58,6 +53,19 @@ export function bookSalaries(ctx, coaching, booker) {
         if (scale < 1) {
             ctx.warn("position_overbooked", `${position.name}'s hours charged to programs cost more than its salary after ga_share, so they're scaled down`, position.key);
         }
+        const sums = { coaching_hours: 0, coaching_cents: 0, booking_hours: 0, booking_cents: 0 };
+        for (const c of charges) {
+            const amount = c.hours * (rate ?? 0) * scale;
+            if (c.line === "coaching") {
+                sums.coaching_hours += c.hours;
+                sums.coaching_cents += amount;
+            }
+            else {
+                sums.booking_hours += c.hours;
+                sums.booking_cents += amount;
+            }
+        }
+        charged.set(position.key, sums);
         for (const c of charges) {
             booker.add({
                 cost_center_type: c.cost_center_type,
@@ -82,4 +90,5 @@ export function bookSalaries(ctx, coaching, booker) {
             wages: true,
         });
     }
+    return charged;
 }

package/dist/planning/staffing.d.ts

@@ -6,6 +6,10 @@ export interface SalariedCoaching {
     position_key: Id;
     offering_key: Id;
     hours: number;
+    /** `salary` hours are charged at the salary's hourly equivalent; `hourly` ones are paid as wages. */
+    pay: "salary" | "hourly";
+    /** The wages for `hourly` hours. */
+    wages: number;
 }
 /** Whole kids: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
 export declare function enrollmentOf(offering: PlanOffering): number;
@@ -29,6 +33,18 @@ export declare class Staffing {
      * count an activity fixes keeps it out of that part of the group.
      */
     private staffBlock;
+    /** An offering's named coach, on an activity outside any block: one of its coaches. */
+    private staffNamedCoach;
+    /**
+     * Splits a block's activities on one date into groups whose times overlap. An activity with no
+     * times overlaps every other.
+     */
+    private overlapping;
+    /**
+     * Warns when a salaried position coaches two activities at once that aren't staffed as one block
+     * group. It's still charged to both.
+     */
+    private checkDoubleBooked;
     /**
      * One RIB's hourly and daily cost, averaged over the RIB resources by `quantity`, and the part of
      * it from resources excluded from MTDC, such as rentals.

package/dist/planning/staffing.js

@@ -115,8 +115,10 @@ export class Staffing {
             fixed: { coaches: fixedCoaches != null, ribs: fixedRibs != null, boats: fixedBoats != null },
             salaried: 0,
             positions: [],
+            hourlyPositions: [],
             level: undefined,
             block: null,
+            group: null,
         };
     }
     blockFor(a) {
@@ -168,15 +170,89 @@ export class Staffing {
                 return [c, totalSailors > 0 ? ((shared.get(c) ?? 0) * n) / totalSailors : 0];
             }));
         }
-        // The block's salaried positions take its first coaching slots, so fewer hourly coaches are paid.
-        const positions = block.salaried_positions ?? [];
-        if (positions.length > 0 && coachTotal > 0) {
+        // The block's salaried positions, and its offerings' named coaches, take its first coaching
+        // slots. Those paid out of a salary mean fewer hourly coaches are paid.
+        // An offering with a fixed coach count keeps out of the shared coaches, so its coach does too.
+        for (const s of group)
+            if (s.fixed.coaches)
+                this.staffNamedCoach(s);
+        const named = (pay) => coached.flatMap((s) => s.a.offering.coach_position_key != null && payOf(s.a.offering) === pay ? [s.a.offering.coach_position_key] : []);
+        const positions = [...new Set([...(block.salaried_positions ?? []), ...named("salary")])];
+        const hourlyPositions = [...new Set(named("hourly"))].filter((key) => !positions.includes(key));
+        if (coachTotal > 0) {
             const salariedTotal = Math.min(positions.length, coachTotal);
+            const hourlyTotal = Math.min(hourlyPositions.length, coachTotal - salariedTotal);
             for (const s of coached) {
                 s.salaried = (salariedTotal * s.coaches) / coachTotal;
-                s.positions = positions.map((key) => ({ key, coaches: s.salaried / positions.length }));
+                s.positions =
+                    salariedTotal > 0 ? positions.map((key) => ({ key, coaches: s.salaried / positions.length })) : [];
+                const hourly = (hourlyTotal * s.coaches) / coachTotal;
+                s.hourlyPositions =
+                    hourlyTotal > 0 ? hourlyPositions.map((key) => ({ key, coaches: hourly / hourlyPositions.length })) : [];
+            }
+        }
+    }
+    /** An offering's named coach, on an activity outside any block: one of its coaches. */
+    staffNamedCoach(s) {
+        const key = s.a.offering.coach_position_key;
+        if (key == null || s.a.kind === "travel" || s.coaches <= 0)
+            return;
+        const coaches = Math.min(1, s.coaches);
+        if (payOf(s.a.offering) === "salary") {
+            s.salaried = coaches;
+            s.positions = [{ key, coaches }];
+        }
+        else {
+            s.hourlyPositions = [{ key, coaches }];
+        }
+    }
+    /**
+     * Splits a block's activities on one date into groups whose times overlap. An activity with no
+     * times overlaps every other.
+     */
+    overlapping(members) {
+        if (members.some((s) => s.a.start_minutes === null || s.a.end_minutes === null))
+            return [members];
+        const sorted = [...members].sort((x, y) => x.a.start_minutes - y.a.start_minutes);
+        const groups = [];
+        let end = -Infinity;
+        for (const s of sorted) {
+            const last = groups.at(-1);
+            if (last !== undefined && s.a.start_minutes < end) {
+                last.push(s);
+                end = Math.max(end, s.a.end_minutes);
+            }
+            else {
+                groups.push([s]);
+                end = s.a.end_minutes;
             }
         }
+        return groups;
+    }
+    /**
+     * Warns when a salaried position coaches two activities at once that aren't staffed as one block
+     * group. It's still charged to both.
+     */
+    checkDoubleBooked(staffed) {
+        const byDay = new Map();
+        for (const s of staffed) {
+            for (const p of [...s.positions, ...s.hourlyPositions]) {
+                if (p.coaches <= 0)
+                    continue;
+                const id = `${p.key}|${s.a.date}`;
+                byDay.set(id, [...(byDay.get(id) ?? []), s]);
+            }
+        }
+        const names = new Map(this.ctx.data.plan_salaried_positions.map((p) => [p.key, p.name]));
+        for (const [id, list] of byDay) {
+            const [key, date] = id.split("|");
+            const clash = list.flatMap((x, i) => list
+                .slice(i + 1)
+                .flatMap((y) => ((x.group !== null && x.group === y.group) || !overlaps(x, y) ? [] : [[x, y]])))[0];
+            if (clash === undefined)
+                continue;
+            this.ctx.warn("position_double_booked", `${names.get(key) ?? key} coaches ${clash[0].a.offering.name} and ${clash[1].a.offering.name} at the same time on ${date}`, key);
+        }
     }
     /**
      * One RIB's hourly and daily cost, averaged over the RIB resources by `quantity`, and the part of
@@ -204,18 +280,26 @@ export class Staffing {
     run(scheduled) {
         const { ctx } = this;
         const staffed = scheduled.map((a) => this.initial(a));
-        const groups = new Map();
+        const days = new Map();
         for (const s of staffed) {
             const block = this.blockFor(s.a);
-            if (block === null)
+            if (block === null) {
+                this.staffNamedCoach(s);
                 continue;
+            }
             const id = `${block.id}|${s.a.date}`;
-            const group = groups.get(id) ?? { block, members: [] };
-            group.members.push(s);
-            groups.set(id, group);
+            const day = days.get(id) ?? { block, members: [] };
+            day.members.push(s);
+            days.set(id, day);
         }
-        for (const { block, members } of groups.values())
-            this.staffBlock(block, members);
+        for (const [id, { block, members }] of days) {
+            this.overlapping(members).forEach((group, i) => {
+                for (const s of group)
+                    s.group = `${id}|${i}`;
+                this.staffBlock(block, group);
+            });
+        }
+        this.checkDoubleBooked(staffed);
         const coaching = [];
         const resourcesByActivity = new Map();
         for (const r of ctx.data.plan_activity_resources) {
@@ -262,7 +346,17 @@ export class Staffing {
             const wages = hourly * paidHours * rate;
             book("coach_wages", wages, "coach_wages", "Hourly coaches × paid hours × the coach level's rate");
             for (const p of s.positions) {
-                coaching.push({ position_key: p.key, offering_key: key, hours: p.coaches * paidHours });
+                coaching.push({
+                    position_key: p.key,
+                    offering_key: key,
+                    hours: p.coaches * paidHours,
+                    pay: "salary",
+                    wages: 0,
+                });
+            }
+            for (const p of s.hourlyPositions) {
+                const hours = p.coaches * paidHours;
+                coaching.push({ position_key: p.key, offering_key: key, hours, pay: "hourly", wages: hours * rate });
             }
             if (s.ribs > 0 && waterHours > 0) {
                 if (ribRate === undefined) {
@@ -352,6 +446,16 @@ export class Staffing {
         }
     }
 }
+function payOf(offering) {
+    return offering.coach_position_pay ?? "salary";
+}
+/** Whether two activities' times overlap. One with no times overlaps everything on its date. */
+function overlaps(x, y) {
+    const [xs, xe, ys, ye] = [x.a.start_minutes, x.a.end_minutes, y.a.start_minutes, y.a.end_minutes];
+    if (xs === null || xe === null || ys === null || ye === null)
+        return true;
+    return xs < ye && ys < xe;
+}
 function hourlyCost(r) {
     return (r.cost_per_hour_cents ?? 0) + (r.fuel_per_hour_cents ?? 0) + (r.maintenance_per_hour_cents ?? 0);
 }

package/dist/planning/types.d.ts

@@ -108,6 +108,10 @@ export interface PlanOffering extends Versioned {
     fixed_boats: number | null;
     cogs_rate: number | null;
     note: string | null;
+    /** A `plan_salaried_positions` key: the salaried coach who takes one coach on each activity. */
+    coach_position_key?: Id | null;
+    /** How that coach is paid for it: out of the salary (the default), or by the hour at the offering's level. */
+    coach_position_pay?: "salary" | "hourly" | null;
 }
 export interface PlanOfferingBoatClass extends Versioned {
     offering_id: Id;
@@ -236,6 +240,10 @@ export interface PlanBonusOwner extends Versioned {
     role_name: string;
     bonus_rate: number;
     account_id: Id;
+    /** Whether the net is counted after the pools are shared out (the default), or before. */
+    basis?: "after_shared_costs" | "before_shared_costs" | null;
+    /** A `plan_salaried_positions` key: the position the bonus pays. */
+    position_key?: Id | null;
 }
 export interface PlanBonusOwnerProduct extends Versioned {
     bonus_owner_id: Id;
@@ -253,6 +261,11 @@ export interface PlanRevenueCharge extends Versioned {
     excluded_from_mtdc: boolean;
     note: string | null;
 }
+/** A day the club is closed, such as Labor Day. */
+export interface PlanClosedDate extends Versioned {
+    date: DateString;
+    name: string;
+}
 /** The catalog plus every row of the plan versions being calculated. */
 export interface PlanData {
     /** The plan year. Fiscal year N ends in calendar year N. */
@@ -289,6 +302,7 @@ export interface PlanData {
     plan_pools: PlanPool[];
     plan_bonus_owners: PlanBonusOwner[];
     plan_bonus_owner_products: PlanBonusOwnerProduct[];
+    plan_closed_dates?: PlanClosedDate[];
 }
 /** One line of cost or revenue for the plan year, on one offering, product, pool or the organization. */
 export interface CostLine {
@@ -359,11 +373,34 @@ export interface OrganizationTotals {
     /** Operating net, plus fundraising net, less capital. */
     total_cents: number;
 }
+/** One salaried position's year: what it's paid, and where its hours went. */
+export interface PositionSummary {
+    position_key: Id;
+    name: string;
+    salary_cents: number;
+    /** Hours it coached out of its salary, and what they charged to the offerings. */
+    salaried_coaching_hours: number;
+    salaried_coaching_cents: number;
+    /** Hours it coached for an hourly wage, on top of its salary, and the wages. */
+    hourly_coaching_hours: number;
+    hourly_coaching_cents: number;
+    /** Its `plan_salaried_bookings` hours, and what they charged. */
+    booking_hours: number;
+    booking_cents: number;
+    /** Every bonus that names it. */
+    bonus_cents: number;
+    /** Salary, hourly wages and bonus. */
+    total_pay_cents: number;
+    /** The year's payroll tax on its total pay. */
+    payroll_tax_cents: number;
+}
 export interface EngineOutput {
     lines: CostLine[];
     /** Each offering's P&L, then each product's, then each program area's. */
     pnl: Pnl[];
     organization: OrganizationTotals;
     activities: ComputedActivity[];
+    /** Each salaried position's pay for the year. */
+    positions: PositionSummary[];
     warnings: EngineWarning[];
 }

package/dist/schema/index.d.ts

@@ -35,12 +35,19 @@ export interface Schema {
     plan_bonus_owner_products: PlanBonusOwnerProducts[];
     plan_bonus_owners: PlanBonusOwners[];
     plan_budget_lines: PlanBudgetLines[];
+    plan_closed_dates: PlanClosedDates[];
     plan_labor_lines: PlanLaborLines[];
     plan_offering_boat_classes: PlanOfferingBoatClasses[];
     plan_offerings: PlanOfferings[];
     plan_pools: PlanPools[];
     plan_rates: PlanRates[];
     plan_resources: PlanResources[];
+    plan_result_lines: PlanResultLines[];
+    plan_result_pnl: PlanResultPnl[];
+    plan_result_positions: PlanResultPositions[];
+    plan_result_versions: PlanResultVersions[];
+    plan_result_warnings: PlanResultWarnings[];
+    plan_results: PlanResults[];
     plan_revenue_charges: PlanRevenueCharges[];
     plan_salaried_bookings: PlanSalariedBookings[];
     plan_salaried_positions: PlanSalariedPositions[];
@@ -511,7 +518,7 @@ export interface PlanBonusOwnerProducts {
     bonus_owner_id: string | PlanBonusOwners;
     product_id: string | Products;
 }
-/** A role, such as a head coach, that earns a bonus on the products it owns. */
+/** A role, such as a program area's director, that earns a bonus on the products it owns. */
 export interface PlanBonusOwners {
     id: string;
     /** The version this row belongs to. */
@@ -519,9 +526,13 @@ export interface PlanBonusOwners {
     /** Stays the same across versions. Copy it where another row asks for this one's Key. */
     key: string;
     role_name: string;
-    /** A share of its products' combined net, after pools. 0.05 means 5%. */
+    /** A share of its products' net. 0.05 means 5%. */
     bonus_rate: string;
     account_id: string | Accounts;
+    /** Whether the net is counted after each offering's share of the pools, such as G&A, or before it. */
+    basis: "after_shared_costs" | "before_shared_costs" | null;
+    /** The salaried position this bonus pays, if any: copy the Key from a salaried position in the Operations Plan. */
+    position_key: string | null;
 }
 /** A cost or revenue entered as an amount. */
 export interface PlanBudgetLines {
@@ -543,6 +554,17 @@ export interface PlanBudgetLines {
     excluded_from_mtdc: boolean;
     note: string | null;
 }
+/** A day the club is closed, such as Labor Day. The P&L warns about an activity on one. */
+export interface PlanClosedDates {
+    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;
+    date: string;
+    /** Why it's closed, such as Labor Day. */
+    name: string;
+}
 /** Labor not tied to an activity, such as training, priced at a staff level. */
 export interface PlanLaborLines {
     id: string;
@@ -609,6 +631,10 @@ export interface PlanOfferings {
     /** Cost of goods sold, as a share of revenue. 0.1 means 10%. */
     cogs_rate: string | null;
     note: string | null;
+    /** A salaried coach who coaches every practice: copy the Key from a salaried position in the Operations Plan. */
+    coach_position_key: string | null;
+    /** Out of their salary, or by the hour at the offering's coach level, on top of their salary. */
+    coach_position_pay: "salary" | "hourly" | null;
 }
 /** Shared costs no single offering owns, such as G&A, divided among the year's offerings by MTDC. */
 export interface PlanPools {
@@ -656,6 +682,108 @@ export interface PlanResources {
     /** Set for a rental, whose cost is left out of modified total direct costs (MTDC). */
     excluded_from_mtdc: boolean;
 }
+/** Each cost and revenue line in a saved version's P&L. Worked out when the version was saved, and never changed. */
+export interface PlanResultLines {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    cost_center_type: "offering" | "product" | "program_area" | "pool" | "org";
+    cost_center_key: string | null;
+    cost_center_name: string;
+    account_id: string | Accounts;
+    function: "program" | "management" | "fundraising" | null;
+    /** Always positive: the account says whether it's revenue or a cost. In cents: 12500 is $125.00. */
+    amount_cents: number;
+    /** What the line is, as the P&L names it. */
+    line: string;
+    explanation: string | null;
+}
+/** A saved version's P&L for each offering, product, and program area. Worked out when the version was saved, and never changed. */
+export interface PlanResultPnl {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    level: "offering" | "product" | "program_area";
+    subject_key: string;
+    name: string;
+    /** In cents: 12500 is $125.00. */
+    revenue_cents: number;
+    /** In cents: 12500 is $125.00. */
+    expense_cents: number;
+    /** In cents: 12500 is $125.00. */
+    net_cents: number;
+    /** Modified total direct costs, which shared costs are divided by. In cents: 12500 is $125.00. */
+    mtdc_cents: number;
+    enrollment: number;
+    days: number;
+    sailor_days: number;
+}
+/** Each salaried position's pay for the year, in a saved version. Worked out when the version was saved, and never changed. */
+export interface PlanResultPositions {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    position_key: string;
+    name: string;
+    /** In cents: 12500 is $125.00. */
+    salary_cents: number;
+    salaried_coaching_hours: string;
+    /** In cents: 12500 is $125.00. */
+    salaried_coaching_cents: number;
+    hourly_coaching_hours: string;
+    /** In cents: 12500 is $125.00. */
+    hourly_coaching_cents: number;
+    booking_hours: string;
+    /** In cents: 12500 is $125.00. */
+    booking_cents: number;
+    /** In cents: 12500 is $125.00. */
+    bonus_cents: number;
+    /** Salary, hourly coaching wages, and bonus. In cents: 12500 is $125.00. */
+    total_pay_cents: number;
+    /** The year's payroll tax on the total pay. In cents: 12500 is $125.00. */
+    payroll_tax_cents: number;
+}
+/** The other saved versions a version's results were worked out with. Worked out when the version was saved, and never changed. */
+export interface PlanResultVersions {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    /** Another saved version in the club's plan when this one was saved. */
+    calculated_with_id: string | PlanVersions;
+}
+/** What the P&L warned about when a version was saved. Worked out when the version was saved, and never changed. */
+export interface PlanResultWarnings {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    /** The kind of warning. */
+    code: string;
+    message: string;
+    subject_key: string | null;
+}
+/** A saved version's club-wide totals. Worked out when the version was saved, and never changed. */
+export interface PlanResults {
+    id: string;
+    /** The saved version these results are for. */
+    version_id: string | PlanVersions;
+    calculated_at: string;
+    /** In cents: 12500 is $125.00. */
+    operating_revenue_cents: number;
+    /** In cents: 12500 is $125.00. */
+    operating_expense_cents: number;
+    /** In cents: 12500 is $125.00. */
+    operating_net_cents: number;
+    /** In cents: 12500 is $125.00. */
+    fundraising_revenue_cents: number;
+    /** In cents: 12500 is $125.00. */
+    fundraising_expense_cents: number;
+    /** In cents: 12500 is $125.00. */
+    fundraising_net_cents: number;
+    /** Spent on capital, such as a coach boat. In cents: 12500 is $125.00. */
+    capital_cents: number;
+    /** Operating net, plus fundraising net, less capital. In cents: 12500 is $125.00. */
+    total_cents: number;
+}
 /** A charge set as a share of each offering's revenue, such as scholarships or card fees. Operations Plan only. */
 export interface PlanRevenueCharges {
     id: string;
@@ -756,6 +884,8 @@ export interface PlanVersions {
     operations_version_id: string | PlanVersions | null;
     /** What you want that the plan's numbers don't capture, for your AI to fill in. For example: every Monday, Wednesday and Friday, except on SPS school holidays, from 4pm until dusk. */
     rules: string | null;
+    /** What the P&L showed when this version was saved, worked out a moment after it's saved. A saved version with none means working them out failed, and an admin can fill them in. */
+    results: (string | PlanResults)[];
 }
 /** One part of the club's plan: a program area's plan, or the Operations Plan. */
 export interface Plans {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyc-seattle/platform",
-  "version": "1.20.1",
+  "version": "1.22.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",
@@ -78,13 +78,16 @@
     "@pulumi/pulumi": "3.273.0",
     "@pulumi/random": "4.21.4",
     "@types/js-yaml": "4.0.9",
+    "@types/luxon": "^3.7.6",
     "@types/node": "^22.19.1",
     "@types/parse": "^3.0.9",
     "esbuild": "0.28.2",
     "eslint": "^9.39.5",
     "google-auth-library": "^11.3.0",
+    "google-spreadsheet": "^5.3.0",
     "googleapis": "^144.0.0",
     "js-yaml": "^5.4.3",
+    "luxon": "^3.7.2",
     "prettier": "^3.9.10",
     "typescript": "~5.9.3",
     "vitest": "^5.0.0",