From b6ba9b03d33eeb58d35ded0e1170a0211a104de2 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:36:30 +0200
Subject: [PATCH 1/4] separate calcualteScoresheet into calculateTally and
 calculateJudgeResult + separate tallyFieldDefinitions (#30)

fixes #32
---
 lib/helpers.test.ts                           | 59 +++++++++++--
 lib/helpers.ts                                | 84 ++++++++++++-------
 .../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                           | 34 ++++++--
 12 files changed, 374 insertions(+), 184 deletions(-)

diff --git a/lib/helpers.test.ts b/lib/helpers.test.ts
index 560f8cd..3ed3b8a 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 { simpleCalculateTallyFactory, 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,7 +70,52 @@ void test('helpers', async t => {
     assert.strictEqual(formatFactor(1.1), '+10 %')
   })
 
-  await t.test('calculateTally', async t => {
+  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('simpleCalculateTallyFactory', async t => {
     const meta: JudgeMeta = {
       judgeId: '1',
       judgeTypeId: 'S',
@@ -78,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>> = [
@@ -93,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', () => {
@@ -107,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 3f807a6..4f4ad2d 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,47 @@ 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
+}
+
+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
  *
@@ -85,41 +128,22 @@ 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)
+    let tally: ScoreTally<Schema> = isTallyScoresheet<Schema>(scoresheet) ? { ...(scoresheet.tally ?? {}) } : {}
 
-  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)
+    for (const mark of filterMarkStream(scoresheet.marks)) {
+      tally[mark.schema as Schema] = (tally[mark.schema as Schema] ?? 0) + (mark.value ?? 1)
     }
-  }
 
-  if (allowedSchemas != null) {
-    const extra = Object.keys(tally).filter(schema => !allowedSchemas.includes(schema as Schema))
+    tally = filterTally(tally, fieldDefinitions)
 
-    // @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 {
+      meta: scoresheet.meta,
+      tally,
+    }
   }
-
-  return tally
 }
 
 /**
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 7694cfb..0bfae59 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 type JudgeTypeGetter<Option extends string = string, MarkSchema extends string = string, TallySchema extends string = string> = (options: Options<Option>) => Readonly<JudgeType<MarkSchema, TallySchema>>
 
-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 */
@@ -184,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 7ce7960a2f333c8c8dc033dea657a8dd362b0300 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:55:40 +0200
Subject: [PATCH 2/4] fix lint

---
 lib/index.ts               | 2 +-
 lib/preconfigured/types.ts | 4 ++--
 package.json               | 2 +-
 tsconfig.eslint.json       | 3 +++
 4 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/lib/index.ts b/lib/index.ts
index 786a7da..39590f7 100644
--- a/lib/index.ts
+++ b/lib/index.ts
@@ -1,7 +1,7 @@
 export {
   filterParticipatingInAll,
   parseCompetitionEventDefinition,
-  calculateTally,
+  filterMarkStream,
   isMarkScoresheet,
   isTallyScoresheet,
 } from './helpers.js'
diff --git a/lib/preconfigured/types.ts b/lib/preconfigured/types.ts
index 2acd861..f3264d9 100644
--- a/lib/preconfigured/types.ts
+++ b/lib/preconfigured/types.ts
@@ -12,13 +12,13 @@ export interface PartiallyConfigureCompetitionEventModelOptions<Option extends s
   name: string
   options: Options<Option>
 }
-export function partiallyConfigureCompetitionEventModel <Schema extends string, Option extends string> (model: CompetitionEventModel<Schema, Option>, options: PartiallyConfigureCompetitionEventModelOptions<Option>): CompetitionEvent {
+export function partiallyConfigureCompetitionEventModel <Option extends string> (model: CompetitionEventModel<Option>, options: PartiallyConfigureCompetitionEventModelOptions<Option>): CompetitionEvent {
   return {
     id: options.id,
     modelId: model.id,
     name: options.name,
     options: model.options.filter(o => !(o.id in options.options)),
-    judges: model.judges.map(j => ((o: Partial<Record<Option, unknown>>) => j({ ...o, ...options.options })) as JudgeTypeGetter),
+    judges: model.judges.map(j => ((o: Partial<Record<Option, unknown>>) => j({ ...o, ...options.options })) as JudgeTypeGetter<Option>),
     calculateEntry (meta, results, o) {
       return model.calculateEntry(meta, results, { ...o, ...options.options })
     },
diff --git a/package.json b/package.json
index 094205b..d744dcc 100644
--- a/package.json
+++ b/package.json
@@ -32,7 +32,7 @@
     "validate": "tsx bin/validate.ts",
     "lint:code": "eslint .",
     "lint:fix": "npm run lint:code -- --fix",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --project tsconfig.eslint.json --noEmit",
     "build": "npm run build:data && npm run build:code",
     "build:code": "tsc -b",
     "build:data": "tsx bin/generate-lists.ts",
diff --git a/tsconfig.eslint.json b/tsconfig.eslint.json
index ac50451..ce7d486 100644
--- a/tsconfig.eslint.json
+++ b/tsconfig.eslint.json
@@ -4,12 +4,15 @@
     "composite": true,
     "checkJs": true,
     "noEmit": true,
+    "outDir": "dist",
+    "resolveJsonModule": true
   },
   "include": [
     "**/*.ts",
     "**/*.js",
     "./*.mjs",
     "./.*.js",
+    "./data/*.json"
   ],
   "exclude": [
     "dist",

From 0942726bef52c939ee2dd2d9125dac8524968550 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:56:24 +0200
Subject: [PATCH 3/4] 0.9.0

---
 package-lock.json | 4 ++--
 package.json      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index e132181..404537c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@ropescore/rulesets",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ropescore/rulesets",
-      "version": "0.8.0",
+      "version": "0.9.0",
       "license": "MIT",
       "devDependencies": {
         "@tsconfig/node20": "^20.1.4",
diff --git a/package.json b/package.json
index d744dcc..2f4a248 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ropescore/rulesets",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Collection of rulesets to calculate rope skipping results",
   "author": "Svante Bengtson <svante@swantzter.se> (https://swantzter.se)",
   "license": "MIT",

From 2ad69b7d27c2367b212c55887cac426246899983 Mon Sep 17 00:00:00 2001
From: Svante Bengtson <svante@swantzter.se>
Date: Sun, 22 Sep 2024 20:59:44 +0200
Subject: [PATCH 4/4] fix gpr publich

---
 .github/workflows/publish.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index cc26a2b..985ccb3 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -24,6 +24,11 @@ jobs:
 
   publish-gpr:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+      packages: write
+      attestations: write
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3