@opndev/tennis-match-center 0.0.4 → 0.0.6

package/Changes

@@ -1,5 +1,43 @@
 Revision history for @opndev/tennis-match-center
 
+0.0.6       2026-11-06 17:20:26Z
+
+  * The roster board says when a group plays, above its name, as a
+    window such as `Mon 10 Nov, 13:00-16:30`: the first start to the end
+    of the last one, from an `ends` list next to `starts`. Without
+    `ends` it reads as before.
+
+  * Groups are named 1, 2, 3, ... instead of A, B, C, ... Z, AA. Bracket
+    seeding sorts group names numerically, so 10 follows 9.
+
+  * A court override can carry `available_until`: the court takes no
+    play that ends after it that day. It works on any court, pro or not.
+    On a pro court the opening time still only lets regular play in.
+
+  * The Planning board's right-click menu and legend leave out a
+    competition that is not available for planning.
+
+  * A day can have its own dark from and light buffer. The boards and
+    the planner take a `day_lighting` list of `{date, dark_from,
+    light_buffer}`, and a day without an entry, or with either left
+    empty, keeps the event's.
+
+  * The Planning board takes `court_overrides` and `day_lighting` from
+    the competitions response as well as from the shell, so Auto-fill
+    plans against what is saved now rather than what the page loaded
+    with. The board also listens for a `planning-settings-saved` event
+    on the window and draws again when it arrives; the cells on it are
+    not touched.
+
+0.0.5       2026-10-12 14:29:04Z
+
+  * After dark a knockout round takes the lowest lit courts. Courts shut
+    for the dark counted as busy, which drew the round up the row to sit
+    beside them.
+
+  * A round is never cut into uneven quarters or eighths. Ten matches
+    halve 5/5 and no longer go 3/3/3/1.
+
 0.0.4       2026-10-10 14:39:58Z
 
   * Auto-fill only adds. The Planning board hands the planner the cells

package/lib/auto-planner.mjs

@@ -19,6 +19,7 @@ import { Plan } from './plan.mjs'
 import { PlanningDay } from './planning-day.mjs'
 import { activePhase, activeSession } from './sessions.mjs'
 import { MATCH_MINUTES } from './match-time.mjs'
+import { lightingForDate, relightSlots } from './lighting.mjs'
 
 /**
  * Every day the competitions say they play on: the dates of their
@@ -197,6 +198,7 @@ class AutoPlanner {
       darkFrom = null,
       dayEnd = '24:00',
       lightBuffer = undefined,
+      dayLighting = [],
       groupSlotsFromSessions = false,
       splitRounds = false,
       sharing = false,
@@ -307,6 +309,7 @@ class AutoPlanner {
       darkFrom,
       dayEnd,
       lightBuffer,
+      dayLighting,
       groupSlotsFromSessions,
       splitRounds,
       sharing,
@@ -433,10 +436,10 @@ class AutoPlanner {
         overridesByDate.set(override.date, new Map())
       }
 
-      overridesByDate.get(override.date).set(
-        override.court_id,
-        override.available_from ? timeToMinutes(override.available_from) : null
-      )
+      overridesByDate.get(override.date).set(override.court_id, {
+        from: override.available_from ? timeToMinutes(override.available_from) : null,
+        until: override.available_until ? timeToMinutes(override.available_until) : null,
+      })
     }
 
     const venue = { overridesByDate, openCourts, proCourts, activeCourts }
@@ -467,14 +470,12 @@ class AutoPlanner {
       courts,
       registrationClosed,
       alwaysByeShortGroups,
-      lightBuffer,
       groupSlotsFromSessions,
       splitRounds,
       standing,
       days,
       competitions,
       slots,
-      darkFromMinutes,
       plan,
       blocks,
       remainingGroupByDate,
@@ -514,23 +515,23 @@ class AutoPlanner {
       const slotsByCompetition = new Map(
         competitions.map(competition => [
           competition.id,
-          competition.slots
+          this.litFor(competition.slots
             ? withMinutes(competition.slots)
             : ((groupSlotsFromSessions || slots.length === 0)
               ? this.dayFor(competition, date)
-              : slots),
+              : slots), date),
         ])
       )
 
       const day = new PlanningDay({
         date,
-        proCourts,
+        proCourts: this.proCourtsFor(date),
         openCourts: this.openCourtsFor(date),
         slotsByCompetition,
         occupancy: taken,
         plan,
-        darkFromMinutes,
-        lightBufferMinutes: lightBuffer,
+        darkFromMinutes: this.darkFromFor(date),
+        lightBufferMinutes: this.lightBufferFor(date),
       })
 
       if (this.sharing) {
@@ -554,7 +555,7 @@ class AutoPlanner {
 
           const last = own[Math.min(slotIndex + runLength - 1, own.length - 1)]
           const needsLight = runNeedsLight(
-            own, slotIndex, runLength, darkFromMinutes
+            own, slotIndex, runLength, this.darkFromFor(date)
           )
 
           timeline.push({
@@ -646,7 +647,7 @@ class AutoPlanner {
         }
 
         const laneCourts = entry.group.is_pro === true
-          ? proCourts
+          ? this.proCourtsFor(date)
           : this.openCourtsFor(date)
         let landed = false
 
@@ -1240,12 +1241,12 @@ class AutoPlanner {
    * competitions placed exactly half of theirs.
    */
   groupDatesFor(competition) {
-    const { sortedSessions, darkFromMinutes, dayEndMinutes } = this.canvas
+    const { sortedSessions, dayEndMinutes } = this.canvas
 
     const sessions = sortedSessions.get(competition.id) ?? []
 
     return (competition.group_dates ?? []).filter(date => {
-      const own = slotsForDate(sessions, date, darkFromMinutes, dayEndMinutes)
+      const own = slotsForDate(sessions, date, this.darkFromFor(date), dayEndMinutes)
 
       return own.length > 0 && own[0].phase === 'group'
     })
@@ -1327,12 +1328,10 @@ class AutoPlanner {
    * phase is on.
    */
   dayFor(competition, on) {
-    const {
-      sortedSessions, darkFromMinutes, dayEndMinutes,
-    } = this.canvas
+    const { sortedSessions, dayEndMinutes } = this.canvas
     const own = sortedSessions.get(competition.id) ?? []
     const fromSessions = slotsForDate(
-      own, on, darkFromMinutes, dayEndMinutes, this.anchorFor(on)
+      own, on, this.darkFromFor(on), dayEndMinutes, this.anchorFor(on)
     )
 
     return fromSessions
@@ -1340,19 +1339,54 @@ class AutoPlanner {
 
   slotsFor(competitionId, date) {
     const {
-      groupSlotsFromSessions, slots, sortedSessions, darkFromMinutes, dayEndMinutes,
+      groupSlotsFromSessions, slots, sortedSessions, dayEndMinutes,
     } = this.canvas
 
     if (!groupSlotsFromSessions && slots.length > 0) {
-      return slots
+      return this.litFor(slots, date)
     }
 
     return slotsForDate(
       sortedSessions.get(Number(competitionId)) ?? [],
-      date, darkFromMinutes, dayEndMinutes, this.anchorFor(date)
+      date, this.darkFromFor(date), dayEndMinutes, this.anchorFor(date)
+    )
+  }
+
+  /**
+   * The lighting on this date: the day's own dark from and light
+   * buffer where it has them, the event's otherwise.
+   *
+   * @param {string} date
+   * @returns {{darkFromMinutes: ?number, lightBufferMinutes: (number|undefined), ownDarkFrom: boolean}}
+   */
+  lightingFor(date) {
+    return lightingForDate(
+      this.dayLighting, date, this.darkFromMinutes, this.lightBuffer
     )
   }
 
+  darkFromFor(date) {
+    return this.lightingFor(date).darkFromMinutes
+  }
+
+  lightBufferFor(date) {
+    return this.lightingFor(date).lightBufferMinutes
+  }
+
+  /**
+   * Slots whose lit_required reads off this date's own dark from.
+   * Left as they are when the day has none.
+   *
+   * @param {Array} slots
+   * @param {string} date
+   * @returns {Array}
+   */
+  litFor(slots, date) {
+    const { ownDarkFrom, darkFromMinutes } = this.lightingFor(date)
+
+    return ownDarkFrom ? relightSlots(slots, darkFromMinutes) : slots
+  }
+
   /**
    * The hour the day's first competition opens, which every
    * competition's slots are measured from.
@@ -1394,7 +1428,7 @@ class AutoPlanner {
    * so courtUsableAt can enforce it without needing to know the date.
    */
   openCourtsFor(date) {
-    const { overridesByDate, openCourts, proCourts, activeCourts } = this.venue
+    const { overridesByDate, openCourts, activeCourts } = this.venue
 
     const overrides = overridesByDate.get(date)
 
@@ -1402,19 +1436,44 @@ class AutoPlanner {
       return openCourts
     }
 
-    const opened = new Map(proCourts
-      .filter(court => overrides.has(court.id))
-      .map(court => [court.id, {
-        ...court, availableFromMinutes: overrides.get(court.id),
-      }]))
+    const shaped = court => this.withOverride(court, overrides.get(court.id))
 
-    if (opened.size === 0) {
+    if (!activeCourts.some(court => overrides.has(court.id))) {
       return openCourts
     }
 
     return activeCourts
-      .filter(court => !court.pro || opened.has(court.id))
-      .map(court => opened.get(court.id) ?? court)
+      .filter(court => !court.pro || overrides.has(court.id))
+      .map(shaped)
+  }
+
+  /**
+   * The pro courts for this date. Only an override's cutoff applies
+   * here: its opening time is about letting regular play in.
+   *
+   * @param {string} date
+   * @returns {Array}
+   */
+  proCourtsFor(date) {
+    const overrides = this.venue.overridesByDate.get(date)
+
+    return this.venue.proCourts.map(court => this.withOverride(
+      court, overrides?.has(court.id)
+        ? { from: null, until: overrides.get(court.id).until }
+        : null
+    ))
+  }
+
+  withOverride(court, override) {
+    if (!override) {
+      return court
+    }
+
+    return {
+      ...court,
+      availableFromMinutes: override.from,
+      availableUntilMinutes: override.until,
+    }
   }
 
   /**
@@ -1584,7 +1643,7 @@ function runNeedsLight(own, slotIndex, runLength, darkFromMinutes) {
  *
  * @param {Array} entries
  * @param {boolean} requireLit
- * @returns {Array<[number, Array]>} Start minute and its entries.
+ * @returns {Array<Array>} Pairs of start minute and its entries.
  */
 function byStartTime(entries, requireLit) {
   const byStart = new Map()

package/lib/bracket-autofill.mjs

@@ -53,7 +53,9 @@ export function autoFillBracket(seeds) {
       qualifiers: pools.qualifiers,
     })
 
-    rawMatches = bracket.matches()
+    // matches() interleaves the sides. A bracket is the left side, then
+    // the right, so two neighbours feed the same next match.
+    rawMatches = [...bracket.matches('left'), ...bracket.matches('right')]
     round = bracket.rounds()[0]
   }
 
@@ -112,23 +114,56 @@ function buildMatches(round, firstRoundSlots) {
  * own representatives are kept apart rather than merely ranked by
  * overall strength - see <tennis-bracket-board>'s own copy of this
  * doc comment for the full rationale.
+ *
+ * The lower tiers are rotated so a group's second place does not draw
+ * the side of the bracket its winner is on. How far depends on the
+ * draw, so it is the first rotation that leaves no group on one side,
+ * found by building the bracket.
  */
-function poolsFromSeeds(seeds) {
-  const tierNumbers = [...new Set(seeds.map(seed => seed.tier))].sort((a, b) => a - b)
-  const poolNames = ['seeded', 'unseeded', 'wildcards', 'qualifiers']
+export function poolsFromSeeds(seeds) {
+  const draw = Math.max(2, nextPowerOfTwo(seeds.length))
+  const tiers = tiersOf(seeds)
+  const longest = Math.max(...tiers.map(tier => tier.length))
+  const half = Math.floor(longest / 2)
 
-  const pools = { seeded: [], unseeded: [], wildcards: [], qualifiers: [] }
+  if (draw < 8) {
+    return poolsFor(tiers, half)
+  }
+
+  const offsets = [half, ...Array.from({ length: longest }, (_, i) => i).filter(i => i !== half)]
 
-  tierNumbers.forEach((tier, tierIndex) => {
-    const ordered = seeds
-      .filter(seed => seed.tier === tier)
-      .sort((a, b) => a.group_name.localeCompare(b.group_name))
-      .map(seed => String(seed.team_id))
+  let best = { offset: half, apart: Infinity }
 
-    const rotated = tierIndex === 0
-      ? ordered
-      : rotate(ordered, Math.floor(ordered.length / 2))
+  for (const offset of offsets) {
+    const apart = groupsOnOneSide(seeds, tiers, draw, offset)
+
+    if (apart < best.apart) {
+      best = { offset, apart }
+    }
+
+    if (apart === 0) {
+      break
+    }
+  }
+
+  return poolsFor(tiers, best.offset)
+}
 
+function tiersOf(seeds) {
+  const tierNumbers = [...new Set(seeds.map(seed => seed.tier))].sort((a, b) => a - b)
+
+  return tierNumbers.map(tier => seeds
+    .filter(seed => seed.tier === tier)
+    .sort((a, b) => a.group_name.localeCompare(b.group_name, undefined, { numeric: true }))
+    .map(seed => String(seed.team_id)))
+}
+
+function poolsFor(tiers, offset) {
+  const poolNames = ['seeded', 'unseeded', 'wildcards', 'qualifiers']
+  const pools = { seeded: [], unseeded: [], wildcards: [], qualifiers: [] }
+
+  tiers.forEach((ordered, tierIndex) => {
+    const rotated = tierIndex === 0 ? ordered : rotate(ordered, offset % Math.max(ordered.length, 1))
     const poolName = poolNames[tierIndex] ?? 'qualifiers'
 
     pools[poolName].push(...rotated)
@@ -137,6 +172,25 @@ function poolsFromSeeds(seeds) {
   return pools
 }
 
+/**
+ * How many groups have a lower tier on the side of the bracket their
+ * winner is on. Two of a group on one side meet before the Final.
+ */
+function groupsOnOneSide(seeds, tiers, draw, offset) {
+  const pools = poolsFor(tiers, offset)
+  const bracket = new SingleEliminationBracket({ draw, ...pools })
+  const side = new Map()
+
+  for (const [name, matches] of [['left', bracket.matches('left')], ['right', bracket.matches('right')]]) {
+    matches.forEach(match => match.split(' vs ').forEach(team => side.set(team, name)))
+  }
+
+  const group = new Map(seeds.map(seed => [String(seed.team_id), seed.group_name]))
+  const winners = new Map(tiers[0].map(team => [group.get(team), side.get(team)]))
+
+  return tiers.slice(1).flat().filter(team => side.get(team) === winners.get(group.get(team))).length
+}
+
 function rotate(array, offset) {
   return [...array.slice(offset), ...array.slice(0, offset)]
 }

package/lib/busy-button.mjs

@@ -18,7 +18,7 @@ const DEFAULT_LABELS = {
  * second press cannot start one on top of the first.
  *
  * @param {?HTMLElement} button
- * @param {() => Promise<boolean>} run Resolves true where the work
+ * @param {function(): Promise<boolean>} run Resolves true where the work
  *   succeeded.
  * @param {{busy: string, done: string, failed: string}} [labels] What
  *   the button says while it works, and afterwards.

package/lib/components/bracket-board.mjs

@@ -4,6 +4,7 @@
 
 import { HTMLElementSugar } from '@skirbi/sugar'
 import { SingleEliminationBracket } from '../bracket-single-elimination.mjs'
+import { poolsFromSeeds } from '../bracket-autofill.mjs'
 
 const ROUND_ORDER = ['R256', 'R128', 'R64', 'R32', 'R16', 'QF', 'SF', 'F']
 
@@ -143,7 +144,9 @@ export class TennisBracketBoardElement extends HTMLElementSugar {
         qualifiers: pools.qualifiers,
       })
 
-      rawMatches = bracket.matches()
+      // matches() interleaves the sides. A bracket is the left side, then
+      // the right, so two neighbours feed the same next match.
+      rawMatches = [...bracket.matches('left'), ...bracket.matches('right')]
       round = bracket.rounds()[0]
     }
 
@@ -280,7 +283,7 @@ export class TennisBracketBoardElement extends HTMLElementSugar {
       return
     }
 
-    const firstRound = this.matches[0]?.round ?? this.firstRoundSlots[0]?.round
+    const firstRound = this.round ?? firstRoundOf(this.matches) ?? this.firstRoundSlots[0]?.round
     const roundNames = roundsFrom(firstRound ?? ROUND_ORDER.at(-1))
 
     let count = slotCount
@@ -473,50 +476,6 @@ function tierLabel(tier) {
   return { 1: 'Winner', 2: 'Runner-up' }[tier] ?? `${tier}th place`
 }
 
-/**
- * Buckets seeds by advancement tier (1st of each group, 2nd of each
- * group, ...) into SingleEliminationBracket's four pools, so a group's
- * own representatives are kept apart rather than merely ranked by
- * overall strength - the generic seeding algorithm has no notion of
- * "these two came from the same source" on its own.
- *
- * Tier 1 -> seeded, in group order. Every later tier is rotated by
- * half its own length before becoming the next pool, so
- * pool[i] never comes from the same group as seeded[i]: with the
- * algorithm's own "Seed k vs Unseeded k" round-1 pairing, that keeps a
- * group's pair in different bracket positions from round 1 onward.
- * When the tier count is a power of two this provably keeps a group's
- * representatives in opposite halves of the draw (they can only meet
- * in the Final) - see bracket-board.test for the worked proof. With an
- * uneven group count or more than 4 tiers (this pool mechanism only
- * has four) the guarantee is best-effort rather than proven.
- */
-function poolsFromSeeds(seeds) {
-  const tierNumbers = [...new Set(seeds.map(seed => seed.tier))].sort((a, b) => a - b)
-  const poolNames = ['seeded', 'unseeded', 'wildcards', 'qualifiers']
-
-  const pools = { seeded: [], unseeded: [], wildcards: [], qualifiers: [] }
-
-  tierNumbers.forEach((tier, tierIndex) => {
-    const ordered = seeds
-      .filter(seed => seed.tier === tier)
-      .sort((a, b) => a.group_name.localeCompare(b.group_name))
-      .map(seed => String(seed.team_id))
-
-    const rotated = tierIndex === 0
-      ? ordered
-      : rotate(ordered, Math.floor(ordered.length / 2))
-
-    // A 5th+ tier has nowhere to go - the algorithm only has four
-    // pools - so it folds into qualifiers rather than being dropped.
-    const poolName = poolNames[tierIndex] ?? 'qualifiers'
-
-    pools[poolName].push(...rotated)
-  })
-
-  return pools
-}
-
 function rotate(array, offset) {
   return [...array.slice(offset), ...array.slice(0, offset)]
 }

package/lib/components/planning-board.mjs

@@ -231,6 +231,8 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
         event.preventDefault()
         this.assignSelection(null)
       })
+
+      window.addEventListener('planning-settings-saved', () => this.refreshSettings())
     }
 
     // The shell (courts/days/slots/the already-saved plan) is plain
@@ -285,6 +287,11 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
    * half, needs re-fetching for that - the grid shell it's layered
    * onto (courts, days, slots) does not change from a pairing edit.
    *
+   * The response also carries the court overrides and the days' own
+   * lighting, which a director edits next to the board. They are taken
+   * the same way, so a plan is made against what is saved now. A
+   * response without them leaves what the board has.
+   *
    * @returns {Promise<boolean>} false if a newer fetch has since
    *   started and this one's result must be discarded.
    */
@@ -296,11 +303,36 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
     }
 
     this.state.competitions = data.competitions
+
+    if (data.court_overrides !== undefined) {
+      this.state.court_overrides = data.court_overrides
+    }
+
+    if (data.day_lighting !== undefined) {
+      this.state.day_lighting = data.day_lighting
+    }
+
     this._divisionHues = null
 
     return true
   }
 
+  /**
+   * Draws the board again with what is saved now. Called when the
+   * settings next to it were saved: the board is not part of that
+   * form, and would otherwise show the old lighting until a reload.
+   * The cells on the board are not touched.
+   */
+  async refreshSettings() {
+    if (!this.isConnected) {
+      return
+    }
+
+    if (await this.fetchCompetitions()) {
+      this.render()
+    }
+  }
+
   /**
    * Shared double-connect/stale-request guard: only the result of the
    * most recently started fetch (shell or competitions, whichever)
@@ -323,11 +355,16 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
    * Competitions relevant to one day, each tagged with the phase that
    * applies on that day - group_dates and knockout_dates for the same
    * competition never overlap, so at most one entry per competition.
+   * A competition not available for planning has none.
    */
   competitionsForDate(date) {
     const entries = []
 
     for (const competition of this.state.competitions) {
+      if (competition.available_for_planning === false) {
+        continue
+      }
+
       if (competition.group_dates.includes(date)) {
         entries.push({ competition, phase: 'group' })
       }
@@ -1310,6 +1347,7 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
         alwaysByeShortGroups: this.alwaysByeShortGroups(),
         relaxed: this.relaxed(),
         courtOverrides: this.state.court_overrides ?? [],
+        dayLighting: this.state.day_lighting ?? [],
 
         // Group play follows each competition's own session, so a
         // competition starting at 09:00 starts at 09:00. The list is
@@ -1778,6 +1816,7 @@ export class TennisPlanningBoardElement extends HTMLElementSugar {
       fallbackSlots: this.state.slots ?? [],
       darkFromMinutes: toMinutes(this.getConfig()['dark-from']),
       lightBufferMinutes: this.lightBuffer() ?? 0,
+      dayLighting: this.state.day_lighting ?? [],
     })
   }
 

package/lib/components/roster-board.mjs

@@ -24,15 +24,21 @@ function dayOf(iso) {
 }
 
 /**
- * When a group starts playing, as far as the planning knows it: the
- * first match of each day it plays.
+ * When a group plays, as far as the planning knows it: from the first
+ * match start to the end of the last one, for each day it plays. A day
+ * without an end reads as just its start.
  *
  * @param {Array<string>} starts - ISO timestamps, one per day
+ * @param {Array<string>} [ends] - ISO timestamps, one per day
  * @returns {string}
  */
-export function startsLine(starts) {
+export function startsLine(starts, ends = []) {
   return starts
-    .map(iso => `${dayOf(iso)}, ${iso.slice(11, 16)}`)
+    .map((iso, day) => {
+      const end = ends[day] ? `-${ends[day].slice(11, 16)}` : ''
+
+      return `${dayOf(iso)}, ${iso.slice(11, 16)}${end}`
+    })
     .join(' / ')
 }
 
@@ -204,11 +210,11 @@ export class TennisRosterBoardElement extends HTMLElementSugar {
         .map(id => this.saved.teams.find(team => team.id === id))
         .filter(Boolean)
 
-      columns.appendChild(this.columnFor(group.name, teams, group.starts))
+      columns.appendChild(this.columnFor(group.name, teams, group.starts, group.ends))
     }
   }
 
-  columnFor(currentGroupName, teams, starts = []) {
+  columnFor(currentGroupName, teams, starts = [], ends = []) {
     const column = document.createElement('div')
 
     column.dataset.group = currentGroupName ?? ''
@@ -234,6 +240,15 @@ export class TennisRosterBoardElement extends HTMLElementSugar {
       }
     })
 
+    if (starts?.length) {
+      const when = document.createElement('p')
+
+      when.dataset.planned = ''
+      when.title = 'When the group plays, per day'
+      when.textContent = startsLine(starts, ends)
+      column.appendChild(when)
+    }
+
     const heading = document.createElement('h3')
     heading.textContent = currentGroupName ? `Group ${currentGroupName}` : 'Unassigned'
     column.appendChild(heading)
@@ -243,15 +258,6 @@ export class TennisRosterBoardElement extends HTMLElementSugar {
     count.textContent = String(teams.length)
     heading.appendChild(count)
 
-    if (starts?.length) {
-      const when = document.createElement('p')
-
-      when.dataset.planned = ''
-      when.title = 'First match of the group, per day'
-      when.textContent = startsLine(starts)
-      column.appendChild(when)
-    }
-
     const list = document.createElement('div')
     list.dataset.list = ''
     column.appendChild(list)

package/lib/components/schedule-board.mjs

@@ -728,6 +728,7 @@ export class TennisScheduleBoardElement extends HTMLElementSugar {
       cells: this.allCellsWithCompetition(),
       darkFromMinutes: toMinutes(this.getConfig()['dark-from']),
       lightBufferMinutes: this.lightBuffer() ?? 0,
+      dayLighting: this.state.day_lighting ?? [],
     })
   }
 

package/lib/court-runs.mjs

@@ -14,7 +14,7 @@
 /**
  * Whether a court may be played on in this slot at all.
  *
- * @param {{lit: boolean, availableFromMinutes: ?number}} court
+ * @param {{lit: boolean, availableFromMinutes: ?number, availableUntilMinutes: ?number}} court
  * @param {{lit_required: boolean, start_minutes: number}} slot
  * @returns {boolean}
  */
@@ -32,6 +32,12 @@ export function courtUsableAt(court, slot) {
     return false
   }
 
+  const closesAt = court.availableUntilMinutes
+
+  if (closesAt != null && slot.end_minutes > closesAt) {
+    return false
+  }
+
   return true
 }
 

package/lib/day-rows.mjs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 import { slotsForDate } from './auto-planner.mjs'
-import { litRequired } from './lighting.mjs'
+import { lightingForDate, litRequired, relightSlots } from './lighting.mjs'
 
 /** What an hour is worth when nothing says otherwise. */
 const FALLBACK_SLOT_MINUTES = 45
@@ -38,13 +38,19 @@ function minutesToTime(minutes) {
  *   row can say whether it needs a lit court.
  * @param {number} [params.lightBufferMinutes] How long before that an
  *   unlit court stops taking new play.
+ * @param {Array} [params.dayLighting] Days with a dark from or a light
+ *   buffer of their own, which overrule the two above on that date.
  * @returns {Array<{key: string, label: string, start_minutes: number,
  *   end_minutes: number}>}
  */
 export function rowsForDate({
   date, competitions, cells, fallbackSlots = [],
-  darkFromMinutes = null, lightBufferMinutes = 0,
+  darkFromMinutes: eventDarkFrom = null, lightBufferMinutes: eventBuffer = 0,
+  dayLighting = null,
 }) {
+  const { darkFromMinutes, lightBufferMinutes, ownDarkFrom } = lightingForDate(
+    dayLighting, date, eventDarkFrom, eventBuffer
+  )
 
   const byKey = new Map()
 
@@ -96,7 +102,11 @@ export function rowsForDate({
 
   // A day nothing is configured for still needs a grid to drag on.
   if (byKey.size === 0) {
-    for (const slot of fallbackSlots ?? []) {
+    const fallback = ownDarkFrom
+      ? relightSlots(fallbackSlots ?? [], darkFromMinutes)
+      : fallbackSlots ?? []
+
+    for (const slot of fallback) {
       byKey.set(slot.key, slot)
     }
   }

package/lib/four-team-planner.mjs

@@ -180,7 +180,8 @@ export function fourTeamMatches(group) {
  * named entry point onto that shared math.
  *
  * @param {number} count
- * @param {{dense?: boolean}} options
+ * @param {object} [options]
+ * @param {boolean} [options.dense]
  * @returns {number[]} unit sizes, largest first
  */
 export function fourTeamUnitSizes(count, { dense = false } = {}) {

package/lib/index.mjs

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

package/lib/knockout-draw.mjs

@@ -161,6 +161,10 @@ export class KnockoutDraw {
         continue
       }
 
+      if (parts > 2 && this.width % parts !== 0) {
+        continue
+      }
+
       if (parts > 2 && count < MIN_ROUND_PART) {
         continue
       }

package/lib/knockout-planner.mjs

@@ -66,7 +66,11 @@ function holdCourts(item, pool, day, where, row) {
   }
 
   const at = court => row.indexOf(court)
-  const busy = new Set(row.filter(court => !pool.includes(court)).map(at))
+  const slot = where.slots[where.slotIndex]
+  const usable = new Set(day.usable(row, slot))
+  const busy = new Set(
+    row.filter(court => usable.has(court) && !pool.includes(court)).map(at)
+  )
   // Where the draw played its last round: one that has to move moves
   // as little as it can.
   const were = (item.draw.lastCourts ?? []).map(id => row.findIndex(c => c.id === id))

package/lib/lighting.mjs

@@ -17,7 +17,8 @@
  * attribute on the element; deciding what that means for a court is a
  * scheduling decision and belongs client-side (spec.md).
  *
- * @param {{slots: Array<{end_minutes?: number}>}} state
+ * @param {object} state
+ * @param {Array<{end_minutes: (number|undefined)}>} state.slots
  * @param {string} [darkFromTime] "HH:MM"
  * @returns {Object} the same state, its slots carrying lit_required
  */
@@ -94,3 +95,44 @@ export function toMinutes(time) {
 
   return Number.isFinite(hours) ? hours * 60 + (Number.isFinite(minutes) ? minutes : 0) : null
 }
+
+/**
+ * The lighting that applies on one date: the day's own dark from and
+ * light buffer where it has them, the event's where it does not.
+ *
+ * @param {?Array<{date: string, dark_from: ?string, light_buffer: ?number}>} dayLighting
+ * @param {string} date
+ * @param {?number} darkFromMinutes The event's.
+ * @param {(number|undefined)} lightBufferMinutes The event's.
+ * @returns {{darkFromMinutes: ?number, lightBufferMinutes: (number|undefined), ownDarkFrom: boolean}}
+ */
+export function lightingForDate(
+  dayLighting, date, darkFromMinutes, lightBufferMinutes
+) {
+  const own = (dayLighting ?? []).find(day => day.date === date)
+  const ownDarkFrom = Boolean(own?.dark_from)
+
+  return {
+    darkFromMinutes: ownDarkFrom ? toMinutes(own.dark_from) : darkFromMinutes,
+    lightBufferMinutes: own?.light_buffer == null
+      ? lightBufferMinutes
+      : Number(own.light_buffer),
+    ownDarkFrom,
+  }
+}
+
+/**
+ * Slots with lit_required read off the given dark from, for a day
+ * that has one of its own. The slots on the board carry the event's
+ * answer, which that day overrules.
+ *
+ * @param {Array} slots
+ * @param {?number} darkFromMinutes
+ * @returns {Array}
+ */
+export function relightSlots(slots, darkFromMinutes) {
+  return slots.map(slot => ({
+    ...slot,
+    lit_required: darkFromMinutes != null && slot.end_minutes > darkFromMinutes,
+  }))
+}

package/lib/occupancy.mjs

@@ -66,6 +66,11 @@ export function courtCanHost(court, slots, darkFromMinutes) {
     return false
   }
 
+  if (court.availableUntilMinutes != null
+    && slots.some(slot => slot.end_minutes > court.availableUntilMinutes)) {
+    return false
+  }
+
   if (darkFromMinutes == null || court.lit) {
     return true
   }

package/lib/paired-court-planner.mjs

@@ -51,9 +51,10 @@ import { courtCanHost } from './occupancy.mjs'
  *   group shape's own round robin, one entry per round - see
  *   group-schedule.mjs's GROUP_TEMPLATES and four-team-planner.mjs's
  *   FOUR_TEAM_TEMPLATE. A round's pairs.length is courtsPerRound.
- * @param {(group: {id: number, teamIds: number[]}) => Array<{slot: number, pairIndex: number, index: number}>} params.matchesFor
- *   A group's own matches, flattened and indexed in play order.
- * @param {?(groupId: number, index: number) => boolean} [params.done]
+ * @param {function(object): Array<object>} params.matchesFor
+ *   Given a group, {id, teamIds}, its own matches as {slot, pairIndex,
+ *   index}, flattened and indexed in play order.
+ * @param {function(number, number): boolean} [params.done]
  *   Which of them are already played, for a day laid out into a plan
  *   that exists.
  * @returns {Array<Array<{groupId: number, index: number}|null>>} slot by court
@@ -167,7 +168,8 @@ function remainderLayout(groups, { template, matchesFor, done }) {
  * slots for no reason.
  *
  * @param {Array<Array<{groupId: number, index: number}|null>>} layout
- * @param {(groupId: number) => {id, competitionId, divisionId, divisionName, divisionGender, groupName}} lookup
+ * @param {function(number): object} lookup Given a group id, its {id,
+ *   competitionId, divisionId, divisionName, divisionGender, groupName}.
  */
 export function placeLayout({ layout, lookup, courts, slots, date, occupancy, darkFrom, blocks }) {
   if (layout.length === 0) {
@@ -252,7 +254,8 @@ export function placeLayout({ layout, lookup, courts, slots, date, occupancy, da
  *   7 groups -> 3, 2, 2      9 groups -> 3, 3, 3
  *
  * @param {number} count
- * @param {{dense?: boolean}} options
+ * @param {object} [options]
+ * @param {boolean} [options.dense]
  * @returns {number[]} unit sizes, largest first
  */
 export function unitSizes(count, { dense = false } = {}) {

package/lib/roster-seeding.mjs

@@ -47,19 +47,11 @@ export function seedGroups(teams, groupCount) {
 }
 
 /**
- * A, B, C, ... Z, AA, AB, ... for group naming.
+ * 1, 2, 3, ... for group naming.
  *
  * @param {number} index zero-based
  * @returns {string}
  */
 export function groupName(index) {
-  let name = ''
-  let n = index
-
-  do {
-    name = String.fromCharCode(65 + (n % 26)) + name
-    n = Math.floor(n / 26) - 1
-  } while (n >= 0)
-
-  return name
+  return String(index + 1)
 }

package/package.json

@@ -40,5 +40,5 @@
   },
   "sideEffects": true,
   "type": "module",
-  "version": "0.0.4"
+  "version": "0.0.6"
 }