@cyc-seattle/platform 1.35.0 → 1.37.0

package/dist/planning/staffing.js

@@ -1,4 +1,3 @@
-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)
@@ -11,33 +10,29 @@ function sum(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);
+function groupBy(rows, key) {
+    const groups = new Map();
+    for (const row of rows)
+        groups.set(key(row), [...(groups.get(key(row)) ?? []), row]);
+    return groups;
 }
 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}`))
+    /** Warns once for each row and plan copy, about the first date it's seen on. */
+    warnOnce(code, message, key, scope = {}) {
+        const id = `${code}|${key}|${scope.version_id ?? ""}`;
+        if (this.warned.has(id))
             return;
-        this.warned.add(`${code}|${key}`);
-        this.ctx.warn(code, message, key);
+        this.warned.add(id);
+        this.ctx.warn(code, message, key, scope);
     }
     /** Whether holding `held` qualifies for `required`, through `qualification_covers`. */
     qualifies(held, required) {
@@ -54,383 +49,378 @@ export class Staffing {
         }
         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);
-                }
+    /**
+     * Gathers each block's activities, times and allocations. A block's paid time runs from its first
+     * activity's start to its last one's end, plus the longest setup and put-away. Its time on the
+     * water is the longest `on_water_minutes` its activities set, or else the span of those that sail.
+     */
+    blocks(scheduled) {
+        const { data } = this.ctx;
+        const staff = groupBy(data.plan_block_staff, (r) => r.block_id);
+        const resources = groupBy(data.plan_block_resources, (r) => r.block_id);
+        const boats = groupBy(data.plan_block_boats, (r) => r.block_id);
+        const rows = new Map(data.plan_activity_blocks.map((b) => [b.id, b]));
+        const members = new Map();
+        for (const a of scheduled) {
+            const id = a.stored.block_id;
+            if (id == null)
+                continue;
+            const row = rows.get(id);
+            if (row === undefined) {
+                this.ctx.warn("unknown_block", `Activity ${a.stored.key} names a missing block`, a.stored.key);
                 continue;
             }
-            boats.set(classId, Math.ceil(n / perBoat));
+            if (row.date !== a.date) {
+                this.ctx.warn("block_date_mismatch", `${a.offering.name}'s activity on ${a.date} is in ${row.name}, which is on ${row.date}`, a.stored.key, { version_id: a.stored.version_id, date: a.date });
+            }
+            members.set(id, [...(members.get(id) ?? []), a]);
         }
-        return boats;
+        const result = new Map();
+        for (const [id, list] of members) {
+            const row = rows.get(id);
+            const span = timeSpan(list);
+            const sailing = list.filter((a) => a.uses_boats);
+            const set = sailing.flatMap((a) => (a.stored.on_water_minutes == null ? [] : [a.stored.on_water_minutes]));
+            const sailingSpan = timeSpan(sailing);
+            const sailingMinutes = sailingSpan.start === null || sailingSpan.end === null
+                ? Math.max(0, ...sailing.map((a) => a.on_water_minutes))
+                : sailingSpan.end - sailingSpan.start;
+            // Each offering's sailors count once, split among its activities in the block.
+            const enrollment = (a) => this.ctx.enrollment.get(a.offering.id) ?? 0;
+            const byOffering = groupBy(list, (a) => a.offering.id);
+            const total = sum([...byOffering.values()].map((own) => enrollment(own[0])));
+            const share = (a) => (total > 0 ? enrollment(a) / total : 1 / byOffering.size) / byOffering.get(a.offering.id).length;
+            result.set(id, {
+                row,
+                members: list,
+                ...span,
+                paid_minutes: (span.start === null || span.end === null ? 0 : span.end - span.start) +
+                    Math.max(0, ...list.map((a) => a.stored.setup_minutes ?? 0)) +
+                    Math.max(0, ...list.map((a) => a.stored.putaway_minutes ?? 0)),
+                on_water_minutes: set.length > 0 ? Math.max(...set) : sailingMinutes,
+                staff: staff.get(id) ?? [],
+                resources: resources.get(id) ?? [],
+                boats: boats.get(id) ?? [],
+                shares: new Map(list.map((a) => [a, share(a)])),
+            });
+        }
+        return result;
     }
-    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]));
+    /** Warns about each activity, other than travel, that's in no block, or in one with no staff. */
+    checkUnallocated(scheduled, blocks) {
+        for (const a of scheduled) {
+            if (a.kind === "travel")
+                continue;
+            const block = a.stored.block_id == null ? undefined : blocks.get(a.stored.block_id);
+            if (block !== undefined && sum(block.staff.map((s) => s.count)) > 0)
+                continue;
+            this.ctx.warn("unallocated_activity", `${a.offering.name}'s ${a.kind} on ${a.date} has no staff`, a.stored.key, {
+                version_id: a.stored.version_id,
+                date: a.date,
+            });
         }
-        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: [],
-            hourlyPositions: [],
-            level: undefined,
-            block: null,
-            group: 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);
+    /** Each program's settings, by its product. */
+    programs() {
+        return new Map(this.ctx.data.plan_programs.map((p) => [p.product_id, p]));
+    }
+    /** Whether a staff member holding `held`, at level `levelKey` if any, may coach a program coached at `required`. */
+    qualifiedFor(held, levelKey, required) {
+        if (levelKey === required)
+            return true;
+        const level = this.ctx.data.plan_staff_levels.find((l) => l.key === required);
+        const needed = level?.qualifications ?? [];
+        return needed.length > 0 && needed.every((q) => this.qualifies(held, q));
     }
     /**
-     * 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.
+     * Warns when a block's sailors are more than its staff or its boats can safely take. Each program's
+     * sailors count against its own sailors per coach, and a coach counts if they're at the staff
+     * level of one of the block's programs, or qualified for it. Boats count the ones sailors bring.
      */
-    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);
+    checkCapacity(block, programs) {
+        const { ctx } = this;
+        const offerings = [
+            ...new Map(block.members.filter((a) => a.kind !== "travel").map((a) => [a.offering.id, a.offering])).values(),
+        ];
+        const sailors = sum(offerings.map((o) => ctx.enrollment.get(o.id) ?? 0));
+        if (sailors <= 0)
+            return;
+        const scope = { version_id: block.row.version_id, date: block.row.date };
+        const where = `${block.row.date}, ${block.row.name}`;
+        let load = 0;
+        let counted = 0;
+        const required = [];
+        for (const o of offerings) {
+            const settings = programs.get(o.product_id);
+            if (settings?.staff_level_key == null || settings.sailors_per_coach == null || settings.sailors_per_coach <= 0) {
+                this.warnOnce("no_program_settings", `${o.name}'s program has no staff level or sailors per coach, so its sailors aren't checked against its staff`, o.product_id, { version_id: o.version_id, date: block.row.date });
+                continue;
+            }
+            const n = ctx.enrollment.get(o.id) ?? 0;
+            load += n / settings.sailors_per_coach;
+            counted += n;
+            required.push(settings.staff_level_key);
         }
-        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];
+        if (counted > 0) {
+            const levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
+            const positions = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
+            const qualified = sum(block.staff.map((s) => {
+                const held = s.position_key != null
+                    ? (positions.get(s.position_key)?.qualifications ?? [])
+                    : (levels.get(s.staff_level_key ?? "")?.qualifications ?? []);
+                const level = s.position_key != null ? null : s.staff_level_key;
+                return required.some((r) => this.qualifiedFor(held, level, r)) ? s.count : 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 =
-                    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 })) : [];
+            if (load > qualified + 1e-9) {
+                ctx.warn("over_capacity", `${where}: ${counted} sailors, but its staff can take ${Math.floor((qualified * counted) / load + 1e-9)}`, block.row.key, scope);
             }
         }
-    }
-    /** 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)
+        if (!block.members.some((a) => a.uses_boats))
             return;
-        const coaches = Math.min(1, s.coaches);
-        if (payOf(s.a.offering) === "salary") {
-            s.salaried = coaches;
-            s.positions = [{ key, coaches }];
+        const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
+        let seats = 0;
+        for (const b of block.boats) {
+            const perBoat = classes.get(b.boat_class_id)?.sailors_per_boat;
+            if (perBoat == null || perBoat <= 0) {
+                this.warnOnce("no_sailors_per_boat", `Boat class ${classes.get(b.boat_class_id)?.name ?? b.boat_class_id} has no sailors per boat, so its boats take no sailors`, b.boat_class_id, scope);
+                continue;
+            }
+            seats += (b.count + (b.sailor_owned ?? 0)) * perBoat;
         }
-        else {
-            s.hourlyPositions = [{ key, coaches }];
+        if (sailors > seats) {
+            ctx.warn("over_capacity", `${where}: ${sailors} sailors, but its boats can take ${seats}`, block.row.key, scope);
         }
     }
     /**
-     * Splits a block's activities on one date into groups whose times overlap. An activity with no
-     * times overlaps every other.
+     * Warns when the organization's boats of one class, or a resource such as RIBs, are given to more
+     * blocks at once on a date than it has. Boats sailors bring don't count.
      */
-    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);
+    checkInventory(blocks) {
+        const { ctx } = this;
+        const dates = groupBy(blocks, (b) => b.row.date);
+        const classes = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
+        const fleet = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r.quantity]));
+        const resources = new Map(ctx.data.plan_resources.map((r) => [r.key, r]));
+        for (const [date, list] of dates) {
+            const check = (code, what, have, used) => {
+                if (have == null)
+                    return;
+                const out = list.flatMap((b) => (used(b) > 0 ? [{ block: b, n: used(b) }] : []));
+                const peak = mostAtOnce(out);
+                if (peak.total <= have)
+                    return;
+                const names = peak.at.map(({ block, n }) => `${block.row.name} ${n}`).join(", ");
+                for (const version of new Set(peak.at.map(({ block }) => block.row.version_id))) {
+                    ctx.warn(code, `${date}: ${peak.total} ${what} out, but the organization has ${have} (${names})`, what, {
+                        version_id: version,
+                        date: date,
+                    });
+                }
+            };
+            const classIds = new Set(list.flatMap((b) => b.boats.filter((x) => x.count > 0).map((x) => x.boat_class_id)));
+            for (const id of classIds) {
+                if (fleet.get(id) == null) {
+                    for (const b of list.filter((x) => x.boats.some((y) => y.boat_class_id === id && y.count > 0))) {
+                        this.warnOnce("no_fleet_quantity", `The Operations Plan doesn't say how many ${classes.get(id)?.name ?? id} the organization has, so they aren't checked`, id, { version_id: b.row.version_id, date });
+                    }
+                }
+                check("over_inventory_boats", classes.get(id)?.name ?? id, fleet.get(id), (b) => sum(b.boats.filter((x) => x.boat_class_id === id).map((x) => x.count)));
             }
-            else {
-                groups.push([s]);
-                end = s.a.end_minutes;
+            const resourceKeys = new Set(list.flatMap((b) => b.resources.map((x) => x.resource_key)));
+            for (const key of resourceKeys) {
+                const resource = resources.get(key);
+                check("over_inventory_resource", resource?.name ?? key, resource?.quantity, (b) => sum(b.resources.filter((x) => x.resource_key === key).map((x) => x.quantity)));
             }
         }
-        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. Returns each position's double-booked hours and dates.
+     * Warns when a salaried position coaches two blocks whose times overlap. It's still charged to
+     * both. Returns each position's double-booked hours and dates.
      */
-    checkDoubleBooked(staffed) {
+    checkDoubleBooked(blocks) {
         const byDay = new Map();
-        for (const s of staffed) {
-            for (const p of [...s.positions, ...s.hourlyPositions]) {
-                if (p.coaches <= 0)
+        for (const b of blocks) {
+            for (const s of b.staff) {
+                if (s.position_key == null || s.count <= 0)
                     continue;
-                const id = `${p.key}|${s.a.date}`;
-                byDay.set(id, [...(byDay.get(id) ?? []), s]);
+                const id = `${s.position_key}|${b.row.date}`;
+                byDay.set(id, [...(byDay.get(id) ?? []), b]);
             }
         }
         const names = new Map(this.ctx.data.plan_salaried_positions.map((p) => [p.key, p.name]));
         const result = new Map();
         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];
+            const clash = list.flatMap((x, i) => list.slice(i + 1).flatMap((y) => (overlaps(x, y) ? [[x, y]] : [])))[0];
             if (clash === undefined)
                 continue;
             const hours = extraCoachMinutes(list) / 60;
-            const sum = result.get(key) ?? { hours: 0, dates: 0 };
-            result.set(key, { hours: sum.hours + hours, dates: sum.dates + 1 });
-            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}` +
-                (hours > 0 ? `, so another coach is needed for ${round2(hours)} hours` : ""), key);
+            const total = result.get(key) ?? { hours: 0, dates: 0 };
+            result.set(key, { hours: total.hours + hours, dates: total.dates + 1 });
+            for (const version of new Set(list.map((b) => b.row.version_id))) {
+                this.ctx.warn("position_double_booked", `${names.get(key) ?? key} coaches ${clash[0].row.name} and ${clash[1].row.name} at the same time on ${date}` +
+                    (hours > 0 ? `, so another coach is needed for ${round2(hours)} hours` : ""), key, { version_id: version, date });
+            }
         }
         return result;
     }
-    /**
-     * 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. */
+    /** Costs every block's staff, RIBs, boats and resources, and checks them against the limits. */
     run(scheduled) {
         const { ctx } = this;
-        const staffed = scheduled.map((a) => this.initial(a));
-        const days = new Map();
-        for (const s of staffed) {
-            const block = this.blockFor(s.a);
-            if (block === null) {
-                this.staffNamedCoach(s);
-                continue;
-            }
-            const id = `${block.id}|${s.a.date}`;
-            const day = days.get(id) ?? { block, members: [] };
-            day.members.push(s);
-            days.set(id, day);
-        }
-        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);
-            });
-        }
-        const doubleBooked = this.checkDoubleBooked(staffed);
+        const blocks = this.blocks(scheduled);
+        this.checkUnallocated(scheduled, blocks);
+        const programs = this.programs();
+        // By date, so a warning given once names the first date it's seen on.
+        for (const block of byDate(blocks))
+            this.checkCapacity(block, programs);
+        this.checkInventory(byDate(blocks));
+        const doubleBooked = this.checkDoubleBooked([...blocks.values()]);
         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 levels = new Map(ctx.data.plan_staff_levels.map((l) => [l.key, l]));
+        const positions = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
         const resources = new Map(ctx.data.plan_resources.map((r) => [r.key, r]));
         const boatClasses = new Map(ctx.data.boat_classes.map((c) => [c.id, c]));
-        const salaried = new Map(ctx.data.plan_salaried_positions.map((p) => [p.key, p]));
-        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 boatRates = new Map(ctx.data.plan_boat_rates.map((r) => [r.boat_class_id, r]));
+        const ribKind = ctx.data.rib_resource_kind_id;
+        const given = new Map();
+        for (const block of byDate(blocks)) {
+            const scope = { version_id: block.row.version_id, date: block.row.date };
+            const paidHours = block.paid_minutes / 60;
+            const waterHours = block.on_water_minutes / 60;
+            // Each cost is split among the block's activities by their offerings' sailors.
             const book = (type, amount, line, name, explanation, mtdcShare = 1) => {
                 if (amount === 0)
                     return;
                 const account = ctx.costAccount(type);
                 if (account === undefined)
                     return;
-                ctx.book({
-                    cost_center_type: "offering",
-                    cost_center_key: key,
-                    account_id: account,
-                    function: ctx.functionFor(account, null, "offering"),
-                    amount,
-                    line_key: `${line}:${key}`,
-                    line_name: name,
-                    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);
-            // A salaried coach paid by the hour may have their own rate, even on a volunteer level.
-            const rateOf = (p) => salaried.get(p.key)?.hourly_coaching_rate_cents ?? rate;
-            const own = s.hourlyPositions.reduce((t, p) => t + p.coaches * (rateOf(p) - rate), 0);
-            const wages = (hourly * rate + own) * paidHours;
-            book("coach_wages", wages, "coach_wages", "Coach wages", "Hourly coaches × paid hours × each one's rate");
-            for (const p of s.positions) {
-                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 * rateOf(p) });
-            }
-            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");
+                for (const [a, share] of block.shares) {
+                    ctx.book({
+                        cost_center_type: "offering",
+                        cost_center_key: a.offering.key,
+                        account_id: account,
+                        function: ctx.functionFor(account, null, "offering"),
+                        amount: amount * share,
+                        line_key: `${line}:${a.offering.key}`,
+                        line_name: name,
+                        explanation,
+                        mtdc_share: mtdcShare,
+                        wages: type === "coach_wages",
+                    });
                 }
-                else {
-                    const cost = s.ribs * (waterHours * ribRate.hourly + ribRate.daily);
-                    const rental = s.ribs * (waterHours * ribRate.hourlyRental + ribRate.rental);
-                    book("ribs", cost, "ribs", "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)
+            };
+            let wages = 0;
+            for (const s of block.staff) {
+                if (s.count <= 0)
                     continue;
-                const boatRate = ctx.data.plan_boat_rates.find((r) => r.boat_class_id === classId);
-                if (boatRate === undefined)
+                if (s.position_key != null) {
+                    const position = positions.get(s.position_key);
+                    const hours = s.count * paidHours;
+                    if (s.pay === "hourly") {
+                        const rate = position?.hourly_coaching_rate_cents;
+                        if (position !== undefined && rate == null) {
+                            this.warnOnce("no_hourly_rate", `${position.name} is paid by the hour to coach but has no hourly rate, so those hours cost nothing`, position.key, scope);
+                        }
+                        wages += hours * (rate ?? 0);
+                        for (const [a, share] of block.shares) {
+                            coaching.push({
+                                position_key: s.position_key,
+                                offering_key: a.offering.key,
+                                hours: hours * share,
+                                pay: "hourly",
+                                wages: hours * share * (rate ?? 0),
+                            });
+                        }
+                    }
+                    else {
+                        for (const [a, share] of block.shares) {
+                            coaching.push({
+                                position_key: s.position_key,
+                                offering_key: a.offering.key,
+                                hours: hours * share,
+                                pay: "salary",
+                                wages: 0,
+                            });
+                        }
+                    }
+                    continue;
+                }
+                const level = s.staff_level_key == null ? undefined : levels.get(s.staff_level_key);
+                if (level === undefined) {
+                    this.warnOnce("unknown_staff_level", `${block.row.name} has staff at a missing staff level, so they cost nothing`, s.staff_level_key ?? s.key, scope);
                     continue;
-                book("boat_maintenance", boats * waterHours * boatRate.maintenance_per_boat_hour_cents, `boats:${classId}`, `Boat maintenance: ${boatClasses.get(classId)?.name ?? "boats"}`, "Boats × on-water hours × the class's maintenance rate");
+                }
+                if (level.pay_type !== "volunteer")
+                    wages += s.count * paidHours * (level.hourly_rate_cents ?? 0);
             }
-            for (const use of resourcesByActivity.get(a.stored.id) ?? []) {
+            book("coach_wages", wages, "coach_wages", "Coach wages", "Staff × paid hours × each one's hourly rate");
+            let ribs = 0;
+            for (const use of block.resources) {
                 const resource = resources.get(use.resource_key);
                 if (resource === undefined) {
-                    this.warnOnce("unknown_resource", `Activity uses missing resource ${use.resource_key}`, use.resource_key);
+                    this.warnOnce("unknown_resource", `${block.row.name} uses missing resource ${use.resource_key}`, use.resource_key, scope);
                     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, `${resource.name}: quantity × hours × hourly cost, plus a day rate`, resource.excluded_from_mtdc ? 0 : 1);
+                const rib = ribKind != null && resource.resource_kind_id === ribKind;
+                if (rib)
+                    ribs += use.quantity;
+                const hours = use.hours ?? (rib ? waterHours : paidHours);
+                const cost = use.quantity * (hours * hourlyCost(resource) + (resource.cost_per_day_cents ?? 0));
+                book(rib ? "ribs" : "resources", cost, rib ? "ribs" : `resource:${resource.key}`, rib ? "RIBs" : resource.name, `${resource.name}: quantity × hours × hourly cost, plus a day rate`, resource.excluded_from_mtdc ? 0 : 1);
+            }
+            for (const b of block.boats) {
+                const rate = boatRates.get(b.boat_class_id);
+                if (rate === undefined || b.count <= 0 || waterHours <= 0)
+                    continue;
+                book("boat_maintenance", b.count * waterHours * rate.maintenance_per_boat_hour_cents, `boats:${b.boat_class_id}`, `Boat maintenance: ${boatClasses.get(b.boat_class_id)?.name ?? "boats"}`, "The organization's boats × on-water hours × the class's maintenance rate");
+            }
+            const coaches = sum(block.staff.map((s) => s.count));
+            const boats = sum(block.boats.map((b) => b.count));
+            for (const [a, share] of block.shares) {
+                given.set(a, { coaches: coaches * share, ribs: ribs * share, boats: boats * share });
             }
         }
-        this.bookTrips(staffed);
+        this.bookTrips(blocks, scheduled);
         return {
             coaching,
             doubleBooked,
-            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,
+            activities: scheduled.map((a) => ({
+                offering_id: a.offering.id,
+                offering_key: a.offering.key,
+                trip_id: a.trip?.id ?? null,
+                activity_id: a.stored.id,
+                date: a.date,
+                kind: a.kind,
+                paid_minutes: a.paid_minutes,
+                on_water_minutes: a.on_water_minutes,
+                uses_boats: a.uses_boats,
+                coaches: given.get(a)?.coaches ?? 0,
+                ribs: given.get(a)?.ribs ?? 0,
+                boats: given.get(a)?.boats ?? 0,
+                block_id: blocks.has(a.stored.block_id ?? "") ? a.stored.block_id : null,
             })),
         };
     }
     /**
-     * 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.
+     * A trip's coaches each fly and stay; the miles are driven once. Its coaches are the staff on the
+     * block of its busiest travel day.
      */
-    bookTrips(staffed) {
+    bookTrips(blocks, scheduled) {
         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 travel = (a) => a.kind === "travel" && a.trip?.id === trip.id;
+            const staffed = [...blocks.values()].filter((b) => b.members.some(travel));
+            const coaches = Math.max(0, ...staffed.map((b) => sum(b.staff.map((s) => s.count))));
+            if (coaches === 0 && ((trip.airfare_cents ?? 0) > 0 || (trip.nights ?? 0) > 0)) {
+                const first = scheduled
+                    .filter(travel)
+                    .map((a) => a.date)
+                    .sort()[0];
+                this.warnOnce("trip_without_staff", `${trip.name} has no staff on a travel day's block, so no coach's airfare or lodging is charged`, trip.key, { version_id: trip.version_id, ...(first !== undefined && { date: first }) });
+            }
             const lodging = ctx.rates?.lodging_per_night_cents ?? null;
             const mileage = ctx.rates?.mileage_rate_cents ?? null;
             if ((trip.nights ?? 0) > 0 && lodging === null) {
@@ -460,37 +450,56 @@ export class Staffing {
         }
     }
 }
-function payOf(offering) {
-    return offering.coach_position_pay ?? "salary";
+const byDate = (blocks) => [...blocks.values()].sort((x, y) => x.row.date.localeCompare(y.row.date));
+/** The first start and last end among `list`; both null when one has no times. */
+function timeSpan(list) {
+    if (list.length === 0 || list.some((a) => a.start_minutes === null || a.end_minutes === null)) {
+        return { start: null, end: null };
+    }
+    return {
+        start: Math.min(...list.map((a) => a.start_minutes)),
+        end: Math.max(...list.map((a) => a.end_minutes)),
+    };
 }
-/** Whether two activities' times overlap. One with no times overlaps everything on its date. */
+/** Whether two blocks' 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)
+    if (x.start === null || x.end === null || y.start === null || y.end === null)
         return true;
-    return xs < ye && ys < xe;
+    return x.start < y.end && y.start < x.end;
 }
 /**
- * Minutes another coach would cover among one position's activities on one date: at each moment
- * it's on n groups, n − 1. A block group staffed together is one. Untimed activities add nothing.
+ * The most of something out at one moment, and the blocks that had it then. A block with no times
+ * is out all day.
+ */
+function mostAtOnce(out) {
+    let best = { total: 0, at: [] };
+    for (const candidate of out) {
+        // The peak starts when some block starts, so each block's start is a moment to check.
+        const at = out.filter((o) => o === candidate || overlapsAt(o.block, candidate.block));
+        const total = sum(at.map((o) => o.n));
+        if (total > best.total)
+            best = { total, at };
+    }
+    return best;
+}
+/** Whether `x` is out at the moment `y` starts. */
+function overlapsAt(x, y) {
+    if (x.start === null || x.end === null || y.start === null)
+        return true;
+    return x.start <= y.start && y.start < x.end;
+}
+/**
+ * Minutes another coach would cover among one position's blocks on one date: at each moment it's on
+ * n blocks, n − 1. Blocks with no times add nothing.
  */
 function extraCoachMinutes(list) {
-    const spans = new Map();
-    list.forEach((s, i) => {
-        if (s.a.start_minutes === null || s.a.end_minutes === null)
-            return;
-        const id = s.group ?? `own|${i}`;
-        const span = spans.get(id);
-        spans.set(id, {
-            start: Math.min(span?.start ?? Infinity, s.a.start_minutes),
-            end: Math.max(span?.end ?? -Infinity, s.a.end_minutes),
-        });
-    });
-    const edges = [...spans.values()]
-        .flatMap(({ start, end }) => [
-        { at: start, step: 1 },
-        { at: end, step: -1 },
-    ])
+    const edges = list
+        .flatMap((b) => b.start === null || b.end === null
+        ? []
+        : [
+            { at: b.start, step: 1 },
+            { at: b.end, step: -1 },
+        ])
         .sort((x, y) => x.at - y.at || x.step - y.step);
     let on = 0;
     let last = 0;