@cyc-seattle/platform 1.14.1 → 1.16.0

package/dist/planning/context.d.ts

@@ -1,4 +1,4 @@
-import type { Account, AccountFunction, CostCenterType, CostType, DateString, EngineWarning, Id, PlanData, PlanOffering, PlanRates, Product } from "./types.ts";
+import type { Account, AccountFunction, CostCenterType, CostType, DateString, EngineWarning, Id, PlanData, PlanOffering, Plan, PlanRates, Product, ProgramArea } from "./types.ts";
 /** The step that recorded an entry. Only `direct` entries count toward MTDC. */
 export type Stage = "direct" | "pool" | "bonus";
 /** One amount, in fractional cents, before lines are rounded and summed. */
@@ -28,6 +28,9 @@ export declare class Context {
     readonly warnings: EngineWarning[];
     readonly accounts: Map<Id, Account>;
     readonly products: Map<Id, Product>;
+    readonly areas: Map<Id, ProgramArea>;
+    /** Each version's plan. */
+    readonly planOfVersion: Map<Id, Plan>;
     readonly offeringsById: Map<Id, PlanOffering>;
     readonly offeringsByKey: Map<Id, PlanOffering>;
     /** Enrollment per offering id. */
@@ -47,6 +50,8 @@ export declare class Context {
     accountType(accountId: Id): Account["type"] | undefined;
     /** Whether `accountId` is `ancestorId` or under it. */
     accountUnder(accountId: Id, ancestorId: Id): boolean;
+    /** The account a product's sales are booked to: its program area's, or its own outside an area. */
+    revenueAccount(product: Product): Id | null;
     /** Whether the offering counts in the plan year: it does, whole, in the year it starts. */
     inYear(offering: PlanOffering): boolean;
     /** The plan year's offerings. */

package/dist/planning/context.js

@@ -7,6 +7,9 @@ export class Context {
     warnings = [];
     accounts;
     products;
+    areas;
+    /** Each version's plan. */
+    planOfVersion;
     offeringsById;
     offeringsByKey;
     /** Enrollment per offering id. */
@@ -21,6 +24,12 @@ export class Context {
         this.fy = fiscalYearDates(data.fiscal_year, data.organization.fiscal_year_start_month);
         this.accounts = new Map(data.accounts.map((a) => [a.id, a]));
         this.products = new Map(data.products.map((p) => [p.id, p]));
+        this.areas = new Map(data.program_areas.map((a) => [a.id, a]));
+        const plans = new Map(data.plans.map((p) => [p.id, p]));
+        this.planOfVersion = new Map(data.plan_versions.flatMap((v) => {
+            const plan = plans.get(v.plan_id);
+            return plan === undefined ? [] : [[v.id, plan]];
+        }));
         this.offeringsById = new Map(data.plan_offerings.map((o) => [o.id, o]));
         this.offeringsByKey = new Map(data.plan_offerings.map((o) => [o.key, o]));
         this.rates = data.plan_rates[0];
@@ -57,7 +66,9 @@ export class Context {
             return account.default_function;
         if (account?.type === "revenue")
             return null;
-        return costCenter === "offering" || costCenter === "product" ? "program" : "management";
+        return costCenter === "offering" || costCenter === "product" || costCenter === "program_area"
+            ? "program"
+            : "management";
     }
     accountType(accountId) {
         return this.accounts.get(accountId)?.type;
@@ -73,6 +84,16 @@ export class Context {
         }
         return false;
     }
+    /** The account a product's sales are booked to: its program area's, or its own outside an area. */
+    revenueAccount(product) {
+        const area = product.program_area_id == null ? undefined : this.areas.get(product.program_area_id);
+        if (area === undefined)
+            return product.revenue_account_id;
+        if (product.revenue_account_id != null && product.revenue_account_id !== area.revenue_account_id) {
+            this.warn("revenue_account_differs", `Product ${product.name} has its own revenue account, but its program area ${area.name}'s is used`, product.id);
+        }
+        return area.revenue_account_id;
+    }
     /** Whether the offering counts in the plan year: it does, whole, in the year it starts. */
     inYear(offering) {
         return within(offering.starts_on, this.fy.from, this.fy.to);

package/dist/planning/engine.js

@@ -16,6 +16,7 @@ export function computePlan(data) {
     const ctx = new Context(data);
     for (const o of data.plan_offerings)
         ctx.enrollment.set(o.id, enrollmentOf(o));
+    checkAreas(ctx);
     const { activities, coaching } = new Staffing(ctx).run(scheduleActivities(ctx));
     countDays(ctx, activities);
     bookRevenue(ctx);
@@ -29,7 +30,70 @@ export function computePlan(data) {
     allocatePools(ctx);
     bookBonuses(ctx);
     const lines = sumLines(ctx);
-    return { lines, pnl: summarize(ctx, lines, mtdcByOffering), activities, warnings: ctx.warnings };
+    return {
+        lines,
+        pnl: summarize(ctx, lines, mtdcByOffering),
+        organization: organizationTotals(ctx, lines),
+        activities,
+        warnings: ctx.warnings,
+    };
+}
+/**
+ * Warns about a program with no program area, an area on another kind of product, and an offering
+ * in the wrong plan: a program area's plan holds only its own programs, and the Operations Plan only
+ * products in no area. The catalog stays live, so the database can't check these.
+ */
+function checkAreas(ctx) {
+    for (const offering of ctx.fyOfferings()) {
+        const product = ctx.products.get(offering.product_id);
+        if (product === undefined)
+            continue;
+        if (product.kind === "program" && product.program_area_id == null) {
+            ctx.warn("program_without_area", `Program ${product.name} has no program area`, product.id);
+        }
+        else if (product.kind !== "program" && product.program_area_id != null) {
+            ctx.warn("area_on_non_program", `Product ${product.name} isn't a program, but has a program area`, product.id);
+        }
+        const plan = ctx.planOfVersion.get(offering.version_id);
+        if (plan === undefined)
+            continue;
+        const wrong = plan.kind === "operations"
+            ? product.program_area_id != null
+            : product.program_area_id != null && product.program_area_id !== plan.program_area_id;
+        if (wrong) {
+            const where = plan.kind === "operations" ? "the Operations Plan" : "another program area's plan";
+            ctx.warn("offering_in_wrong_plan", `Offering ${offering.name} of ${product.name} is in ${where}`, offering.key);
+        }
+    }
+}
+/**
+ * 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.
+ */
+function organizationTotals(ctx, lines) {
+    const operating = { revenue_cents: 0, expense_cents: 0, net_cents: 0 };
+    const fundraising = { revenue_cents: 0, expense_cents: 0, net_cents: 0 };
+    let capital = 0;
+    for (const l of lines) {
+        const type = ctx.accountType(l.account_id);
+        if (type === "asset") {
+            capital += l.amount_cents;
+            continue;
+        }
+        const totals = l.function === "fundraising" ? fundraising : operating;
+        if (type === "revenue")
+            totals.revenue_cents += l.amount_cents;
+        else if (type === "expense")
+            totals.expense_cents += l.amount_cents;
+    }
+    for (const t of [operating, fundraising])
+        t.net_cents = t.revenue_cents - t.expense_cents;
+    return {
+        operating,
+        fundraising,
+        capital_cents: capital,
+        total_cents: operating.net_cents + fundraising.net_cents - capital,
+    };
 }
 /** Sums entries into lines by cost center, account, function and line key, in whole cents. */
 function sumLines(ctx) {
@@ -64,7 +128,7 @@ function sumLines(ctx) {
     })
         .filter((l) => l.amount_cents !== 0);
 }
-/** Each plan-year offering's P&L, then each product's. */
+/** Each plan-year offering's P&L, then each product's, then each program area's. */
 function summarize(ctx, lines, mtdcByOffering) {
     const pnl = (level, key, own, counts) => {
         const byAccount = new Map();
@@ -113,7 +177,33 @@ function summarize(ctx, lines, mtdcByOffering) {
             sailor_days: add("sailor_days"),
         });
     });
-    return [...offeringPnl, ...productPnl];
+    const areaIds = new Set();
+    for (const o of offerings) {
+        const area = ctx.products.get(o.product_id)?.program_area_id;
+        if (area != null)
+            areaIds.add(area);
+    }
+    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 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];
 }
 function divide(totals, by) {
     if (by <= 0)

package/dist/planning/lines.d.ts

@@ -1,8 +1,9 @@
 import type { Context, EntryInput } from "./context.ts";
 /**
  * Records amounts on their cost centers. Amounts on an offering, a pool or the organization are
- * recorded right away. Amounts on a product wait until `flush`, then are divided among its offerings
- * by MTDC, so every offering's own costs are in first, whatever order the lines come in.
+ * recorded right away. Amounts on a product or program area wait until `flush`, then are divided
+ * among its offerings by MTDC, so every offering's own costs are in first, whatever order the lines
+ * come in.
  */
 export declare class CostCenterBooker {
     private readonly ctx;
@@ -13,7 +14,10 @@ export declare class CostCenterBooker {
     add(entry: EntryInput): void;
     flush(): void;
 }
-/** Records the plan year's `plan_budget_lines`. */
+/**
+ * Records the plan year's `plan_budget_lines`. Capital, a line on an asset account, is the
+ * organization's: fundraising pays for it, so it never reaches a program area or an offering.
+ */
 export declare function bookBudgetLines(ctx: Context, booker: CostCenterBooker): void;
 /** Records `plan_labor_lines`: hours × the staff level's rate, as wages. */
 export declare function bookLaborLines(ctx: Context, booker: CostCenterBooker): void;

package/dist/planning/lines.js

@@ -1,8 +1,9 @@
 import { spreadWeights } from "./measures.js";
 /**
  * Records amounts on their cost centers. Amounts on an offering, a pool or the organization are
- * recorded right away. Amounts on a product wait until `flush`, then are divided among its offerings
- * by MTDC, so every offering's own costs are in first, whatever order the lines come in.
+ * recorded right away. Amounts on a product or program area wait until `flush`, then are divided
+ * among its offerings by MTDC, so every offering's own costs are in first, whatever order the lines
+ * come in.
  */
 export class CostCenterBooker {
     ctx;
@@ -11,24 +12,27 @@ export class CostCenterBooker {
     constructor(ctx) {
         this.ctx = ctx;
     }
-    weightsFor(productId) {
-        if (!this.weights.has(productId))
-            this.weights.set(productId, spreadWeights(this.ctx, productId));
-        return this.weights.get(productId) ?? null;
+    weightsFor(type, key) {
+        const id = `${type}:${key}`;
+        if (!this.weights.has(id))
+            this.weights.set(id, spreadWeights(this.ctx, type, key));
+        return this.weights.get(id) ?? null;
     }
     add(entry) {
-        if (entry.cost_center_type === "product" && entry.cost_center_key != null)
+        const spread = entry.cost_center_type === "product" || entry.cost_center_type === "program_area";
+        if (spread && entry.cost_center_key != null)
             this.pending.push(entry);
         else
             this.ctx.book(entry);
     }
     flush() {
         const pending = this.pending.splice(0);
-        const weights = pending.map((entry) => this.weightsFor(entry.cost_center_key));
+        const weights = pending.map((entry) => this.weightsFor(entry.cost_center_type, entry.cost_center_key));
         pending.forEach((entry, i) => {
             const w = weights[i] ?? null;
             if (w === null) {
-                this.ctx.warn("product_without_offerings", `Product ${entry.cost_center_key} has no offering in the plan year, so ${entry.line_key} stays at the product`, entry.cost_center_key ?? undefined);
+                const what = entry.cost_center_type === "product" ? "Product" : "Program area";
+                this.ctx.warn(`${entry.cost_center_type}_without_offerings`, `${what} ${entry.cost_center_key} has no offering in the plan year, so ${entry.line_key} stays there`, entry.cost_center_key ?? undefined);
                 this.ctx.book(entry);
                 return;
             }
@@ -42,23 +46,32 @@ function checkCostCenter(ctx, type, key, line) {
     const known = type === "org" ||
         (type === "offering" && key != null && ctx.offeringsByKey.has(key)) ||
         (type === "product" && key != null && ctx.products.has(key)) ||
+        (type === "program_area" && key != null && ctx.areas.has(key)) ||
         (type === "pool" && key != null && ctx.data.plan_pools.some((p) => p.key === key));
     if (!known)
         ctx.warn("unknown_cost_center", `Line ${line} is on a missing ${type} ${key ?? ""}`, line);
     return known;
 }
-/** Records the plan year's `plan_budget_lines`. */
+/**
+ * Records the plan year's `plan_budget_lines`. Capital, a line on an asset account, is the
+ * organization's: fundraising pays for it, so it never reaches a program area or an offering.
+ */
 export function bookBudgetLines(ctx, booker) {
     for (const line of ctx.data.plan_budget_lines) {
         if (line.fiscal_year !== ctx.data.fiscal_year)
             continue;
         if (!checkCostCenter(ctx, line.cost_center_type, line.cost_center_key, line.key))
             continue;
+        const capital = ctx.accountType(line.account_id) === "asset";
+        const onOrg = line.cost_center_type === "org" || capital;
+        if (capital && line.cost_center_type !== "org") {
+            ctx.warn("capital_off_org", `Line ${line.name} is capital, which only the organization pays for, so it's moved there`, line.key);
+        }
         booker.add({
-            cost_center_type: line.cost_center_type,
-            cost_center_key: line.cost_center_type === "org" ? null : line.cost_center_key,
+            cost_center_type: onOrg ? "org" : line.cost_center_type,
+            cost_center_key: onOrg ? null : line.cost_center_key,
             account_id: line.account_id,
-            function: ctx.functionFor(line.account_id, line.function, line.cost_center_type),
+            function: ctx.functionFor(line.account_id, line.function, onOrg ? "org" : line.cost_center_type),
             amount: line.amount_cents,
             line_key: `budget:${line.key}`,
             explanation: line.name,

package/dist/planning/measures.d.ts

@@ -3,5 +3,8 @@ import type { Id } from "./types.ts";
 /** Modified total direct costs: an offering's direct expenses, less those excluded from MTDC. */
 export declare function mtdc(ctx: Context, offeringKey: Id): number;
 export declare function revenue(ctx: Context, offeringKey: Id): number;
-/** How a product-level amount divides among the product's plan-year offerings, by MTDC. Null when it has none. */
-export declare function spreadWeights(ctx: Context, productId: Id): Map<Id, number> | null;
+/**
+ * How an amount on a product or program area divides among its plan-year offerings, by MTDC. Null
+ * when it has none.
+ */
+export declare function spreadWeights(ctx: Context, type: "product" | "program_area", key: Id): Map<Id, number> | null;

package/dist/planning/measures.js

@@ -18,9 +18,14 @@ export function mtdc(ctx, offeringKey) {
 export function revenue(ctx, offeringKey) {
     return sumEntries(ctx, offeringKey, (e) => (ctx.accountType(e.account_id) === "revenue" ? 1 : 0));
 }
-/** How a product-level amount divides among the product's plan-year offerings, by MTDC. Null when it has none. */
-export function spreadWeights(ctx, productId) {
-    const offerings = ctx.fyOfferings().filter((o) => o.product_id === productId);
+/**
+ * How an amount on a product or program area divides among its plan-year offerings, by MTDC. Null
+ * when it has none.
+ */
+export function spreadWeights(ctx, type, key) {
+    const offerings = ctx
+        .fyOfferings()
+        .filter((o) => type === "product" ? o.product_id === key : ctx.products.get(o.product_id)?.program_area_id === key);
     if (offerings.length === 0)
         return null;
     const weights = new Map(offerings.map((o) => [o.key, Math.max(0, mtdc(ctx, o.key))]));

package/dist/planning/revenue.d.ts

@@ -2,5 +2,9 @@ import type { Context } from "./context.ts";
 import type { ComputedActivity } from "./types.ts";
 /** Counts each offering's days: the dates it has an activity other than travel. */
 export declare function countDays(ctx: Context, activities: ComputedActivity[]): void;
-/** Records each offering's revenue, price × enrollment, with its COGS and card fees. */
+/**
+ * Records each offering's revenue, price × enrollment, with its COGS and the Operations Plan's
+ * charges set as a share of revenue. A charge on a revenue account adds revenue; on an expense
+ * account, a cost.
+ */
 export declare function bookRevenue(ctx: Context): void;

package/dist/planning/revenue.js

@@ -9,7 +9,11 @@ export function countDays(ctx, activities) {
     for (const [key, set] of dates)
         ctx.days.set(key, set.size);
 }
-/** Records each offering's revenue, price × enrollment, with its COGS and card fees. */
+/**
+ * Records each offering's revenue, price × enrollment, with its COGS and the Operations Plan's
+ * charges set as a share of revenue. A charge on a revenue account adds revenue; on an expense
+ * account, a cost.
+ */
 export function bookRevenue(ctx) {
     for (const offering of ctx.fyOfferings()) {
         const product = ctx.products.get(offering.product_id);
@@ -22,11 +26,12 @@ export function bookRevenue(ctx) {
         const total = price * enrollment;
         if (total === 0)
             continue;
-        if (product.revenue_account_id == null) {
+        const revenueAccount = ctx.revenueAccount(product);
+        if (revenueAccount == null) {
             ctx.warn("no_revenue_account", `Product ${product.name} has no revenue account`, product.id);
             continue;
         }
-        const book = (account, amount, line, explanation) => ctx.book({
+        const book = (account, amount, line, explanation, mtdc_share = 1) => ctx.book({
             cost_center_type: "offering",
             cost_center_key: offering.key,
             account_id: account,
@@ -34,18 +39,18 @@ export function bookRevenue(ctx) {
             amount,
             line_key: `${line}:${offering.key}`,
             explanation,
+            mtdc_share,
         });
-        book(product.revenue_account_id, total, "revenue", `${price}¢ × ${enrollment} enrolled`);
+        book(revenueAccount, total, "revenue", `${price}¢ × ${enrollment} enrolled`);
         if (offering.cogs_rate != null && offering.cogs_rate > 0) {
             const cogs = ctx.costAccount("cogs");
             if (cogs !== undefined)
                 book(cogs, total * offering.cogs_rate, "cogs", `${offering.cogs_rate} × revenue`);
         }
-        const cardFeeRate = ctx.rates?.card_fee_rate ?? 0;
-        if (cardFeeRate > 0) {
-            const fees = ctx.costAccount("card_fees");
-            if (fees !== undefined)
-                book(fees, total * cardFeeRate, "card_fees", `${cardFeeRate} × revenue`);
+        for (const charge of ctx.data.plan_revenue_charges) {
+            if (!(charge.product_kinds ?? []).includes(product.kind))
+                continue;
+            book(charge.account_id, total * charge.rate, `charge:${charge.key}`, `${charge.name}: ${charge.rate} × revenue`, charge.excluded_from_mtdc ? 0 : 1);
         }
     }
 }

package/dist/planning/salaried.js

@@ -32,12 +32,22 @@ export function bookSalaries(ctx, coaching, booker) {
             })),
             ...ctx.data.plan_salaried_bookings
                 .filter((b) => b.position_id === position.id)
-                .map((b) => ({
-                cost_center_type: "product",
-                cost_center_key: b.product_id,
-                hours: b.hours,
-                line: b.kind,
-            })),
+                .flatMap((b) => {
+                if ((b.product_id == null) === (b.program_area_id == null)) {
+                    ctx.warn("booking_cost_center", `Booking ${b.key} must name a product or a program area, not both or neither, so it's left out`, b.key);
+                    return [];
+                }
+                return [
+                    b.product_id != null
+                        ? { cost_center_type: "product", cost_center_key: b.product_id, hours: b.hours, line: b.kind }
+                        : {
+                            cost_center_type: "program_area",
+                            cost_center_key: b.program_area_id,
+                            hours: b.hours,
+                            line: b.kind,
+                        },
+                ];
+            }),
         ];
         if (rate === null && charges.length > 0) {
             ctx.warn("no_paid_hours", `${position.name} has hours charged to programs but no paid_hours_per_year, so they cost nothing`, position.key);

package/dist/planning/types.d.ts

@@ -11,13 +11,23 @@ export interface Versioned {
     /** Stable across versions; references from other plans use it. */
     key: Id;
 }
-export type CostCenterType = "offering" | "product" | "pool" | "org";
+export type CostCenterType = "offering" | "product" | "program_area" | "pool" | "org";
 export type AccountFunction = "program" | "management" | "fundraising";
+export type ProductKind = "program" | "charter" | "storage_lease" | "merchandise" | "event_hosting" | "other";
 export interface Product {
     id: Id;
     name: string;
-    kind: "program" | "charter" | "storage_lease" | "merchandise" | "event_hosting" | "other";
+    kind: ProductKind;
+    /** For a product in no program area. A product in one uses the area's. */
     revenue_account_id: Id | null;
+    /** Every program has one; merchandise, storage and charters have none. */
+    program_area_id: Id | null;
+}
+/** A part of the club's programs, such as Summer, with its revenue account. */
+export interface ProgramArea {
+    id: Id;
+    name: string;
+    revenue_account_id: Id;
 }
 export interface Account {
     id: Id;
@@ -56,13 +66,24 @@ export interface Organization {
     fiscal_year_start_month: number;
 }
 /** A cost the engine calculates. The organization sets which account each is recorded in. */
-export type CostType = "coach_wages" | "salaries" | "payroll_tax" | "ribs" | "boat_maintenance" | "resources" | "travel" | "cogs" | "card_fees";
+export type CostType = "coach_wages" | "salaries" | "payroll_tax" | "ribs" | "boat_maintenance" | "resources" | "travel" | "cogs";
 export interface OrganizationCostAccount {
     id: Id;
     organization_id: Id;
     cost_type: CostType;
     account_id: Id;
 }
+/** A plan: a program area's for one year, or the organization's Operations Plan. */
+export interface Plan {
+    id: Id;
+    kind: "program_area" | "operations";
+    program_area_id: Id | null;
+}
+/** A plan version. The engine reads only which plan it belongs to. */
+export interface PlanVersion {
+    id: Id;
+    plan_id: Id;
+}
 export type ActivityKind = "practice" | "regatta" | "clinic" | "travel";
 export interface PlanOffering extends Versioned {
     product_id: Id;
@@ -152,8 +173,6 @@ export interface PlanBudgetLine extends Versioned {
 export interface PlanRates extends Versioned {
     /** Employer payroll costs, as a share of wages. */
     payroll_tax_rate: number | null;
-    /** Card processing fees, as a share of revenue. */
-    card_fee_rate: number | null;
     lodging_per_night_cents: number | null;
     mileage_rate_cents: number | null;
 }
@@ -174,9 +193,11 @@ export interface PlanSalariedPosition extends Versioned {
     remainder_pool_id: Id | null;
     form_990_line: string | null;
 }
+/** Hours charged to a product, or to a program area and shared among its offerings: one of the two. */
 export interface PlanSalariedBooking extends Versioned {
     position_id: Id;
-    product_id: Id;
+    product_id: Id | null;
+    program_area_id: Id | null;
     kind: "management";
     hours: number;
 }
@@ -220,6 +241,18 @@ export interface PlanBonusOwnerProduct extends Versioned {
     bonus_owner_id: Id;
     product_id: Id;
 }
+/** A charge set as a share of each offering's revenue, such as scholarships or card fees. */
+export interface PlanRevenueCharge extends Versioned {
+    name: string;
+    /** A share, such as 0.02 for 2%. */
+    rate: number;
+    /** The kinds of product it applies to. */
+    product_kinds: ProductKind[] | null;
+    /** A revenue account adds revenue; an expense account adds a cost. */
+    account_id: Id;
+    excluded_from_mtdc: boolean;
+    note: string | null;
+}
 /** 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. */
@@ -229,11 +262,15 @@ export interface PlanData {
     /** 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 plans and versions being calculated, so the engine can tell which plan each offering is in. */
+    plans: Plan[];
+    plan_versions: PlanVersion[];
     plan_offerings: PlanOffering[];
     plan_offering_boat_classes: PlanOfferingBoatClass[];
     plan_trips: PlanTrip[];
@@ -242,6 +279,7 @@ export interface PlanData {
     plan_labor_lines: PlanLaborLine[];
     plan_budget_lines: PlanBudgetLine[];
     plan_rates: PlanRates[];
+    plan_revenue_charges: PlanRevenueCharge[];
     plan_staff_levels: PlanStaffLevel[];
     plan_salaried_positions: PlanSalariedPosition[];
     plan_salaried_bookings: PlanSalariedBooking[];
@@ -269,10 +307,10 @@ export interface Totals {
     expense_cents: number;
     net_cents: number;
 }
-/** One offering's P&L for the plan year, or a product's, which adds up its offerings. */
+/** 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";
-    /** An offering key, or a product id. */
+    level: "offering" | "product" | "program_area";
+    /** An offering key, a product id, or a program area id. */
     key: Id;
     /** Each account's total, revenue and expense alike. */
     by_account: {
@@ -309,10 +347,23 @@ export interface EngineWarning {
     /** The key of the row it's about, when there is one. */
     key?: string;
 }
+/**
+ * The organization's year: operating revenue pays for operating costs, and fundraising for capital.
+ * Capital is buying something lasting, on an asset account, and never reaches a program area.
+ */
+export interface OrganizationTotals {
+    operating: Totals;
+    fundraising: Totals;
+    /** Spent on capital, positive. */
+    capital_cents: number;
+    /** Operating net, plus fundraising net, less capital. */
+    total_cents: number;
+}
 export interface EngineOutput {
     lines: CostLine[];
-    /** Each offering's P&L, then each product's. */
+    /** Each offering's P&L, then each product's, then each program area's. */
     pnl: Pnl[];
+    organization: OrganizationTotals;
     activities: ComputedActivity[];
     warnings: EngineWarning[];
 }

package/package.json

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