From a4132c82ab2d1e27e579279c0e12eaefb3fb4ca0 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 1 Sep 2024 17:56:31 +0200
Subject: [PATCH 1/6] WIP ijru@4

---
 lib/rulesets/ijru@4.0.0.ts | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 lib/rulesets/ijru@4.0.0.ts

diff --git a/lib/rulesets/ijru@4.0.0.ts b/lib/rulesets/ijru@4.0.0.ts
new file mode 100644
index 0000000..7a5499b
--- /dev/null
+++ b/lib/rulesets/ijru@4.0.0.ts
@@ -0,0 +1,49 @@
+import { type Ruleset } from './types.js'
+
+import ijruSpeed100 from '../models/competition-events/ijru.speed@1.0.0.js'
+import ijruOverall100 from '../models/overalls/ijru.overall@1.0.0.js'
+
+import eIjruSpDdDdsr44x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.dd.ddsr.4.4x30@1.0.0.js'
+import eIjruSpDdDdss360100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.dd.ddss.3.60@1.0.0.js'
+import eIjruSpSrSrdr22x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srdr.2.2x30@1.0.0.js'
+import eIjruSpSrSrse1180100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srse.1.180@1.0.0.js'
+import eIjruSpSrSrsr44x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srsr.4.4x30@1.0.0.js'
+import eIjruSpSrSrss130100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srss.1.30@1.0.0.js'
+import eIjruSpSrSrtu10100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srtu.1.0@1.0.0.js'
+
+export default {
+  id: 'ijru@4.0.0',
+  name: 'IJRU v4.0.0',
+  competitionEvents: [
+    eIjruSpSrSrss130100,
+    eIjruSpSrSrse1180100,
+    eIjruSpSrSrtu10100,
+    // eIjruFsSrSrif175400,
+
+    eIjruSpSrSrsr44x30100,
+    eIjruSpSrSrdr22x30100,
+    eIjruSpDdDdsr44x30100,
+    eIjruSpDdDdss360100,
+
+    // eIjruFsSrSrpf275400,
+    // eIjruFsSrSrtf475400,
+    // eIjruFsDdDdsf375400,
+    // eIjruFsDdDdpf475400,
+    // eIjruFsDdDdtf590400,
+    // eIjruFsWhWhpf275400,
+
+    // TODO: DDC
+  ],
+  overalls: [
+    // eIjruOaSrIsro10400,
+    // eIjruOaXdTxdo40400,
+  ],
+  competitionEventModels: [
+    // ijruFreestyleSrwh400,
+    // ijruFreestyleDd400,
+    ijruSpeed100,
+  ],
+  overallModels: [
+    ijruOverall100,
+  ],
+} satisfies Ruleset

From 79fd37b5ee8ce5ec3a9297653577eb1ef1c26f28 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Mon, 2 Sep 2024 00:48:16 +0200
Subject: [PATCH 2/6] WIP

---
 .../ijru.freestyle.sr@4.0.0.ts                | 503 ++++++++++++++++++
 1 file changed, 503 insertions(+)
 create mode 100644 lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts

diff --git a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
new file mode 100644
index 0000000..81053aa
--- /dev/null
+++ b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
@@ -0,0 +1,503 @@
+import { RSRWrongJudgeTypeError } from '../../errors'
+import { calculateTally, clampNumber, formatFactor, isMarkScoresheet, matchMeta, roundTo, roundToCurry } from '../../helpers'
+import type { CompetitionEventModel, JudgeTypeGetter, Options, ScoreTally, TableDefinition } from '../types'
+
+type Option = 'discipline' | 'interactions' |
+  'maxRqGymnasticsPower' | 'maxRqMultiples' | 'maxRqRopeManipulation' |
+  'maxRqInteractions'
+
+// pres
+const Fp = 0.6
+const presWeights = {
+  ent: 0.25,
+  form: 0.25,
+  music: 0.2,
+  crea: 0.15,
+  variety: 0.15,
+}
+
+// deduc
+const Fv = 0.05
+const Fb = 0.05
+const Fq = 0.025
+const Fm1 = 0.05
+const Fm2 = 0.075
+const Fm = 0.1
+
+// reqEl
+export function getRqMax (options: Options<Option>) {
+  return {
+    rqGymnasticsPower: typeof options.maxRqGymnasticsPower === 'number' ? options.maxRqGymnasticsPower : 6,
+    rqMultiples: typeof options.maxRqMultiples === 'number' ? options.maxRqMultiples : 6,
+    rqRopeManipulation: typeof options.maxRqRopeManipulation === 'number' ? options.maxRqRopeManipulation : 6,
+    rqInteractions: typeof options.maxRqInteractions === 'number' ? options.maxRqInteractions : 6,
+  }
+}
+
+// diff
+export function L (l: number): number {
+  if (l === 0) return 0
+  return roundTo(0.1 * Math.pow(1.5, l), 2)
+}
+
+// ======
+// JUDGES
+// ======
+export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
+  const components = ['ent', 'form', 'music', 'crea', 'variety'] as const
+  type Component = typeof components[number]
+
+  type Schema = 'miss' | `${Component}${'Plus' | 'Minus'}${'' | 'Adj'}`
+
+  const fieldDefinitions = [
+    {
+      schema: 'entPlus',
+      name: 'Entertainment +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'entMinus',
+      name: 'Entertainment -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'formPlus',
+      name: 'Form/Execution +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'formMinus',
+      name: 'Form/Execution -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'musicPlus',
+      name: 'Musicality +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'musicMinus',
+      name: 'Musicality -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'creaPlus',
+      name: 'Creativity +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'creaMinus',
+      name: 'Creativity -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'creaPlus',
+      name: 'Variety +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'creaMinus',
+      name: 'Repetitive -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'miss',
+      name: 'Miss',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'entPlusAdj',
+      name: 'Adjustment Entertainment +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'entMinusAdj',
+      name: 'Adjustment Entertainment -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'formPlusAdj',
+      name: 'Adjustment Form/Execution +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'formMinusAdj',
+      name: 'Adjustment Form/Execution -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'musicPlusAdj',
+      name: 'Adjustment Musicality +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'musicMinusAdj',
+      name: 'Adjustment Musicality -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'creaPlusAdj',
+      name: 'Adjustment Creativity +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'creaMinusAdj',
+      name: 'Adjustment Creativity -',
+      min: 0,
+      step: 1,
+    },
+
+    {
+      schema: 'creaPlusAdj',
+      name: 'Adjustment Variety +',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'creaMinusAdj',
+      name: 'Adjustment Repetitive -',
+      min: 0,
+      step: 1,
+    },
+  ]
+  const id = 'P'
+  return {
+    id,
+    name: 'Presentation',
+    fieldDefinitions,
+    calculateScoresheet: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally: ScoreTally<Schema> = calculateTally(scsh, fieldDefinitions)
+      let p = 0
+
+      for (const component of components) {
+        let cScore = 12
+
+        cScore += tally[`${component}Plus`] ?? 0
+        cScore -= tally[`${component}Minus`] ?? 0
+        cScore -= tally.miss ?? 0
+
+        cScore = clampNumber(cScore, { min: 0, max: 24, step: 1 })
+
+        // TODO: this doesn't work for tally scoresheets, like, at all. How to
+        // handle adjustments and direct conversion from mark to tally
+        // scoresheets?
+        if (isMarkScoresheet(scsh)) {
+          for (const mark of scsh.marks) {
+            if (mark.schema === `${component}PlusAdj` && cScore < 24) cScore++
+            else if (mark.schema === `${component}MinusAdj` && cScore > 0) cScore--
+          }
+        }
+
+        cScore = Math.round(clampNumber(cScore, { min: 0, max: 24, step: 1 }))
+
+        p += cScore * presWeights[component]
+      }
+      p = clampNumber(p, { min: 0, max: 24 })
+
+      return {
+        meta: scsh.meta,
+        result: {
+          p,
+          nm: tally.miss ?? 0,
+        },
+        statuses: {},
+      }
+    },
+  }
+}
+
+export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
+  const isWH = options.discipline === 'wh'
+  const hasInteractions = options.interactions === true
+
+  const maxRq = getRqMax(options)
+
+  const fieldDefinitions = [
+    {
+      schema: 'timeViolation',
+      name: 'Time Violations',
+      min: 0,
+      max: 2,
+      step: 1,
+    },
+    {
+      schema: 'spaceViolation',
+      name: 'Space Violations',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'miss',
+      name: 'Misses',
+      min: 0,
+      step: 1,
+    },
+    {
+      schema: 'break',
+      name: 'Breaks',
+      min: 0,
+      step: 1,
+    },
+
+    ...(isWH
+      ? [{
+          schema: 'rqGymnasticsPower',
+          name: 'Power/Gymnastics',
+          min: 0,
+          max: maxRq.rqGymnasticsPower,
+          step: 1,
+        }, {
+          schema: 'rqMultiples',
+          name: 'Multiples',
+          min: 0,
+          max: maxRq.rqMultiples,
+          step: 1,
+        }, {
+          schema: 'rqRopeManipulation',
+          name: 'Rope manipulation',
+          min: 0,
+          max: maxRq.rqRopeManipulation,
+          step: 1,
+        }, {
+          schema: 'rqInteractions',
+          name: 'Partner interactions',
+          min: 0,
+          max: maxRq.rqInteractions,
+          step: 1,
+        }]
+      : []
+    ),
+
+    ...(!isWH && hasInteractions
+      ? [{
+          schema: 'rqInteractions',
+          name: 'Pairs interactions',
+          min: 0,
+          max: maxRq.rqInteractions,
+          step: 1,
+        }]
+      : []
+    ),
+  ]
+  const id = 'T'
+  return {
+    id,
+    name: 'Technical Judge',
+    fieldDefinitions,
+    calculateScoresheet: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+      return {
+        meta: scsh.meta,
+        result: {
+          nm: tally.miss ?? 0,
+          nb: tally.break ?? 0,
+          nv: (tally.timeViolation ?? 0) + (tally.spaceViolation ?? 0),
+
+          ...(isWH
+            ? {
+                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
+                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
+                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
+                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
+              }
+            : {}
+          ),
+
+          ...(!isWH && hasInteractions
+            ? {
+                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
+              }
+            : {}
+          ),
+        },
+        statuses: {},
+      }
+    },
+  }
+}
+
+export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+  const maxRq = getRqMax(options)
+
+  const fieldDefinitions = [
+    {
+      name: 'Level 0.5',
+      schema: 'diffL0.5',
+      min: 0,
+      step: 1,
+    },
+    ...Array(8).fill(undefined).map((el, idx) => ({
+      name: `Level ${idx + 1}`,
+      schema: `diffL${idx + 1}` as const,
+      min: 0,
+      step: 1,
+    })),
+
+    // Not used in any math, just for tracking
+    {
+      name: 'Repeated Skills',
+      schema: 'rep',
+      min: 0,
+      step: 1,
+    },
+  ] as const
+  const levels: Record<string, number> = Object.fromEntries(Array(8).fill(undefined).map((el, idx) => [`diffL${idx + 1}`, idx + 1] as const))
+  levels['diffL0.5'] = 0.5
+  // TODO: handle this being either Dp, Dm, Dr for SR or Da, Db for WH
+  const id = 'D'
+  return {
+    id,
+    // TODO: handle for the different judges
+    name: 'Difficulty',
+    fieldDefinitions,
+    calculateScoresheet: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
+      return {
+        meta: scsh.meta,
+        result: {
+          d,
+
+          aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
+          aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
+          aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
+        },
+        statuses: {},
+      }
+    },
+  }
+}
+
+// ======
+// TABLES
+// ======
+export const freestylePreviewTableHeaders: TableDefinition = {
+  headers: [
+    { text: 'Diff (D)', key: 'D', formatter: roundToCurry(2) },
+    { text: 'Pres (P)', key: 'P', formatter: formatFactor },
+    { text: 'Req. El (Q)', key: 'Q', formatter: formatFactor },
+    { text: 'Deduc (M)', key: 'M', formatter: formatFactor },
+    { text: 'Result (R)', key: 'R', formatter: roundToCurry(2) },
+  ],
+}
+
+export const freestyleResultTableHeaders: TableDefinition = {
+  headers: [
+    { text: 'Diff', key: 'D', color: 'gray', formatter: roundToCurry(2) },
+    { text: 'Pres', key: 'P', color: 'gray', formatter: formatFactor },
+    { text: 'Req. El', key: 'Q', color: 'gray', formatter: formatFactor },
+    { text: 'Deduc', key: 'M', color: 'gray', formatter: formatFactor },
+
+    { text: 'Score', key: 'R', formatter: roundToCurry(2), primary: 'score' },
+    { text: 'Rank', key: 'S', color: 'red', primary: 'rank' },
+  ],
+}
+
+export default {
+  id: 'ijru.freestyle.sr@4.0.0',
+  name: 'IJRU Single Rope Freestyle v4.0.0',
+  options: [
+    { id: 'discipline', name: 'Discipline', type: 'enum', enum: ['sr', 'dd', 'wh', 'ts', 'xd'] },
+    { id: 'interactions', name: 'Has Interactions', type: 'boolean' },
+    { id: 'maxRqGymnasticsPower', name: 'Power/Gymnastics Required Elements', type: 'number', min: 0, step: 1 },
+    { id: 'maxRqMultiples', name: 'Multiples Required Elements', type: 'number', min: 0, step: 1 },
+    { id: 'maxRqRopeManipulation', name: 'Rope Manipulation Required Elements', type: 'number', min: 0, step: 1 },
+    { id: 'maxRqInteractions', name: 'Interactions Required Elements', type: 'number', min: 0, step: 1 },
+  ],
+  judges: [presentationJudge, technicalJudge, difficultyJudge],
+
+  calculateEntry (meta, res, options) {
+    const results = res.filter(r => matchMeta(r.meta, meta))
+    if (!results.length) return
+
+    const raw: Record<string, number> = {}
+
+    // for (const scoreType of ['D', 'aF', 'aE', 'aM', 'm', 'v', 'Q'] as const) {
+    //   const scores = results.map(el => el.result[scoreType]).filter(el => typeof el === 'number')
+    //   if (['m', 'v'].includes(scoreType)) raw[scoreType] = roundTo(ijruAverage(scores), 4)
+    //   else if (['aF', 'aE', 'aM'].includes(scoreType)) raw[scoreType] = roundTo(ijruAverage(scores), 6)
+    //   else raw[scoreType] = roundTo(ijruAverage(scores), 2) // D, Q
+
+    //   if (typeof raw[scoreType] !== 'number' || isNaN(Number(raw[scoreType]))) raw[scoreType] = (['D', 'aF', 'aE', 'aM'].includes(scoreType) ? 0 : 1)
+    //   if (scoreType === 'aM' && noMusic) raw[scoreType] = 0
+    // }
+
+    // raw.M = roundTo(-(1 - raw.m - raw.v), 2) // the minus is because they're already prepped to 1- and that needs to be reversed
+
+    // raw.P = roundTo(1 + (raw.aE + raw.aF + raw.aM), 2)
+
+    // raw.R = roundTo(raw.D * raw.P * raw.M * raw.Q, 2)
+    // raw.R = raw.R < 0 ? 0 : raw.R
+
+    return {
+      meta,
+      result: raw,
+      statuses: {},
+    }
+  },
+  rankEntries (res, options) {
+    let results = [...res]
+    // const tiePriority = ['R', 'M', 'Q', 'P', 'D'] as const
+    results.sort(function (a, b) {
+      if (a.result.R !== b.result.R) return (b.result.R ?? 0) - (a.result.R ?? 0) // descending 100 wins over 50
+      if (a.result.M !== b.result.M) return (b.result.M ?? 1) - (a.result.M ?? 1) // descending *1 wins over *.9
+      if (a.result.Q !== b.result.Q) return (b.result.Q ?? 1) - (a.result.Q ?? 1) // descending *1 wins over *.9
+      if (a.result.P !== b.result.P) return (b.result.P ?? 1) - (a.result.P ?? 1) // descending 1.35 wins over 0.95
+      if (a.result.D !== b.result.D) return (b.result.D ?? 0) - (a.result.D ?? 0) // descending 100 wins over 50
+      return 0
+    })
+
+    const high = results.length > 0 ? results[0].result.R ?? 0 : 0
+    const low = results.length > 1 ? results[results.length - 1].result.R ?? 0 : 0
+
+    results = results.map((el, idx, arr) => ({
+      ...el,
+      result: {
+        ...el.result,
+        S: arr.findIndex(score =>
+          score.result.R === el.result.R &&
+          score.result.M === el.result.M &&
+          score.result.Q === el.result.Q &&
+          score.result.P === el.result.P &&
+          score.result.D === el.result.D
+        ) + 1,
+        N: roundTo((((100 - 1) * ((el.result.R ?? 0) - low)) / ((high - low) !== 0 ? high - low : 1)) + 1, 2),
+      },
+    }))
+
+    return results
+  },
+
+  previewTable: options => freestylePreviewTableHeaders,
+  resultTable: options => freestyleResultTableHeaders,
+} satisfies CompetitionEventModel<string, Option>

From 1b89437ba7cbdd0bb579fafe2b92a32c90ebec84 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sat, 21 Sep 2024 13:02:53 +0200
Subject: [PATCH 3/6] WIP for #32

---
 lib/helpers.test.ts                           |  49 +++-
 lib/helpers.ts                                |  84 ++++---
 .../ijru.freestyle.sr@4.0.0.ts                | 217 ++++++++++--------
 lib/models/types.ts                           |  28 ++-
 4 files changed, 251 insertions(+), 127 deletions(-)

diff --git a/lib/helpers.test.ts b/lib/helpers.test.ts
index 560f8cd..bd52785 100644
--- a/lib/helpers.test.ts
+++ b/lib/helpers.test.ts
@@ -1,7 +1,7 @@
-import { calculateTally, clampNumber, formatFactor, isObject, parseCompetitionEventDefinition, roundTo, roundToCurry, roundToMultiple } from './helpers.js'
+import { calculateTally, clampNumber, filterMarkStream, formatFactor, isObject, parseCompetitionEventDefinition, roundTo, roundToCurry, roundToMultiple } from './helpers.js'
 import assert from 'node:assert'
 import test from 'node:test'
-import type { JudgeMeta, Mark } from './models/types.js'
+import type { GenericMark, JudgeMeta, Mark } from './models/types.js'
 
 void test('helpers', async t => {
   await t.test('isObject', async t => {
@@ -70,6 +70,51 @@ void test('helpers', async t => {
     assert.strictEqual(formatFactor(1.1), '+10 %')
   })
 
+  await t.test('filterMarkStream', async t => {
+    const tests: Array<[name: string, input: Array<Mark<string>>, output: Array<GenericMark<string>>]> = [
+      [
+        'No special marks',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }],
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }],
+      ],
+      [
+        'Start at clear mark',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'clear' }, { sequence: 4, timestamp: 4, schema: 'b' }, { sequence: 5, timestamp: 5, schema: 'b' }],
+        [{ sequence: 4, timestamp: 4, schema: 'b' }, { sequence: 5, timestamp: 5, schema: 'b' }],
+      ],
+      [
+        'Handle single undo',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'undo', target: 2 }, { sequence: 4, timestamp: 4, schema: 'b' }, { sequence: 5, timestamp: 5, schema: 'b' }],
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 4, timestamp: 4, schema: 'b' }, { sequence: 5, timestamp: 5, schema: 'b' }],
+      ],
+      [
+        'Handle two undos right after each other',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'b' }, { sequence: 4, timestamp: 4, schema: 'undo', target: 2 }, { sequence: 5, timestamp: 5, schema: 'undo', target: 3 }, { sequence: 6, timestamp: 6, schema: 'b' }],
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 6, timestamp: 6, schema: 'b' }],
+      ],
+      [
+        'Cannot undo an undo - silent ignore',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'b' }, { sequence: 4, timestamp: 4, schema: 'undo', target: 2 }, { sequence: 5, timestamp: 5, schema: 'undo', target: 4 }, { sequence: 6, timestamp: 6, schema: 'b' }],
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'b' }, { sequence: 6, timestamp: 6, schema: 'b' }],
+      ],
+      [
+        'Cannot undo a clear mark - silent ignore',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'b' }, { sequence: 4, timestamp: 4, schema: 'clear' }, { sequence: 5, timestamp: 5, schema: 'undo', target: 4 }, { sequence: 6, timestamp: 6, schema: 'b' }],
+        [{ sequence: 6, timestamp: 6, schema: 'b' }],
+      ],
+      [
+        'Cannot undo before a clear mark - silent ignore',
+        [{ sequence: 1, timestamp: 1, schema: 'a' }, { sequence: 2, timestamp: 2, schema: 'a' }, { sequence: 3, timestamp: 3, schema: 'b' }, { sequence: 4, timestamp: 4, schema: 'clear' }, { sequence: 5, timestamp: 5, schema: 'undo', target: 2 }, { sequence: 6, timestamp: 6, schema: 'b' }],
+        [{ sequence: 6, timestamp: 6, schema: 'b' }],
+      ],
+    ]
+    for (const [title, input, output] of tests) {
+      await t.test(title, () => {
+        assert.deepStrictEqual(filterMarkStream(input), output)
+      })
+    }
+  })
+
   await t.test('calculateTally', async t => {
     const meta: JudgeMeta = {
       judgeId: '1',
diff --git a/lib/helpers.ts b/lib/helpers.ts
index 3f807a6..808cf82 100644
--- a/lib/helpers.ts
+++ b/lib/helpers.ts
@@ -1,3 +1,5 @@
+import { RSRWrongJudgeTypeError } from './errors.js'
+import type { GenericMark, Mark } from './models/types.js'
 import { type JudgeFieldDefinition, type ScoreTally, isClearMark, isUndoMark, type Meta, type EntryResult, type TallyScoresheet, type MarkScoresheet } from './models/types.js'
 import { type CompetitionEventDefinition } from './preconfigured/types.js'
 
@@ -76,6 +78,33 @@ export function formatFactor (value: number): string {
   else return `-${roundTo((1 - value) * 100, 0)} %`
 }
 
+export function filterMarkStream <Schema extends string> (rawMarks: Readonly<Array<Readonly<Mark<Schema>>>>): Array<GenericMark<Schema>> {
+  const clearMarkIdx = rawMarks.findLastIndex(mark => mark.schema === 'clear')
+  const marks = rawMarks.slice(clearMarkIdx + 1)
+  for (let idx = 0; idx < marks.length; idx++) {
+    const mark = marks[idx]
+    if (isUndoMark(mark)) {
+      let targetIdx = -1
+      // We're doing an optimised check here since the undone mark need to be
+      // before the undo mark, and will most likely be just before teh undo mark
+      // therefore findIndex or findLastIndex would be wasteful
+      for (let tIdx = idx - 1; tIdx >= 0; tIdx--) {
+        if (marks[tIdx].sequence === mark.target) {
+          targetIdx = tIdx
+          break
+        }
+      }
+      if (targetIdx >= 0 && !isUndoMark(marks[targetIdx]) && !isClearMark(marks[targetIdx])) {
+        marks.splice(targetIdx, 1)
+        idx--
+      }
+      marks.splice(idx, 1)
+      idx--
+    }
+  }
+  return marks
+}
+
 /**
  * Takes a scoresheet and returns a tally
  *
@@ -85,41 +114,38 @@ export function formatFactor (value: number): string {
  * Each value of the tally will also be clamped to the specified max, min and
  * step size for that field schema.
  */
-export function calculateTally <Schema extends string> (scoresheet: Pick<TallyScoresheet<Schema>, 'tally'> | Pick<MarkScoresheet<Schema>, 'marks'>, fieldDefinitions?: Readonly<Array<JudgeFieldDefinition<Schema>>>): ScoreTally<Schema> {
-  let tally: ScoreTally<Schema> = isTallyScoresheet<Schema>(scoresheet) ? { ...(scoresheet.tally ?? {}) } : {}
-  const allowedSchemas = fieldDefinitions?.map(f => f.schema)
-
-  if (isMarkScoresheet(scoresheet)) {
-    for (const mark of scoresheet.marks) {
-      if (isUndoMark(mark)) {
-        const target = scoresheet.marks.find(m => m.sequence === mark.target)
-        if (target == null || isUndoMark(target) || isClearMark(target)) continue
-        tally[target.schema as Schema] = (tally[target.schema as Schema] ?? 0) - (target.value ?? 1)
-      } else if (isClearMark(mark)) {
-        tally = {}
-      } else {
-        tally[mark.schema as Schema] = (tally[mark.schema as Schema] ?? 0) + (mark.value ?? 1)
-      }
+export function simpleCalculateTallyFactory <Schema extends string> (judgeTypeId: string, fieldDefinitions?: Readonly<Array<JudgeFieldDefinition<Schema>>>) {
+  return function simpleCalculateTally (scoresheet: MarkScoresheet<Schema>) {
+    if (!matchMeta(scoresheet.meta, { judgeTypeId })) throw new RSRWrongJudgeTypeError(scoresheet.meta.judgeTypeId, judgeTypeId)
+    const tally: ScoreTally<Schema> = isTallyScoresheet<Schema>(scoresheet) ? { ...(scoresheet.tally ?? {}) } : {}
+    const allowedSchemas = fieldDefinitions?.map(f => f.schema)
+
+    for (const mark of filterMarkStream(scoresheet.marks)) {
+      tally[mark.schema as Schema] = (tally[mark.schema as Schema] ?? 0) + (mark.value ?? 1)
     }
-  }
 
-  if (fieldDefinitions != null) {
-    for (const field of fieldDefinitions) {
-      if (typeof tally[field.schema] !== 'number') continue
-      // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
-      tally[field.schema] = clampNumber(tally[field.schema] as number, field)
+    if (fieldDefinitions != null) {
+      for (const field of fieldDefinitions) {
+        const v = tally[field.schema]
+        if (typeof v !== 'number') continue
+
+        tally[field.schema] = clampNumber(v, field)
+      }
     }
-  }
 
-  if (allowedSchemas != null) {
-    const extra = Object.keys(tally).filter(schema => !allowedSchemas.includes(schema as Schema))
+    if (allowedSchemas != null) {
+      const extra = Object.keys(tally).filter(schema => !allowedSchemas.includes(schema as Schema))
 
-    // @ts-expect-error Yes I know schema doesn't exist in the target object, I'm deleting the schemas that shouldn't be there
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-    for (const schema of extra) delete tally[schema]
-  }
+      // @ts-expect-error Yes I know schema doesn't exist in the target object, I'm deleting the schemas that shouldn't be there
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      for (const schema of extra) delete tally[schema]
+    }
 
-  return tally
+    return {
+      meta: scoresheet.meta,
+      tally,
+    }
+  }
 }
 
 /**
diff --git a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
index 81053aa..3964832 100644
--- a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
+++ b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
@@ -1,5 +1,5 @@
 import { RSRWrongJudgeTypeError } from '../../errors'
-import { calculateTally, clampNumber, formatFactor, isMarkScoresheet, matchMeta, roundTo, roundToCurry } from '../../helpers'
+import { clampNumber, filterMarkStream, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
 import type { CompetitionEventModel, JudgeTypeGetter, Options, ScoreTally, TableDefinition } from '../types'
 
 type Option = 'discipline' | 'interactions' |
@@ -13,7 +13,7 @@ const presWeights = {
   form: 0.25,
   music: 0.2,
   crea: 0.15,
-  variety: 0.15,
+  vari: 0.15,
 }
 
 // deduc
@@ -44,179 +44,208 @@ export function L (l: number): number {
 // JUDGES
 // ======
 export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
-  const components = ['ent', 'form', 'music', 'crea', 'variety'] as const
-  type Component = typeof components[number]
-
-  type Schema = 'miss' | `${Component}${'Plus' | 'Minus'}${'' | 'Adj'}`
-
-  const fieldDefinitions = [
+  const components = ['ent', 'form', 'music', 'crea', 'vari'] as const
+  const markDefinitions = [
     {
       schema: 'entPlus',
       name: 'Entertainment +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'entMinus',
       name: 'Entertainment -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'formPlus',
       name: 'Form/Execution +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'formMinus',
       name: 'Form/Execution -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'musicPlus',
       name: 'Musicality +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'musicMinus',
       name: 'Musicality -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'creaPlus',
       name: 'Creativity +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'creaMinus',
       name: 'Creativity -',
-      min: 0,
-      step: 1,
     },
 
     {
-      schema: 'creaPlus',
+      schema: 'variPlus',
       name: 'Variety +',
-      min: 0,
-      step: 1,
     },
     {
-      schema: 'creaMinus',
+      schema: 'variMinus',
       name: 'Repetitive -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'miss',
       name: 'Miss',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'entPlusAdj',
       name: 'Adjustment Entertainment +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'entMinusAdj',
       name: 'Adjustment Entertainment -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'formPlusAdj',
       name: 'Adjustment Form/Execution +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'formMinusAdj',
       name: 'Adjustment Form/Execution -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'musicPlusAdj',
       name: 'Adjustment Musicality +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'musicMinusAdj',
       name: 'Adjustment Musicality -',
-      min: 0,
-      step: 1,
     },
 
     {
       schema: 'creaPlusAdj',
       name: 'Adjustment Creativity +',
-      min: 0,
-      step: 1,
     },
     {
       schema: 'creaMinusAdj',
       name: 'Adjustment Creativity -',
-      min: 0,
-      step: 1,
     },
 
     {
-      schema: 'creaPlusAdj',
+      schema: 'variPlusAdj',
       name: 'Adjustment Variety +',
+    },
+    {
+      schema: 'variMinusAdj',
+      name: 'Adjustment Repetitive -',
+    },
+  ] as const
+  const tallyDefinitions = [
+    {
+      schema: 'ent',
+      name: 'Entertainment',
       min: 0,
+      max: 24,
       step: 1,
     },
     {
-      schema: 'creaMinusAdj',
-      name: 'Adjustment Repetitive -',
+      schema: 'form',
+      name: 'Form/Execution',
       min: 0,
+      max: 24,
       step: 1,
     },
-  ]
+    {
+      schema: 'music',
+      name: 'Musicality',
+      min: 0,
+      max: 24,
+      step: 1,
+    },
+    {
+      schema: 'crea',
+      name: 'Creativity',
+      min: 0,
+      max: 24,
+      step: 1,
+    },
+    {
+      schema: 'vari',
+      name: 'Variety',
+      min: 0,
+      max: 24,
+      step: 1,
+    },
+    {
+      schema: 'miss',
+      name: 'Miss',
+      min: 0,
+      step: 1,
+    },
+  ] as const
+  const tallyDefMap = new Map(tallyDefinitions.map(d => [d.schema, d]))
+  type TallySchema = typeof tallyDefinitions[number]['schema']
   const id = 'P'
   return {
     id,
     name: 'Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions,
+    tallyDefinitions,
+    calculateTally: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<Schema> = calculateTally(scsh, fieldDefinitions)
-      let p = 0
+      const marks = filterMarkStream(scsh.marks)
+      const tally: Required<ScoreTally<TallySchema>> = {
+        ent: 12,
+        form: 12,
+        music: 12,
+        crea: 12,
+        vari: 12,
+        miss: 0,
+      }
 
-      for (const component of components) {
-        let cScore = 12
+      const stageOneMarks = ['miss', ...components.flatMap(c => [`${c}Plus`, `${c}Minus`])]
 
-        cScore += tally[`${component}Plus`] ?? 0
-        cScore -= tally[`${component}Minus`] ?? 0
-        cScore -= tally.miss ?? 0
+      for (const mark of marks) {
+        if (stageOneMarks.includes(mark.schema)) {
+          const sign = mark.schema.endsWith('Minus') ? -1 : 1
+          const schema = mark.schema.replace(/(Plus|Minus)$/, '') as TallySchema
 
-        cScore = clampNumber(cScore, { min: 0, max: 24, step: 1 })
+          tally[schema] = tally[schema] + ((mark.value ?? 1) * sign)
+        }
+      }
+
+      for (const field of tallyDefinitions) {
+        const v = tally[field.schema]
+        if (typeof v !== 'number') continue
+        tally[field.schema] = clampNumber(v, field)
+      }
+
+      const stageTwoMarks = components.flatMap(c => [`${c}PlusAdj`, `${c}MinusAdj`])
+
+      for (const mark of marks) {
+        if (stageTwoMarks.includes(mark.schema)) {
+          const sign = mark.schema.endsWith('MinusAdj') ? -1 : 1
+          const schema = mark.schema.replace(/(Plus|Minus)Adj$/, '') as TallySchema
+          const field = tallyDefMap.get(schema)
+          if (field == null) throw new TypeError(`Could not find tally field with schema ${schema} - This error should not occur.`)
+
+          if (sign > 0 && 'max' in field && tally[schema] >= field.max) continue
+          if (sign < 0 && 'min' in field && tally[schema] <= field.min) continue
 
-        // TODO: this doesn't work for tally scoresheets, like, at all. How to
-        // handle adjustments and direct conversion from mark to tally
-        // scoresheets?
-        if (isMarkScoresheet(scsh)) {
-          for (const mark of scsh.marks) {
-            if (mark.schema === `${component}PlusAdj` && cScore < 24) cScore++
-            else if (mark.schema === `${component}MinusAdj` && cScore > 0) cScore--
-          }
+          tally[schema] = tally[schema] + ((mark.value ?? 1) * sign)
         }
+      }
 
-        cScore = Math.round(clampNumber(cScore, { min: 0, max: 24, step: 1 }))
+      return { meta: scsh.meta, tally }
+    },
+    calculateJudgeResult: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      let p = 0
+
+      for (const component of components) {
+        let cScore = (scsh.tally[component] ?? 12) - (scsh.tally.miss ?? 0)
+        cScore = clampNumber(cScore, { min: 0, max: 24, step: 1 })
 
         p += cScore * presWeights[component]
       }
@@ -226,7 +255,7 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
         meta: scsh.meta,
         result: {
           p,
-          nm: tally.miss ?? 0,
+          nm: scsh.tally.miss ?? 0,
         },
         statuses: {},
       }
@@ -311,30 +340,31 @@ export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Technical Judge',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
       return {
         meta: scsh.meta,
         result: {
-          nm: tally.miss ?? 0,
-          nb: tally.break ?? 0,
-          nv: (tally.timeViolation ?? 0) + (tally.spaceViolation ?? 0),
+          nm: scsh.tally.miss ?? 0,
+          nb: scsh.tally.break ?? 0,
+          nv: (scsh.tally.timeViolation ?? 0) + (scsh.tally.spaceViolation ?? 0),
 
           ...(isWH
             ? {
-                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
-                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
-                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
-                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
+                aqP: clampNumber(maxRq.rqGymnasticsPower - (scsh.tally.rqGymnasticsPower ?? 0), { min: 0 }),
+                aqM: clampNumber(maxRq.rqMultiples - (scsh.tally.rqMultiples ?? 0), { min: 0 }),
+                aqR: clampNumber(maxRq.rqRopeManipulation - (scsh.tally.rqRopeManipulation ?? 0), { min: 0 }),
+                aqI: clampNumber(maxRq.rqInteractions - (scsh.tally.rqInteractions ?? 0), { min: 0 }),
               }
             : {}
           ),
 
           ...(!isWH && hasInteractions
             ? {
-                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
+                aqI: clampNumber(maxRq.rqInteractions - (scsh.tally.rqInteractions ?? 0), { min: 0 }),
               }
             : {}
           ),
@@ -347,6 +377,7 @@ export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
 
 export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   const maxRq = getRqMax(options)
+  const isWH = options.discipline === 'wh'
 
   const fieldDefinitions = [
     {
@@ -378,19 +409,25 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
     id,
     // TODO: handle for the different judges
     name: 'Difficulty',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
-      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
+      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (scsh.tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
         result: {
           d,
 
-          aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
-          aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
-          aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
+          ...(isWH
+            ? {}
+            : {
+                aqP: clampNumber(maxRq.rqGymnasticsPower - (scsh.tally.rqGymnasticsPower ?? 0), { min: 0 }),
+                aqM: clampNumber(maxRq.rqMultiples - (scsh.tally.rqMultiples ?? 0), { min: 0 }),
+                aqR: clampNumber(maxRq.rqRopeManipulation - (scsh.tally.rqRopeManipulation ?? 0), { min: 0 }),
+              }
+          ),
         },
         statuses: {},
       }
diff --git a/lib/models/types.ts b/lib/models/types.ts
index 7694cfb..f7cc675 100644
--- a/lib/models/types.ts
+++ b/lib/models/types.ts
@@ -1,7 +1,7 @@
 import { isObject } from '../helpers.js'
 import { type CompetitionEventDefinition } from '../preconfigured/types.js'
 
-export interface JudgeType<Schema extends string> {
+export interface JudgeType<MarkSchema extends string, TallySchema extends string = MarkSchema> {
   /**
    * This should be unique for the model, but may be the same as a judge used
    * in another model. For example it could be D for a Difficulty judge.
@@ -13,18 +13,31 @@ export interface JudgeType<Schema extends string> {
    */
   name: string
   /**
-   * Field
+   * These are the mark types available for the judge type providing the valid
+   * mark schemas for this judge type
    */
-  fieldDefinitions: Readonly<Array<JudgeFieldDefinition<Schema>>>
+  markDefinitions: Readonly<Array<JudgeMarkDefinition<MarkSchema>>>
   /**
-   * This takes a judge scoresheet, and summarises it into a judge score.
+   * These are the tally fields the marks will get converted into when calling
+   * calculateTally, and some validation parameters for them. These can be used
+   * to generate tabulator interfaces.
    */
-  calculateScoresheet: (scoresheet: Scoresheet<Schema>) => JudgeResult
+  tallyDefinitions: Readonly<Array<JudgeFieldDefinition<TallySchema>>>
+  /**
+   *
+   */
+  calculateTally: (scoresheet: MarkScoresheet<MarkSchema>) => TallyScoresheet<TallySchema>
+  /**
+   * This takes a tally scoresheet, and summarises it into a judge score. If the
+   * judge has submitted a mark scoresheet it should first be processed with
+   * calculateTally
+   */
+  calculateJudgeResult: (scoresheet: TallyScoresheet<TallySchema>) => JudgeResult
 }
 
 export type JudgeTypeGetter<Schema extends string = string, Option extends string = string> = (options: Options<Option>) => Readonly<JudgeType<Schema>>
 
-export interface JudgeFieldDefinition<Schema extends string> {
+export interface JudgeMarkDefinition<Schema extends string> {
   /**
    * an unique identifier for this field to identify it's marks or tally.
    * Multiple judge types can however be using this field with the same schema,
@@ -35,6 +48,9 @@ export interface JudgeFieldDefinition<Schema extends string> {
    * The human readable name of the field, such as "Level 8"
    */
   name: string
+}
+
+export interface JudgeFieldDefinition<Schema extends string> extends JudgeMarkDefinition<Schema> {
   /** the minimum value for this field, if not set the value is not capped */
   min?: number
   /** the maximum value for this field, if not set the value is not capped */

From fc8f7f859dc4a8fa609d9c48ffea9d9b8c0fa95c Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:22:38 +0200
Subject: [PATCH 4/6] finalise split of calculateScoresheet

---
 lib/helpers.test.ts                           | 12 ++--
 lib/helpers.ts                                | 34 +++++-----
 .../ijru.freestyle.sr@4.0.0.ts                | 44 ++++++-------
 .../ijru.freestyle@2.0.0.ts                   | 50 +++++++++------
 .../ijru.freestyle@3.0.0.test.ts              | 54 ++++++++++------
 .../ijru.freestyle@3.0.0.ts                   | 50 +++++++++------
 .../ijru.speed@1.0.0.test.ts                  | 62 +++++++++++--------
 .../competition-events/ijru.speed@1.0.0.ts    | 26 ++++----
 .../svgf-rh.freestyle@2020.ts                 | 38 ++++++++----
 .../svgf-vh.freestyle@2023.ts                 | 45 +++++++++-----
 .../competition-events/svgf-vh.speed@2023.ts  | 16 ++---
 .../competition-events/svgf-vh.timing@2023.ts | 40 +++++++++---
 lib/models/types.ts                           |  6 +-
 13 files changed, 290 insertions(+), 187 deletions(-)

diff --git a/lib/helpers.test.ts b/lib/helpers.test.ts
index bd52785..3ed3b8a 100644
--- a/lib/helpers.test.ts
+++ b/lib/helpers.test.ts
@@ -1,4 +1,4 @@
-import { calculateTally, clampNumber, filterMarkStream, formatFactor, isObject, parseCompetitionEventDefinition, roundTo, roundToCurry, roundToMultiple } from './helpers.js'
+import { simpleCalculateTallyFactory, clampNumber, filterMarkStream, formatFactor, isObject, parseCompetitionEventDefinition, roundTo, roundToCurry, roundToMultiple } from './helpers.js'
 import assert from 'node:assert'
 import test from 'node:test'
 import type { GenericMark, JudgeMeta, Mark } from './models/types.js'
@@ -115,7 +115,7 @@ void test('helpers', async t => {
     }
   })
 
-  await t.test('calculateTally', async t => {
+  await t.test('simpleCalculateTallyFactory', async t => {
     const meta: JudgeMeta = {
       judgeId: '1',
       judgeTypeId: 'S',
@@ -123,10 +123,6 @@ void test('helpers', async t => {
       participantId: '1',
       competitionEvent: 'e.ijru.sp.sr.srss.1.30@1.0.0',
     }
-    await t.test('Should return tally for a TallyScoresheet', () => {
-      const tally = { entPlus: 2, entMinus: 1 }
-      assert.deepStrictEqual(calculateTally({ meta, tally }), tally)
-    })
 
     await t.test('Should return tally for MarkScoresheet', () => {
       const marks: Array<Mark<string>> = [
@@ -138,7 +134,7 @@ void test('helpers', async t => {
         formPlus: 2,
         formCheck: 1,
       }
-      assert.deepStrictEqual(calculateTally({ meta, marks }), tally)
+      assert.deepStrictEqual(simpleCalculateTallyFactory(meta.judgeTypeId)({ meta, marks }), { meta, tally })
     })
 
     await t.test('Should return tally for MarkScoresheet with undo marks', () => {
@@ -152,7 +148,7 @@ void test('helpers', async t => {
         formPlus: 1,
         formCheck: 1,
       }
-      assert.deepStrictEqual(calculateTally({ meta, marks }), tally)
+      assert.deepStrictEqual(simpleCalculateTallyFactory(meta.judgeTypeId)({ meta, marks }), { meta, tally })
     })
   })
 
diff --git a/lib/helpers.ts b/lib/helpers.ts
index 808cf82..4f4ad2d 100644
--- a/lib/helpers.ts
+++ b/lib/helpers.ts
@@ -105,6 +105,20 @@ export function filterMarkStream <Schema extends string> (rawMarks: Readonly<Arr
   return marks
 }
 
+export function filterTally <Schema extends string> (_tally: ScoreTally, fieldDefinitions?: Readonly<Array<JudgeFieldDefinition<Schema>>>): ScoreTally<Schema> {
+  if (fieldDefinitions == null) return _tally as ScoreTally<Schema>
+  const tally: ScoreTally<Schema> = {}
+
+  for (const field of fieldDefinitions) {
+    const v = _tally[field.schema]
+    if (typeof v !== 'number') continue
+
+    tally[field.schema] = clampNumber(v, field)
+  }
+
+  return tally
+}
+
 /**
  * Takes a scoresheet and returns a tally
  *
@@ -117,29 +131,13 @@ export function filterMarkStream <Schema extends string> (rawMarks: Readonly<Arr
 export function simpleCalculateTallyFactory <Schema extends string> (judgeTypeId: string, fieldDefinitions?: Readonly<Array<JudgeFieldDefinition<Schema>>>) {
   return function simpleCalculateTally (scoresheet: MarkScoresheet<Schema>) {
     if (!matchMeta(scoresheet.meta, { judgeTypeId })) throw new RSRWrongJudgeTypeError(scoresheet.meta.judgeTypeId, judgeTypeId)
-    const tally: ScoreTally<Schema> = isTallyScoresheet<Schema>(scoresheet) ? { ...(scoresheet.tally ?? {}) } : {}
-    const allowedSchemas = fieldDefinitions?.map(f => f.schema)
+    let tally: ScoreTally<Schema> = isTallyScoresheet<Schema>(scoresheet) ? { ...(scoresheet.tally ?? {}) } : {}
 
     for (const mark of filterMarkStream(scoresheet.marks)) {
       tally[mark.schema as Schema] = (tally[mark.schema as Schema] ?? 0) + (mark.value ?? 1)
     }
 
-    if (fieldDefinitions != null) {
-      for (const field of fieldDefinitions) {
-        const v = tally[field.schema]
-        if (typeof v !== 'number') continue
-
-        tally[field.schema] = clampNumber(v, field)
-      }
-    }
-
-    if (allowedSchemas != null) {
-      const extra = Object.keys(tally).filter(schema => !allowedSchemas.includes(schema as Schema))
-
-      // @ts-expect-error Yes I know schema doesn't exist in the target object, I'm deleting the schemas that shouldn't be there
-      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-      for (const schema of extra) delete tally[schema]
-    }
+    tally = filterTally(tally, fieldDefinitions)
 
     return {
       meta: scoresheet.meta,
diff --git a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
index 3964832..9d65ea4 100644
--- a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
+++ b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
@@ -1,5 +1,5 @@
 import { RSRWrongJudgeTypeError } from '../../errors'
-import { clampNumber, filterMarkStream, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
+import { clampNumber, filterMarkStream, filterTally, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
 import type { CompetitionEventModel, JudgeTypeGetter, Options, ScoreTally, TableDefinition } from '../types'
 
 type Option = 'discipline' | 'interactions' |
@@ -43,7 +43,7 @@ export function L (l: number): number {
 // ======
 // JUDGES
 // ======
-export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const presentationJudge: JudgeTypeGetter<string, string, Option> = options => {
   const components = ['ent', 'form', 'music', 'crea', 'vari'] as const
   const markDefinitions = [
     {
@@ -241,10 +241,11 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
     },
     calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally = filterTally(scsh.tally, tallyDefinitions)
       let p = 0
 
       for (const component of components) {
-        let cScore = (scsh.tally[component] ?? 12) - (scsh.tally.miss ?? 0)
+        let cScore = (tally[component] ?? 12) - (tally.miss ?? 0)
         cScore = clampNumber(cScore, { min: 0, max: 24, step: 1 })
 
         p += cScore * presWeights[component]
@@ -255,7 +256,7 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
         meta: scsh.meta,
         result: {
           p,
-          nm: scsh.tally.miss ?? 0,
+          nm: tally.miss ?? 0,
         },
         statuses: {},
       }
@@ -263,7 +264,7 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
+export const technicalJudge: JudgeTypeGetter<string, string, Option> = options => {
   const isWH = options.discipline === 'wh'
   const hasInteractions = options.interactions === true
 
@@ -345,19 +346,20 @@ export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
     calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
     calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       return {
         meta: scsh.meta,
         result: {
-          nm: scsh.tally.miss ?? 0,
-          nb: scsh.tally.break ?? 0,
-          nv: (scsh.tally.timeViolation ?? 0) + (scsh.tally.spaceViolation ?? 0),
+          nm: tally.miss ?? 0,
+          nb: tally.break ?? 0,
+          nv: (tally.timeViolation ?? 0) + (tally.spaceViolation ?? 0),
 
           ...(isWH
             ? {
-                aqP: clampNumber(maxRq.rqGymnasticsPower - (scsh.tally.rqGymnasticsPower ?? 0), { min: 0 }),
-                aqM: clampNumber(maxRq.rqMultiples - (scsh.tally.rqMultiples ?? 0), { min: 0 }),
-                aqR: clampNumber(maxRq.rqRopeManipulation - (scsh.tally.rqRopeManipulation ?? 0), { min: 0 }),
-                aqI: clampNumber(maxRq.rqInteractions - (scsh.tally.rqInteractions ?? 0), { min: 0 }),
+                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
+                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
+                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
+                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
               }
             : {}
           ),
@@ -375,7 +377,7 @@ export const technicalJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+export const difficultyJudgeFactory: (id: string, name: string) => JudgeTypeGetter<string, string, Option> = (id, name) => options => {
   const maxRq = getRqMax(options)
   const isWH = options.discipline === 'wh'
 
@@ -403,18 +405,16 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   ] as const
   const levels: Record<string, number> = Object.fromEntries(Array(8).fill(undefined).map((el, idx) => [`diffL${idx + 1}`, idx + 1] as const))
   levels['diffL0.5'] = 0.5
-  // TODO: handle this being either Dp, Dm, Dr for SR or Da, Db for WH
-  const id = 'D'
   return {
     id,
-    // TODO: handle for the different judges
-    name: 'Difficulty',
+    name,
     markDefinitions: fieldDefinitions,
     tallyDefinitions: fieldDefinitions,
     calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
     calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (scsh.tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
         result: {
@@ -423,9 +423,9 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
           ...(isWH
             ? {}
             : {
-                aqP: clampNumber(maxRq.rqGymnasticsPower - (scsh.tally.rqGymnasticsPower ?? 0), { min: 0 }),
-                aqM: clampNumber(maxRq.rqMultiples - (scsh.tally.rqMultiples ?? 0), { min: 0 }),
-                aqR: clampNumber(maxRq.rqRopeManipulation - (scsh.tally.rqRopeManipulation ?? 0), { min: 0 }),
+                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
+                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
+                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
               }
           ),
         },
@@ -471,7 +471,7 @@ export default {
     { id: 'maxRqRopeManipulation', name: 'Rope Manipulation Required Elements', type: 'number', min: 0, step: 1 },
     { id: 'maxRqInteractions', name: 'Interactions Required Elements', type: 'number', min: 0, step: 1 },
   ],
-  judges: [presentationJudge, technicalJudge, difficultyJudge],
+  judges: [presentationJudge, technicalJudge, difficultyJudgeFactory('Dp', 'Difficulty - Power and Gymnastics'), difficultyJudgeFactory('Dm', 'Difficulty - Multiples'), difficultyJudgeFactory('Dr', 'Difficulty - Rope Manipulation')],
 
   calculateEntry (meta, res, options) {
     const results = res.filter(r => matchMeta(r.meta, meta))
diff --git a/lib/models/competition-events/ijru.freestyle@2.0.0.ts b/lib/models/competition-events/ijru.freestyle@2.0.0.ts
index 8751f1c..ee64578 100644
--- a/lib/models/competition-events/ijru.freestyle@2.0.0.ts
+++ b/lib/models/competition-events/ijru.freestyle@2.0.0.ts
@@ -1,6 +1,6 @@
 import { RSRWrongJudgeTypeError } from '../../errors'
-import { calculateTally, formatFactor, matchMeta, roundTo, roundToCurry } from '../../helpers'
-import { type ScoreTally, type JudgeTypeGetter, type JudgeFieldDefinition, type TableDefinition, type CompetitionEventModel } from '../types'
+import { filterTally, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
+import { type JudgeTypeGetter, type JudgeFieldDefinition, type TableDefinition, type CompetitionEventModel } from '../types'
 import { ijruAverage } from './ijru.freestyle@3.0.0'
 
 type Option = 'noMusicality' | 'discipline' | 'interactions'
@@ -24,10 +24,9 @@ export function L (l: number): number {
 // ======
 // JUDGES
 // ======
-export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const routinePresentationJudge: JudgeTypeGetter<Option> = options => {
   const noMusicality = options.noMusicality === true
 
-  type Schema = `entertainment${'Plus' | 'Check' | 'Minus'}` | `musicality${'Plus' | 'Check' | 'Minus'}`
   const fieldDefinitions = [
     {
       schema: 'entertainmentPlus',
@@ -75,10 +74,13 @@ export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options
   return {
     id,
     name: 'Routine Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<Schema> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const enTop = (tally.entertainmentPlus ?? 0) - (tally.entertainmentMinus ?? 0)
       const enBottom = (tally.entertainmentPlus ?? 0) + (tally.entertainmentCheck ?? 0) + (tally.entertainmentMinus ?? 0)
       const enAvg = enTop / (enBottom || 1)
@@ -104,7 +106,7 @@ export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options
   }
 }
 
-export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const athletePresentationJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Form and Execution +',
@@ -135,10 +137,13 @@ export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options
   return {
     id,
     name: 'Athlete Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const top = (tally.formExecutionPlus ?? 0) - (tally.formExecutionMinus ?? 0)
       const bottom = (tally.formExecutionPlus ?? 0) + (tally.formExecutionCheck ?? 0) + (tally.formExecutionMinus ?? 0)
       const avg = top / (bottom || 1)
@@ -155,7 +160,7 @@ export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options
   }
 }
 
-export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options => {
+export const requiredElementsJudge: JudgeTypeGetter<Option> = options => {
   const isDD = options.discipline === 'dd'
   const hasInteractions = options.interactions === true
   const fieldDefinitions = [
@@ -230,10 +235,12 @@ export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options =>
   return {
     id,
     name: 'Required Elements',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
 
       let score = rqFields.map(f => tally[f.schema] ?? 0).reduce((a, b) => a + b)
       score = score > max ? max : score
@@ -255,7 +262,7 @@ export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options =>
   }
 }
 
-export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+export const difficultyJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Level 0.5',
@@ -276,10 +283,13 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Difficulty',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const D = fieldDefinitions.map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
@@ -394,4 +404,4 @@ export default {
 
   previewTable: options => freestylePreviewTableHeaders,
   resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/ijru.freestyle@3.0.0.test.ts b/lib/models/competition-events/ijru.freestyle@3.0.0.test.ts
index 7902d63..95b6f8f 100644
--- a/lib/models/competition-events/ijru.freestyle@3.0.0.test.ts
+++ b/lib/models/competition-events/ijru.freestyle@3.0.0.test.ts
@@ -68,14 +68,18 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => judge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
+        () => judge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'S' }, marks: [] }),
+        new RSRWrongJudgeTypeError('S', 'Pr')
+      )
+      assert.throws(
+        () => judge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('S', 'Pr')
       )
     })
 
     await t.test('calculates a tally scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({
+        judge({}).calculateJudgeResult({
           meta,
           tally: {
             entertainmentPlus: 10,
@@ -93,7 +97,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('calculates a tally scoresheet with musicality turned off', () => {
       assert.deepStrictEqual(
-        judge({ noMusicality: true }).calculateScoresheet({
+        judge({ noMusicality: true }).calculateJudgeResult({
           meta,
           tally: {
             entertainmentPlus: 10,
@@ -111,7 +115,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Correct default values for empty scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({ meta, tally: {} }),
+        judge({}).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { aE: 0, aM: 0 }, statuses: {} }
       )
     })
@@ -131,14 +135,18 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => judge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
+        () => judge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'S' }, marks: [] }),
+        new RSRWrongJudgeTypeError('S', 'Pa')
+      )
+      assert.throws(
+        () => judge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('S', 'Pa')
       )
     })
 
     await t.test('calculates a tally scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({
+        judge({}).calculateJudgeResult({
           meta,
           tally: {
             formExecutionPlus: 10,
@@ -154,7 +162,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Correct default values for empty scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({ meta, tally: {} }),
+        judge({}).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { m: 1, aF: 0 }, statuses: {} }
       )
     })
@@ -174,14 +182,18 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => judge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
+        () => judge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'S' }, marks: [] }),
+        new RSRWrongJudgeTypeError('S', 'R')
+      )
+      assert.throws(
+        () => judge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('S', 'R')
       )
     })
 
     await t.test('calculates a tally scoresheet (SR, no interactions) with capping', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({
+        judge({}).calculateJudgeResult({
           meta,
           tally: {
             rqGymnasticsPower: 6,
@@ -201,7 +213,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('calculates a tally scoresheet (SR, interactions)', () => {
       assert.deepStrictEqual(
-        judge({ interactions: true }).calculateScoresheet({
+        judge({ interactions: true }).calculateJudgeResult({
           meta,
           tally: {
             rqGymnasticsPower: 3,
@@ -222,7 +234,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('calculates a tally scoresheet (DD, no interactions) with capping', () => {
       assert.deepStrictEqual(
-        judge({ discipline: 'dd' }).calculateScoresheet({
+        judge({ discipline: 'dd' }).calculateJudgeResult({
           meta,
           tally: {
             rqGymnasticsPower: 6,
@@ -243,7 +255,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('calculates a tally scoresheet (DD, interactions)', () => {
       assert.deepStrictEqual(
-        judge({ interactions: true, discipline: 'dd' }).calculateScoresheet({
+        judge({ interactions: true, discipline: 'dd' }).calculateJudgeResult({
           meta,
           tally: {
             rqGymnasticsPower: 6,
@@ -264,22 +276,22 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Correct default values for empty scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({ meta, tally: {} }),
+        judge({}).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { Q: 0.7, m: 1, v: 1 }, statuses: {} }
       )
 
       assert.deepStrictEqual(
-        judge({ interactions: true }).calculateScoresheet({ meta, tally: {} }),
+        judge({ interactions: true }).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { Q: 0.6, m: 1, v: 1 }, statuses: {} }
       )
 
       assert.deepStrictEqual(
-        judge({ discipline: 'dd' }).calculateScoresheet({ meta, tally: {} }),
+        judge({ discipline: 'dd' }).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { Q: 0.8, m: 1, v: 1 }, statuses: {} }
       )
 
       assert.deepStrictEqual(
-        judge({ interactions: true, discipline: 'dd' }).calculateScoresheet({ meta, tally: {} }),
+        judge({ interactions: true, discipline: 'dd' }).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { Q: 0.7, m: 1, v: 1 }, statuses: {} }
       )
     })
@@ -299,14 +311,18 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => judge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
+        () => judge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'S' }, marks: [] }),
+        new RSRWrongJudgeTypeError('S', 'D')
+      )
+      assert.throws(
+        () => judge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('S', 'D')
       )
     })
 
     await t.test('calculates a tally scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({
+        judge({}).calculateJudgeResult({
           meta,
           tally: {
             'diffL0.5': 1,
@@ -326,7 +342,7 @@ void test('ijru.freestyle@3.0.0', async t => {
 
     await t.test('Correct default values for empty scoresheet', () => {
       assert.deepStrictEqual(
-        judge({}).calculateScoresheet({ meta, tally: {} }),
+        judge({}).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { D: 0 }, statuses: {} }
       )
     })
diff --git a/lib/models/competition-events/ijru.freestyle@3.0.0.ts b/lib/models/competition-events/ijru.freestyle@3.0.0.ts
index 384691b..fe16202 100644
--- a/lib/models/competition-events/ijru.freestyle@3.0.0.ts
+++ b/lib/models/competition-events/ijru.freestyle@3.0.0.ts
@@ -1,6 +1,6 @@
 import { RSRWrongJudgeTypeError } from '../../errors.js'
-import { calculateTally, formatFactor, matchMeta, roundTo, roundToCurry } from '../../helpers.js'
-import type { CompetitionEventModel, JudgeFieldDefinition, JudgeTypeGetter, ScoreTally, TableDefinition } from '../types.js'
+import { filterTally, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers.js'
+import type { CompetitionEventModel, JudgeFieldDefinition, JudgeTypeGetter, TableDefinition } from '../types.js'
 
 type Option = 'noMusicality' | 'discipline' | 'interactions'
 
@@ -46,10 +46,9 @@ export const ijruAverage = (scores: number[]): number => {
 // ======
 // JUDGES
 // ======
-export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const routinePresentationJudge: JudgeTypeGetter<Option> = options => {
   const noMusicality = options.noMusicality === true
 
-  type Schema = `entertainment${'Plus' | 'Check' | 'Minus'}` | `musicality${'Plus' | 'Check' | 'Minus'}`
   const fieldDefinitions = [
     {
       schema: 'entertainmentPlus',
@@ -97,10 +96,13 @@ export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options
   return {
     id,
     name: 'Routine Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<Schema> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const enTop = 3 * ((tally.entertainmentPlus ?? 0) - (tally.entertainmentMinus ?? 0))
       const enBottom = (tally.entertainmentPlus ?? 0) + (tally.entertainmentCheck ?? 0) + (tally.entertainmentMinus ?? 0)
       const enAvg = enTop / (enBottom || 1)
@@ -126,7 +128,7 @@ export const routinePresentationJudge: JudgeTypeGetter<string, Option> = options
   }
 }
 
-export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const athletePresentationJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Form and Execution +',
@@ -157,10 +159,13 @@ export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options
   return {
     id,
     name: 'Athlete Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const top = 3 * ((tally.formExecutionPlus ?? 0) - (tally.formExecutionMinus ?? 0))
       const bottom = (tally.formExecutionPlus ?? 0) + (tally.formExecutionCheck ?? 0) + (tally.formExecutionMinus ?? 0)
       const avg = top / (bottom || 1)
@@ -177,7 +182,7 @@ export const athletePresentationJudge: JudgeTypeGetter<string, Option> = options
   }
 }
 
-export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options => {
+export const requiredElementsJudge: JudgeTypeGetter<Option> = options => {
   const isDD = options.discipline === 'dd'
   const hasInteractions = options.interactions === true
   const fieldDefinitions = [
@@ -245,10 +250,12 @@ export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options =>
   return {
     id,
     name: 'Required Elements',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
 
       let score = rqFields.map(f => tally[f.schema] ?? 0).reduce((a, b) => a + b)
       score = score > max ? max : score
@@ -267,7 +274,7 @@ export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options =>
   }
 }
 
-export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+export const difficultyJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Level 0.5',
@@ -296,10 +303,13 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Difficulty',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
+
       const D = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
@@ -412,4 +422,4 @@ export default {
 
   previewTable: options => freestylePreviewTableHeaders,
   resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/ijru.speed@1.0.0.test.ts b/lib/models/competition-events/ijru.speed@1.0.0.test.ts
index 38840bf..d0bbf9d 100644
--- a/lib/models/competition-events/ijru.speed@1.0.0.test.ts
+++ b/lib/models/competition-events/ijru.speed@1.0.0.test.ts
@@ -17,28 +17,32 @@ void test('ijru.speed@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => mod.speedJudge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'Shj' }, tally: { step: 5 } }),
+        () => mod.speedJudge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'Shj' }, marks: [] }),
+        new RSRWrongJudgeTypeError('Shj', 'S')
+      )
+      assert.throws(
+        () => mod.speedJudge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'Shj' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('Shj', 'S')
       )
     })
 
     await t.test('calculates a tally scoresheet', () => {
       assert.deepStrictEqual(
-        mod.speedJudge({}).calculateScoresheet({ meta, tally: { step: 5 } }),
+        mod.speedJudge({}).calculateJudgeResult({ meta, tally: { step: 5 } }),
         { meta, result: { a: 5 }, statuses: {} }
       )
     })
 
     await t.test('default to 0 for blank scoresheet', () => {
       assert.deepStrictEqual(
-        mod.speedJudge({}).calculateScoresheet({ meta, tally: {} }),
+        mod.speedJudge({}).calculateJudgeResult({ meta, tally: {} }),
         { meta, result: { a: 0 }, statuses: {} }
       )
     })
 
     await t.test('calculates a mark scoresheet', () => {
       assert.deepStrictEqual(
-        mod.speedJudge({}).calculateScoresheet({
+        mod.speedJudge({}).calculateTally({
           meta,
           marks: [
             { timestamp: Date.now(), sequence: 1, schema: 'step' },
@@ -47,7 +51,7 @@ void test('ijru.speed@3.0.0', async t => {
             { timestamp: Date.now(), sequence: 4, schema: 'step' },
           ],
         }),
-        { meta, result: { a: 2 }, statuses: {} }
+        { meta, tally: { step: 2 } }
       )
     })
   })
@@ -64,42 +68,46 @@ void test('ijru.speed@3.0.0', async t => {
 
     await t.test('Throws on incorrect meta.judgeTypeId', () => {
       assert.throws(
-        () => mod.speedHeadJudge({}).calculateScoresheet({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
+        () => mod.speedHeadJudge({}).calculateTally({ meta: { ...meta, judgeTypeId: 'S' }, marks: [] }),
+        new RSRWrongJudgeTypeError('S', 'Shj')
+      )
+      assert.throws(
+        () => mod.speedHeadJudge({}).calculateJudgeResult({ meta: { ...meta, judgeTypeId: 'S' }, tally: { step: 5 } }),
         new RSRWrongJudgeTypeError('S', 'Shj')
       )
     })
 
     await t.test('calculates a tally scoresheet', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({}).calculateScoresheet({ meta, tally: { step: 5 } }),
+        mod.speedHeadJudge({}).calculateJudgeResult({ meta, tally: { step: 5 } }),
         { meta, result: { a: 5, m: 0 }, statuses: {} }
       )
     })
 
     await t.test('calculates a tally scoresheet with false start', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({}).calculateScoresheet({ meta, tally: { step: 11, falseStart: 2 } }),
+        mod.speedHeadJudge({}).calculateJudgeResult({ meta, tally: { step: 11, falseStart: 2 } }),
         { meta, result: { a: 11, m: 10 }, statuses: {} }
       )
     })
 
     await t.test('calculates a tally scoresheet with false switches and false start', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({ falseSwitches: 2 }).calculateScoresheet({ meta, tally: { step: 11, falseSwitch: 2, falseStart: 1 } }),
+        mod.speedHeadJudge({ falseSwitches: 2 }).calculateJudgeResult({ meta, tally: { step: 11, falseSwitch: 2, falseStart: 1 } }),
         { meta, result: { a: 11, m: 30 }, statuses: {} }
       )
     })
 
     await t.test('calculates a tally scoresheet with capped false switches', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({ falseSwitches: 1 }).calculateScoresheet({ meta, tally: { step: 11, falseSwitch: 2 } }),
+        mod.speedHeadJudge({ falseSwitches: 1 }).calculateJudgeResult({ meta, tally: { step: 11, falseSwitch: 2 } }),
         { meta, result: { a: 11, m: 10 }, statuses: {} }
       )
     })
 
     await t.test('calculates a mark scoresheet', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({}).calculateScoresheet({
+        mod.speedHeadJudge({}).calculateTally({
           meta,
           marks: [
             { timestamp: Date.now(), sequence: 1, schema: 'step' },
@@ -108,13 +116,13 @@ void test('ijru.speed@3.0.0', async t => {
             { timestamp: Date.now(), sequence: 4, schema: 'step' },
           ],
         }),
-        { meta, result: { a: 2, m: 0 }, statuses: {} }
+        { meta, tally: { step: 2 } }
       )
     })
 
     await t.test('calculates a mark scoresheet with false start', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({}).calculateScoresheet({
+        mod.speedHeadJudge({}).calculateTally({
           meta,
           marks: [
             { timestamp: Date.now(), sequence: 1, schema: 'falseStart' },
@@ -124,13 +132,13 @@ void test('ijru.speed@3.0.0', async t => {
             { timestamp: Date.now(), sequence: 5, schema: 'step' },
           ],
         }),
-        { meta, result: { a: 2, m: 10 }, statuses: {} }
+        { meta, tally: { step: 2, falseStart: 1 } }
       )
     })
 
     await t.test('calculates a mark scoresheet with false switches', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({ falseSwitches: 1 }).calculateScoresheet({
+        mod.speedHeadJudge({ falseSwitches: 1 }).calculateTally({
           meta,
           marks: [
             { timestamp: Date.now(), sequence: 1, schema: 'step' },
@@ -140,13 +148,13 @@ void test('ijru.speed@3.0.0', async t => {
             { timestamp: Date.now(), sequence: 5, schema: 'step' },
           ],
         }),
-        { meta, result: { a: 2, m: 10 }, statuses: {} }
+        { meta, tally: { step: 2, falseSwitch: 1 } }
       )
     })
 
     await t.test('calculates a mark scoresheet with capped false switches', () => {
       assert.deepStrictEqual(
-        mod.speedHeadJudge({ falseSwitches: 1 }).calculateScoresheet({
+        mod.speedHeadJudge({ falseSwitches: 1 }).calculateTally({
           meta,
           marks: [
             { timestamp: Date.now(), sequence: 1, schema: 'step' },
@@ -157,7 +165,7 @@ void test('ijru.speed@3.0.0', async t => {
             { timestamp: Date.now(), sequence: 6, schema: 'falseSwitch' },
           ],
         }),
-        { meta, result: { a: 2, m: 10 }, statuses: {} }
+        { meta, tally: { step: 2, falseSwitch: 1 } }
       )
     })
   })
@@ -178,9 +186,9 @@ void test('ijru.speed@3.0.0', async t => {
       }
       const options = { falseSwitches: 3 }
       const scores = [
-        mod.speedHeadJudge(options).calculateScoresheet({ meta: jMeta('1', 'Shj'), tally: { step: 11, falseStart: 0, falseSwitch: 0 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('2'), tally: { step: 10 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('3'), tally: { step: 10 } }),
+        mod.speedHeadJudge(options).calculateJudgeResult({ meta: jMeta('1', 'Shj'), tally: { step: 11, falseStart: 0, falseSwitch: 0 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('2'), tally: { step: 10 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('3'), tally: { step: 10 } }),
       ]
       const result = mod.default.calculateEntry(eMeta, scores, options)
       assert.deepStrictEqual(result, {
@@ -205,9 +213,9 @@ void test('ijru.speed@3.0.0', async t => {
     await t.test('With false starts and switches', () => {
       const options = { falseSwitches: 3 }
       const scores = [
-        mod.speedHeadJudge(options).calculateScoresheet({ meta: jMeta('1', 'Shj'), tally: { step: 24, falseStart: 1, falseSwitch: 1 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('2'), tally: { step: 25 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('3'), tally: { step: 26 } }),
+        mod.speedHeadJudge(options).calculateJudgeResult({ meta: jMeta('1', 'Shj'), tally: { step: 24, falseStart: 1, falseSwitch: 1 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('2'), tally: { step: 25 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('3'), tally: { step: 26 } }),
       ]
       const result = mod.default.calculateEntry(eMeta, scores, options)
       assert.deepStrictEqual(result, {
@@ -220,9 +228,9 @@ void test('ijru.speed@3.0.0', async t => {
     await t.test('Not within three', () => {
       const options = { falseSwitches: 3 }
       const scores = [
-        mod.speedHeadJudge(options).calculateScoresheet({ meta: jMeta('1', 'Shj'), tally: { step: 10, falseStart: 0, falseSwitch: 0 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('2'), tally: { step: 15 } }),
-        mod.speedJudge(options).calculateScoresheet({ meta: jMeta('3'), tally: { step: 20 } }),
+        mod.speedHeadJudge(options).calculateJudgeResult({ meta: jMeta('1', 'Shj'), tally: { step: 10, falseStart: 0, falseSwitch: 0 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('2'), tally: { step: 15 } }),
+        mod.speedJudge(options).calculateJudgeResult({ meta: jMeta('3'), tally: { step: 20 } }),
       ]
       const result = mod.default.calculateEntry(eMeta, scores, options)
       assert.deepStrictEqual(result, {
diff --git a/lib/models/competition-events/ijru.speed@1.0.0.ts b/lib/models/competition-events/ijru.speed@1.0.0.ts
index bf3f11f..501822e 100644
--- a/lib/models/competition-events/ijru.speed@1.0.0.ts
+++ b/lib/models/competition-events/ijru.speed@1.0.0.ts
@@ -1,6 +1,6 @@
 import { RSRWrongJudgeTypeError } from '../../errors.js'
-import { calculateTally, matchMeta, roundTo } from '../../helpers.js'
-import type { CompetitionEventModel, JudgeTypeGetter, ScoreTally, TableDefinition } from '../types.js'
+import { filterTally, matchMeta, roundTo, simpleCalculateTallyFactory } from '../../helpers.js'
+import type { CompetitionEventModel, JudgeTypeGetter, TableDefinition } from '../types.js'
 import { ijruAverage } from './ijru.freestyle@3.0.0.js'
 
 type Option = 'falseSwitches'
@@ -11,7 +11,7 @@ const SpeedDed = 10
 // ======
 // JUDGES
 // ======
-export const speedJudge: JudgeTypeGetter<string, Option> = options => {
+export const speedJudge: JudgeTypeGetter< Option> = options => {
   const fieldDefinitions = [{
     schema: 'step',
     name: 'Score',
@@ -22,10 +22,12 @@ export const speedJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Speed',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       return {
         meta: scsh.meta,
         result: {
@@ -37,7 +39,7 @@ export const speedJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const speedHeadJudge: JudgeTypeGetter<string, Option> = options => {
+export const speedHeadJudge: JudgeTypeGetter<Option> = options => {
   const falseSwitches = Number.isSafeInteger(options.falseSwitches) && options.falseSwitches as number > 0 ? options.falseSwitches as number : undefined
   const fieldDefinitions = [
     {
@@ -67,10 +69,12 @@ export const speedHeadJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Speed Head Judge',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       return {
         meta: scsh.meta,
         result: {
@@ -166,4 +170,4 @@ export default {
 
   previewTable: options => speedPreviewTableHeaders,
   resultTable: options => speedResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/svgf-rh.freestyle@2020.ts b/lib/models/competition-events/svgf-rh.freestyle@2020.ts
index 7803ca7..527d61a 100644
--- a/lib/models/competition-events/svgf-rh.freestyle@2020.ts
+++ b/lib/models/competition-events/svgf-rh.freestyle@2020.ts
@@ -1,5 +1,5 @@
 import { RSRWrongJudgeTypeError } from '../../errors'
-import { calculateTally, clampNumber, matchMeta, roundTo, roundToCurry } from '../../helpers'
+import { clampNumber, filterMarkStream, filterTally, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
 import { type ScoreTally, type JudgeTypeGetter, type TableDefinition, type CompetitionEventModel } from '../types'
 import { ijruAverage } from './ijru.freestyle@3.0.0'
 
@@ -13,7 +13,7 @@ export function L (l: number): number {
 // ======
 // JUDGES
 // ======
-export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+export const difficultyJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Level 0.5',
@@ -34,10 +34,12 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Difficulty',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       const D = fieldDefinitions.map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
@@ -50,7 +52,7 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const presentationJudge: JudgeTypeGetter<Option> = options => {
   const isDD = options.discipline === 'dd'
   const fieldDefinitions = [
     {
@@ -105,12 +107,26 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
       step: 0.5,
     },
   ]
+  const id = 'P'
   return {
-    id: 'P',
+    id,
     name: 'Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      let tally: ScoreTally = {}
+
+      for (const mark of filterMarkStream(scsh.marks)) {
+        tally[mark.schema] = mark.value
+      }
+
+      tally = filterTally(tally, fieldDefinitions)
+
+      return { meta: scsh.meta, tally }
+    },
+    calculateJudgeResult: scsh => {
+      const tally = filterTally(scsh.tally, fieldDefinitions)
 
       const score = fieldDefinitions.map(f => tally[f.schema] ?? 0).reduce((a, b) => a + b)
 
@@ -227,4 +243,4 @@ export default {
 
   previewTable: options => freestylePreviewTableHeaders,
   resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/svgf-vh.freestyle@2023.ts b/lib/models/competition-events/svgf-vh.freestyle@2023.ts
index 0bfa163..562bf50 100644
--- a/lib/models/competition-events/svgf-vh.freestyle@2023.ts
+++ b/lib/models/competition-events/svgf-vh.freestyle@2023.ts
@@ -1,5 +1,5 @@
 import { RSRWrongJudgeTypeError } from '../../errors.js'
-import { calculateTally, clampNumber, formatFactor, matchMeta, roundTo, roundToCurry } from '../../helpers.js'
+import { clampNumber, filterMarkStream, filterTally, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers.js'
 import type { CompetitionEventModel, JudgeFieldDefinition, JudgeTypeGetter, ScoreTally, TableDefinition } from '../types.js'
 import { average } from './svgf-vh.speed@2023.js'
 
@@ -13,7 +13,7 @@ export function L (l: number): number {
 // ======
 // JUDGES
 // ======
-export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
+export const difficultyJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       name: 'Level 0.5',
@@ -34,10 +34,12 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Difficulty',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       const D = fieldDefinitions.map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
       return {
         meta: scsh.meta,
@@ -50,7 +52,7 @@ export const difficultyJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
+export const presentationJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [
     {
       schema: 'musicOnBeat',
@@ -86,10 +88,23 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Presentation',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      let tally: ScoreTally = {}
+
+      for (const mark of filterMarkStream(scsh.marks)) {
+        tally[mark.schema] = mark.value
+      }
+
+      tally = filterTally(tally, fieldDefinitions)
+
+      return { meta: scsh.meta, tally }
+    },
+    calculateJudgeResult: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
 
       const score = fieldDefinitions.map(f => tally[f.schema] ?? 0).reduce((a, b) => a + b)
 
@@ -104,7 +119,7 @@ export const presentationJudge: JudgeTypeGetter<string, Option> = options => {
   }
 }
 
-export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options => {
+export const requiredElementsJudge: JudgeTypeGetter<Option> = options => {
   const isDD = options.discipline === 'dd'
   let fieldDefinitions: Array<JudgeFieldDefinition<string>>
 
@@ -190,10 +205,12 @@ export const requiredElementsJudge: JudgeTypeGetter<string, Option> = options =>
   return {
     id,
     name: 'Obligatoriska',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
 
       const completed = fieldDefinitions
         .map<number>(f => (tally[f.schema] ?? 0) >= 1 ? 1 : 0)
@@ -322,4 +339,4 @@ export default {
 
   previewTable: options => freestylePreviewTableHeaders,
   resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/svgf-vh.speed@2023.ts b/lib/models/competition-events/svgf-vh.speed@2023.ts
index e001075..56f0db2 100644
--- a/lib/models/competition-events/svgf-vh.speed@2023.ts
+++ b/lib/models/competition-events/svgf-vh.speed@2023.ts
@@ -1,6 +1,6 @@
 import { RSRWrongJudgeTypeError } from '../../errors.js'
-import { calculateTally, matchMeta, roundTo, roundToCurry } from '../../helpers.js'
-import type { CompetitionEventModel, JudgeTypeGetter, ScoreTally, TableDefinition } from '../types.js'
+import { filterTally, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers.js'
+import type { CompetitionEventModel, JudgeTypeGetter, TableDefinition } from '../types.js'
 
 type Option = never
 
@@ -12,7 +12,7 @@ export function average (scores: number[]): number {
 // ======
 // JUDGES
 // ======
-export const speedJudge: JudgeTypeGetter<string, Option> = options => {
+export const speedJudge: JudgeTypeGetter<Option> = options => {
   const fieldDefinitions = [{
     schema: 'step',
     name: 'Score',
@@ -23,10 +23,12 @@ export const speedJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Speed',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions: fieldDefinitions,
+    tallyDefinitions: fieldDefinitions,
+    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally = filterTally(scsh.tally, fieldDefinitions)
       return {
         meta: scsh.meta,
         result: {
@@ -97,4 +99,4 @@ export default {
 
   previewTable: options => speedPreviewTableHeaders,
   resultTable: options => speedResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/competition-events/svgf-vh.timing@2023.ts b/lib/models/competition-events/svgf-vh.timing@2023.ts
index f62785c..862f1c0 100644
--- a/lib/models/competition-events/svgf-vh.timing@2023.ts
+++ b/lib/models/competition-events/svgf-vh.timing@2023.ts
@@ -1,5 +1,5 @@
 import { RSRWrongJudgeTypeError } from '../../errors.js'
-import { calculateTally, matchMeta, roundTo, roundToCurry } from '../../helpers.js'
+import { filterMarkStream, filterTally, matchMeta, roundTo, roundToCurry } from '../../helpers.js'
 import type { CompetitionEventModel, JudgeTypeGetter, ScoreTally, TableDefinition } from '../types.js'
 import { average } from './svgf-vh.speed@2023.js'
 
@@ -8,8 +8,15 @@ type Option = never
 // ======
 // JUDGES
 // ======
-export const timingJudge: JudgeTypeGetter<string, Option> = options => {
-  const fieldDefinitions = [{
+export const timingJudge: JudgeTypeGetter<Option> = options => {
+  const markDefinitions = [{
+    schema: 'start',
+    name: 'Start Timer',
+  }, {
+    schema: 'pause',
+    name: 'Pause Timer',
+  }] as const
+  const tallyDefinitions = [{
     schema: 'seconds',
     name: 'Seconds',
     min: 0,
@@ -19,10 +26,29 @@ export const timingJudge: JudgeTypeGetter<string, Option> = options => {
   return {
     id,
     name: 'Timing',
-    fieldDefinitions,
-    calculateScoresheet: scsh => {
+    markDefinitions,
+    tallyDefinitions,
+    calculateTally: scsh => {
+      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
+      const tally: ScoreTally<(typeof tallyDefinitions)[number]['schema']> = {}
+
+      let lastStart: undefined | number
+      for (const mark of filterMarkStream(scsh.marks)) {
+        if (lastStart == null && mark.schema === 'start') {
+          lastStart = mark.timestamp
+        } else if (lastStart != null && mark.schema === 'pause') {
+          tally.seconds = (tally.seconds ?? 0) + Math.round((mark.timestamp - lastStart) / 1000)
+        }
+      }
+
+      return {
+        meta: scsh.meta,
+        tally,
+      }
+    },
+    calculateJudgeResult: scsh => {
       if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally: ScoreTally<(typeof fieldDefinitions)[number]['schema']> = calculateTally(scsh, fieldDefinitions)
+      const tally: ScoreTally<(typeof tallyDefinitions)[number]['schema']> = filterTally(scsh.tally, tallyDefinitions)
       return {
         meta: scsh.meta,
         result: {
@@ -93,4 +119,4 @@ export default {
 
   previewTable: options => timingPreviewTableHeaders,
   resultTable: options => timingResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>
diff --git a/lib/models/types.ts b/lib/models/types.ts
index f7cc675..0bfae59 100644
--- a/lib/models/types.ts
+++ b/lib/models/types.ts
@@ -35,7 +35,7 @@ export interface JudgeType<MarkSchema extends string, TallySchema extends string
   calculateJudgeResult: (scoresheet: TallyScoresheet<TallySchema>) => JudgeResult
 }
 
-export type JudgeTypeGetter<Schema extends string = string, Option extends string = string> = (options: Options<Option>) => Readonly<JudgeType<Schema>>
+export type JudgeTypeGetter<Option extends string = string, MarkSchema extends string = string, TallySchema extends string = string> = (options: Options<Option>) => Readonly<JudgeType<MarkSchema, TallySchema>>
 
 export interface JudgeMarkDefinition<Schema extends string> {
   /**
@@ -200,8 +200,8 @@ export interface BaseModel<Option extends string> {
 }
 
 // TODO: optional panel configuration to be used for checks that all judges have scored
-export interface CompetitionEventModel<Schema extends string = string, Option extends string = string> extends BaseModel<Option> {
-  judges: Array<JudgeTypeGetter<Schema, Option>>
+export interface CompetitionEventModel<Option extends string = string, MarkSchema extends string = string, TallySchema extends string = string> extends BaseModel<Option> {
+  judges: Array<JudgeTypeGetter<Option, MarkSchema, TallySchema>>
 
   previewTable: TableDefinitionGetter<Option>
   resultTable: TableDefinitionGetter<Option>

From 8ccbd3b1f5bd24b0f0a7704f9f63d1689b0d2bf7 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:28:35 +0200
Subject: [PATCH 5/6] update WIP rules to latest version

---
 lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
index 9d65ea4..a97d89c 100644
--- a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
+++ b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
@@ -43,7 +43,7 @@ export function L (l: number): number {
 // ======
 // JUDGES
 // ======
-export const presentationJudge: JudgeTypeGetter<string, string, Option> = options => {
+export const presentationJudge: JudgeTypeGetter<Option> = options => {
   const components = ['ent', 'form', 'music', 'crea', 'vari'] as const
   const markDefinitions = [
     {
@@ -264,7 +264,7 @@ export const presentationJudge: JudgeTypeGetter<string, string, Option> = option
   }
 }
 
-export const technicalJudge: JudgeTypeGetter<string, string, Option> = options => {
+export const technicalJudge: JudgeTypeGetter<Option> = options => {
   const isWH = options.discipline === 'wh'
   const hasInteractions = options.interactions === true
 
@@ -377,7 +377,7 @@ export const technicalJudge: JudgeTypeGetter<string, string, Option> = options =
   }
 }
 
-export const difficultyJudgeFactory: (id: string, name: string) => JudgeTypeGetter<string, string, Option> = (id, name) => options => {
+export const difficultyJudgeFactory: (id: string, name: string) => JudgeTypeGetter<Option> = (id, name) => options => {
   const maxRq = getRqMax(options)
   const isWH = options.discipline === 'wh'
 
@@ -537,4 +537,4 @@ export default {
 
   previewTable: options => freestylePreviewTableHeaders,
   resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<string, Option>
+} satisfies CompetitionEventModel<Option>

From 05239bd118ee816b50797e0c96b1d81da926b5c7 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:34:42 +0200
Subject: [PATCH 6/6] remove ijru@4 rules for now

---
 .../ijru.freestyle.sr@4.0.0.ts                | 540 ------------------
 lib/rulesets/ijru@4.0.0.ts                    |  49 --
 2 files changed, 589 deletions(-)
 delete mode 100644 lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
 delete mode 100644 lib/rulesets/ijru@4.0.0.ts

diff --git a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts b/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
deleted file mode 100644
index a97d89c..0000000
--- a/lib/models/competition-events/ijru.freestyle.sr@4.0.0.ts
+++ /dev/null
@@ -1,540 +0,0 @@
-import { RSRWrongJudgeTypeError } from '../../errors'
-import { clampNumber, filterMarkStream, filterTally, formatFactor, matchMeta, roundTo, roundToCurry, simpleCalculateTallyFactory } from '../../helpers'
-import type { CompetitionEventModel, JudgeTypeGetter, Options, ScoreTally, TableDefinition } from '../types'
-
-type Option = 'discipline' | 'interactions' |
-  'maxRqGymnasticsPower' | 'maxRqMultiples' | 'maxRqRopeManipulation' |
-  'maxRqInteractions'
-
-// pres
-const Fp = 0.6
-const presWeights = {
-  ent: 0.25,
-  form: 0.25,
-  music: 0.2,
-  crea: 0.15,
-  vari: 0.15,
-}
-
-// deduc
-const Fv = 0.05
-const Fb = 0.05
-const Fq = 0.025
-const Fm1 = 0.05
-const Fm2 = 0.075
-const Fm = 0.1
-
-// reqEl
-export function getRqMax (options: Options<Option>) {
-  return {
-    rqGymnasticsPower: typeof options.maxRqGymnasticsPower === 'number' ? options.maxRqGymnasticsPower : 6,
-    rqMultiples: typeof options.maxRqMultiples === 'number' ? options.maxRqMultiples : 6,
-    rqRopeManipulation: typeof options.maxRqRopeManipulation === 'number' ? options.maxRqRopeManipulation : 6,
-    rqInteractions: typeof options.maxRqInteractions === 'number' ? options.maxRqInteractions : 6,
-  }
-}
-
-// diff
-export function L (l: number): number {
-  if (l === 0) return 0
-  return roundTo(0.1 * Math.pow(1.5, l), 2)
-}
-
-// ======
-// JUDGES
-// ======
-export const presentationJudge: JudgeTypeGetter<Option> = options => {
-  const components = ['ent', 'form', 'music', 'crea', 'vari'] as const
-  const markDefinitions = [
-    {
-      schema: 'entPlus',
-      name: 'Entertainment +',
-    },
-    {
-      schema: 'entMinus',
-      name: 'Entertainment -',
-    },
-
-    {
-      schema: 'formPlus',
-      name: 'Form/Execution +',
-    },
-    {
-      schema: 'formMinus',
-      name: 'Form/Execution -',
-    },
-
-    {
-      schema: 'musicPlus',
-      name: 'Musicality +',
-    },
-    {
-      schema: 'musicMinus',
-      name: 'Musicality -',
-    },
-
-    {
-      schema: 'creaPlus',
-      name: 'Creativity +',
-    },
-    {
-      schema: 'creaMinus',
-      name: 'Creativity -',
-    },
-
-    {
-      schema: 'variPlus',
-      name: 'Variety +',
-    },
-    {
-      schema: 'variMinus',
-      name: 'Repetitive -',
-    },
-
-    {
-      schema: 'miss',
-      name: 'Miss',
-    },
-
-    {
-      schema: 'entPlusAdj',
-      name: 'Adjustment Entertainment +',
-    },
-    {
-      schema: 'entMinusAdj',
-      name: 'Adjustment Entertainment -',
-    },
-
-    {
-      schema: 'formPlusAdj',
-      name: 'Adjustment Form/Execution +',
-    },
-    {
-      schema: 'formMinusAdj',
-      name: 'Adjustment Form/Execution -',
-    },
-
-    {
-      schema: 'musicPlusAdj',
-      name: 'Adjustment Musicality +',
-    },
-    {
-      schema: 'musicMinusAdj',
-      name: 'Adjustment Musicality -',
-    },
-
-    {
-      schema: 'creaPlusAdj',
-      name: 'Adjustment Creativity +',
-    },
-    {
-      schema: 'creaMinusAdj',
-      name: 'Adjustment Creativity -',
-    },
-
-    {
-      schema: 'variPlusAdj',
-      name: 'Adjustment Variety +',
-    },
-    {
-      schema: 'variMinusAdj',
-      name: 'Adjustment Repetitive -',
-    },
-  ] as const
-  const tallyDefinitions = [
-    {
-      schema: 'ent',
-      name: 'Entertainment',
-      min: 0,
-      max: 24,
-      step: 1,
-    },
-    {
-      schema: 'form',
-      name: 'Form/Execution',
-      min: 0,
-      max: 24,
-      step: 1,
-    },
-    {
-      schema: 'music',
-      name: 'Musicality',
-      min: 0,
-      max: 24,
-      step: 1,
-    },
-    {
-      schema: 'crea',
-      name: 'Creativity',
-      min: 0,
-      max: 24,
-      step: 1,
-    },
-    {
-      schema: 'vari',
-      name: 'Variety',
-      min: 0,
-      max: 24,
-      step: 1,
-    },
-    {
-      schema: 'miss',
-      name: 'Miss',
-      min: 0,
-      step: 1,
-    },
-  ] as const
-  const tallyDefMap = new Map(tallyDefinitions.map(d => [d.schema, d]))
-  type TallySchema = typeof tallyDefinitions[number]['schema']
-  const id = 'P'
-  return {
-    id,
-    name: 'Presentation',
-    markDefinitions,
-    tallyDefinitions,
-    calculateTally: scsh => {
-      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const marks = filterMarkStream(scsh.marks)
-      const tally: Required<ScoreTally<TallySchema>> = {
-        ent: 12,
-        form: 12,
-        music: 12,
-        crea: 12,
-        vari: 12,
-        miss: 0,
-      }
-
-      const stageOneMarks = ['miss', ...components.flatMap(c => [`${c}Plus`, `${c}Minus`])]
-
-      for (const mark of marks) {
-        if (stageOneMarks.includes(mark.schema)) {
-          const sign = mark.schema.endsWith('Minus') ? -1 : 1
-          const schema = mark.schema.replace(/(Plus|Minus)$/, '') as TallySchema
-
-          tally[schema] = tally[schema] + ((mark.value ?? 1) * sign)
-        }
-      }
-
-      for (const field of tallyDefinitions) {
-        const v = tally[field.schema]
-        if (typeof v !== 'number') continue
-        tally[field.schema] = clampNumber(v, field)
-      }
-
-      const stageTwoMarks = components.flatMap(c => [`${c}PlusAdj`, `${c}MinusAdj`])
-
-      for (const mark of marks) {
-        if (stageTwoMarks.includes(mark.schema)) {
-          const sign = mark.schema.endsWith('MinusAdj') ? -1 : 1
-          const schema = mark.schema.replace(/(Plus|Minus)Adj$/, '') as TallySchema
-          const field = tallyDefMap.get(schema)
-          if (field == null) throw new TypeError(`Could not find tally field with schema ${schema} - This error should not occur.`)
-
-          if (sign > 0 && 'max' in field && tally[schema] >= field.max) continue
-          if (sign < 0 && 'min' in field && tally[schema] <= field.min) continue
-
-          tally[schema] = tally[schema] + ((mark.value ?? 1) * sign)
-        }
-      }
-
-      return { meta: scsh.meta, tally }
-    },
-    calculateJudgeResult: scsh => {
-      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally = filterTally(scsh.tally, tallyDefinitions)
-      let p = 0
-
-      for (const component of components) {
-        let cScore = (tally[component] ?? 12) - (tally.miss ?? 0)
-        cScore = clampNumber(cScore, { min: 0, max: 24, step: 1 })
-
-        p += cScore * presWeights[component]
-      }
-      p = clampNumber(p, { min: 0, max: 24 })
-
-      return {
-        meta: scsh.meta,
-        result: {
-          p,
-          nm: tally.miss ?? 0,
-        },
-        statuses: {},
-      }
-    },
-  }
-}
-
-export const technicalJudge: JudgeTypeGetter<Option> = options => {
-  const isWH = options.discipline === 'wh'
-  const hasInteractions = options.interactions === true
-
-  const maxRq = getRqMax(options)
-
-  const fieldDefinitions = [
-    {
-      schema: 'timeViolation',
-      name: 'Time Violations',
-      min: 0,
-      max: 2,
-      step: 1,
-    },
-    {
-      schema: 'spaceViolation',
-      name: 'Space Violations',
-      min: 0,
-      step: 1,
-    },
-    {
-      schema: 'miss',
-      name: 'Misses',
-      min: 0,
-      step: 1,
-    },
-    {
-      schema: 'break',
-      name: 'Breaks',
-      min: 0,
-      step: 1,
-    },
-
-    ...(isWH
-      ? [{
-          schema: 'rqGymnasticsPower',
-          name: 'Power/Gymnastics',
-          min: 0,
-          max: maxRq.rqGymnasticsPower,
-          step: 1,
-        }, {
-          schema: 'rqMultiples',
-          name: 'Multiples',
-          min: 0,
-          max: maxRq.rqMultiples,
-          step: 1,
-        }, {
-          schema: 'rqRopeManipulation',
-          name: 'Rope manipulation',
-          min: 0,
-          max: maxRq.rqRopeManipulation,
-          step: 1,
-        }, {
-          schema: 'rqInteractions',
-          name: 'Partner interactions',
-          min: 0,
-          max: maxRq.rqInteractions,
-          step: 1,
-        }]
-      : []
-    ),
-
-    ...(!isWH && hasInteractions
-      ? [{
-          schema: 'rqInteractions',
-          name: 'Pairs interactions',
-          min: 0,
-          max: maxRq.rqInteractions,
-          step: 1,
-        }]
-      : []
-    ),
-  ]
-  const id = 'T'
-  return {
-    id,
-    name: 'Technical Judge',
-    markDefinitions: fieldDefinitions,
-    tallyDefinitions: fieldDefinitions,
-    calculateTally: simpleCalculateTallyFactory(id, fieldDefinitions),
-    calculateJudgeResult: scsh => {
-      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally = filterTally(scsh.tally, fieldDefinitions)
-      return {
-        meta: scsh.meta,
-        result: {
-          nm: tally.miss ?? 0,
-          nb: tally.break ?? 0,
-          nv: (tally.timeViolation ?? 0) + (tally.spaceViolation ?? 0),
-
-          ...(isWH
-            ? {
-                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
-                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
-                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
-                aqI: clampNumber(maxRq.rqInteractions - (tally.rqInteractions ?? 0), { min: 0 }),
-              }
-            : {}
-          ),
-
-          ...(!isWH && hasInteractions
-            ? {
-                aqI: clampNumber(maxRq.rqInteractions - (scsh.tally.rqInteractions ?? 0), { min: 0 }),
-              }
-            : {}
-          ),
-        },
-        statuses: {},
-      }
-    },
-  }
-}
-
-export const difficultyJudgeFactory: (id: string, name: string) => JudgeTypeGetter<Option> = (id, name) => options => {
-  const maxRq = getRqMax(options)
-  const isWH = options.discipline === 'wh'
-
-  const fieldDefinitions = [
-    {
-      name: 'Level 0.5',
-      schema: 'diffL0.5',
-      min: 0,
-      step: 1,
-    },
-    ...Array(8).fill(undefined).map((el, idx) => ({
-      name: `Level ${idx + 1}`,
-      schema: `diffL${idx + 1}` as const,
-      min: 0,
-      step: 1,
-    })),
-
-    // Not used in any math, just for tracking
-    {
-      name: 'Repeated Skills',
-      schema: 'rep',
-      min: 0,
-      step: 1,
-    },
-  ] as const
-  const levels: Record<string, number> = Object.fromEntries(Array(8).fill(undefined).map((el, idx) => [`diffL${idx + 1}`, idx + 1] as const))
-  levels['diffL0.5'] = 0.5
-  return {
-    id,
-    name,
-    markDefinitions: fieldDefinitions,
-    tallyDefinitions: fieldDefinitions,
-    calculateTally: simpleCalculateTallyFactory<string>(id, fieldDefinitions),
-    calculateJudgeResult: scsh => {
-      if (!matchMeta(scsh.meta, { judgeTypeId: id })) throw new RSRWrongJudgeTypeError(scsh.meta.judgeTypeId, id)
-      const tally = filterTally(scsh.tally, fieldDefinitions)
-      const d = fieldDefinitions.filter(f => f.schema !== 'rep').map(f => (tally[f.schema] ?? 0) * L(levels[f.schema])).reduce((a, b) => a + b)
-      return {
-        meta: scsh.meta,
-        result: {
-          d,
-
-          ...(isWH
-            ? {}
-            : {
-                aqP: clampNumber(maxRq.rqGymnasticsPower - (tally.rqGymnasticsPower ?? 0), { min: 0 }),
-                aqM: clampNumber(maxRq.rqMultiples - (tally.rqMultiples ?? 0), { min: 0 }),
-                aqR: clampNumber(maxRq.rqRopeManipulation - (tally.rqRopeManipulation ?? 0), { min: 0 }),
-              }
-          ),
-        },
-        statuses: {},
-      }
-    },
-  }
-}
-
-// ======
-// TABLES
-// ======
-export const freestylePreviewTableHeaders: TableDefinition = {
-  headers: [
-    { text: 'Diff (D)', key: 'D', formatter: roundToCurry(2) },
-    { text: 'Pres (P)', key: 'P', formatter: formatFactor },
-    { text: 'Req. El (Q)', key: 'Q', formatter: formatFactor },
-    { text: 'Deduc (M)', key: 'M', formatter: formatFactor },
-    { text: 'Result (R)', key: 'R', formatter: roundToCurry(2) },
-  ],
-}
-
-export const freestyleResultTableHeaders: TableDefinition = {
-  headers: [
-    { text: 'Diff', key: 'D', color: 'gray', formatter: roundToCurry(2) },
-    { text: 'Pres', key: 'P', color: 'gray', formatter: formatFactor },
-    { text: 'Req. El', key: 'Q', color: 'gray', formatter: formatFactor },
-    { text: 'Deduc', key: 'M', color: 'gray', formatter: formatFactor },
-
-    { text: 'Score', key: 'R', formatter: roundToCurry(2), primary: 'score' },
-    { text: 'Rank', key: 'S', color: 'red', primary: 'rank' },
-  ],
-}
-
-export default {
-  id: 'ijru.freestyle.sr@4.0.0',
-  name: 'IJRU Single Rope Freestyle v4.0.0',
-  options: [
-    { id: 'discipline', name: 'Discipline', type: 'enum', enum: ['sr', 'dd', 'wh', 'ts', 'xd'] },
-    { id: 'interactions', name: 'Has Interactions', type: 'boolean' },
-    { id: 'maxRqGymnasticsPower', name: 'Power/Gymnastics Required Elements', type: 'number', min: 0, step: 1 },
-    { id: 'maxRqMultiples', name: 'Multiples Required Elements', type: 'number', min: 0, step: 1 },
-    { id: 'maxRqRopeManipulation', name: 'Rope Manipulation Required Elements', type: 'number', min: 0, step: 1 },
-    { id: 'maxRqInteractions', name: 'Interactions Required Elements', type: 'number', min: 0, step: 1 },
-  ],
-  judges: [presentationJudge, technicalJudge, difficultyJudgeFactory('Dp', 'Difficulty - Power and Gymnastics'), difficultyJudgeFactory('Dm', 'Difficulty - Multiples'), difficultyJudgeFactory('Dr', 'Difficulty - Rope Manipulation')],
-
-  calculateEntry (meta, res, options) {
-    const results = res.filter(r => matchMeta(r.meta, meta))
-    if (!results.length) return
-
-    const raw: Record<string, number> = {}
-
-    // for (const scoreType of ['D', 'aF', 'aE', 'aM', 'm', 'v', 'Q'] as const) {
-    //   const scores = results.map(el => el.result[scoreType]).filter(el => typeof el === 'number')
-    //   if (['m', 'v'].includes(scoreType)) raw[scoreType] = roundTo(ijruAverage(scores), 4)
-    //   else if (['aF', 'aE', 'aM'].includes(scoreType)) raw[scoreType] = roundTo(ijruAverage(scores), 6)
-    //   else raw[scoreType] = roundTo(ijruAverage(scores), 2) // D, Q
-
-    //   if (typeof raw[scoreType] !== 'number' || isNaN(Number(raw[scoreType]))) raw[scoreType] = (['D', 'aF', 'aE', 'aM'].includes(scoreType) ? 0 : 1)
-    //   if (scoreType === 'aM' && noMusic) raw[scoreType] = 0
-    // }
-
-    // raw.M = roundTo(-(1 - raw.m - raw.v), 2) // the minus is because they're already prepped to 1- and that needs to be reversed
-
-    // raw.P = roundTo(1 + (raw.aE + raw.aF + raw.aM), 2)
-
-    // raw.R = roundTo(raw.D * raw.P * raw.M * raw.Q, 2)
-    // raw.R = raw.R < 0 ? 0 : raw.R
-
-    return {
-      meta,
-      result: raw,
-      statuses: {},
-    }
-  },
-  rankEntries (res, options) {
-    let results = [...res]
-    // const tiePriority = ['R', 'M', 'Q', 'P', 'D'] as const
-    results.sort(function (a, b) {
-      if (a.result.R !== b.result.R) return (b.result.R ?? 0) - (a.result.R ?? 0) // descending 100 wins over 50
-      if (a.result.M !== b.result.M) return (b.result.M ?? 1) - (a.result.M ?? 1) // descending *1 wins over *.9
-      if (a.result.Q !== b.result.Q) return (b.result.Q ?? 1) - (a.result.Q ?? 1) // descending *1 wins over *.9
-      if (a.result.P !== b.result.P) return (b.result.P ?? 1) - (a.result.P ?? 1) // descending 1.35 wins over 0.95
-      if (a.result.D !== b.result.D) return (b.result.D ?? 0) - (a.result.D ?? 0) // descending 100 wins over 50
-      return 0
-    })
-
-    const high = results.length > 0 ? results[0].result.R ?? 0 : 0
-    const low = results.length > 1 ? results[results.length - 1].result.R ?? 0 : 0
-
-    results = results.map((el, idx, arr) => ({
-      ...el,
-      result: {
-        ...el.result,
-        S: arr.findIndex(score =>
-          score.result.R === el.result.R &&
-          score.result.M === el.result.M &&
-          score.result.Q === el.result.Q &&
-          score.result.P === el.result.P &&
-          score.result.D === el.result.D
-        ) + 1,
-        N: roundTo((((100 - 1) * ((el.result.R ?? 0) - low)) / ((high - low) !== 0 ? high - low : 1)) + 1, 2),
-      },
-    }))
-
-    return results
-  },
-
-  previewTable: options => freestylePreviewTableHeaders,
-  resultTable: options => freestyleResultTableHeaders,
-} satisfies CompetitionEventModel<Option>
diff --git a/lib/rulesets/ijru@4.0.0.ts b/lib/rulesets/ijru@4.0.0.ts
deleted file mode 100644
index 7a5499b..0000000
--- a/lib/rulesets/ijru@4.0.0.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { type Ruleset } from './types.js'
-
-import ijruSpeed100 from '../models/competition-events/ijru.speed@1.0.0.js'
-import ijruOverall100 from '../models/overalls/ijru.overall@1.0.0.js'
-
-import eIjruSpDdDdsr44x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.dd.ddsr.4.4x30@1.0.0.js'
-import eIjruSpDdDdss360100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.dd.ddss.3.60@1.0.0.js'
-import eIjruSpSrSrdr22x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srdr.2.2x30@1.0.0.js'
-import eIjruSpSrSrse1180100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srse.1.180@1.0.0.js'
-import eIjruSpSrSrsr44x30100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srsr.4.4x30@1.0.0.js'
-import eIjruSpSrSrss130100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srss.1.30@1.0.0.js'
-import eIjruSpSrSrtu10100 from '../preconfigured/competition-events/ijru/1.0.0/e.ijru.sp.sr.srtu.1.0@1.0.0.js'
-
-export default {
-  id: 'ijru@4.0.0',
-  name: 'IJRU v4.0.0',
-  competitionEvents: [
-    eIjruSpSrSrss130100,
-    eIjruSpSrSrse1180100,
-    eIjruSpSrSrtu10100,
-    // eIjruFsSrSrif175400,
-
-    eIjruSpSrSrsr44x30100,
-    eIjruSpSrSrdr22x30100,
-    eIjruSpDdDdsr44x30100,
-    eIjruSpDdDdss360100,
-
-    // eIjruFsSrSrpf275400,
-    // eIjruFsSrSrtf475400,
-    // eIjruFsDdDdsf375400,
-    // eIjruFsDdDdpf475400,
-    // eIjruFsDdDdtf590400,
-    // eIjruFsWhWhpf275400,
-
-    // TODO: DDC
-  ],
-  overalls: [
-    // eIjruOaSrIsro10400,
-    // eIjruOaXdTxdo40400,
-  ],
-  competitionEventModels: [
-    // ijruFreestyleSrwh400,
-    // ijruFreestyleDd400,
-    ijruSpeed100,
-  ],
-  overallModels: [
-    ijruOverall100,
-  ],
-} satisfies Ruleset