@opndev/tennis-match-center 0.0.2 → 0.0.4

package/lib/auto-planner.mjs

@@ -5,11 +5,12 @@
 import { bandDistance, computeSectionBands } from './court-bands.mjs'
 import { courtUsableAt, runFits } from './court-runs.mjs'
 import {
-  fourTeamUnitLayout, fourTeamUnitSizes, placeLayout,
+  fourTeamUnitLayout, fourTeamUnitSizes,
 } from './four-team-planner.mjs'
 import { groupRuns } from './group-schedule.mjs'
 import { wavesForDivision } from './knockout-waves.mjs'
 import { makeFiveTeamPlanner } from './five-team-planner.mjs'
+import { remainderOf } from './run-queue-planner.mjs'
 import { threeTeamUnitLayout, threeTeamUnits } from './three-team-planner.mjs'
 import { makeOccupancy, courtCanHost } from './occupancy.mjs'
 import { assignKnockout } from './knockout-planner.mjs'
@@ -19,6 +20,37 @@ import { PlanningDay } from './planning-day.mjs'
 import { activePhase, activeSession } from './sessions.mjs'
 import { MATCH_MINUTES } from './match-time.mjs'
 
+/**
+ * Every day the competitions say they play on: the dates of their
+ * groups and knockouts, and of their sessions.
+ *
+ * @param {Array} competitions
+ * @returns {string[]} sorted, once each
+ */
+export function eventDays(competitions) {
+  const days = new Set()
+
+  for (const competition of competitions ?? []) {
+    if (competition.available_for_planning === false) {
+      continue
+    }
+
+    for (const date of competition.group_dates ?? []) {
+      days.add(date)
+    }
+
+    for (const date of competition.knockout_dates ?? []) {
+      days.add(date)
+    }
+
+    for (const session of competition.sessions ?? []) {
+      days.add(session.date)
+    }
+  }
+
+  return [...days].sort()
+}
+
 /**
  * Automatically fills the Planning grid (which competition gets which
  * court/hour cell) instead of a director dragging out every cell by
@@ -86,142 +118,1017 @@ import { MATCH_MINUTES } from './match-time.mjs'
 const GAMES_PER_POOL_SIZE = { 3: 3, 4: 6, 5: 10 }
 
 export function autoFillPlanning(params) {
-  const {
-    courts,
-    slots: rawSlots,
-    days,
-    competitions: allCompetitions,
-    registrationClosed = false,
-    alwaysByeShortGroups = false,
-    courtOverrides = [],
-    darkFrom = null,
-    dayEnd = '24:00',
-    lightBuffer = undefined,
-    groupSlotsFromSessions = false,
-    splitRounds = false,
-  } = params
-
-  const competitions = allCompetitions
-    .filter(competition => competition.available_for_planning !== false)
-    .map(competition => ({
-      ...competition,
-      groups: (competition.groups ?? []).map(group => ({
-        ...group,
-        team_ids: group.team_ids
-          ?? Array.from({ length: group.team_count ?? 0 }, (_, i) => i),
-      })),
-    }))
-
-  const slots = withMinutes(rawSlots ?? [])
-  const darkFromMinutes = darkFrom == null ? null : timeToMinutes(darkFrom)
-
-  const dayEndMinutes = timeToMinutes(dayEnd)
-  const plan = new Plan()
-  const blocks = plan.blocks
-  const remainingGroupByDate = new Map()
-  const fiveTeam = makeFiveTeamPlanner()
-  const fourTeamGroups = []
-  const threeTeamGroups = []
-  const boltOnGroups = []
-  const noTemplateWarned = new Set()
-  let fourTeamUnits = null
-  let builtThreeTeamUnits = null
+  const strict = planOnce(params)
+
+  if (!params.relaxed || params.sharing || groupShortfall(strict) === 0) {
+    return strict
+  }
+
+  // The strict rules could not place everything, and the caller has said
+  // some of them may be broken: plan again with the courts shared.
+  const shared = planOnce({ ...params, sharing: true })
+  const better = groupShortfall(shared) < groupShortfall(strict) ? shared : strict
+
+  // Sharing is built for groups of five. A competition still short that
+  // had no section to share is not short for want of trying.
+  const unshared = [...new Set(
+    better.shortfall
+      .filter(entry => entry.phase === 'group' && entry.missing > 0)
+      .map(entry => entry.competition_id)
+  )].filter(id => !shared.shareable.includes(id))
+
+  return unshared.length === 0
+    ? better
+    : {
+      ...better,
+      warnings: [
+        ...(better.warnings ?? []),
+        ...unshared.map(id => ({ competition_id: id, kind: 'not-shareable' })),
+      ],
+    }
+}
+
+/**
+ * How many group matches a result could not place.
+ *
+ * @param {Object} result
+ * @returns {number}
+ */
+function groupShortfall(result) {
+  return (result.shortfall ?? [])
+    .filter(entry => entry.phase === 'group')
+    .reduce((total, entry) => total + (entry.missing ?? 0), 0)
+}
 
+function planOnce(params) {
+  const planner = new AutoPlanner(params)
+  const result = planner.fill()
+  const overflow = knockoutOverflow(planner.competitions, result)
+
+  if (planner.splitRounds || overflow === 0) {
+    return result
+  }
+
+  const retried = planOnce({ ...params, splitRounds: true })
+
+  return knockoutOverflow(planner.competitions, retried) < overflow
+    ? retried
+    : result
+}
+
+/**
+ * One run of the planner: what the event looks like, set up once, and
+ * the days filled in order.
+ */
+class AutoPlanner {
 
   /**
-   * Whether this competition is mostly played on shared pairs.
-   *
-   * A competition of one shape is laid out by that shape's planner and
-   * there is nothing to decide. A mixed one has to choose which goes
-   * first, because the two do not divide into each other: a pair runs
-   * in threes and a 5-team group in fives, so whichever is laid down
-   * second has to fit around the other's leftovers.
+   * @param {Object} params What autoFillPlanning takes.
+   */
+  constructor(params) {
+    const {
+      courts,
+      slots: rawSlots,
+      days: namedDays,
+      competitions: allCompetitions,
+      registrationClosed = false,
+      alwaysByeShortGroups = false,
+      courtOverrides = [],
+      darkFrom = null,
+      dayEnd = '24:00',
+      lightBuffer = undefined,
+      groupSlotsFromSessions = false,
+      splitRounds = false,
+      sharing = false,
+      // Cells the plan already holds, for a canvas smaller than the
+      // event: what they hold is work this run does not owe, and the
+      // courts and hours they sit on are taken.
+      standing = [],
+    } = params
+
+    const rules = { registrationClosed, alwaysByeShortGroups }
+
+    const days = namedDays ?? eventDays(allCompetitions)
+
+    const competitions = allCompetitions
+      .filter(competition => competition.available_for_planning !== false)
+      .map(competition => ({
+        ...competition,
+        groups: (competition.groups ?? []).map(group => ({
+          ...group,
+          team_ids: group.team_ids
+            ?? Array.from({ length: group.team_count ?? 0 }, (_, i) => i),
+        })),
+      }))
+
+    const slots = withMinutes(rawSlots ?? [])
+    const darkFromMinutes = darkFrom == null ? null : timeToMinutes(darkFrom)
+
+    const dayEndMinutes = timeToMinutes(dayEnd)
+    const plan = new Plan()
+    const blocks = plan.blocks
+    const remainingGroupByDate = new Map()
+
+    // What the saved plan already holds, for a canvas that is not the
+    // whole event: a fill of one day is handed the other days' cells
+    // so it plans what is left rather than the draw from the top.
+    const alreadyPlaced = new Map()
+
+    // A group's fixtures are known one by one - a cell carries the
+    // match_slot it was booked for - so what is left is the template
+    // minus those, holes and all. The knockout only knows counts.
+    const playedFixtures = new Map()
+
+    for (const block of standing) {
+      if (block.phase === 'group') {
+        if (block.group_id != null && block.match_slot != null) {
+          const slots = playedFixtures.get(block.group_id) ?? new Set()
+
+          slots.add(block.match_slot)
+          playedFixtures.set(block.group_id, slots)
+        }
+
+        continue
+      }
+
+      if (block.round == null) {
+        continue
+      }
+
+      const key = [block.competition_id, block.division_id ?? null, block.round].join('|')
+
+      alreadyPlaced.set(key, (alreadyPlaced.get(key) ?? 0) + 1)
+    }
+
+    const fiveTeam = makeFiveTeamPlanner()
+    const fourTeamGroups = []
+    const threeTeamGroups = []
+    const boltOnGroups = []
+    const noTemplateWarned = new Set()
+    let fourTeamUnits = null
+    let builtThreeTeamUnits = null
+
+
+    const knockoutUnits = []
+
+    const proDivisions = new Set()
+
+    for (const competition of competitions) {
+      for (const group of competition.groups ?? []) {
+        if (group.is_pro === true && group.division_id != null) {
+          proDivisions.add(group.division_id)
+        }
+      }
+    }
+
+    const sortedSessions = new Map()
+    for (const competition of competitions) {
+      sortedSessions.set(
+        competition.id,
+        [...competition.sessions].sort((a, b) =>
+          (a.date + a.start_time).localeCompare(b.date + b.start_time)
+        )
+      )
+    }
+
+    const canvas = {
+      sortedSessions, days, darkFromMinutes, dayEndMinutes,
+      competitions, knockoutUnits, groupSlotsFromSessions, slots,
+    }
+
+    Object.assign(this, {
+      courts,
+      rawSlots,
+      namedDays,
+      allCompetitions,
+      registrationClosed,
+      alwaysByeShortGroups,
+      courtOverrides,
+      darkFrom,
+      dayEnd,
+      lightBuffer,
+      groupSlotsFromSessions,
+      splitRounds,
+      sharing,
+      standing,
+      rules,
+      days,
+      competitions,
+      slots,
+      darkFromMinutes,
+      dayEndMinutes,
+      plan,
+      blocks,
+      remainingGroupByDate,
+      alreadyPlaced,
+      playedFixtures,
+      fiveTeam,
+      fourTeamGroups,
+      threeTeamGroups,
+      boltOnGroups,
+      noTemplateWarned,
+      fourTeamUnits,
+      builtThreeTeamUnits,
+      knockoutUnits,
+      proDivisions,
+      sortedSessions,
+      canvas,
+    })
+
+    for (const competition of competitions) {
+      const derived = (competition.divisions ?? [])
+        .filter(division =>
+          division.knockout_matches != null || division.team_count != null
+        )
+        .map(division => ({
+          division_id: division.id,
+          division_name: division.name,
+          division_gender: division.gender ?? null,
+          level: division.level ?? 0,
+          waves: wavesForDivision(division, { itf: competition.itf === true }),
+        }))
+        .filter(bracket => bracket.waves.length > 0)
+
+      const brackets = derived.length > 0
+        ? derived
+        : (competition.knockout_rounds_by_division
+          ?? (competition.games_needed_by_round?.length
+            ? [competition.games_needed_by_round]
+            : []))
+
+      for (const bracket of brackets) {
+        const division = Array.isArray(bracket) ? null : bracket
+        const waves = this.owedWaves(
+          Array.isArray(bracket) ? bracket : bracket.waves,
+          competition.id,
+          division?.division_id ?? null
+        )
+
+        if (waves.length === 0) {
+          continue
+        }
+
+        knockoutUnits.push(new KnockoutDraw({
+          competition,
+          waves,
+          divisionId: division?.division_id ?? null,
+          divisionName: division?.division_name ?? null,
+          divisionGender: division?.division_gender ?? null,
+          level: division?.level ?? 0,
+          isPro: proDivisions.has(division?.division_id),
+        }))
+      }
+
+      if (Array.isArray(competition.groups) && competition.groups.length === 0) {
+        continue
+      }
+
+      const boltOn = this.pooledLeads(competition)
+
+      for (const group of competition.groups ?? []) {
+        if (this.shortGroup(group)) {
+          const size = group.pool_size ?? group.team_ids.length
+          const asFull = alwaysByeShortGroups || !registrationClosed
+          const padded = asFull && size > group.team_ids.length
+            ? paddedWithByes(group, size)
+            : group
+
+          fourTeamGroups.push({ competition, group: padded })
+          continue
+        }
+
+        if ((group.team_ids ?? []).length === 3) {
+          threeTeamGroups.push({ competition, group, placed: new Set() })
+          continue
+        }
+
+        if (boltOn) {
+          boltOnGroups.push({ competition, group, placed: new Set() })
+          continue
+        }
+
+        for (const { date, count } of fiveTeam.enqueue({
+          competition,
+          group,
+          dates: this.groupDatesFor(competition),
+          asFull: alwaysByeShortGroups || !registrationClosed,
+          done: this.fixtureDone.bind(this),
+        })) {
+          const key = groupKey(competition.id, date)
+          remainingGroupByDate.set(
+            key, (remainingGroupByDate.get(key) ?? 0) + count
+          )
+        }
+      }
+    }
+
+    const activeCourts = courts.filter(court => court.active)
+    const proCourts = activeCourts.filter(court => court.pro)
+    const openCourts = activeCourts.filter(court => !court.pro)
+
+    const overridesByDate = new Map()
+
+    for (const override of courtOverrides) {
+      if (!overridesByDate.has(override.date)) {
+        overridesByDate.set(override.date, new Map())
+      }
+
+      overridesByDate.get(override.date).set(
+        override.court_id,
+        override.available_from ? timeToMinutes(override.available_from) : null
+      )
+    }
+
+    const venue = { overridesByDate, openCourts, proCourts, activeCourts }
+
+    Object.assign(this, {
+      activeCourts,
+      proCourts,
+      openCourts,
+      overridesByDate,
+      venue,
+    })
+
+    fiveTeam.prepare({
+      slotsFor: this.slotsFor.bind(this),
+      courts: openCourts,
+      usable: courtUsableAt,
+      sharing,
+    })
+  }
+
+  /**
+   * Fills every day of the canvas and says what did not fit.
    *
-   * The shape with the most matches takes the courts first. Amateur
-   * Doubles is mostly fives, so its handful of fours fill in around
-   * them. Singles is the other way round, and planning its one 5-team
-   * group first left a court with four slots nothing could use, since
-   * nothing in the tournament is four slots long.
+   * @returns {Object} the plan's result
    */
-  function pooledLeads(competition) {
-    let pooled = 0
-    let owned = 0
+  fill() {
+    let {
+      courts,
+      registrationClosed,
+      alwaysByeShortGroups,
+      lightBuffer,
+      groupSlotsFromSessions,
+      splitRounds,
+      standing,
+      days,
+      competitions,
+      slots,
+      darkFromMinutes,
+      plan,
+      blocks,
+      remainingGroupByDate,
+      fiveTeam,
+      threeTeamGroups,
+      boltOnGroups,
+      noTemplateWarned,
+      fourTeamUnits,
+      builtThreeTeamUnits,
+      knockoutUnits,
+      sortedSessions,
+      canvas,
+      proCourts,
+      openCourts,
+      overridesByDate,
+    } = this
+
+    for (const date of days) {
+      const taken = makeOccupancy()
+
+      // Cells the plan already holds on this day - what was played
+      // there. The canvas keeps them: their courts are gone for those
+      // hours, and the work in them is work this run does not owe.
+      for (const block of standing) {
+        if (block.date !== date) {
+          continue
+        }
 
-    for (const group of competition.groups ?? []) {
-      const teams = (group.team_ids ?? []).length
-      const matches = (teams * (teams - 1)) / 2
+        const slot = (slots.length > 0 ? slots : []).find(one => one.key === block.slot)
+        const start = slot?.start_minutes ?? timeToMinutes(block.slot)
+        const end = slot?.end_minutes ?? start + MATCH_MINUTES
 
-      if (shortGroup(group)) {
-        pooled += matches
-      } else {
-        owned += matches
+        taken.take(date, block.court_id, start, end)
+        plan.place(block)
+      }
+
+      const slotsByCompetition = new Map(
+        competitions.map(competition => [
+          competition.id,
+          competition.slots
+            ? withMinutes(competition.slots)
+            : ((groupSlotsFromSessions || slots.length === 0)
+              ? this.dayFor(competition, date)
+              : slots),
+        ])
+      )
+
+      const day = new PlanningDay({
+        date,
+        proCourts,
+        openCourts: this.openCourtsFor(date),
+        slotsByCompetition,
+        occupancy: taken,
+        plan,
+        darkFromMinutes,
+        lightBufferMinutes: lightBuffer,
+      })
+
+      if (this.sharing) {
+        this.assignShared(day)
       }
+
+      const timeline = []
+
+      for (const competition of competitions) {
+        const own = slotsByCompetition.get(competition.id) ?? []
+
+        const runLength = fiveTeam.runLengthFor(competition.id, date)
+
+        own.forEach((slot, slotIndex) => {
+          const phase = slot.phase
+            ?? activePhase(sortedSessions.get(competition.id), date, slot.key)
+
+          if (phase !== 'group') {
+            return
+          }
+
+          const last = own[Math.min(slotIndex + runLength - 1, own.length - 1)]
+          const needsLight = runNeedsLight(
+            own, slotIndex, runLength, darkFromMinutes
+          )
+
+          timeline.push({
+            competition, phase: 'group', slots: own, slotIndex, slot, needsLight,
+          })
+        })
+      }
+
+      const lit = byStartTime(timeline.filter(e => e.needsLight), true)
+
+      for (const [, entries] of lit) {
+        this.assign(entries, true, day)
+      }
+
+      const daylight = byStartTime(timeline.filter(e => !e.needsLight), false)
+
+      for (const [, entries] of daylight) {
+        this.assign(entries, false, day)
+      }
+
+      fourTeamUnits ??= this.buildFourTeamUnits()
+      day.placeGroupUnits(
+        fourTeamUnits, fourTeamUnitLayout, slots,
+        this.fixtureDone.bind(this)
+      )
+
+      builtThreeTeamUnits ??= this.buildThreeTeamUnits()
+      day.placeGroupUnits(
+        builtThreeTeamUnits, threeTeamUnitLayout, slots,
+        this.fixtureDone.bind(this)
+      )
+
+      for (const entry of boltOnGroups) {
+        const opened = this.groupDatesFor(entry.competition).includes(date)
+
+        if (entry.placed.has(date) || !opened) {
+          continue
+        }
+
+        const own = slotsByCompetition.get(entry.competition.id) ?? []
+
+        if (own.length === 0 || own[0].phase === 'knockout') {
+          continue
+        }
+
+        const dates = this.groupDatesFor(entry.competition)
+        const teamIds = entry.group.team_ids ?? []
+        const size = entry.group.pool_size ?? teamIds.length
+
+        const asFull = alwaysByeShortGroups || !registrationClosed
+        const seats = asFull && size > teamIds.length
+          ? Array.from({ length: size }, (_, i) => teamIds[i] ?? -(i + 1))
+          : teamIds
+
+        const runs = groupRuns({ teamIds: seats, groupSize: size })
+
+        if (runs.length === 0 && teamIds.length > 0
+          && !noTemplateWarned.has(entry.group.id)) {
+          noTemplateWarned.add(entry.group.id)
+
+          plan.warn({
+            competition_id: entry.competition.id,
+            kind: 'no-template',
+            division_id: entry.group.division_id ?? null,
+            division_name: entry.group.division_name ?? null,
+            group_id: entry.group.id,
+            group_name: entry.group.name ?? null,
+            teams: teamIds.length,
+          })
+
+          plan.short(
+            entry.competition, 'group',
+            GAMES_PER_POOL_SIZE[entry.group.pool_size] ?? 6
+          )
+        }
+
+        const today = runs.filter(run =>
+          (dates.length === 1 ? dates[0] : dates[run.day - 1]) === date
+        )
+        const cells = today
+          .map(run => remainderOf(
+            run, entry.group.id, this.fixtureDone.bind(this)
+          ))
+          .filter(run => run !== null)
+          .flatMap(run => run.positions)
+
+        if (cells.length === 0) {
+          continue
+        }
+
+        const laneCourts = entry.group.is_pro === true
+          ? proCourts
+          : this.openCourtsFor(date)
+        let landed = false
+
+        const last = own.length - cells.length
+
+        for (let start = 0; start <= last && !landed; start++) {
+          const window = own.slice(start, start + cells.length)
+
+          for (const court of laneCourts) {
+            const usable = window.every(slot =>
+              courtUsableAt(court, slot)
+                && taken.free(
+                  date, court.id, slot.start_minutes, slot.end_minutes
+                )
+            )
+
+            if (!usable) {
+              continue
+            }
+
+            window.forEach((slot, offset) => {
+              blocks.push({
+                competition_id: entry.competition.id,
+                division_id: entry.group.division_id ?? null,
+                division_name: entry.group.division_name ?? null,
+                division_gender: entry.group.division_gender ?? null,
+                group_id: entry.group.id,
+                group_name: entry.group.name ?? null,
+                phase: 'group',
+                round: 'group',
+                match_slot: cells[offset] ?? null,
+                court_id: court.id,
+                date,
+                slot: slot.key,
+              })
+
+              taken.take(date, court.id, slot.start_minutes, slot.end_minutes)
+            })
+
+            entry.placed.add(date)
+            landed = true
+            break
+          }
+        }
+
+        if (!landed) {
+          plan.short(entry.competition, 'group', cells.length)
+        }
+      }
+
+      assignKnockout(day, {
+        competitions,
+        draws: knockoutUnits,
+        sessions: sortedSessions,
+        split: splitRounds,
+      })
     }
 
-    return pooled > owned
+    refuseLateStarts({
+      competitions, sortedSessions, plan, overridesByDate,
+      slotsFor: this.slotsFor.bind(this),
+      runLengthFor: (id, date) => fiveTeam.runLengthFor(id, date),
+    })
+
+    const placed = plan.blocks.filter(block => !plan.dropped.has(block))
+
+    for (const entry of threeTeamGroups) {
+      const got = placed.filter(block =>
+        block.group_id === entry.group.id && block.phase === 'group'
+      ).length
+      const missing = GAMES_PER_POOL_SIZE[3] - got
+
+      if (missing > 0) {
+        plan.short(entry.competition, 'group', missing)
+      }
+    }
+
+    for (const [competitionId, count] of this.unplacedFourTeamMatches(fourTeamUnits ?? [])) {
+      plan.short(competitions.find(own => own.id === competitionId), 'group', count)
+    }
+
+    for (const competition of competitions) {
+      if (competition.sessions.length === 0) {
+        // Nothing can be planned without a session, and a competition
+        // that owes matches should not just go quiet.
+        const owes = (competition.groups ?? []).length > 0
+          || knockoutUnits.some(draw => draw.competition.id === competition.id)
+
+        if (owes) {
+          plan.warn({ competition_id: competition.id, kind: 'no-sessions' })
+        }
+
+        continue
+      }
+
+      // A session on a day the plan does not have can place nothing.
+      const outside = [...new Set(competition.sessions.map(session => session.date))]
+        .filter(date => !days.includes(date))
+        .sort()
+
+      if (outside.length > 0) {
+        plan.warn({
+          competition_id: competition.id, kind: 'outside-days', dates: outside,
+        })
+      }
+
+      // Only what this canvas was asked for. Handed one day, the
+      // planner is not short of the group play that belongs to Friday -
+      // it was never asked to place it, and saying so would bury the
+      // one number a director is looking for.
+      const canvas = new Set(days)
+
+      const missingGroup = [...remainingGroupByDate]
+        .filter(([key]) =>
+          key.slice(0, key.indexOf(':')) === String(competition.id)
+            && canvas.has(key.slice(key.indexOf(':') + 1))
+        )
+        .reduce((total, left) => total + Math.max(left[1], 0), 0)
+
+      // A draw's remainder is only this canvas's problem when the
+      // canvas holds every day the draw had to play on. Otherwise what
+      // is left of it belongs to a day nobody asked about.
+      const ownsTheDraw = (competition.knockout_dates ?? [])
+        .every(date => canvas.has(date))
+
+      const missingKnockout = ownsTheDraw
+        ? knockoutUnits
+          .filter(draw => draw.competition.id === competition.id)
+          .reduce((total, draw) => total + draw.unplanned, 0)
+        : 0
+
+      plan.short(competition, 'group', missingGroup)
+      plan.short(competition, 'knockout', missingKnockout)
+    }
+
+    const result = plan.result(competitions)
+
+    const shareable = this.sharing
+      ? competitions
+        .filter(own => days.some(date => fiveTeam.sharedFor(own.id, date)))
+        .map(own => own.id)
+      : []
+
+    return Object.assign(result, { split: this.split ?? [], shareable })
   }
 
   /**
-   * A group with fewer teams than its division is configured for. It
-   * plays three matches a day on a court pair shared with other short
-   * groups, so it is held back from the ordinary allocation.
+   * The matches of four-team units that were never laid out.
+   *
+   * A unit that found no room on a day it plays has placed nothing, and
+   * nothing else would say so. What it owes that day is its share of
+   * the unit's sequence, less what the plan already holds.
+   *
+   * @param {Array} units
+   * @returns {Map<number, number>} unplaced matches by competition
    */
+  unplacedFourTeamMatches(units) {
+    const missing = new Map()
+    const competitionOf = new Map()
+    const done = this.fixtureDone.bind(this)
+
+    for (const unit of units) {
+      const dates = unit.dates.slice(0, 2)
+      const groups = unit.entries.map(entry => ({
+        id: entry.group.id,
+        teamIds: entry.group.team_ids,
+        groupSize: entry.group.pool_size,
+      }))
+
+      for (const entry of unit.entries) {
+        competitionOf.set(entry.group.id, entry.competition.id)
+      }
+
+      const whole = fourTeamUnitLayout(groups, () => false)
+      const firstDay = Math.floor(whole.length / dates.length)
+
+      dates.forEach((date, dayIndex) => {
+        if (!this.days.includes(date) || unit.placed.has(date)) {
+          return
+        }
+
+        const share = dayIndex === 0 ? whole.slice(0, firstDay) : whole.slice(firstDay)
+
+        for (const cell of share.flat().filter(Boolean)) {
+          if (!done(cell.groupId, cell.index)) {
+            const id = competitionOf.get(cell.groupId)
+
+            missing.set(id, (missing.get(id) ?? 0) + 1)
+          }
+        }
+      })
+    }
+
+    return missing
+  }
+
   /**
-   * Whether a group is played on a shared pair of courts rather than
-   * one of its own.
+   * Plays a section on shared courts, for the competitions that have one.
    *
-   * Every 4-team group is: three rounds of two matches, a round taking
-   * both courts, two or three groups taking turns. That is how a
-   * 4-team group is played, not a special case for an uneven one.
+   * The competitions take turns at the courts that are free for the
+   * front of the run, each within its own quota, so every category
+   * keeps its share of the section and still opens when its session
+   * says. Each group plays the front of its run on the court it was
+   * given. The back goes to a court that lasts the whole section, two
+   * groups to a court: one in the first, third and fifth match slot and
+   * the other in the second, fourth and sixth, so neither waits longer
+   * than a match. Groups of a competition pair with each other first,
+   * in court order, so neighbours in a band share a court.
    *
-   * The exception is a group of four sitting in a division configured
-   * for five. While registration is open it may still fill from the
-   * waitlist, so capacity is held for it as a five - the spare cells
-   * are the point, not waste. Once registration closes it is a 4-team
-   * group like any other.
+   * @param {PlanningDay} day
    */
-  function shortGroup(group) {
-    const teams = (group.team_ids ?? []).length
+  assignShared(day) {
+    const { fiveTeam, competitions } = this
+    const { date } = day
 
-    if (teams === 3) {
-      return group.pool_size >= 4
+    this.split ??= []
+
+    const sharing = competitions
+      .map(competition => ({
+        competition,
+        shared: fiveTeam.sharedFor(competition.id, date),
+      }))
+      .filter(entry => entry.shared)
+
+    if (sharing.length === 0) {
+      return
     }
 
-    if (teams !== 4) {
-      return false
+    for (const entry of sharing) {
+      const { shared, competition } = entry
+      const slots = day.slotsFor(competition.id)
+
+      entry.front = slots.slice(shared.first, shared.first + shared.front)
+      entry.back = slots.slice(
+        shared.first + shared.front, shared.first + shared.length
+      )
+      entry.turns = []
     }
 
-    return group.pool_size === 4
-      || (registrationClosed && !alwaysByeShortGroups)
+    const used = new Set()
+    let progressed = true
+
+    while (progressed) {
+      progressed = false
+
+      for (const entry of sharing) {
+        const { competition, shared } = entry
+
+        const free = day.openCourts.filter(court =>
+          !used.has(court.id)
+            && entry.front.every(slot => day.isFree(court, slot))
+        )
+
+        if (free.length === 0) {
+          continue
+        }
+
+        const [court] = free
+        const choice = pickRun({
+          planner: fiveTeam, phase: 'group', competition, date,
+          sectionIndex: shared.index, court, usable: free, proCourt: false,
+          strictQuota: true,
+        })
+
+        if (!choice || choice.blocked) {
+          continue
+        }
+
+        const run = fiveTeam.commit(
+          competition.id, date, shared.index, choice.index
+        )
+
+        run.courts = [court.id]
+        used.add(court.id)
+        entry.turns.push({ run, court })
+        this.placeMatches(day, competition, run, court, entry.front, 0)
+        progressed = true
+      }
+    }
+
+    this.shareBack(day, sharing)
   }
 
-  /*
-   * The dates a competition is actually in its group phase.
+  /**
+   * Gives every group of a shared section the courts for the back of its
+   * run, and shares a court only where there are fewer than groups.
    *
-   * group_dates says which days the draw wants; the sessions say what
-   * the competition is doing on them, and the two disagree whenever
-   * the last group date is also the day it switches to knockout.
+   * With T groups and N courts that last, T - N pairs have to share and
+   * the rest keep a court each. A group that is already on a court that
+   * lasts stays on it; one that is not has to move. A pair is a mover
+   * with a group that stays where it can, so the fewest groups change
+   * court, and a pair takes the court of the one that stays.
    *
-   * A unit cuts its sequence into one part per date. Counting a
-   * knockout day among them handed a half to a day that then refused
-   * it, and the matches were simply lost: three of the four pooled
-   * competitions placed exactly half of theirs.
+   * @param {PlanningDay} day
+   * @param {Array} sharing
    */
-  function groupDatesFor(competition) {
-    const sessions = sortedSessions.get(competition.id) ?? []
+  shareBack(day, sharing) {
+    const turns = sharing.flatMap(entry => entry.turns.map(turn => ({ ...turn, entry })))
 
-    return (competition.group_dates ?? []).filter(date => {
-      const own = slotsForDate(sessions, date, darkFromMinutes, dayEndMinutes)
+    if (turns.length === 0) {
+      return
+    }
 
-      return own.length > 0 && own[0].phase === 'group'
+    const first = turns[0].entry
+    const lasting = day.openCourts.filter(
+      court => first.back.every(slot => day.isFree(court, slot))
+    )
+    const lasts = new Set(lasting.map(court => court.id))
+    const needed = Math.max(0, turns.length - lasting.length)
+
+    const stayers = turns.filter(turn => lasts.has(turn.court.id))
+    const movers = turns.filter(turn => !lasts.has(turn.court.id))
+    const pairs = []
+
+    // A mover with a stayer of its own competition first, then across.
+    for (const entry of sharing) {
+      const own = turn => turn.entry === entry
+
+      for (const mover of movers.filter(own)) {
+        const stayer = stayers.find(
+          other => own(other) && !pairs.some(pair => pair.includes(other))
+        )
+
+        if (stayer && pairs.length < needed) {
+          pairs.push([stayer, mover])
+        }
+      }
+    }
+
+    const free = list => list.filter(turn => !pairs.some(pair => pair.includes(turn)))
+
+    for (const mover of free(movers)) {
+      const stayer = free(stayers)[0]
+
+      if (stayer && pairs.length < needed) {
+        pairs.push([stayer, mover])
+      }
+    }
+
+    // Still short of pairs: whoever is left, two by two.
+    const rest = free(turns)
+
+    for (let i = 0; pairs.length < needed && i + 1 < rest.length; i += 2) {
+      pairs.push([rest[i], rest[i + 1]])
+    }
+
+    const used = new Set()
+    const book = (members, court) => {
+      used.add(court.id)
+
+      members.forEach(({ run, entry }, turn) => {
+        // Alone, a group plays its back in a row; two take turns.
+        const slots = members.length === 1
+          ? entry.back.slice(0, entry.shared.back)
+          : entry.back.filter((slot, i) => i % 2 === turn)
+
+        if (court.id !== run.courts[0]) {
+          run.movesAt ??= slots[0]?.key
+        }
+
+        this.placeMatches(day, entry.competition, run, court, slots, entry.shared.front)
+        run.courts.push(court.id)
+      })
+    }
+
+    // Groups that keep a court to themselves, on the one they are on.
+    const singles = free(turns)
+
+    for (const turn of singles.filter(other => lasts.has(other.court.id))) {
+      book([turn], turn.court)
+    }
+
+    for (const members of pairs) {
+      const own = members.find(turn => lasts.has(turn.court.id) && !used.has(turn.court.id))
+      const court = own?.court ?? lasting.find(candidate => !used.has(candidate.id))
+
+      if (court) {
+        book(members, court)
+      }
+    }
+
+    for (const turn of singles.filter(other => !lasts.has(other.court.id))) {
+      const court = lasting.find(candidate => !used.has(candidate.id))
+
+      if (court) {
+        book([turn], court)
+      }
+    }
+
+    for (const { competition, turns: own } of sharing) {
+      for (const { run } of own) {
+        if (new Set(run.courts).size > 1) {
+          this.split.push({
+            competition_id: competition.id,
+            group_id: run.groupId,
+            group_name: run.groupName ?? null,
+            division_name: run.divisionName ?? null,
+            date: day.date,
+            courts: [...new Set(run.courts)],
+            moves_at: run.movesAt ?? null,
+          })
+        }
+      }
+    }
+  }
+
+  /**
+   * Books some of a run's matches on one court, in order.
+   *
+   * @param {PlanningDay} day
+   * @param {Object} competition
+   * @param {Object} run
+   * @param {Object} court
+   * @param {Array} slots One slot per match, in play order.
+   * @param {number} from Which match of the run the first slot holds.
+   */
+  placeMatches(day, competition, run, court, slots, from) {
+    slots.forEach((slot, i) => {
+      day.place({
+        competition_id: competition.id,
+        division_id: run.divisionId ?? null,
+        division_name: run.divisionName ?? null,
+        division_gender: run.divisionGender ?? null,
+        group_id: run.groupId ?? null,
+        group_name: run.groupName ?? null,
+        phase: 'group',
+        round: 'group',
+        match_slot: run.positions[from + i] ?? null,
+        court_id: court.id,
+        date: day.date,
+        slot: slot.key,
+      }, slot)
+
+      this.decrement(competition.id, 'group', day.date)
     })
   }
 
-  function buildFourTeamUnits() {
+  /**
+   * Hands the day's courts to the competitions whose turn it is.
+   *
+   * @param {Array} entries Group slots that start together.
+   * @param {boolean} requireLit Whether this is the lit pass.
+   * @param {PlanningDay} day
+   */
+  assign(entries, requireLit, day) {
+    const { fiveTeam } = this
+    const { date } = day
+
+    const eligible = entries.filter(({ competition, phase }) =>
+      this.remainingFor(competition.id, phase, date) > 0
+    )
+
+    if (eligible.length === 0) {
+      return
+    }
+
+    const context = {
+      date,
+      taken: day.occupancy,
+      blocks: day.plan.blocks,
+      fiveTeam,
+      requireLit,
+      decrement: this.decrement.bind(this),
+      remainingFor: this.remainingFor.bind(this),
+    }
+
+    assignCourts(
+      day.proCourts,
+      eligible.filter(({ competition }) => competition.is_pro),
+      { ...context, proCourt: true }
+    )
+
+    assignCourts(day.openCourts, eligible, context)
+  }
+
+  buildFourTeamUnits() {
+    const { fourTeamGroups } = this
+
     const pools = new Map()
 
     for (const entry of fourTeamGroups) {
-      const dates = groupDatesFor(entry.competition)
+      const dates = this.groupDatesFor(entry.competition)
       const pairing = entry.group.pairing ?? 'auto'
 
       const key = [
@@ -278,11 +1185,13 @@ export function autoFillPlanning(params) {
    * a vacant-seat bye, and there is no pairs/triples choice to honour
    * (see paired-court-planner.mjs's TODO).
    */
-  function buildThreeTeamUnits() {
+  buildThreeTeamUnits() {
+    const { threeTeamGroups } = this
+
     const pools = new Map()
 
     for (const entry of threeTeamGroups) {
-      const dates = groupDatesFor(entry.competition)
+      const dates = this.groupDatesFor(entry.competition)
 
       const isTeamCup = (entry.group.team_size ?? 2) >= 4
 
@@ -318,167 +1227,139 @@ export function autoFillPlanning(params) {
     return units
   }
 
-  const knockoutUnits = []
+  /*
+   * The dates a competition is actually in its group phase.
+   *
+   * group_dates says which days the draw wants; the sessions say what
+   * the competition is doing on them, and the two disagree whenever
+   * the last group date is also the day it switches to knockout.
+   *
+   * A unit cuts its sequence into one part per date. Counting a
+   * knockout day among them handed a half to a day that then refused
+   * it, and the matches were simply lost: three of the four pooled
+   * competitions placed exactly half of theirs.
+   */
+  groupDatesFor(competition) {
+    const { sortedSessions, darkFromMinutes, dayEndMinutes } = this.canvas
 
-  const proDivisions = new Set()
+    const sessions = sortedSessions.get(competition.id) ?? []
 
-  for (const competition of competitions) {
-    for (const group of competition.groups ?? []) {
-      if (group.is_pro === true && group.division_id != null) {
-        proDivisions.add(group.division_id)
-      }
-    }
-  }
+    return (competition.group_dates ?? []).filter(date => {
+      const own = slotsForDate(sessions, date, darkFromMinutes, dayEndMinutes)
 
-  const sortedSessions = new Map()
-  for (const competition of competitions) {
-    sortedSessions.set(
-      competition.id,
-      [...competition.sessions].sort((a, b) =>
-        (a.date + a.start_time).localeCompare(b.date + b.start_time)
-      )
-    )
+      return own.length > 0 && own[0].phase === 'group'
+    })
   }
 
-  for (const competition of competitions) {
-    const derived = (competition.divisions ?? [])
-      .filter(division =>
-        division.knockout_matches != null || division.team_count != null
-      )
-      .map(division => ({
-        division_id: division.id,
-        division_name: division.name,
-        division_gender: division.gender ?? null,
-        level: division.level ?? 0,
-        waves: wavesForDivision(division, { itf: competition.itf === true }),
-      }))
-      .filter(bracket => bracket.waves.length > 0)
-
-    const brackets = derived.length > 0
-      ? derived
-      : (competition.knockout_rounds_by_division
-        ?? (competition.games_needed_by_round?.length
-          ? [competition.games_needed_by_round]
-          : []))
-
-    for (const bracket of brackets) {
-      const waves = Array.isArray(bracket) ? bracket : bracket.waves
-      const division = Array.isArray(bracket) ? null : bracket
-
-      knockoutUnits.push(new KnockoutDraw({
-        competition,
-        waves,
-        divisionId: division?.division_id ?? null,
-        divisionName: division?.division_name ?? null,
-        divisionGender: division?.division_gender ?? null,
-        level: division?.level ?? 0,
-        isPro: proDivisions.has(division?.division_id),
-      }))
-    }
-
-    if (Array.isArray(competition.groups) && competition.groups.length === 0) {
-      continue
-    }
-
-    const boltOn = pooledLeads(competition)
+  /**
+   * Whether this competition is mostly played on shared pairs.
+   *
+   * A competition of one shape is laid out by that shape's planner and
+   * there is nothing to decide. A mixed one has to choose which goes
+   * first, because the two do not divide into each other: a pair runs
+   * in threes and a 5-team group in fives, so whichever is laid down
+   * second has to fit around the other's leftovers.
+   *
+   * The shape with the most matches takes the courts first. Amateur
+   * Doubles is mostly fives, so its handful of fours fill in around
+   * them. Singles is the other way round, and planning its one 5-team
+   * group first left a court with four slots nothing could use, since
+   * nothing in the tournament is four slots long.
+   */
+  pooledLeads(competition) {
+    let pooled = 0
+    let owned = 0
 
     for (const group of competition.groups ?? []) {
-      if (shortGroup(group)) {
-        const size = group.pool_size ?? group.team_ids.length
-        const asFull = alwaysByeShortGroups || !registrationClosed
-        const padded = asFull && size > group.team_ids.length
-          ? paddedWithByes(group, size)
-          : group
-
-        fourTeamGroups.push({ competition, group: padded })
-        continue
-      }
-
-      if ((group.team_ids ?? []).length === 3) {
-        threeTeamGroups.push({ competition, group, placed: new Set() })
-        continue
-      }
-
-      if (boltOn) {
-        boltOnGroups.push({ competition, group, placed: new Set() })
-        continue
-      }
+      const teams = (group.team_ids ?? []).length
+      const matches = (teams * (teams - 1)) / 2
 
-      for (const { date, count } of fiveTeam.enqueue({
-        competition,
-        group,
-        dates: groupDatesFor(competition),
-        asFull: alwaysByeShortGroups || !registrationClosed,
-      })) {
-        const key = groupKey(competition.id, date)
-        remainingGroupByDate.set(
-          key, (remainingGroupByDate.get(key) ?? 0) + count
-        )
+      if (this.shortGroup(group)) {
+        pooled += matches
+      } else {
+        owned += matches
       }
     }
-  }
 
-  function remainingFor(competitionId, phase, date) {
-    return remainingGroupByDate.get(groupKey(competitionId, date)) ?? 0
+    return pooled > owned
   }
 
-  function decrement(competitionId, phase, date) {
-    const groupDateKey = groupKey(competitionId, date)
-    remainingGroupByDate.set(
-      groupDateKey, remainingGroupByDate.get(groupDateKey) - 1
-    )
-  }
+  /**
+   * A group with fewer teams than its division is configured for. It
+   * plays three matches a day on a court pair shared with other short
+   * groups, so it is held back from the ordinary allocation.
+   */
+  /**
+   * Whether a group is played on a shared pair of courts rather than
+   * one of its own.
+   *
+   * Every 4-team group is: three rounds of two matches, a round taking
+   * both courts, two or three groups taking turns. That is how a
+   * 4-team group is played, not a special case for an uneven one.
+   *
+   * The exception is a group of four sitting in a division configured
+   * for five. While registration is open it may still fill from the
+   * waitlist, so capacity is held for it as a five - the spare cells
+   * are the point, not waste. Once registration closes it is a 4-team
+   * group like any other.
+   */
+  shortGroup(group) {
+    const { registrationClosed, alwaysByeShortGroups } = this.rules
 
-  const activeCourts = courts.filter(court => court.active)
-  const proCourts = activeCourts.filter(court => court.pro)
-  const openCourts = activeCourts.filter(court => !court.pro)
+    const teams = (group.team_ids ?? []).length
 
-  const overridesByDate = new Map()
+    if (teams === 3) {
+      return group.pool_size >= 4
+    }
 
-  for (const override of courtOverrides) {
-    if (!overridesByDate.has(override.date)) {
-      overridesByDate.set(override.date, new Map())
+    if (teams !== 4) {
+      return false
     }
 
-    overridesByDate.get(override.date).set(
-      override.court_id,
-      override.available_from ? timeToMinutes(override.available_from) : null
-    )
+    return group.pool_size === 4
+      || (registrationClosed && !alwaysByeShortGroups)
   }
 
   /**
-   * The non-pro courts usable on this date - openCourts, plus any
-   * normally-pro court a director has opened up for the day. The
-   * override travels with the court object itself (availableFromMinutes),
-   * so courtUsableAt can enforce it without needing to know the date.
+   * The hours this competition may use on this date.
+   *
+   * Its sessions say: when it opens, how long a match is, and which
+   * phase is on.
    */
-  function openCourtsFor(date) {
-    const overrides = overridesByDate.get(date)
+  dayFor(competition, on) {
+    const {
+      sortedSessions, darkFromMinutes, dayEndMinutes,
+    } = this.canvas
+    const own = sortedSessions.get(competition.id) ?? []
+    const fromSessions = slotsForDate(
+      own, on, darkFromMinutes, dayEndMinutes, this.anchorFor(on)
+    )
 
-    if (!overrides) {
-      return openCourts
-    }
+    return fromSessions
+  }
 
-    const opened = new Map(proCourts
-      .filter(court => overrides.has(court.id))
-      .map(court => [court.id, {
-        ...court, availableFromMinutes: overrides.get(court.id),
-      }]))
+  slotsFor(competitionId, date) {
+    const {
+      groupSlotsFromSessions, slots, sortedSessions, darkFromMinutes, dayEndMinutes,
+    } = this.canvas
 
-    if (opened.size === 0) {
-      return openCourts
+    if (!groupSlotsFromSessions && slots.length > 0) {
+      return slots
     }
 
-    return activeCourts
-      .filter(court => !court.pro || opened.has(court.id))
-      .map(court => opened.get(court.id) ?? court)
+    return slotsForDate(
+      sortedSessions.get(Number(competitionId)) ?? [],
+      date, darkFromMinutes, dayEndMinutes, this.anchorFor(date)
+    )
   }
 
   /**
    * The hour the day's first competition opens, which every
    * competition's slots are measured from.
    */
-  function anchorFor(date) {
+  anchorFor(date) {
+    const { competitions, sortedSessions, knockoutUnits } = this.canvas
+
     const opens = []
 
     for (const competition of competitions) {
@@ -506,391 +1387,165 @@ export function autoFillPlanning(params) {
     return opens.length === 0 ? null : Math.min(...opens)
   }
 
-  function slotsFor(competitionId, date) {
-    if (!groupSlotsFromSessions && slots.length > 0) {
-      return slots
-    }
-
-    return slotsForDate(
-      sortedSessions.get(Number(competitionId)) ?? [],
-      date, darkFromMinutes, dayEndMinutes, anchorFor(date)
-    )
-  }
-
-  fiveTeam.prepare({ slotsFor, courts: openCourts, usable: courtUsableAt })
-
-  for (const date of days) {
-    const taken = makeOccupancy()
-
-    const slotsByCompetition = new Map(
-      competitions.map(competition => [
-        competition.id,
-        competition.slots
-          ? withMinutes(competition.slots)
-          : ((groupSlotsFromSessions || slots.length === 0)
-            ? slotsForDate(
-              sortedSessions.get(competition.id) ?? [],
-              date, darkFromMinutes, dayEndMinutes, anchorFor(date)
-            )
-            : slots),
-      ])
-    )
-
-    function assign(entries, requireLit) {
-      const eligible = entries.filter(({ competition, phase }) =>
-        remainingFor(competition.id, phase, date) > 0
-      )
-
-      if (eligible.length === 0) {
-        return
-      }
-
-      const context = {
-        date, taken, blocks, remainingFor, decrement, fiveTeam, requireLit,
-      }
-
-      assignCourts(
-        proCourts,
-        eligible.filter(({ competition }) => competition.is_pro),
-        { ...context, proCourt: true }
-      )
-
-      assignCourts(openCourtsFor(date), eligible, context)
-    }
-
-    const timeline = []
-
-    for (const competition of competitions) {
-      const own = slotsByCompetition.get(competition.id) ?? []
-
-      const runLength = fiveTeam.runLengthFor(competition.id, date)
-
-      own.forEach((slot, slotIndex) => {
-        const phase = slot.phase
-          ?? activePhase(sortedSessions.get(competition.id), date, slot.key)
-
-        if (phase !== 'group') {
-          return
-        }
-
-        const last = own[Math.min(slotIndex + runLength - 1, own.length - 1)]
-        const needsLight = runNeedsLight(
-          own, slotIndex, runLength, darkFromMinutes
-        )
-
-        timeline.push({
-          competition, phase: 'group', slots: own, slotIndex, slot, needsLight,
-        })
-      })
-    }
-
-    const lit = byStartTime(timeline.filter(e => e.needsLight), true)
-
-    for (const [, entries] of lit) {
-      assign(entries, true)
-    }
+  /**
+   * The non-pro courts usable on this date - openCourts, plus any
+   * normally-pro court a director has opened up for the day. The
+   * override travels with the court object itself (availableFromMinutes),
+   * so courtUsableAt can enforce it without needing to know the date.
+   */
+  openCourtsFor(date) {
+    const { overridesByDate, openCourts, proCourts, activeCourts } = this.venue
 
-    const daylight = byStartTime(timeline.filter(e => !e.needsLight), false)
+    const overrides = overridesByDate.get(date)
 
-    for (const [, entries] of daylight) {
-      assign(entries, false)
+    if (!overrides) {
+      return openCourts
     }
 
-    function placeGroupUnit(unit, unitLayoutFn) {
-      const unitDates = unit.dates.slice(0, 2)
-      const dayIndex = unitDates.indexOf(date)
-
-      if (dayIndex === -1 || unit.placed.has(date)) {
-        return false
-      }
-
-      const unitSlots = slotsByCompetition
-        .get(unit.entries[0].competition.id) ?? slots
-
-      if (unitSlots.length === 0 || unitSlots[0].phase === 'knockout') {
-        return false
-      }
-
-      const sequence = unitLayoutFn(unit.entries.map(entry => ({
-        id: entry.group.id,
-        teamIds: entry.group.team_ids,
-        groupSize: entry.group.pool_size,
-      })))
-
-      const firstDay = Math.floor(sequence.length / unitDates.length)
-      const layout = dayIndex === 0
-        ? sequence.slice(0, firstDay)
-        : sequence.slice(firstDay)
-
-      const before = blocks.length
-
-      const placed = placeLayout({
-        layout,
-        lookup: groupId => {
-          const entry = unit.entries.find(x => x.group.id === groupId)
-
-          return {
-            id: entry.group.id,
-            competitionId: entry.competition.id,
-            divisionId: entry.group.division_id ?? null,
-            divisionName: entry.group.division_name ?? null,
-            divisionGender: entry.group.division_gender ?? null,
-            groupName: entry.group.name ?? null,
-          }
-        },
-        courts: unit.isPro ? proCourts : openCourtsFor(date),
-        slots: unitSlots,
-        date,
-        occupancy: taken,
-        darkFrom: darkFromMinutes,
-        blocks,
-      })
-
-      if (placed) {
-        unit.placed.add(date)
-        return new Set(blocks.slice(before).map(block => block.court_id)).size
-      }
+    const opened = new Map(proCourts
+      .filter(court => overrides.has(court.id))
+      .map(court => [court.id, {
+        ...court, availableFromMinutes: overrides.get(court.id),
+      }]))
 
-      return false
+    if (opened.size === 0) {
+      return openCourts
     }
 
-    function placeGroupUnitsForDate(units, unitLayoutFn) {
-      for (const kind of [true, false]) {
-        const due = units.filter(unit =>
-          unit.isPro === kind && !unit.placed.has(date)
-            && unit.dates.includes(date)
-        )
-
-        if (due.length === 0) {
-          continue
-        }
-
-        const order = []
-
-        for (const unit of due) {
-          if (!order.includes(unit.divisionId)) {
-            order.push(unit.divisionId)
-          }
-        }
-
-        const roomCourts = (kind ? proCourts : openCourtsFor(date)).length
-
-        const quota = new Map(order.map((divisionId, index) => {
-          const mine = due.filter(unit => unit.divisionId === divisionId)
-          const share = mine.length / due.length
-
-          return [
-            divisionId,
-            index === order.length - 1
-              ? Infinity
-              : Math.max(2, Math.round(share * roomCourts)),
-          ]
-        }))
-
-        const claimed = new Map()
-
-        for (const unit of due) {
-          const mine = claimed.get(unit.divisionId) ?? 0
-
-          if (mine >= (quota.get(unit.divisionId) ?? Infinity)) {
-            continue
-          }
-
-          const courtsUsed = placeGroupUnit(unit, unitLayoutFn)
+    return activeCourts
+      .filter(court => !court.pro || opened.has(court.id))
+      .map(court => opened.get(court.id) ?? court)
+  }
 
-          if (courtsUsed) {
-            claimed.set(
-              unit.divisionId, (claimed.get(unit.divisionId) ?? 0) + courtsUsed
-            )
-          }
-        }
+  /**
+   * What a draw still owes, given what is already planned for it.
+   *
+   * A day handed to the planner on its own gets the rounds that have
+   * not been placed anywhere - a fill of the Thursday should not
+   * lay out the R32 that was played on the Tuesday. A round part-laid
+   * keeps the rest of itself; a round already whole is dropped.
+   *
+   * @param {Array} waves
+   * @param {number} competitionId
+   * @param {?number} divisionId
+   * @returns {Array}
+   */
+  owedWaves(waves, competitionId, divisionId) {
+    const { alreadyPlaced } = this
 
-        for (const unit of due) {
-          if (!unit.placed.has(date)) {
-            placeGroupUnit(unit, unitLayoutFn)
-          }
-        }
-      }
+    if (alreadyPlaced.size === 0) {
+      return waves
     }
 
-    fourTeamUnits ??= buildFourTeamUnits()
-    placeGroupUnitsForDate(fourTeamUnits, fourTeamUnitLayout)
-
-    builtThreeTeamUnits ??= buildThreeTeamUnits()
-    placeGroupUnitsForDate(builtThreeTeamUnits, threeTeamUnitLayout)
-
-    for (const entry of boltOnGroups) {
-      const opened = groupDatesFor(entry.competition).includes(date)
-
-      if (entry.placed.has(date) || !opened) {
-        continue
-      }
-
-      const own = slotsByCompetition.get(entry.competition.id) ?? []
-
-      if (own.length === 0 || own[0].phase === 'knockout') {
-        continue
-      }
-
-      const dates = groupDatesFor(entry.competition)
-      const teamIds = entry.group.team_ids ?? []
-      const size = entry.group.pool_size ?? teamIds.length
-
-      const asFull = alwaysByeShortGroups || !registrationClosed
-      const seats = asFull && size > teamIds.length
-        ? Array.from({ length: size }, (_, i) => teamIds[i] ?? -(i + 1))
-        : teamIds
+    return waves
+      .map(wave => ({
+        ...wave,
+        count: wave.count - (alreadyPlaced.get(
+          [competitionId, divisionId, wave.round].join('|')
+        ) ?? 0),
+      }))
+      .filter(wave => wave.count > 0)
+  }
 
-      const runs = groupRuns({ teamIds: seats, groupSize: size })
+  /**
+   * Whether this fixture of this group is already in the plan.
+   *
+   * @param {Map<number, Set<number>>} playedFixtures by group
+   * @param {number} groupId
+   * @param {number} index
+   * @returns {boolean}
+   */
+  fixtureDone(groupId, index) {
+    return this.playedFixtures.get(groupId)?.has(index) === true
+  }
 
-      if (runs.length === 0 && teamIds.length > 0
-        && !noTemplateWarned.has(entry.group.id)) {
-        noTemplateWarned.add(entry.group.id)
+  remainingFor(competitionId, phase, date) {
+    const { remainingGroupByDate } = this
 
-        plan.warn({
-          competition_id: entry.competition.id,
-          kind: 'no-template',
-          division_id: entry.group.division_id ?? null,
-          division_name: entry.group.division_name ?? null,
-          group_id: entry.group.id,
-          group_name: entry.group.name ?? null,
-          teams: teamIds.length,
-        })
+    return remainingGroupByDate.get(groupKey(competitionId, date)) ?? 0
+  }
 
-        plan.short(
-          entry.competition, 'group',
-          GAMES_PER_POOL_SIZE[entry.group.pool_size] ?? 6
-        )
-      }
+  decrement(competitionId, phase, date) {
+    const { remainingGroupByDate } = this
 
-      const today = runs.filter(run =>
-        (dates.length === 1 ? dates[0] : dates[run.day - 1]) === date
-      )
-      const cells = today.flatMap(run => run.positions)
+    const groupDateKey = groupKey(competitionId, date)
+    remainingGroupByDate.set(
+      groupDateKey, remainingGroupByDate.get(groupDateKey) - 1
+    )
+  }
+}
 
-      if (cells.length === 0) {
-        continue
-      }
 
-      const laneCourts = entry.group.is_pro === true
-        ? proCourts
-        : openCourtsFor(date)
-      let landed = false
 
-      const last = own.length - cells.length
+/**
+ * How good a plan is, lowest winning: what it could not place, then
+ * what it left overflowing its own knockout days, then how late it
+ * runs.
+ *
+ * A day that fits is worth more than a day that finishes early, and a
+ * plan that finishes early is worth more than one that dribbles into
+ * the evening. Nothing else is measured, because nothing else is what
+ * a director is deciding between at eleven at night.
+ *
+ * @param {Array} competitions
+ * @param {Object} result
+ * @returns {number[]}
+ */
+export function planScore(competitions, result) {
+  const short = (result.shortfall ?? [])
+    .reduce((total, entry) => total + (entry.missing ?? 0), 0)
 
-      for (let start = 0; start <= last && !landed; start++) {
-        const window = own.slice(start, start + cells.length)
+  const last = (result.blocks ?? [])
+    .reduce((latest, block) => {
+      const ends = `${block.date} ${block.slot}`
 
-        for (const court of laneCourts) {
-          const usable = window.every(slot =>
-            courtUsableAt(court, slot)
-              && taken.free(
-                date, court.id, slot.start_minutes, slot.end_minutes
-              )
-          )
+      return ends > latest ? ends : latest
+    }, '')
 
-          if (!usable) {
-            continue
-          }
+  return [short, knockoutOverflow(competitions, result), last === '' ? 0 : 1, last]
+}
 
-          window.forEach((slot, offset) => {
-            blocks.push({
-              competition_id: entry.competition.id,
-              division_id: entry.group.division_id ?? null,
-              division_name: entry.group.division_name ?? null,
-              division_gender: entry.group.division_gender ?? null,
-              group_id: entry.group.id,
-              group_name: entry.group.name ?? null,
-              phase: 'group',
-              round: 'group',
-              match_slot: cells[offset] ?? null,
-              court_id: court.id,
-              date,
-              slot: slot.key,
-            })
+/**
+ * Plans the same canvas several ways and keeps the best of them.
+ *
+ * The levers a director reaches for on the night - open the pro
+ * courts, bundle the groups denser, cut the rounds - are cheap to try
+ * and hard to judge by eye, and the answer is not the same twice: it
+ * depends on what is left to place and how much room is left to place
+ * it in. So try them and measure, rather than choosing in advance.
+ *
+ * @param {Object} params What autoFillPlanning takes.
+ * @param {Array<Object>} options One overlay of params per attempt.
+ * @returns {Object} the winning result, with `chosen` saying which
+ *   overlay produced it.
+ */
+export function bestPlan(params, options = [{}]) {
+  const competitions = params.competitions ?? []
 
-            taken.take(date, court.id, slot.start_minutes, slot.end_minutes)
-          })
+  let best = null
 
-          entry.placed.add(date)
-          landed = true
-          break
-        }
-      }
+  for (const option of options) {
+    const result = autoFillPlanning({ ...params, ...option })
+    const score = planScore(competitions, result)
 
-      if (!landed) {
-        plan.short(entry.competition, 'group', cells.length)
-      }
+    if (best === null || cheaper(score, best.score)) {
+      best = { result, score, option }
     }
-
-    const day = new PlanningDay({
-      date,
-      proCourts,
-      openCourts: openCourtsFor(date),
-      slotsByCompetition,
-      occupancy: taken,
-      plan,
-      darkFromMinutes,
-      lightBufferMinutes: lightBuffer,
-    })
-
-    assignKnockout(day, {
-      competitions,
-      draws: knockoutUnits,
-      sessions: sortedSessions,
-      split: splitRounds,
-    })
   }
 
-  refuseLateStarts({
-    competitions, sortedSessions, plan, overridesByDate,
-    slotsFor, runLengthFor: (id, date) => fiveTeam.runLengthFor(id, date),
-  })
-
-  const placed = plan.blocks.filter(block => !plan.dropped.has(block))
-
-  for (const entry of threeTeamGroups) {
-    const got = placed.filter(block =>
-      block.group_id === entry.group.id && block.phase === 'group'
-    ).length
-    const missing = GAMES_PER_POOL_SIZE[3] - got
-
-    if (missing > 0) {
-      plan.short(entry.competition, 'group', missing)
-    }
-  }
+  return { ...best.result, chosen: best.option }
+}
 
-  for (const competition of competitions) {
-    if (competition.sessions.length === 0) {
+function cheaper(score, than) {
+  for (let i = 0; i < Math.max(score.length, than.length); i++) {
+    if (score[i] === than[i]) {
       continue
     }
 
-    const missingGroup = [...remainingGroupByDate]
-      .filter(([key]) =>
-        key.slice(0, key.indexOf(':')) === String(competition.id)
-      )
-      .reduce((total, [, left]) => total + Math.max(left, 0), 0)
-
-    const missingKnockout = knockoutUnits
-      .filter(draw => draw.competition.id === competition.id)
-      .reduce((total, draw) => total + draw.unplanned, 0)
-
-    plan.short(competition, 'group', missingGroup)
-    plan.short(competition, 'knockout', missingKnockout)
-  }
-
-  const result = plan.result(competitions)
-
-  const overflow = knockoutOverflow(competitions, result)
-
-  if (splitRounds || overflow === 0) {
-    return result
+    return score[i] < than[i]
   }
 
-  const retried = autoFillPlanning({ ...params, splitRounds: true })
-
-  return knockoutOverflow(competitions, retried) < overflow ? retried : result
+  return false
 }
 
 /**
@@ -1099,6 +1754,7 @@ function groupKey(competitionId, date) {
  */
 function pickRun({
   planner, phase, competition, date, sectionIndex, court, usable, proCourt,
+  strictQuota = false,
 }) {
   if (phase !== 'group') {
     return null
@@ -1107,7 +1763,7 @@ function pickRun({
   return planner.pick(competition.id, date, sectionIndex, {
     courtPosition: usable.indexOf(court),
     courtCount: usable.length,
-  }, { proCourt })
+  }, { proCourt, strictQuota })
 }
 
 function assignCourts(courtList, eligible, context) {
@@ -1228,30 +1884,53 @@ function withMinutes(slots) {
 export function slotsForDate(
   sessions, date, darkFromMinutes, dayEnd = 24 * 60, anchor = null
 ) {
-  const active = activeSession(sessions, date)
-
-  if (!active) {
+  // Every session the date has of its own, in order - a day can hold
+  // more than one, and the phase already knew that: groups in the
+  // morning and the knockout from three. Taking only the last of them
+  // generated the whole day from three o'clock and left the morning
+  // with no slots to play in at all.
+  //
+  // A date with no session of its own carries on under the last one
+  // before it, which is how a competition keeps its clock across the
+  // days between its sessions.
+  const own = (sessions ?? [])
+    .filter(session => session.date === date)
+    .sort((a, b) => a.start_time.localeCompare(b.start_time))
+
+  const running = own.length > 0
+    ? own
+    : [activeSession(sessions, date)].filter(Boolean)
+
+  if (running.length === 0) {
     return []
   }
 
-  const length = Math.max(1, active.playtime ?? MATCH_MINUTES)
-  const opens = timeToMinutes(active.start_time)
-
-  const from = anchor == null || anchor > opens
-    ? opens
-    : anchor + Math.ceil((opens - anchor) / length) * length
-
   const slots = []
 
-  for (let start = from; start + length <= dayEnd; start += length) {
-    slots.push({
-      key: minutesToTime(start),
-      start_minutes: start,
-      end_minutes: start + length,
-      lit_required: darkFromMinutes != null && start + length > darkFromMinutes,
-      phase: active.phase,
-    })
-  }
+  running.forEach((session, index) => {
+    const length = Math.max(1, session.playtime ?? MATCH_MINUTES)
+    const opens = timeToMinutes(session.start_time)
+
+    // A session runs until the next one takes over, and the last one
+    // until the day ends.
+    const until = index + 1 < running.length
+      ? timeToMinutes(running[index + 1].start_time)
+      : dayEnd
+
+    const from = index > 0 || anchor == null || anchor > opens
+      ? opens
+      : anchor + Math.ceil((opens - anchor) / length) * length
+
+    for (let start = from; start + length <= until; start += length) {
+      slots.push({
+        key: minutesToTime(start),
+        start_minutes: start,
+        end_minutes: start + length,
+        lit_required: darkFromMinutes != null && start + length > darkFromMinutes,
+        phase: session.phase,
+      })
+    }
+  })
 
   return slots
 }