@cyc-seattle/platform 1.7.0 → 1.9.0

package/dist/planning/activities.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from "./context.ts";
+import type { ActivityKind, PlanActivity, PlanOffering, PlanTrip } from "./types.ts";
+/** A stored activity, before staffing, with its paid time and time on the water. */
+export interface ScheduledActivity {
+    offering: PlanOffering;
+    trip: PlanTrip | null;
+    stored: PlanActivity;
+    date: string;
+    kind: ActivityKind;
+    paid_minutes: number;
+    on_water_minutes: number;
+    uses_boats: boolean;
+}
+/**
+ * The plan year's activities. Paid time is start to end plus setup and put-away; on-water time is
+ * `on_water_minutes` if set, otherwise the whole span, and zero when the activity uses no boats.
+ */
+export declare function scheduleActivities(ctx: Context): ScheduledActivity[];

package/dist/planning/activities.js

@@ -0,0 +1,33 @@
+import { minutesOf } from "./dates.js";
+/**
+ * The plan year's activities. Paid time is start to end plus setup and put-away; on-water time is
+ * `on_water_minutes` if set, otherwise the whole span, and zero when the activity uses no boats.
+ */
+export function scheduleActivities(ctx) {
+    const trips = new Map(ctx.data.plan_trips.map((t) => [t.id, t]));
+    const result = [];
+    for (const activity of ctx.data.plan_activities) {
+        const offering = ctx.offeringsById.get(activity.offering_id);
+        if (offering === undefined) {
+            ctx.warn("unknown_offering", `Activity ${activity.key} names a missing offering`, activity.key);
+            continue;
+        }
+        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 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,
+            kind: activity.kind,
+            paid_minutes: span + (activity.setup_minutes ?? 0) + (activity.putaway_minutes ?? 0),
+            on_water_minutes: usesBoats ? (activity.on_water_minutes ?? span) : 0,
+            uses_boats: usesBoats,
+        });
+    }
+    return result.sort((a, b) => a.date.localeCompare(b.date) || a.offering.key.localeCompare(b.offering.key));
+}

package/dist/planning/bonus.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from "./context.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.
+ */
+export declare function bookBonuses(ctx: Context): void;

package/dist/planning/bonus.js

@@ -0,0 +1,49 @@
+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.
+ */
+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);
+        if (bonus === 0)
+            continue;
+        const weights = new Map();
+        for (const key of offeringKeys) {
+            const r = revenue(ctx, key);
+            if (r > 0)
+                weights.set(key, r);
+        }
+        const total = [...weights.values()].reduce((t, w) => t + w, 0);
+        for (const [key, w] of weights) {
+            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,
+                line_key: `bonus:${owner.key}`,
+                explanation: `${owner.role_name}: ${owner.bonus_rate} × combined net of its products`,
+                stage: "bonus",
+                mtdc_share: 0,
+            });
+        }
+    }
+}

package/dist/planning/context.d.ts

@@ -0,0 +1,54 @@
+import type { Account, AccountFunction, CostCenterType, CostType, DateString, EngineWarning, Id, PlanData, PlanOffering, PlanRates, Product } 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. */
+export interface Entry {
+    cost_center_type: CostCenterType;
+    cost_center_key: Id | null;
+    account_id: Id;
+    function: AccountFunction | null;
+    amount: number;
+    line_key: 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. */
+    mtdc_share: number;
+    /** Whether it's wages, which payroll tax is charged on. */
+    wages: boolean;
+}
+export type EntryInput = Omit<Entry, "stage" | "mtdc_share" | "wages"> & Partial<Pick<Entry, "stage" | "mtdc_share" | "wages">>;
+/** Lookups over the input, and the entries recorded so far, shared by every step. */
+export declare class Context {
+    /** The plan year's first and last days. */
+    readonly fy: {
+        from: DateString;
+        to: DateString;
+    };
+    readonly entries: Entry[];
+    readonly warnings: EngineWarning[];
+    readonly accounts: Map<Id, Account>;
+    readonly products: Map<Id, Product>;
+    readonly offeringsById: Map<Id, PlanOffering>;
+    readonly offeringsByKey: Map<Id, PlanOffering>;
+    /** Enrollment per offering id. */
+    readonly enrollment: Map<string, number>;
+    /** Days per offering key: the dates it has an activity other than travel. */
+    readonly days: Map<string, number>;
+    readonly rates: PlanRates | undefined;
+    private readonly costAccounts;
+    readonly data: PlanData;
+    constructor(data: PlanData);
+    /** The account the organization records a calculated cost type in. */
+    costAccount(type: CostType): Id | undefined;
+    warn(code: string, message: string, key?: string): void;
+    book(entry: EntryInput): void;
+    /** An entry's function: the line's if set, otherwise its account's default, otherwise by cost center. */
+    functionFor(accountId: Id, explicit: AccountFunction | null | undefined, costCenter: CostCenterType): AccountFunction | null;
+    accountType(accountId: Id): Account["type"] | undefined;
+    /** Whether `accountId` is `ancestorId` or under it. */
+    accountUnder(accountId: Id, ancestorId: Id): boolean;
+    /** 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. */
+    fyOfferings(): PlanOffering[];
+}

package/dist/planning/context.js

@@ -0,0 +1,84 @@
+import { fiscalYearDates, within } from "./dates.js";
+/** Lookups over the input, and the entries recorded so far, shared by every step. */
+export class Context {
+    /** The plan year's first and last days. */
+    fy;
+    entries = [];
+    warnings = [];
+    accounts;
+    products;
+    offeringsById;
+    offeringsByKey;
+    /** Enrollment per offering id. */
+    enrollment = new Map();
+    /** Days per offering key: the dates it has an activity other than travel. */
+    days = new Map();
+    rates;
+    costAccounts;
+    data;
+    constructor(data) {
+        this.data = data;
+        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.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];
+        if (data.plan_rates.length > 1)
+            this.warn("many_rates", "More than one plan_rates row, so the first is used");
+        this.costAccounts = new Map(data.organization_cost_accounts
+            .filter((c) => c.organization_id === data.organization.id)
+            .map((c) => [c.cost_type, c.account_id]));
+    }
+    /** The account the organization records a calculated cost type in. */
+    costAccount(type) {
+        const account = this.costAccounts.get(type);
+        if (account === undefined) {
+            this.warn("no_cost_account", `The organization has no account set for ${type}, so that cost is left out`, type);
+        }
+        return account;
+    }
+    warn(code, message, key) {
+        if (this.warnings.some((w) => w.code === code && w.message === message))
+            return;
+        this.warnings.push(key === undefined ? { code, message } : { code, message, key });
+    }
+    book(entry) {
+        if (entry.amount === 0 || !Number.isFinite(entry.amount))
+            return;
+        this.entries.push({ stage: "direct", mtdc_share: 1, wages: false, ...entry });
+    }
+    /** An entry's function: the line's if set, otherwise its account's default, otherwise by cost center. */
+    functionFor(accountId, explicit, costCenter) {
+        if (explicit != null)
+            return explicit;
+        const account = this.accounts.get(accountId);
+        if (account?.default_function != null)
+            return account.default_function;
+        if (account?.type === "revenue")
+            return null;
+        return costCenter === "offering" || costCenter === "product" ? "program" : "management";
+    }
+    accountType(accountId) {
+        return this.accounts.get(accountId)?.type;
+    }
+    /** Whether `accountId` is `ancestorId` or under it. */
+    accountUnder(accountId, ancestorId) {
+        const seen = new Set();
+        for (let a = this.accounts.get(accountId); a !== undefined && !seen.has(a.id);) {
+            if (a.id === ancestorId)
+                return true;
+            seen.add(a.id);
+            a = a.parent_id == null ? undefined : this.accounts.get(a.parent_id);
+        }
+        return false;
+    }
+    /** 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);
+    }
+    /** The plan year's offerings. */
+    fyOfferings() {
+        return this.data.plan_offerings.filter((o) => this.inYear(o));
+    }
+}

package/dist/planning/dates.d.ts

@@ -0,0 +1,12 @@
+import type { DateString, TimeString } from "./types.ts";
+export declare function addDays(date: DateString, days: number): DateString;
+/** ISO weekday, 1 = Monday. */
+export declare function isoWeekday(date: DateString): number;
+/** Fiscal year N ends in calendar year N, so a July start makes FY2027 2026-07-01 to 2027-06-30. */
+export declare function fiscalYearDates(fiscalYear: number, startMonth: number): {
+    from: DateString;
+    to: DateString;
+};
+export declare function minutesOf(time: TimeString): number;
+/** Whether `date` falls in a window whose open ends are unbounded. */
+export declare function within(date: DateString, from: DateString | null | undefined, to: DateString | null | undefined): boolean;

package/dist/planning/dates.js

@@ -0,0 +1,31 @@
+function toUtc(date) {
+    return new Date(`${date}T00:00:00Z`);
+}
+function fromUtc(d) {
+    return d.toISOString().slice(0, 10);
+}
+export function addDays(date, days) {
+    const d = toUtc(date);
+    d.setUTCDate(d.getUTCDate() + days);
+    return fromUtc(d);
+}
+/** ISO weekday, 1 = Monday. */
+export function isoWeekday(date) {
+    const day = toUtc(date).getUTCDay();
+    return day === 0 ? 7 : day;
+}
+/** Fiscal year N ends in calendar year N, so a July start makes FY2027 2026-07-01 to 2027-06-30. */
+export function fiscalYearDates(fiscalYear, startMonth) {
+    const startYear = startMonth === 1 ? fiscalYear : fiscalYear - 1;
+    const from = `${startYear}-${String(startMonth).padStart(2, "0")}-01`;
+    const nextYear = `${startYear + 1}-${String(startMonth).padStart(2, "0")}-01`;
+    return { from, to: addDays(nextYear, -1) };
+}
+export function minutesOf(time) {
+    const [h, m] = time.split(":").map(Number);
+    return h * 60 + m;
+}
+/** Whether `date` falls in a window whose open ends are unbounded. */
+export function within(date, from, to) {
+    return (from == null || date >= from) && (to == null || date <= to);
+}

package/dist/planning/engine.d.ts

@@ -0,0 +1,10 @@
+import type { EngineOutput, Pnl, PlanData, Totals } from "./types.ts";
+/**
+ * Calculates the plan year's P&L from a plan's rows. The steps run in the order
+ * docs/planning-engine.md gives, each reading only what earlier steps recorded.
+ */
+export declare function computePlan(data: PlanData): EngineOutput;
+/** An offering's or product's P&L for one day it runs. Null when it has no days. */
+export declare function perDay(pnl: Pnl): Totals | null;
+/** An offering's or product's P&L for one sailor on one day. Null when it has no sailor-days. */
+export declare function perSailorDay(pnl: Pnl): Totals | null;

package/dist/planning/engine.js

@@ -0,0 +1,134 @@
+import { scheduleActivities } from "./activities.js";
+import { bookBonuses } from "./bonus.js";
+import { Context } from "./context.js";
+import { bookBudgetLines, bookLaborLines, CostCenterBooker } from "./lines.js";
+import { mtdc } from "./measures.js";
+import { bookPayrollTax } from "./payroll.js";
+import { allocatePools } from "./pools.js";
+import { bookRevenue, countDays } from "./revenue.js";
+import { bookSalaries } from "./salaried.js";
+import { enrollmentOf, Staffing } from "./staffing.js";
+/**
+ * Calculates the plan year's P&L from a plan's rows. The steps run in the order
+ * docs/planning-engine.md gives, each reading only what earlier steps recorded.
+ */
+export function computePlan(data) {
+    const ctx = new Context(data);
+    for (const o of data.plan_offerings)
+        ctx.enrollment.set(o.id, enrollmentOf(o));
+    const { activities, coaching } = new Staffing(ctx).run(scheduleActivities(ctx));
+    countDays(ctx, activities);
+    bookRevenue(ctx);
+    const booker = new CostCenterBooker(ctx);
+    bookBudgetLines(ctx, booker);
+    bookLaborLines(ctx, booker);
+    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 lines = sumLines(ctx);
+    return { lines, pnl: summarize(ctx, lines, mtdcByOffering), activities, warnings: ctx.warnings };
+}
+/** Sums entries into lines by cost center, account, function and line key, in whole cents. */
+function sumLines(ctx) {
+    const lines = new Map();
+    for (const e of ctx.entries) {
+        const id = [e.cost_center_type, e.cost_center_key, e.account_id, e.function, e.line_key].join("|");
+        const line = lines.get(id) ?? {
+            cost_center_type: e.cost_center_type,
+            cost_center_key: e.cost_center_key,
+            account_id: e.account_id,
+            function: e.function,
+            amount_cents: 0,
+            line_key: e.line_key,
+            explanation: e.explanation,
+            exact: 0,
+        };
+        line.exact += e.amount;
+        lines.set(id, line);
+    }
+    // Rounding each line key's running total across cost centers keeps its total to the cent.
+    const carried = new Map();
+    return [...lines.values()]
+        .sort((a, b) => (a.cost_center_key ?? "").localeCompare(b.cost_center_key ?? "") ||
+        a.line_key.localeCompare(b.line_key) ||
+        a.account_id.localeCompare(b.account_id) ||
+        a.cost_center_type.localeCompare(b.cost_center_type))
+        .map(({ exact, ...line }) => {
+        const id = [line.account_id, line.function, line.line_key].join("|");
+        const before = carried.get(id) ?? 0;
+        carried.set(id, before + exact);
+        return { ...line, amount_cents: Math.round(before + exact) - Math.round(before) };
+    })
+        .filter((l) => l.amount_cents !== 0);
+}
+/** Each plan-year offering's P&L, then each product's. */
+function summarize(ctx, lines, mtdcByOffering) {
+    const pnl = (level, key, own, counts) => {
+        const byAccount = new Map();
+        let revenue = 0;
+        let expense = 0;
+        for (const l of own) {
+            byAccount.set(l.account_id, (byAccount.get(l.account_id) ?? 0) + l.amount_cents);
+            const type = ctx.accountType(l.account_id);
+            if (type === "revenue")
+                revenue += l.amount_cents;
+            else if (type === "expense")
+                expense += l.amount_cents;
+        }
+        return {
+            level,
+            key,
+            revenue_cents: revenue,
+            expense_cents: expense,
+            net_cents: revenue - expense,
+            by_account: [...byAccount]
+                .filter(([, amount]) => amount !== 0)
+                .map(([account_id, amount_cents]) => ({ account_id, amount_cents }))
+                .sort((a, b) => a.account_id.localeCompare(b.account_id)),
+            ...counts,
+        };
+    };
+    const offerings = ctx.fyOfferings().sort((a, b) => a.key.localeCompare(b.key));
+    const offeringPnl = offerings.map((o) => {
+        const enrollment = ctx.enrollment.get(o.id) ?? 0;
+        const days = ctx.days.get(o.key) ?? 0;
+        return pnl("offering", o.key, lines.filter((l) => l.cost_center_type === "offering" && l.cost_center_key === o.key), { mtdc_cents: Math.round(mtdcByOffering.get(o.key) ?? 0), enrollment, days, sailor_days: enrollment * days });
+    });
+    const productIds = new Set(offerings.map((o) => o.product_id));
+    for (const l of lines)
+        if (l.cost_center_type === "product" && l.cost_center_key !== null)
+            productIds.add(l.cost_center_key);
+    const productPnl = [...productIds].sort().map((id) => {
+        const own = offeringPnl.filter((s) => ctx.offeringsByKey.get(s.key)?.product_id === id);
+        const keys = new Set(own.map((s) => s.key));
+        const add = (field) => own.reduce((t, s) => t + s[field], 0);
+        return pnl("product", 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" && l.cost_center_key === id)), {
+            mtdc_cents: add("mtdc_cents"),
+            enrollment: add("enrollment"),
+            days: add("days"),
+            sailor_days: add("sailor_days"),
+        });
+    });
+    return [...offeringPnl, ...productPnl];
+}
+function divide(totals, by) {
+    if (by <= 0)
+        return null;
+    return {
+        revenue_cents: Math.round(totals.revenue_cents / by),
+        expense_cents: Math.round(totals.expense_cents / by),
+        net_cents: Math.round(totals.net_cents / by),
+    };
+}
+/** An offering's or product's P&L for one day it runs. Null when it has no days. */
+export function perDay(pnl) {
+    return divide(pnl, pnl.days);
+}
+/** An offering's or product's P&L for one sailor on one day. Null when it has no sailor-days. */
+export function perSailorDay(pnl) {
+    return divide(pnl, pnl.sailor_days);
+}

package/dist/planning/index.d.ts

@@ -0,0 +1,2 @@
+export { computePlan, perDay, perSailorDay } from "./engine.ts";
+export type * from "./types.ts";

package/dist/planning/index.js

@@ -0,0 +1 @@
+export { computePlan, perDay, perSailorDay } from "./engine.js";

package/dist/planning/lines.d.ts

@@ -0,0 +1,19 @@
+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.
+ */
+export declare class CostCenterBooker {
+    private readonly ctx;
+    private readonly weights;
+    private readonly pending;
+    constructor(ctx: Context);
+    private weightsFor;
+    add(entry: EntryInput): void;
+    flush(): void;
+}
+/** Records the plan year's `plan_budget_lines`. */
+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

@@ -0,0 +1,91 @@
+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.
+ */
+export class CostCenterBooker {
+    ctx;
+    weights = new Map();
+    pending = [];
+    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;
+    }
+    add(entry) {
+        if (entry.cost_center_type === "product" && 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));
+        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);
+                this.ctx.book(entry);
+                return;
+            }
+            for (const [key, share] of w) {
+                this.ctx.book({ ...entry, cost_center_type: "offering", cost_center_key: key, amount: entry.amount * share });
+            }
+        });
+    }
+}
+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 === "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`. */
+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;
+        booker.add({
+            cost_center_type: line.cost_center_type,
+            cost_center_key: line.cost_center_type === "org" ? null : line.cost_center_key,
+            account_id: line.account_id,
+            function: ctx.functionFor(line.account_id, line.function, line.cost_center_type),
+            amount: line.amount_cents,
+            line_key: `budget:${line.key}`,
+            explanation: line.name,
+            mtdc_share: line.excluded_from_mtdc ? 0 : 1,
+        });
+    }
+}
+/** Records `plan_labor_lines`: hours × the staff level's rate, as wages. */
+export function bookLaborLines(ctx, booker) {
+    const levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
+    for (const line of ctx.data.plan_labor_lines) {
+        if (!checkCostCenter(ctx, line.cost_center_type, line.cost_center_key, line.key))
+            continue;
+        const level = levels.get(line.staff_level_key);
+        if (level === undefined) {
+            ctx.warn("unknown_staff_level", `Labor line ${line.key} names a missing staff level`, line.key);
+            continue;
+        }
+        booker.add({
+            cost_center_type: line.cost_center_type,
+            cost_center_key: line.cost_center_type === "org" ? null : line.cost_center_key,
+            account_id: line.account_id,
+            function: ctx.functionFor(line.account_id, line.function, line.cost_center_type),
+            amount: level.pay_type === "volunteer" ? 0 : line.hours * (level.hourly_rate_cents ?? 0),
+            line_key: `labor:${line.key}`,
+            explanation: `${line.name}: hours × ${level.name}'s rate`,
+            wages: true,
+        });
+    }
+}

package/dist/planning/measures.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "./context.ts";
+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;

package/dist/planning/measures.js

@@ -0,0 +1,31 @@
+function counts(entry) {
+    return entry.stage === "direct";
+}
+/** Sums the entries an offering's base counts, weighting each by `weigh`. */
+function sumEntries(ctx, offeringKey, weigh) {
+    let total = 0;
+    for (const e of ctx.entries) {
+        if (e.cost_center_type !== "offering" || e.cost_center_key !== offeringKey || !counts(e))
+            continue;
+        total += e.amount * weigh(e);
+    }
+    return total;
+}
+/** Modified total direct costs: an offering's direct expenses, less those excluded from MTDC. */
+export function mtdc(ctx, offeringKey) {
+    return sumEntries(ctx, offeringKey, (e) => (ctx.accountType(e.account_id) === "expense" ? e.mtdc_share : 0));
+}
+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);
+    if (offerings.length === 0)
+        return null;
+    const weights = new Map(offerings.map((o) => [o.key, Math.max(0, mtdc(ctx, o.key))]));
+    const total = [...weights.values()].reduce((t, w) => t + w, 0);
+    if (total <= 0)
+        return new Map(offerings.map((o) => [o.key, 1 / offerings.length]));
+    return new Map([...weights].map(([k, w]) => [k, w / total]));
+}

package/dist/planning/payroll.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from "./context.ts";
+/** Records payroll tax at the year's rate on every wage so far, wherever the wage is. */
+export declare function bookPayrollTax(ctx: Context): void;

package/dist/planning/payroll.js

@@ -0,0 +1,31 @@
+/** Records payroll tax at the year's rate on every wage so far, wherever the wage is. */
+export function bookPayrollTax(ctx) {
+    const rate = ctx.rates?.payroll_tax_rate ?? 0;
+    if (rate <= 0)
+        return;
+    const wages = new Map();
+    for (const e of ctx.entries) {
+        if (!e.wages)
+            continue;
+        const id = [e.cost_center_type, e.cost_center_key, e.function].join("|");
+        const sum = wages.get(id) ?? { ...e, amount: 0 };
+        sum.amount += e.amount;
+        wages.set(id, sum);
+    }
+    if (wages.size === 0)
+        return;
+    const account = ctx.costAccount("payroll_tax");
+    if (account === undefined)
+        return;
+    for (const w of wages.values()) {
+        ctx.book({
+            cost_center_type: w.cost_center_type,
+            cost_center_key: w.cost_center_key,
+            account_id: account,
+            function: w.function,
+            amount: w.amount * rate,
+            line_key: "payroll_tax",
+            explanation: `${rate} × wages`,
+        });
+    }
+}

package/dist/planning/pools.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from "./context.ts";
+/**
+ * Divides everything in each pool among all of the plan year's offerings by MTDC, keeping each
+ * amount's account and function. Shared costs never count toward MTDC, so one pool's split never shifts
+ * another's.
+ */
+export declare function allocatePools(ctx: Context): void;