@opndev/tennis-match-center 0.0.3 → 0.0.4

package/lib/components/planning-board.mjs

@@ -136,8 +136,14 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
           <input data-always-bye-short-groups type="checkbox">
           Always give a short group its bye
         </label>
+        <label data-relaxed hidden>
+          <input data-relaxed-sharing type="checkbox">
+          Share courts when they run short (clear the plan first)
+        </label>
         <p data-short-groups hidden></p>
         <p data-auto-fill-shortfall hidden></p>
+        <p data-auto-fill-split hidden></p>
+        <p data-auto-fill-starts hidden></p>
         <p data-auto-fill-warnings hidden></p>
         <button data-clear-all type="button" hidden>Clear planning (all)</button>
         <button data-clear-day type="button" hidden>Clear planning (day)</button>
@@ -182,6 +188,7 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
       // replacing the grid.
       this.$('[data-registration-closed]').addEventListener('change', () => this.render())
       this.$('[data-always-bye-short-groups]').addEventListener('change', () => this.render())
+      this.$('[data-relaxed-sharing]').addEventListener('change', () => this.render())
       this.$('[data-show-data]').addEventListener('change', () => this.render())
       this.$('[data-narrow-empty]').addEventListener('change', () => this.render())
       this.$('[data-clear-all]').addEventListener('click', () => this.clearAll())
@@ -239,7 +246,7 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
       return
     }
 
-    this.blocks = this.state.blocks.map(block => ({ ...block }))
+    this.blocks = this.withPlayed(this.state.blocks.map(block => ({ ...block })))
     this.selection = new Set()
     this.selectionDate = null
     this.isSelecting = false
@@ -736,6 +743,60 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
     this.paintSelection()
   }
 
+  /**
+   * The saved plan with what actually happened written over it.
+   *
+   * The plan is what was intended. The matches are what was played,
+   * on the court and at the hour they really ran, and the two part
+   * company the moment the plan is changed or a session disagrees with
+   * the day - Monday opened at 08:00 where the sessions said 09:00, and
+   * not one cell of 2166 lined up.
+   *
+   * So a played cell wins twice over: the plan's cell for that same
+   * fixture goes, wherever it had put it, and so does whatever the
+   * plan had on that court at that hour.
+   *
+   * @param {Array} blocks
+   * @returns {Array}
+   */
+  withPlayed(blocks) {
+    const played = this.state.played_cells ?? []
+
+    if (played.length === 0) {
+      return blocks
+    }
+
+    const fixtures = new Set(played.map(cell => this.fixtureKey(cell)))
+    const where = new Set(played.map(cell => `${cell.date}|${cell.court_id}|${cell.slot}`))
+
+    return [
+      ...blocks.filter(block =>
+        !fixtures.has(this.fixtureKey(block))
+          && !where.has(`${block.date}|${block.court_id}|${block.slot}`)
+      ),
+      ...played.map(cell => ({ ...cell, id: null })),
+    ]
+  }
+
+  /**
+   * What a cell is for, as far as two cells can be said to be the
+   * same one: the fixture, not where it was put.
+   *
+   * @param {Object} cell
+   * @returns {string}
+   */
+  fixtureKey(cell) {
+    // A group fixture is its group and its slot; a knockout one is
+    // its round and its slot. The phase decides which, because a
+    // planned group cell carries no round and a played one says
+    // 'group', and they are the same fixture.
+    const of = cell.phase === 'knockout'
+      ? [cell.round ?? '', cell.match_slot ?? '']
+      : [cell.group_id ?? '', cell.match_slot ?? '']
+
+    return [cell.competition_id, cell.division_id ?? '', cell.phase, ...of].join('|')
+  }
+
   /**
    * The blocks under the current selection.
    *
@@ -1170,6 +1231,18 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
     return this.$('[data-always-bye-short-groups]')?.checked ?? false
   }
 
+  /**
+   * Whether groups may share courts when the courts run short.
+   *
+   * Off, a group stays on one court for its whole run and what does not
+   * fit is reported. On, a plan that falls short is planned again with
+   * courts shared. The board only adds to what is on it, so a plan made
+   * strictly has to be cleared before sharing can rearrange it.
+   */
+  relaxed() {
+    return this.$('[data-relaxed-sharing]')?.checked ?? false
+  }
+
   /**
    * Left off the element, the planner's own default stands. "0" is a
    * real answer, hence no `|| undefined`.
@@ -1202,6 +1275,11 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
   }
 
   /**
+   * Fills in what the sessions ask for and the grid does not hold yet.
+   *
+   * It only ever adds: what is on the board stands, and the planner
+   * works around it. To plan a day afresh, clear it first.
+   *
    * Re-fetches the competitions/groups config before computing, so a
    * pairing (or any other config) changed on the Competitions page
    * just before clicking this is what actually gets planned against -
@@ -1223,13 +1301,14 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
         return
       }
 
-      const { blocks, shortfall, warnings } = autoFillPlanning({
+      const { blocks, shortfall, warnings, split } = autoFillPlanning({
         courts: this.state.courts,
         slots: this.state.slots,
         days: this.state.days,
         competitions: this.state.competitions,
         registrationClosed: this.registrationClosed(),
         alwaysByeShortGroups: this.alwaysByeShortGroups(),
+        relaxed: this.relaxed(),
         courtOverrides: this.state.court_overrides ?? [],
 
         // Group play follows each competition's own session, so a
@@ -1240,11 +1319,21 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
         darkFrom: this.getConfig()['dark-from'],
         dayEnd: this.getConfig()['day-end'] || undefined,
         lightBuffer: this.lightBuffer(),
+        standing: this.blocks,
       })
 
-      this.blocks = blocks
+      // The planner hands back the cells it was given on the days it
+      // planned, along with what it added. A cell on a day outside the
+      // canvas never reaches it.
+      const canvas = new Set(this.state.days)
+
+      this.blocks = [
+        ...this.blocks.filter(block => !canvas.has(block.date)),
+        ...blocks,
+      ]
       this.lastAutoFillShortfall = shortfall
       this.lastAutoFillWarnings = warnings
+      this.lastAutoFillSplit = split ?? []
       this.selection = new Set()
 
       const short = this.shortGroups()
@@ -1270,14 +1359,106 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
   }
 
   /**
-   * Empties the whole grid - only ever mutates the in-browser copy
-   * until Save is pressed, same as any other change here.
+   * Which groups ended up on more than one court, and where.
+   *
+   * A group is named by its competition, division and letter: the
+   * letter alone is in every division. Then the court it started on,
+   * the court it moved to and when it first plays there.
+   *
+   * @param {Array<{competition_id: number, group_name: ?string,
+   *   group_id: number, division_name: ?string, date: string,
+   *   courts: number[], moves_at: ?string}>} split
+   * @returns {string}
+   */
+  splitSummary(split) {
+    const courtName = id => this.state.courts.find(court => court.id === id)?.name ?? id
+
+    const named = split.slice(0, 6).map(entry => {
+      const competition = this.state.competitions
+        .find(candidate => candidate.id === entry.competition_id)?.name
+      const group = entry.group_name ?? `#${entry.group_id}`
+      const whom = [competition, entry.division_name].filter(Boolean).join(': ')
+      const [from, ...to] = entry.courts.map(courtName)
+      const moved = to.length
+        ? `${from}, then ${to.join(', then ')}${entry.moves_at ? ` from ${entry.moves_at}` : ''}`
+        : from
+
+      return `${whom}, group ${group} (${entry.date.slice(5)}): ${moved}`
+    })
+
+    const more = split.length > named.length
+      ? `, and ${split.length - named.length} more`
+      : ''
+
+    return `${split.length} group(s) share courts: ${named.join(' · ')}${more}`
+  }
+
+  /**
+   * How many groups of each competition start in each block of the
+   * day, one line a day: "Singles 6/4/6".
+   *
+   * Where courts are shared it is the number to look at. Each category
+   * should spread as evenly as it can over the blocks, and a group's
+   * block is the hour its first match starts.
+   *
+   * @returns {string[]}
+   */
+  startSpread() {
+    const first = new Map()
+
+    for (const block of this.blocks) {
+      if (block.phase !== 'group' || block.group_id == null) {
+        continue
+      }
+
+      const key = [block.competition_id, block.date, block.group_id].join('|')
+      const held = first.get(key)
+
+      if (!held || block.slot < held.slot) {
+        first.set(key, block)
+      }
+    }
+
+    const days = new Map()
+
+    for (const block of first.values()) {
+      const day = days.get(block.date) ?? new Map()
+      const starts = day.get(block.competition_id) ?? new Map()
+
+      starts.set(block.slot, (starts.get(block.slot) ?? 0) + 1)
+      day.set(block.competition_id, starts)
+      days.set(block.date, day)
+    }
+
+    return [...days.keys()].sort().map(date => {
+      const spread = [...days.get(date)].map(([competitionId, starts]) => {
+        const name = this.state.competitions
+          .find(competition => competition.id === competitionId)?.name ?? `#${competitionId}`
+        const counts = [...starts.keys()].sort().map(slot => starts.get(slot))
+
+        return `${name} ${counts.join('/')}`
+      })
+
+      return `${date}: ${spread.join(' · ')}`
+    })
+  }
+
+  /**
+   * Empties the grid, bar what was played.
+   *
+   * A day that has happened cannot be unplanned: clearing it would
+   * leave the matches on it with no cell to sit in, and the next
+   * auto-fill would hand their courts to somebody else.
+   *
+   * Only ever mutates the in-browser copy until Save is pressed, same
+   * as any other change here.
    */
   clearAll() {
-    this.blocks = []
+    this.blocks = this.blocks.filter(block => block.played === true)
     this.selection = new Set()
     this.lastAutoFillShortfall = null
     this.lastAutoFillWarnings = null
+    this.lastAutoFillSplit = null
 
     this.dispatchEvent(new CustomEvent('tennis-planning:changed', {
       bubbles: true,
@@ -1289,14 +1470,18 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
 
   /**
    * Empties just the currently active day tab's cells, leaving every
-   * other day untouched.
+   * other day untouched - and leaving what was played on it, because
+   * a cell a match was played in is a record of the day rather than a
+   * plan for it.
    */
   clearDay(date) {
     if (!date) {
       return
     }
 
-    this.blocks = this.blocks.filter(block => block.date !== date)
+    this.blocks = this.blocks.filter(block =>
+      block.date !== date || block.played === true
+    )
     this.selection = new Set()
 
     this.dispatchEvent(new CustomEvent('tennis-planning:changed', {
@@ -1316,6 +1501,7 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
     this.$('[data-save]').hidden = false
     this.$('[data-registration]').hidden = false
     this.$('[data-always-bye]').hidden = false
+    this.$('[data-relaxed]').hidden = false
     this.$('[data-view-toggle]').hidden = false
     this.$('[data-narrow-toggle]').hidden = false
 
@@ -1326,6 +1512,15 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
     plan.hidden = !showData
     this.$('[data-schedule]').hidden = showData
 
+    // How the groups spread over the blocks of the day is for reading
+    // the plan as data, not for every Auto-fill.
+    const startsEl = this.$('[data-auto-fill-starts]')
+    const starts = showData ? this.startSpread() : []
+
+    startsEl.hidden = starts.length === 0
+    startsEl.style.whiteSpace = 'pre-line'
+    startsEl.textContent = starts.join('\n')
+
     if (showData) {
       plan.textContent = JSON.stringify(this.planData(), null, 2)
       return
@@ -1361,6 +1556,15 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
       shortfallEl.hidden = true
     }
 
+    const splitEl = this.$('[data-auto-fill-split]')
+
+    if (this.lastAutoFillSplit?.length) {
+      splitEl.hidden = false
+      splitEl.textContent = this.splitSummary(this.lastAutoFillSplit)
+    } else {
+      splitEl.hidden = true
+    }
+
     // What the plan could not honour, or had to guess. A plan that
     // quietly does something other than what it was set up to do is
     // the hardest kind of wrong to spot, so it says so here rather
@@ -1380,6 +1584,21 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
               + `no match schedule exists for that few, so it was not planned at all`
           }
 
+          if (warning.kind === 'not-shareable') {
+            return `${name}: sharing courts cannot help, it only works for `
+              + `groups of five`
+          }
+
+          if (warning.kind === 'no-sessions') {
+            return `${name}: has matches to play but no sessions, so it was `
+              + `not planned at all`
+          }
+
+          if (warning.kind === 'outside-days') {
+            return `${name}: has sessions on ${warning.dates.join(', ')}, which `
+              + `are not days of this event, so nothing was planned for them`
+          }
+
           return `${name} (${warning.phase}, ${warning.date}) was due on at `
             + `${warning.expected} but opens at ${warning.earliest}`
         })
@@ -1847,6 +2066,12 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
       match.setAttribute('round', block.round)
     }
 
+    // Played, and therefore not the planner's to move: it is where it
+    // is because that is where it happened.
+    if (block.played === true) {
+      match.setAttribute('played', '')
+    }
+
     if (block.match_slot != null) {
       match.setAttribute('fixture', block.match_slot)
     }

package/lib/components/schedule-board.mjs

@@ -10,7 +10,7 @@ import { competitionHue, divisionHues } from '../division-hues.mjs'
 import { setNameText } from '../flags.mjs'
 import { rowsForDate } from '../day-rows.mjs'
 import { courtCanTake, toMinutes } from '../lighting.mjs'
-import { PX_PER_MINUTE, TennisDayGridElement } from './day-grid.mjs'
+import { TennisDayGridElement } from './day-grid.mjs'
 import { withBusyButton } from '../busy-button.mjs'
 
 const KNOCKOUT_ROUND_ORDER = ['R256', 'R128', 'R64', 'R32', 'R16', 'QF', 'SF', 'F']
@@ -468,10 +468,15 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
    * Sent as a delete rather than as an empty save: which rows to drop
    * follows from the event and the date, and a board that holds one
    * day at a time could not send the rest of them to be replaced.
+   *
+   * A played match is not dropped. The database refuses to let the
+   * planner delete or move one, so the server keeps it - and a board
+   * that emptied its own copy anyway would show a morning that has
+   * been played as an empty morning until the next reload.
    */
   clearAll() {
     return this.clear(this.getConfig()['clear-api'], null, () => {
-      this.matches = []
+      this.matches = this.matches.filter(match => match.played === true)
       this.unscheduledByCompetition = new Map()
     })
   }
@@ -482,7 +487,9 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
     }
 
     return this.clear(`${this.getConfig()['day-api']}/${date}`, date, () => {
-      this.matches = this.matches.filter(match => match.date !== date)
+      this.matches = this.matches.filter(match =>
+        match.date !== date || match.played === true
+      )
     })
   }
 
@@ -948,9 +955,6 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
       rows: this.rowsFor(date),
       cellFor: (court, courtIndex, slot) => this.cellFor(court, date, slot),
       compact: this.$('[data-narrow-empty]')?.checked ?? false,
-      // A scheduled cell carries four names and what is being played,
-      // where a planned one carries a division and a group.
-      scale: PX_PER_MINUTE * 2,
     })
 
     return grid

package/lib/court-bands.mjs

@@ -20,13 +20,18 @@
  *   division needs across every section, keyed by division id.
  * @param {number[]} params.capacities How many courts each section can
  *   actually host (already filtered for lit/usable, per caller).
+ * @param {number} [params.rotation] Which day of the competition this
+ *   is, counting from zero. Where a division's runs do not divide
+ *   evenly over the sections, the extra ones move two sections on each
+ *   day, the same way its groups do.
  * @returns {{
  *   quotasBySection: Array<Map<string|number, number>>,
  *   bandsBySection: Array<Map<string|number, {start: number, end: number}>>
  * }}
  */
-export function computeSectionBands({ divisions, totals, capacities }) {
+export function computeSectionBands({ divisions, totals, capacities, rotation = 0 }) {
   const sectionCount = capacities.length
+  const evened = evenQuotas({ divisions, totals, capacities, rotation })
   const quotasBySection = []
   const bandsBySection = []
   const granted = new Map(divisions.map(id => [id, 0]))
@@ -104,6 +109,15 @@ export function computeSectionBands({ divisions, totals, capacities }) {
       room -= 1
     }
 
+    // Where every division can be spread as evenly as its runs allow
+    // and the sections can hold it, that is the answer, whatever the
+    // capacity-driven shares above came to.
+    if (evened) {
+      for (const id of divisions) {
+        quotas.set(id, evened[section].get(id))
+      }
+    }
+
     // The band a division sits in, as a fraction of the section's own
     // courts, straight from what it was just given. Divisions come in
     // priority order, so the strongest field takes the lowest courts
@@ -129,6 +143,71 @@ export function computeSectionBands({ divisions, totals, capacities }) {
   return { quotasBySection, bandsBySection }
 }
 
+/**
+ * Each division's runs spread as evenly over the sections as they go.
+ *
+ * Every division takes the whole number of runs that divides evenly in
+ * each section, and whatever is left over goes one to a section, to the
+ * sections with the most room, so the extra run of one division sits
+ * where another's does not and the sections fill alike. Ties go to the
+ * earliest section, turned two sections on for each day of rotation:
+ * the group that had an extra run in a section yesterday is the one a
+ * rotation sends to the section two on today.
+ *
+ * Only when the sections can hold it. If they cannot, the caller's own
+ * capacity-driven shares are all there is, and this says so with null.
+ *
+ * @returns {?Array<Map<string|number, number>>} quotas by section
+ */
+function evenQuotas({ divisions, totals, capacities, rotation }) {
+  const sections = capacities.length
+
+  if (sections === 0) {
+    return null
+  }
+
+  const load = new Array(sections).fill(0)
+  const quotas = capacities.map(() => new Map())
+
+  for (const id of divisions) {
+    const base = Math.floor((totals.get(id) ?? 0) / sections)
+
+    for (let section = 0; section < sections; section++) {
+      quotas[section].set(id, base)
+      load[section] += base
+    }
+  }
+
+  // Earliest first, turned by the day: [0, 1, 2], then [2, 0, 1].
+  const turn = (2 * rotation) % sections
+  const order = Array.from({ length: sections }, (_, i) => (i + turn) % sections)
+
+  for (const id of divisions) {
+    const extra = (totals.get(id) ?? 0) % sections
+    const given = new Set()
+
+    for (let i = 0; i < extra; i++) {
+      let best = -1
+
+      for (const section of order) {
+        if (given.has(section)) {
+          continue
+        }
+
+        if (best === -1 || capacities[section] - load[section] > capacities[best] - load[best]) {
+          best = section
+        }
+      }
+
+      given.add(best)
+      load[best] += 1
+      quotas[best].set(id, quotas[best].get(id) + 1)
+    }
+  }
+
+  return load.every((runs, section) => runs <= capacities[section]) ? quotas : null
+}
+
 /**
  * How far a court (as a fraction of its list) sits from a division's
  * band. Zero inside the band; a band is an interval, not a point, so a

package/lib/four-team-planner.mjs

@@ -211,6 +211,6 @@ export function fourTeamUnitSizes(count, { dense = false } = {}) {
  * @param {Array<{id: number, teamIds: number[]}>} groups
  * @returns {Array<Array<{groupId: number, index: number}>>} slot by court
  */
-export function fourTeamUnitLayout(groups) {
-  return unitLayout(groups, { template: FOUR_TEAM_TEMPLATE, matchesFor: fourTeamMatches })
+export function fourTeamUnitLayout(groups, done = null) {
+  return unitLayout(groups, { template: FOUR_TEAM_TEMPLATE, matchesFor: fourTeamMatches, done })
 }

package/lib/index.mjs

@@ -2,6 +2,6 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-const VERSION = "0.0.3";export { VERSION }
+const VERSION = "0.0.4";export { VERSION }
 export { autoFillBracket } from './bracket-autofill.mjs'
 

package/lib/knockout-draw.mjs

@@ -58,6 +58,7 @@ export class KnockoutDraw {
     this.lastCourts = null
     this.lastParts = 1
     this.freeFrom = -Infinity
+    this.freeDate = null
   }
 
   /** Whether every round of the draw has been planned. */
@@ -108,11 +109,22 @@ export class KnockoutDraw {
    * Whether this draw may go on in this slot: it has a round left and
    * has had whatever rest it is owed.
    *
+   * Rest is owed within a day and a night is more of it than any rule
+   * asks, so a draw arriving on a new date is ready from its first
+   * slot. The slot index it was last free from means nothing on
+   * another day's list, which is what used to lock a draw that could
+   * not finish out of every day after it.
+   *
    * @param {number} slotIndex
+   * @param {?string} [date]
    * @returns {boolean}
    */
-  readyAt(slotIndex) {
-    return !this.done && slotIndex >= this.freeFrom
+  readyAt(slotIndex, date = null) {
+    if (this.done) {
+      return false
+    }
+
+    return date !== this.freeDate || slotIndex >= this.freeFrom
   }
 
   /**
@@ -123,19 +135,31 @@ export class KnockoutDraw {
    * narrow it leaves the parts; quarters and eighths need parts that
    * still hold matches of their own.
    *
+   * A round does not have to be a power of two. Three of a round of
+   * eight played and five left is the same thing as a bracket with
+   * byes, and five still halves - 3 then 2 - which is what pays for
+   * the rest. A cut that would leave a part with nothing in it is not
+   * offered.
+   *
    * @param {boolean} split Whether cutting is allowed at all.
    * @returns {Array<{parts: number, count: number}>} Courts needed
-   *   (count) for each number of parts.
+   *   (count) for the widest part.
    */
   cuts(split) {
     const options = []
 
     for (const parts of SPLIT_SIZES) {
-      if (parts > 1 && (!split || this.width % parts !== 0)) {
+      if (parts > 1 && !split) {
         continue
       }
 
-      const count = parts === 1 ? this.width : this.width / parts
+      const count = parts === 1 ? this.width : Math.ceil(this.width / parts)
+
+      // Every part has to hold something: a round of five in four
+      // parts is three parts and an empty one.
+      if (parts > 1 && count * (parts - 1) >= this.width) {
+        continue
+      }
 
       if (parts > 2 && count < MIN_ROUND_PART) {
         continue
@@ -190,9 +214,11 @@ export class KnockoutDraw {
    * @param {number} params.parts The cut they were booked in.
    * @param {number} params.slotIndex Where the cut started.
    * @param {number} params.restSlots Slots owed after a whole round.
+   * @param {?string} [params.date] The day that slot index belongs to.
    */
-  book({ count, parts, slotIndex, restSlots }) {
+  book({ count, parts, slotIndex, restSlots, date = null }) {
     this.placed += count
+    this.freeDate = date
 
     if (this.placedInRound + count < this.width) {
       this.placedInRound += count

package/lib/knockout-planner.mjs

@@ -4,7 +4,7 @@
 
 import { MATCH_MINUTES, REST_MINUTES } from './match-time.mjs'
 import { SPLIT_SIZES } from './knockout-draw.mjs'
-import { activePhase, activeSession } from './sessions.mjs'
+import { activePhase, activeRounds, activeSession } from './sessions.mjs'
 
 
 /**
@@ -242,7 +242,7 @@ function placeRound(item, held, day, where) {
     }
   }
 
-  draw.book({ count: placed, parts, slotIndex, restSlots })
+  draw.book({ count: placed, parts, slotIndex, restSlots, date: day.date })
 }
 
 /**
@@ -327,8 +327,11 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
     const ownSession = activeSession(ownSessions, date)
     const restSlots = restSlotsFor(ownSession?.playtime ?? MATCH_MINUTES)
 
+    // A slot with no phase of its own belongs to a replan, which owns
+    // the whole day whatever the session had meant it for.
     const firstSlot = own.findIndex(slot =>
-      (slot.phase ?? activePhase(ownSessions, date, slot.key)) === 'knockout'
+      slot.phase === null
+        || (slot.phase ?? activePhase(ownSessions, date, slot.key)) === 'knockout'
     )
 
     if (firstSlot === -1) {
@@ -349,6 +352,7 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
 
     for (let slotIndex = firstSlot; slotIndex < own.length; slotIndex++) {
       const slot = own[slotIndex]
+      const onRounds = activeRounds(ownSessions, date, slot.key)
 
       /** The lane's courts with nothing on them in this slot. */
       function free() {
@@ -360,7 +364,11 @@ export function assignKnockout(day, { competitions, draws, sessions, split }) {
       }
 
       let ready = units
-        .filter(draw => draw.readyAt(slotIndex))
+        .filter(draw => draw.readyAt(slotIndex, date))
+        // A session may say which rounds are on. Nothing else opens
+        // until one does, and a draw whose turn has not come waits
+        // for the day it was given rather than running ahead.
+        .filter(draw => onRounds == null || onRounds.includes(draw.round?.round))
         .sort((a, b) => (b.width - a.width) || (b.level - a.level))
 
       if (ready.length === 0) {