Appearance
Multi-stage events (carnivals)
Audience: Event organisers and timing operators running a competition scored across more than one day or race.
A multi-stage event is one competition decided over several races — an Easter 3 Days, a summer carnival, a two-race sprint weekend, a winter league. Manager models it as a container that references two or more ordinary events as its stages. Each stage is a completely normal meshO Manager event: it has its own classes, courses, competitors, start times, card downloads and results, and it runs on the day exactly as a standalone event does. The container adds what a carnival needs on top — matching each runner across the stages, combining their results into overall standings, and generating chase starts for a later stage.
Status: New in this release, and still evolving. See What isn't supported yet.
Are multi-day events a separate kind of event? No — and that is the whole design. There is no "multi-day event type" to choose at creation and no separate mode to run the day in. Every stage is an ordinary event, so everything you already know still applies; the container sits above them and is the only new thing to learn.
The vocabulary
| Term | What it means |
|---|---|
| Multi-stage event | The container: the carnival as a whole. Appears as one row on the Events page. |
| Stage | One race of the carnival, numbered from 1. Each stage is an ordinary event (or a placeholder for one that doesn't exist yet). |
| Placeholder stage | A stage you have declared but whose event doesn't exist yet — a planned day. |
| Standing | One competitor's combined result across the stages: their per-stage contributions, a total, and a position. |
| Identity | One person, matched across the stages. Two stage entries that are the same runner share one identity, and therefore one standing. |
| Scoring method | How a stage result becomes a number to combine — total time, points, a place→points table, a formula of your own, and more. |
| Chase start | A start list for a later stage where each competitor starts at their deficit behind the leader, so the first across the line wins. Also called a pursuit start. |
Creating a carnival
From scratch
Click New Event on the Events page. The dialog offers three cards — Individual, Relay and Multi-stage. Choose Multi-stage, and the card asks you for one thing only:
| Field | What it does |
|---|---|
| Kind | Carnival — stages scored and combined into overall standings, which is everything this page describes. Or Knock-out — rounds whose field comes from the round before, described on Knock-out competitions. Chosen once: it cannot be changed after the container is created. |
Click Create. Manager makes a Carnival with three placeholder stages on consecutive days starting today, names it after the day of the week, and opens it at its overview. (A Knock-out gets no placeholder stages — its rounds are created from a template instead.)
Why it doesn't ask for a name, a date or a stage count. It used to. A name, a first date and a number of stages chosen before the competition exists are guesses you revise anyway, so the dialog seeds sensible ones and gets out of your way. Rename the carnival and set its real dates on the Stages tab, where you can also add, remove and reorder stages. Nothing seeded here is fixed.
From Eventor
An Eventor event that has several races (Eventor's own multi-day forms) can be imported as a carnival in one step. In the same dialog, choose Multi-stage with the kind set to Carnival, then click Import from Eventor and pick the event. Manager creates the container — named after the Eventor event — and imports one meshO event per Eventor race, splitting the entries by race and attaching each as a stage. The Eventor route is hidden when the kind is set to Knock-out, since a knock-out's rounds come from a template rather than from an entry list.
Note: This is also a bug fix. The old single-event import derived its date from the first race and created exactly one event however many races the Eventor event had — importing a 3 Days silently produced stage 1 only. Import it as multi-stage and you get three stages.
If you pick an Eventor event that has only one race, Manager tells you so and creates nothing, rather than making a one-stage carnival you would then have to unpick.
From events you have already created
If the events already exist — you set up each day separately, or a previous day has already been run — create the container as above and then attach each event to a stage on the Stages tab. Attaching changes nothing about the event itself; it only records that it belongs to this carnival.
Where a carnival appears on the Events page
A multi-stage event renders as one row, with its stages nested under it:
▾ Australian 3 Days 2027 Multi-stage · 3 stages
Stage 1 — Prologue Fri 26 Mar Complete
Stage 2 Sat 27 Mar ● Live
Stage 3 — Chase Sun 28 Mar Upcoming- The group is collapsed by default, and expanded automatically when one of its stages is live or dated today.
- Clicking the group header opens the carnival's overview.
- Clicking a stage row opens that stage's event, exactly as clicking any event card does. Everything about running a stage is unchanged.
- A stage never also appears as a standalone row — an event belongs to at most one carnival.
- The group is Upcoming if any of its stages is upcoming, otherwise History — so a carnival half-run stays in front of you rather than disappearing into History.
- A badge on the header shows how many cross-stage identities are waiting for a decision (see Matching competitors).
Inside a stage, the app bar shows a breadcrumb back to the carnival, plus previous/next stage navigation.
The carnival overview
Opening the group header lands you on the overview — on the Stages tab, which is where a carnival's next move usually is. There are five tabs:
| Tab | What it's for |
|---|---|
| Stages | The stage list — name the carnival, add, remove, reorder, create or attach events, counting flags and weights. |
| Standings | The overall result: position, per-stage columns, total, status. Live. |
| Scoring | How stage results combine: method, best-N, tie-breaks, per-class overrides. |
| Chase starts | Generate a chase (pursuit) start into a later stage. |
| Competitors | Cross-stage identity: who is the same person in which stages. |
A knock-out competition shows a different set — Bracket, Rounds, Classification and Stages. See Knock-out competitions.
The Stages tab
This is where you name the carnival and lay out its stages. A Name field sits above the table — the carnival's own name, seeded from the day of the week when you created it, so this is usually the first thing you change.
Below it, one row per stage, in order:
| Column | What it does |
|---|---|
| Stage | The stage number, 1..N. Always contiguous — removing a stage renumbers the rest. |
| Event | The stage's event, as a link. A stage with no event yet reads Not yet created. |
| Date | The event's date once the event exists; the planned date while it's a placeholder. |
| Event Data | A summary of what's in the stage event so far — how many classes and competitors, and how many have results. |
| Counts | Whether this stage counts toward the standings. Off for a training race or a prologue that only seeds the chase. |
| Weight | Multiplies this stage's contribution — 2 for a double-points final, 0.5 for a half-weight prologue. |
| Optional | When on, a competitor who missed this stage isn't penalised for it. |
| Actions | The ⋮ menu — see below. |
A stage has no name of its own. There is no Name column: a stage is identified by its number, and by the name of the event attached to it. If you want stage 1 to read Prologue, name its event Prologue. The carnival's own name is the field above the table.
Add stage at the foot of the table adds another placeholder.
The ⋮ menu on each row offers:
- Move up / Move down — reorder, which renumbers.
- Create event — creates a new event pre-filled from the stage's planned date and attaches it. The quickest route from "we're planning three days" to three real events. Only offered while the stage has no event.
- Use existing event — attaches an event you have already created. Only events that aren't already part of some carnival are offered, because an event belongs to at most one container.
- Detach event — removes the link but leaves the event alone: it becomes a standalone event again, with all its data. Removing a stage, or deleting the whole container, does the same — stage events are never deleted with the carnival.
- Copy entries from… — see below.
- Remove stage.
Copy entries from another stage
Most carnivals run the same field every day, and typing it in twice is nobody's idea of a good time. Copy entries from… brings another stage's classes and entered competitors across into this one, choosing whether to copy classes, competitors, or both.
What travels is the entry and nothing else: names, clubs, cards and bibs — no times, no statuses, no results. A class of the same name is reused rather than duplicated, and anyone already entered in this stage is left alone, so running it twice is safe and the confirmation tells you how much was already there as well as how much was added.
One catch it warns you about: a competitor has to be in a class, so if you copy competitors without their classes, anyone whose class isn't in this stage yet is left behind. Copy the classes too.
Note: A list of more than ten stages draws an advisory note. There's no hard limit, but a long list is far more often a mistake than a real carnival.
The tab also raises advisory notes when the stage flags and the scoring settings disagree — for example, marking stages optional when the scoring never drops one, or setting a best-N that can never drop anything.
Matching competitors across the stages
Each stage has its own competitor list, with its own competitor records. Before anything can be combined, Manager has to work out who is the same person in which stages. This is the part of a carnival that most often goes wrong in practice, so it is explicit and reviewable rather than hidden.
How Manager matches
Signals are tried strongest first. The top four match automatically:
| Rank | Signal | Notes |
|---|---|---|
| 1 | Registry ID | The Competitor Registry entry behind the entry. The strongest signal available. |
| 2 | IOF ID | The competitor's IOF person ID, where the entries carry one. |
| 3 | Registration number | The external entry id (e.g. Eventor's), with its provider. |
| 4 | Name and club | Used only when it isn't ambiguous — a name+club that names two people in the same stage is twins (or a duplicate entry), so it isn't used to merge them at all. |
Then two weaker signals:
| Rank | Signal | Notes |
|---|---|---|
| 5 | Name only | Also matched automatically, but only when no club contradicts it — that is, when at most one of the entries records a club at all. A field entered by hand often carries no ids and no club, and leaving those runners unmatched isn't a neutral outcome: they drop silently out of the standings and out of any chase seeded from them. Where the same name appears under two different clubs, the merge is not made — it becomes a Suggested identity for you to decide. |
| 6 | Card number | Off by default, and only ever a suggestion. Hire cards are reassigned between stages, so card matching can merge two different people into one standing. Turn on Match on card number only when everyone uses their own card. |
What this means in practice. Two entries with the same name and nothing else to go on will be merged for you. That is deliberate — the alternative loses people from the results — but it is the one automatic merge that can be wrong on a large field with common names. Two runners called Sam Taylor, both entered by hand with no club, become one standing. Check the Matched panel for a carnival where hand entry is the norm; splitting them takes one click.
The Competitors tab
Identities are grouped into four panels:
- Matched — automatically matched on a strong signal. Each shows what it matched on. Use Split off this stage if it's really two people.
- Suggested — a weak signal suggests these are the same person. Confirm to merge them, or leave them separate.
- Ambiguous — two competitors of one stage resolved to the same person. Their standing is blocked until you decide, because publishing a total for someone who might be two people is worse than publishing nothing for them.
- One stage only — appears in a single stage. Normal for a late entry or someone running one day.
Confirming a suggestion or splitting an identity is remembered: a split is a targeted rejection of that particular grouping, so rejecting a name-based suggestion doesn't stop the same runner being matched by their registry ID later. A rejected suggestion isn't offered again.
Changed your mind about a split? The entry you split off carries a Rejoin action. Rejoining records the two as one person again — in the standings, and in every chase seeded from them. So a split made under time pressure is not a one-way door.
Where an identity was matched only by name, Manager notes that adding the competitor to the Competitor Registry would match them by ID at future events instead of by name — the durable fix.
The switch at the top of the tab is Match on card number (rank 6 above), with its warning about hire cards. Refresh re-runs the matching, and once nothing is left to decide the tab says so.
Dropping a stage for one competitor
Sometimes a stage cannot be made right. Day 1's timing data is lost for one runner, the jury agrees to drop the day for them, and there is nothing to correct in the stage itself — the stage is fine, it just should not count for that person.
Each stage cell on this tab carries a Drop this stage for this competitor button. It asks for a reason, which is required and is recorded with the decision, then:
- The stage's own result is left exactly as it is — the day's own results list is unchanged, and so is every export of it.
- It stops counting towards that competitor's overall standing, which shows the stage struck through and labelled Excluded for this competitor by the operator.
- The cell here shows the time struck through too, with your reason on the tooltip.
Count this stage again puts it back, and needs no reason.
This is the only way to change what a stage contributes without changing the stage. There is deliberately no way to type in a time or a score for a stage somebody has no result in — that would make the standing impossible to reproduce from the stages, which is the guarantee the whole carnival rests on.
Classes across stages
Classes are linked between stages by exact name — M21A in stage 1 is M21A in stage 2. This is the same rule most timing software uses, and it is what makes the standings work without you configuring anything.
Keep class names identical across your stages. A class named M21A on day 1 and M21 A on day 2 is two different classes, and everybody in it will fall out of the combined standings. Renaming the class on the later stage is the fix.
When a competitor's class genuinely differs between stages — they moved up an age class between days, or were entered in the wrong one — they are listed under their latest class and are not ranked in the earlier one. This is deliberate: a total combining two different classes is a wrong result nobody notices.
Not yet available in the UI. Both of these have settings behind them — a table mapping differently-named classes to each other, and a policy choosing what a class change does. Neither has a screen yet, so today the behaviour is exactly as described above: exact-name linking, and a class change means no ranking. If your carnival needs something else, say so.
Scoring
The Scoring tab decides how a stage result becomes a number, and how the numbers combine.
Choosing a method
Thirteen built-in methods are offered, in this order:
| Method | What it scores |
|---|---|
| Total time (default) | Adds up the stage times. The fastest total wins. |
| Total time behind | Adds up how far behind each stage winner a competitor finished, so a long stage cannot dominate the total just by being long. |
| Points, scaled ratio (Scottish) | The winner scores the points scale you set and everyone else scores in proportion: the scale × the winner's time ÷ their own. A scale of 1000 is the Scottish method; 800 and 1200 are also in use. |
| Standard (z-score) | Measures a run against the spread of the field: 1000 points for an average time, and 200 more for each standard deviation faster. Comparable across very different courses. |
| Percent of winner | The winner scores 100; a score is that competitor's percentage of the winning run. |
| Percent behind | The winner scores the full points scale, and every one percent behind the winner costs a point. |
| Kilometre rate | The pace each competitor ran: stage time divided by course length, in minutes per kilometre. A stage with no course length scores nothing. |
| Points from par (Welsh) | Scores against par, the mean time of the leading half of the field: par is 1250 points, and each one percent from par is worth six. |
| Median-normalised | Measured against the median time rather than the winner, so one exceptional run does not compress everybody else. A median run scores the full points scale. |
| Points less minutes behind (Danish) | The winner scores the full points scale, and each whole minute behind costs one point. Runners inside the same minute tie. |
| Fixed place points (Brazilian) | Scores by place from an F1-style table: 100 for the win, then 85, 75, 68 and so on down to 1 point for 35th. |
| Reverse place | Scores by place counted from the back: the winner scores the number of starters, and last place still scores 1. |
| Participation | Every eligible finish scores the same, whatever the time. |
Where is "Place points"? Scoring from a place→points table is not offered as a built-in, because a built-in has no table to read — it would score everybody nothing. Author one as a custom method of the Place table kind instead; see below.
Whichever you pick, the rest of the tab is the same:
- Combine stages by — Sum, Average, Best stage, or Count of stages.
- Count best N stages — keep only each competitor's best N counting stages. Blank counts them all. The dropped stage stays visible in the standings, struck through and labelled Dropped as the worst counting stage — never silently hidden.
- Rounding and Decimals — applied once, to the final total, not stage by stage.
- Tie-breaks — applied in order until one separates the tied competitors: better final stage, better single stage, count back by stage, or share the position.
- Per-class scoring — override any of the above for one class. Carnivals commonly score elite classes on total time and junior classes on points with a dropped worst stage.
Custom methods
If none of the built-ins is your federation's rule, build your own on the Scoring tab via New custom method. Two kinds:
Formula — an expression evaluated per competitor per stage, e.g. maxPoints * winnerTime / time. Variables cover the competitor's own run (time, place), the stage's field (winnerTime, meanTime, medianTime, stdDev, parTime, starters, finishers), the course (courseLengthKm) and the carnival (stageNumber, stageCount, maxPoints). Times are in seconds. The functions are min, max, abs, round, floor, ceil, sqrt, pow, clamp and if. The editor lists them all, inserts them on click, validates as you type, and points at the exact character where an expression is wrong.
Place table — points per finishing place: rows of from place, to place, points, plus points for places beyond the table. A fill-down helper builds long tables quickly. This is how you score from a place→points table, including the Nordic and club-league tables.
Tied places. The editor offers a choice of how shared places are handled — average the tied places, or give every tied runner the highest or the lowest. It has no effect yet: whichever you choose, a tied runner currently scores the points for their own place. If your rules depend on it, check the result before relying on it.
Both show a live preview against your carnival's real results while you edit, so you can see what the rule does before applying it.
Note: A method is snapshotted into the carnival when you select it. Editing the global method afterwards does not silently change published standings — the carnival tells you the method has changed and offers Update to latest when you're ready. Renaming a method isn't a scoring change.
Standings
The Standings tab is the overall result.
| Column | What it shows |
|---|---|
| Pos | Overall position. Blank when the competitor isn't ranked. |
| Competitor / Club | The identity's name and club. |
| Stage 1..N | That stage's contribution. A stage that didn't count is struck through, with a tooltip saying why. |
| Total | The combined total, with * while it's provisional. |
| Status | Complete, Provisional, Incomplete or Not ranked. |
Standings update live. A card downloaded at stage 3 updates the overall within about half a second — nothing to press, no recompute step in the normal flow. (There is a Recompute action, under the Actions menu, for the rare case where you want to force it — for example straight after changing something outside Manager.)
Choosing what to show
The Class selector at the top offers more than one class at a time:
- A single class — the ordinary view, one class ranked on its own.
- All classes — every class, one after another.
- Combined (all classes) and Combined (selected classes) — one ranking pooled across classes. This is what you want for an overall carnival prize, or a club competition ranked across age classes.
Combining is only offered when it is honest. If the classes aren't all scored the same way, or the method's scores don't mean the same thing from one class to another — total time across a 3 km and a 9 km course, say — Manager refuses rather than producing a league table of unlike things. Scoring the classes on a method that normalises across courses (Standard z-score, Percent of winner, Median-normalised) is what makes a combined ranking meaningful.
Two more controls sit alongside: Show (all, or the top N) and Times (show or hide the per-stage columns), for cutting the table down to something you can read on a screen or hand to a prize-giving.
Warnings you might see
Two banners appear above the table when something is wrong, and both mean the standings in front of you are not the whole truth:
- A stage could not be read. "Stage N could not be read, so these standings are missing it." Usually the stage's event is open somewhere else — another Manager window, another operator's machine. Close it, then Recompute.
- The scoring method isn't in this build. "This carnival is scored by X, which this version of meshO does not have." No standings are produced at all, deliberately — scoring by a different method would be worse than scoring by none. Choose a method on the Scoring tab, or update Manager.
Why a stage didn't count
The tooltip on a struck-through cell always names the reason:
| Reason | Meaning |
|---|---|
| This stage does not count toward the standings | The stage's Counts flag is off. |
| Dropped as the worst counting stage | Best-N is in force and this was the dropped stage. |
| The stage result cannot be counted | The stage status can't produce a result — MP, DNF, DSQ, over time, or an OK with no running time. |
| No result in this stage | Didn't start, didn't enter, or hasn't finished yet. |
| Excluded for this competitor by the operator | You dropped this stage for this competitor — see Dropping a stage for one competitor. |
What the overall statuses mean
| Status | Meaning |
|---|---|
| Complete | Every required stage counted. A normal, final overall result. |
| Provisional | Something is still in progress or preliminary — a stage still running, or a preliminary (radio-derived) result. The total is real but may change; it carries *. |
| Incomplete | A required counting stage produced no countable result. Under a time-based method they have no overall time and no position — the standard carnival rule. Under a points method they still carry a total and a position; the missed stage scores zero. |
| Not ranked | Never rankable: an unresolved ambiguous identity, or a status like Out of Competition / No Timing. |
An optional stage forgives a missed stage entirely — no penalty and no Incomplete.
Chase starts
A chase (pursuit) start sets each competitor's start time in a later stage to their deficit behind the leader, so the finishing order across the line is the overall result. Generate it on the Chase starts tab.
The settings are grouped into three sections.
Chase
| Setting | What it does |
|---|---|
| Chase into | The stage the start times are written into. |
| Standings after | Which stages the deficits come from — usually every stage before the target. |
| Classes | One class, or all of them. |
Start times
| Setting | What it does |
|---|---|
| Mode | Interval draw, Chase (leader first), Reversed chase (leader last), Seeded interval start (leader first) or Seeded interval start (leader last). |
| Leader starts at | The time of day the overall leader sets off. |
| Time scaling | Compresses the gaps — 0.5 halves every deficit. Chase modes only. |
| Round to (seconds) | Rounds the computed times. Chase modes only. |
| Maximum time after | The cutoff. Anyone further behind than this goes into the restart block. Chase modes only. |
| Start interval | The gap between starters. Seeded interval modes only — they have no cutoff and no restart block, so the whole class goes off in standing order from the first start. |
Restart block (chase modes only)
| Setting | What it does |
|---|---|
| Restart block begins | When the block sets off. |
| Restart block starts | At intervals, or All together — the mass restart most carnivals run for the competitors who are out of the chase. |
| Restart interval | How far apart its starters are, when starting at intervals. |
Preview shows the full plan before anything is written — each competitor's gap, current start time, new start time, and whether they're in the restart block. Apply writes the times into the target stage's competitors as ordinary allocated start times, so everything downstream (start lists, exports, the start-time cascade, the audit trail) works with no special handling.
Points to know:
- The restart block catches everyone outside the cutoff, anyone unranked, and anyone with no standing at all (a late entry to the final stage). They start in standing order, at even intervals from the restart time or all together.
- Applying twice is safe. The second run writes nothing, because nothing changed. Regenerate freely after a correction.
- A competitor who already punched a start in the target stage is flagged in the preview.
- Competitors on identical computed times are left together. They are level on the standings, and separating them would be a handicap nobody raced for. There is no setting for this — the behaviour other software calls start pairwise is simply always on.
- Nobody entered in the target stage yet? The preview says so, and offers to copy the classes and entries from an earlier stage — the same Copy entries operation, from where you are already standing.
Points-based scoring cannot be chased
A chase is a race against a time gap, and a points method has none. If a class is scored on points, Manager refuses to build a chase for it and says so on that class's card: "{class} is scored on points, so there are no time gaps to chase. Score it on time to generate chase starts." Other classes in the same carnival that are scored on time preview normally alongside it.
It is refused rather than quietly turned into something else. If it degenerated into an interval start, your first start, cutoff and scaling would all be silently ignored, and what came out would look like a chase that had gone wrong rather than a start list anyone chose. If an interval start in standings order is what you want, ask for it — that is the Seeded interval start mode, on a class scored by time.
Exporting a carnival
The Standings tab's Actions menu holds both exports, next to Recompute.
Overall standings as CSV — Export CSV. One row per competitor, one column per stage, plus the total. A stage that didn't count is bracketed rather than blanked, and a provisional total carries *, so the spreadsheet says the same thing the screen did. Export one class, or all of them.
Overall standings as PDF — Export PDF. The table as you have it on screen, laid out for printing or pinning up: whatever class or combined view you have selected, and whichever of the Show and Times options you have set. This is the one to reach for at prize-giving.
IOF XML — export a stage's results the usual way. When the event is a stage of a carnival, the file additionally carries the stage's raceNumber and each competitor's overall standing as an IOF OverallResult — the standard's own answer to multi-stage results, which makes the output consumable by SplitsBrowser, Eventor and Livelox with no bespoke format. A standalone event's export is unchanged.
Live results, screens and splits work per stage exactly as they always do.
A worked carnival
A three-day Easter carnival, days 2 and 3 counting, day 3 a chase:
- New Event → Multi-stage → Carnival. Create. You get three placeholder stages on consecutive days from today.
- Stages tab. Rename the carnival in the Name field at the top. Set each stage's planned date to Good Friday, Saturday, Sunday. Turn Counts off for the prologue if it only seeds the chase. Create event on each stage, or Use existing event to attach the events you've already built — naming those events Prologue, Middle and Chase is what puts those words on the stage rows.
- Set each stage up as an ordinary event — classes, courses, competitors, start times. Nothing carnival-specific here. If days 2 and 3 run the same field, Copy entries from… stage 1 rather than importing three times.
- Competitors tab, once at least two stages have entries. Work through Ambiguous first (they block standings), then Suggested. Aim for an empty badge.
- Scoring tab. Total time, summed, is the default and what most carnivals use. Set best-N, weights or per-class overrides if your rules call for them.
- Run stage 1 normally. The Standings tab fills in live.
- Run stage 2 normally.
- Chase starts tab before stage 3: chase into stage 3, standings after stage 2, leader at 10:00, cutoff 30 minutes, restart block from 11:00. Preview, then Apply.
- Run stage 3. The finish order in each class is the overall result; the Standings tab confirms it.
- Export the standings as PDF for the prize-giving and CSV for the spreadsheet, and each stage's IOF XML for upload.
Not yet supported
- Knock-out scoring inside a carnival. A knock-out is its own kind of multi-stage event, not a scoring method — see Knock-out competitions.
- Relay carnivals. A multi-day relay isn't modelled — times carried forward between stages of a relay aren't computed. Individual stages of an ordinary relay event work normally. See Relay events.
- Importing a multi-race IOF XML file as a carnival from the UI. Multi-race files are detected and parsed, and the Eventor path is wired up, but the file-upload wizard doesn't yet offer the step — import each race's file into its own stage event instead.
- Editing race names and dates during the Eventor import. They're imported as Eventor has them; rename and re-date afterwards on the Stages tab.
- Team/patrol carnivals — a carnival of team events isn't modelled.
- Registry write-back — confirming an identity doesn't yet create or update the Competitor Registry entry for you.
- Class name mappings and the class-change policy — the settings exist but have no screen; see Classes across stages.
- Excluding one stage for one competitor — dropping a single person's single stage from their standing is not yet possible from the UI.
- Tied places in a place table — the choice is offered and doesn't yet take effect.
Common mistakes
- A competitor is missing from the standings entirely. They're probably in an Ambiguous identity, which blocks the standing until you decide. Check the Competitors tab — the badge on the group header counts these.
- Two people merged into one standing. Almost always card-number matching with hire cards. Turn Match on card number off, and split the identity.
- A total looks too short. Look at the struck-through stage cell — the tooltip names the reason (didn't count, dropped as worst, ineligible status, no result).
- Someone has no overall time at all. Under a time-based method, an Incomplete competitor has no total and no position by design. If your rules say otherwise, score on points — a missed stage then scores zero and they keep a position — or mark the stage Optional.
- The chase refused a class. That class is scored on points, so there are no time gaps to chase. Score it on time, or use the Seeded interval start mode instead.
- Everyone from one class dropped out of the standings. Check the class is named identically in every stage —
M21AandM21 Aare two different classes. - Two people with the same name became one standing. Where there is nothing but a name to go on and no club contradicts it, Manager merges them. Split the identity on the Competitors tab; Rejoin puts it back if you were wrong.
- Editing the global scoring method didn't change the standings. Correct — the method is snapshotted when selected. Use Update to latest on the Scoring tab.
- A stage event vanished from the Events list. It's nested inside its carnival's row. Expand the group.
- Deleting the carnival didn't delete the events. Also correct — stage events survive as standalone events.
Related
- Creating an event — the New Event dialog and event settings
- Importing event data — Eventor and IOF imports, including multi-race
- Start times and Drawing start times — the ordinary start-allocation routes
- Knock-out competitions — the other kind of multi-stage event: rounds whose fields are advanced from the round before, rather than stages added up
- Relay events — the other multi-part event shape
- Competitor Registry — the durable fix for cross-stage matching
- Results and Exporting data
- Status and race time rules — the statuses behind stage eligibility