@cyc-seattle/platform 1.7.0 → 1.9.0

package/dist/planning/pools.js

@@ -0,0 +1,39 @@
+import { mtdc } from "./measures.js";
+/**
+ * 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 function allocatePools(ctx) {
+    const weights = new Map(ctx.fyOfferings().map((o) => [o.key, Math.max(0, mtdc(ctx, o.key))]));
+    const total = [...weights.values()].reduce((t, w) => t + w, 0);
+    const pools = new Map(ctx.data.plan_pools.map((p) => [p.key, p]));
+    const pooled = [];
+    const kept = [];
+    for (const e of ctx.entries)
+        (e.cost_center_type === "pool" ? pooled : kept).push(e);
+    if (pooled.length === 0)
+        return;
+    ctx.entries.splice(0, ctx.entries.length, ...kept);
+    if (total <= 0) {
+        ctx.warn("no_mtdc", "No offering in the plan year has MTDC, so the shared costs stay with the organization");
+    }
+    for (const e of pooled) {
+        const pool = pools.get(e.cost_center_key ?? "");
+        const base = {
+            account_id: e.account_id,
+            function: e.function,
+            line_key: `pool:${e.cost_center_key}:${e.line_key}`,
+            explanation: `${pool?.name ?? "Pool"}: ${e.explanation}`,
+            stage: "pool",
+            mtdc_share: 0,
+        };
+        if (total <= 0) {
+            ctx.book({ ...base, cost_center_type: "org", cost_center_key: null, amount: e.amount });
+            continue;
+        }
+        for (const [key, w] of weights) {
+            ctx.book({ ...base, cost_center_type: "offering", cost_center_key: key, amount: (e.amount * w) / total });
+        }
+    }
+}

package/dist/planning/revenue.d.ts

@@ -0,0 +1,6 @@
+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. */
+export declare function bookRevenue(ctx: Context): void;

package/dist/planning/revenue.js

@@ -0,0 +1,51 @@
+/** Counts each offering's days: the dates it has an activity other than travel. */
+export function countDays(ctx, activities) {
+    const dates = new Map();
+    for (const a of activities) {
+        if (a.kind === "travel")
+            continue;
+        dates.set(a.offering_key, (dates.get(a.offering_key) ?? new Set()).add(a.date));
+    }
+    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. */
+export function bookRevenue(ctx) {
+    for (const offering of ctx.fyOfferings()) {
+        const product = ctx.products.get(offering.product_id);
+        if (product === undefined) {
+            ctx.warn("unknown_product", `Offering ${offering.key} names a missing product`, offering.key);
+            continue;
+        }
+        const enrollment = ctx.enrollment.get(offering.id) ?? 0;
+        const price = offering.price_cents ?? 0;
+        const total = price * enrollment;
+        if (total === 0)
+            continue;
+        if (product.revenue_account_id == null) {
+            ctx.warn("no_revenue_account", `Product ${product.name} has no revenue account`, product.id);
+            continue;
+        }
+        const book = (account, amount, line, explanation) => ctx.book({
+            cost_center_type: "offering",
+            cost_center_key: offering.key,
+            account_id: account,
+            function: ctx.functionFor(account, null, "offering"),
+            amount,
+            line_key: `${line}:${offering.key}`,
+            explanation,
+        });
+        book(product.revenue_account_id, 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`);
+        }
+    }
+}

package/dist/planning/salaried.d.ts

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

package/dist/planning/salaried.js

@@ -0,0 +1,75 @@
+/**
+ * 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 function bookSalaries(ctx, coaching, booker) {
+    if (ctx.data.plan_salaried_positions.length === 0)
+        return;
+    const account = ctx.costAccount("salaries");
+    if (account === undefined)
+        return;
+    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
+            ? salary / position.paid_hours_per_year
+            : null;
+        const charges = [
+            ...coaching
+                .filter((c) => c.position_key === position.key)
+                .map((c) => ({
+                cost_center_type: "offering",
+                cost_center_key: c.offering_key,
+                hours: c.hours,
+                line: "coaching",
+            })),
+            ...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,
+            })),
+        ];
+        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);
+        }
+        const available = salary * (1 - (position.ga_share ?? 0));
+        const demand = charges.reduce((t, c) => t + c.hours * (rate ?? 0), 0);
+        const scale = demand > available && demand > 0 ? available / demand : 1;
+        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);
+        }
+        for (const c of charges) {
+            booker.add({
+                cost_center_type: c.cost_center_type,
+                cost_center_key: c.cost_center_key,
+                account_id: account,
+                function: ctx.functionFor(account, null, "offering"),
+                amount: c.hours * (rate ?? 0) * scale,
+                line_key: `salary:${position.key}:${c.line}`,
+                explanation: `${position.name}: ${c.line} hours at the salary's hourly equivalent`,
+                wages: true,
+            });
+        }
+        const remainderPool = position.remainder_pool_id == null ? undefined : pools.get(position.remainder_pool_id);
+        booker.add({
+            cost_center_type: remainderPool === undefined ? "org" : "pool",
+            cost_center_key: remainderPool?.key ?? null,
+            account_id: account,
+            function: ctx.functionFor(account, null, "pool"),
+            amount: salary - demand * scale,
+            line_key: `salary:${position.key}:remainder`,
+            explanation: `${position.name}: salary not charged to coaching or bookings`,
+            wages: true,
+        });
+    }
+}

package/dist/planning/staffing.d.ts

@@ -0,0 +1,48 @@
+import type { Context } from "./context.ts";
+import type { ScheduledActivity } from "./activities.ts";
+import type { ComputedActivity, Id, PlanOffering } from "./types.ts";
+/** Hours a salaried position coached, by offering key, for the salaried rule. */
+export interface SalariedCoaching {
+    position_key: Id;
+    offering_key: Id;
+    hours: number;
+}
+/** Whole kids: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
+export declare function enrollmentOf(offering: PlanOffering): number;
+export declare class Staffing {
+    private readonly ctx;
+    private readonly boatClasses;
+    private readonly offeringBoatClasses;
+    private readonly covers;
+    private readonly warned;
+    constructor(ctx: Context);
+    private warnOnce;
+    /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
+    qualifies(held: Id[], required: Id): boolean;
+    private levelFor;
+    private sailorsByClass;
+    private boatsFor;
+    private initial;
+    private blockFor;
+    /**
+     * Staffs a block's activities on one date as one group, then gives each activity its share. A
+     * count an activity fixes keeps it out of that part of the group.
+     */
+    private staffBlock;
+    /**
+     * 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.
+     */
+    private ribRate;
+    /** Staffs every activity, and records what its coaches, RIBs, boats and resources cost. */
+    run(scheduled: ScheduledActivity[]): {
+        activities: ComputedActivity[];
+        coaching: SalariedCoaching[];
+    };
+    /**
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are those of its
+     * travel days; with none, the offering's coaching ratio sets them.
+     */
+    private bookTrips;
+}
+export declare function round2(n: number): number;

package/dist/planning/staffing.js

@@ -0,0 +1,360 @@
+import { isoWeekday, within } from "./dates.js";
+/** Whole kids: `target_enrollment` if set, otherwise `capacity × fill_rate` rounded. */
+export function enrollmentOf(offering) {
+    if (offering.target_enrollment != null)
+        return Math.round(offering.target_enrollment);
+    return Math.round((offering.capacity ?? 0) * (offering.fill_rate ?? 0));
+}
+function sum(values) {
+    let total = 0;
+    for (const v of values)
+        total += v;
+    return total;
+}
+/** Coaches for `enrollment` sailors: at least `min_coaches`, and one per `sailors_per_coach`. */
+function coachesFor(offering, enrollment) {
+    const ratio = offering.sailors_per_coach;
+    const byRatio = ratio != null && ratio > 0 ? Math.ceil(enrollment / ratio) : 0;
+    return Math.max(offering.min_coaches ?? 0, byRatio);
+}
+export class Staffing {
+    ctx;
+    boatClasses;
+    offeringBoatClasses = new Map();
+    covers = new Map();
+    warned = new Set();
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.boatClasses = new Map(ctx.data.boat_classes.map((b) => [b.id, b]));
+        for (const row of ctx.data.plan_offering_boat_classes) {
+            this.offeringBoatClasses.set(row.offering_id, [...(this.offeringBoatClasses.get(row.offering_id) ?? []), row]);
+        }
+        for (const c of ctx.data.qualification_covers) {
+            this.covers.set(c.qualification_id, new Set([...(this.covers.get(c.qualification_id) ?? []), c.covers_id]));
+        }
+    }
+    warnOnce(code, message, key) {
+        if (this.warned.has(`${code}|${key}`))
+            return;
+        this.warned.add(`${code}|${key}`);
+        this.ctx.warn(code, message, key);
+    }
+    /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
+    qualifies(held, required) {
+        const seen = new Set();
+        const stack = [...held];
+        while (stack.length > 0) {
+            const q = stack.pop();
+            if (q === required)
+                return true;
+            if (seen.has(q))
+                continue;
+            seen.add(q);
+            stack.push(...(this.covers.get(q) ?? []));
+        }
+        return false;
+    }
+    levelFor(offering, block) {
+        const levels = this.ctx.data.plan_staff_levels;
+        const blockLevel = block?.coach_level_id == null ? undefined : levels.find((l) => l.id === block.coach_level_id);
+        if (blockLevel !== undefined)
+            return blockLevel;
+        if (offering.coach_level_key == null)
+            return undefined;
+        return levels.find((l) => l.key === offering.coach_level_key);
+    }
+    sailorsByClass(offering, enrollment) {
+        const onClubBoats = enrollment * (1 - (offering.byob_share ?? 0));
+        const classes = this.offeringBoatClasses.get(offering.id) ?? [];
+        if (classes.length === 0)
+            return new Map([["", onClubBoats]]);
+        return new Map(classes.map((c) => [c.boat_class_id, onClubBoats * c.share]));
+    }
+    boatsFor(sailors, offeringKey) {
+        const boats = new Map();
+        for (const [classId, n] of sailors) {
+            const perBoat = this.boatClasses.get(classId)?.sailors_per_boat;
+            if (perBoat == null || perBoat <= 0) {
+                if (n > 0) {
+                    this.warnOnce("no_sailors_per_boat", classId === ""
+                        ? `Offering ${offeringKey} sails boats but names no boat class`
+                        : `Boat class ${classId} has no sailors_per_boat, so offering ${offeringKey} counts no boats in it`, offeringKey);
+                }
+                continue;
+            }
+            boats.set(classId, Math.ceil(n / perBoat));
+        }
+        return boats;
+    }
+    initial(a) {
+        const { offering, stored } = a;
+        const enrollment = this.ctx.enrollment.get(offering.id) ?? 0;
+        const fixedCoaches = stored.fixed_coaches ?? offering.fixed_coaches;
+        const fixedRibs = stored.fixed_ribs ?? offering.fixed_ribs;
+        const fixedBoats = stored.fixed_boats ?? offering.fixed_boats;
+        const coaches = fixedCoaches ?? coachesFor(offering, enrollment);
+        const travel = a.kind === "travel";
+        const ribs = fixedRibs ?? (travel ? 0 : Math.ceil(coaches * (offering.ribs_per_coach ?? 0)));
+        const sailors = a.uses_boats ? this.sailorsByClass(offering, enrollment) : new Map();
+        let boats;
+        if (!a.uses_boats)
+            boats = new Map();
+        else if (fixedBoats != null) {
+            const total = sum(sailors.values());
+            boats = new Map([...sailors].map(([c, n]) => [c, total > 0 ? (fixedBoats * n) / total : fixedBoats / sailors.size]));
+        }
+        else
+            boats = this.boatsFor(sailors, offering.key);
+        return {
+            a,
+            enrollment,
+            coaches,
+            ribs,
+            boats,
+            sailors,
+            fixed: { coaches: fixedCoaches != null, ribs: fixedRibs != null, boats: fixedBoats != null },
+            salaried: 0,
+            positions: [],
+            level: undefined,
+            block: null,
+        };
+    }
+    blockFor(a) {
+        if (a.kind === "travel")
+            return null;
+        return (this.ctx.data.plan_activity_block_rules.find((b) => b.offering_keys.includes(a.offering.key) &&
+            within(a.date, b.starts_on, b.ends_on) &&
+            (b.weekdays == null || b.weekdays.length === 0 || b.weekdays.includes(isoWeekday(a.date)))) ?? null);
+    }
+    /**
+     * Staffs a block's activities on one date as one group, then gives each activity its share. A
+     * count an activity fixes keeps it out of that part of the group.
+     */
+    staffBlock(block, group) {
+        for (const s of group)
+            s.block = block;
+        const byEnrollment = (members, total, s) => sum(members.map((m) => m.enrollment)) > 0
+            ? (total * s.enrollment) / sum(members.map((m) => m.enrollment))
+            : total / members.length;
+        const coached = group.filter((s) => !s.fixed.coaches);
+        let coachTotal = 0;
+        if (coached.length > 0) {
+            const load = sum(coached.map((s) => {
+                const ratio = s.a.offering.sailors_per_coach;
+                return ratio != null && ratio > 0 ? s.enrollment / ratio : 0;
+            }));
+            coachTotal = Math.max(Math.ceil(load - 1e-9), ...coached.map((s) => s.a.offering.min_coaches ?? 0));
+            for (const s of coached)
+                s.coaches = byEnrollment(coached, coachTotal, s);
+        }
+        const ribbed = group.filter((s) => !s.fixed.ribs);
+        if (ribbed.length > 0) {
+            const coaches = sum(ribbed.map((s) => s.coaches));
+            const ratio = Math.max(...ribbed.map((s) => s.a.offering.ribs_per_coach ?? 0));
+            const ribTotal = Math.ceil(coaches * ratio - 1e-9);
+            for (const s of ribbed)
+                s.ribs = coaches > 0 ? (ribTotal * s.coaches) / coaches : 0;
+        }
+        const boated = group.filter((s) => !s.fixed.boats && s.a.uses_boats);
+        const sailorsByClass = new Map();
+        for (const s of boated) {
+            for (const [c, n] of s.sailors)
+                sailorsByClass.set(c, (sailorsByClass.get(c) ?? 0) + n);
+        }
+        const shared = this.boatsFor(sailorsByClass, group[0]?.a.offering.key ?? "");
+        for (const s of boated) {
+            s.boats = new Map([...s.sailors].map(([c, n]) => {
+                const totalSailors = sailorsByClass.get(c) ?? 0;
+                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) {
+            const salariedTotal = Math.min(positions.length, coachTotal);
+            for (const s of coached) {
+                s.salaried = (salariedTotal * s.coaches) / coachTotal;
+                s.positions = positions.map((key) => ({ key, coaches: s.salaried / positions.length }));
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    ribRate() {
+        const kind = this.ctx.data.rib_resource_kind_id;
+        if (kind == null)
+            return undefined;
+        const ribs = this.ctx.data.plan_resources.filter((r) => r.resource_kind_id === kind);
+        if (ribs.length === 0)
+            return undefined;
+        const weight = (r) => r.quantity ?? 1;
+        const totalWeight = sum(ribs.map(weight));
+        const average = (rows, cost) => sum(rows.map((r) => weight(r) * cost(r))) / totalWeight;
+        const rentals = ribs.filter((r) => r.excluded_from_mtdc);
+        return {
+            hourly: average(ribs, hourlyCost),
+            daily: average(ribs, (r) => r.cost_per_day_cents ?? 0),
+            hourlyRental: average(rentals, hourlyCost),
+            rental: average(rentals, (r) => r.cost_per_day_cents ?? 0),
+        };
+    }
+    /** Staffs every activity, and records what its coaches, RIBs, boats and resources cost. */
+    run(scheduled) {
+        const { ctx } = this;
+        const staffed = scheduled.map((a) => this.initial(a));
+        const groups = new Map();
+        for (const s of staffed) {
+            const block = this.blockFor(s.a);
+            if (block === null)
+                continue;
+            const id = `${block.id}|${s.a.date}`;
+            const group = groups.get(id) ?? { block, members: [] };
+            group.members.push(s);
+            groups.set(id, group);
+        }
+        for (const { block, members } of groups.values())
+            this.staffBlock(block, members);
+        const coaching = [];
+        const resourcesByActivity = new Map();
+        for (const r of ctx.data.plan_activity_resources) {
+            resourcesByActivity.set(r.activity_id, [...(resourcesByActivity.get(r.activity_id) ?? []), r]);
+        }
+        const resources = new Map(ctx.data.plan_resources.map((r) => [r.key, r]));
+        const ribRate = this.ribRate();
+        for (const s of staffed) {
+            const { a } = s;
+            const offering = a.offering;
+            const key = offering.key;
+            const paidHours = a.paid_minutes / 60;
+            const waterHours = a.on_water_minutes / 60;
+            const book = (type, amount, line, explanation, mtdcShare = 1) => {
+                if (amount === 0)
+                    return;
+                const account = ctx.costAccount(type);
+                if (account === undefined)
+                    return;
+                ctx.book({
+                    cost_center_type: "offering",
+                    cost_center_key: key,
+                    account_id: account,
+                    function: ctx.functionFor(account, null, "offering"),
+                    amount,
+                    line_key: `${line}:${key}`,
+                    explanation,
+                    mtdc_share: mtdcShare,
+                    wages: type === "coach_wages",
+                });
+            };
+            s.level = this.levelFor(offering, s.block);
+            const hourly = s.coaches - s.salaried;
+            if (offering.required_qualification != null && s.level !== undefined) {
+                if (!this.qualifies(s.level.qualifications ?? [], offering.required_qualification)) {
+                    this.warnOnce("unqualified_level", `Offering ${key}'s coach level ${s.level.name} lacks its required qualification`, key);
+                }
+            }
+            if (hourly > 0 && s.level === undefined) {
+                this.warnOnce("no_coach_level", `Offering ${key} has coaches but no coach level, so they cost nothing`, key);
+            }
+            const volunteer = s.level?.pay_type === "volunteer";
+            const rate = volunteer ? 0 : (s.level?.hourly_rate_cents ?? 0);
+            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 });
+            }
+            if (s.ribs > 0 && waterHours > 0) {
+                if (ribRate === undefined) {
+                    this.warnOnce("no_rib_rate", "No RIB resource is in the plan, so RIBs cost nothing", "ribs");
+                }
+                else {
+                    const cost = s.ribs * (waterHours * ribRate.hourly + ribRate.daily);
+                    const rental = s.ribs * (waterHours * ribRate.hourlyRental + ribRate.rental);
+                    book("ribs", cost, "ribs", "RIBs × on-water hours × the RIB rate, plus a day rate", cost > 0 ? 1 - rental / cost : 1);
+                }
+            }
+            for (const [classId, boats] of s.boats) {
+                if (boats <= 0 || waterHours <= 0)
+                    continue;
+                const boatRate = ctx.data.plan_boat_rates.find((r) => r.boat_class_id === classId);
+                if (boatRate === undefined)
+                    continue;
+                book("boat_maintenance", boats * waterHours * boatRate.maintenance_per_boat_hour_cents, `boats:${classId}`, "Boats × on-water hours × the class's maintenance rate");
+            }
+            for (const use of resourcesByActivity.get(a.stored.id) ?? []) {
+                const resource = resources.get(use.resource_key);
+                if (resource === undefined) {
+                    this.warnOnce("unknown_resource", `Activity uses missing resource ${use.resource_key}`, use.resource_key);
+                    continue;
+                }
+                const hours = use.hours ?? paidHours;
+                book("resources", use.quantity * (hours * hourlyCost(resource) + (resource.cost_per_day_cents ?? 0)), `resource:${use.resource_key}`, `${resource.name}: quantity × hours × hourly cost, plus a day rate`, resource.excluded_from_mtdc ? 0 : 1);
+            }
+        }
+        this.bookTrips(staffed);
+        return {
+            coaching,
+            activities: staffed.map((s) => ({
+                offering_id: s.a.offering.id,
+                offering_key: s.a.offering.key,
+                trip_id: s.a.trip?.id ?? null,
+                activity_id: s.a.stored.id,
+                date: s.a.date,
+                kind: s.a.kind,
+                paid_minutes: s.a.paid_minutes,
+                on_water_minutes: s.a.on_water_minutes,
+                uses_boats: s.a.uses_boats,
+                coaches: s.coaches,
+                ribs: s.ribs,
+                boats: sum(s.boats.values()),
+                block_rule_id: s.block?.id ?? null,
+            })),
+        };
+    }
+    /**
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are those of its
+     * travel days; with none, the offering's coaching ratio sets them.
+     */
+    bookTrips(staffed) {
+        const { ctx } = this;
+        for (const trip of ctx.data.plan_trips) {
+            const offering = ctx.offeringsById.get(trip.offering_id);
+            if (offering === undefined || !ctx.inYear(offering))
+                continue;
+            const travel = staffed.find((s) => s.a.trip?.id === trip.id);
+            const coaches = travel?.coaches ?? offering.fixed_coaches ?? coachesFor(offering, ctx.enrollment.get(offering.id) ?? 0);
+            const lodging = ctx.rates?.lodging_per_night_cents ?? null;
+            const mileage = ctx.rates?.mileage_rate_cents ?? null;
+            if ((trip.nights ?? 0) > 0 && lodging === null) {
+                this.warnOnce("no_rate", "Trips have nights but no lodging_per_night_cents rate", "lodging_per_night_cents");
+            }
+            if ((trip.miles ?? 0) > 0 && mileage === null) {
+                this.warnOnce("no_rate", "Trips have miles but no mileage_rate_cents rate", "mileage_rate_cents");
+            }
+            const amount = coaches * (trip.airfare_cents ?? 0) +
+                coaches * (trip.nights ?? 0) * (lodging ?? 0) +
+                (trip.miles ?? 0) * (mileage ?? 0);
+            if (amount === 0)
+                continue;
+            const account = ctx.costAccount("travel");
+            if (account === undefined)
+                continue;
+            ctx.book({
+                cost_center_type: "offering",
+                cost_center_key: offering.key,
+                account_id: account,
+                function: ctx.functionFor(account, null, "offering"),
+                amount,
+                line_key: `trip:${trip.key}`,
+                explanation: `${trip.name}: ${round2(coaches)} coaches, ${trip.nights ?? 0} nights, ${trip.miles ?? 0} miles`,
+            });
+        }
+    }
+}
+function hourlyCost(r) {
+    return (r.cost_per_hour_cents ?? 0) + (r.fuel_per_hour_cents ?? 0) + (r.maintenance_per_hour_cents ?? 0);
+}
+export function round2(n) {
+    return Math.round(n * 100) / 100;
+}