Progression Policy

The Progression Policy (POLICY_TYPE_PROGRESSION) controls automated behaviors related to participant progression through tournament structures, including qualifier placement, double-exit BYE propagation, and qualifier replacement rules.

Policy Type: progression

When to Use:

• Automatically placing qualifiers into main draws
• Controlling BYE propagation in double-exit scenarios
• Managing qualifier replacement when matchUp outcomes change
• Automating participant flow between structures
• Enforcing federation-specific progression rules

---

Policy Structure

{
  progression: {
    policyName?: string;                    // Optional policy identifier
    doubleExitPropagateBye?: boolean;       // a double exit produces a BYE, not an exit (default: true)
    autoPlaceQualifiers?: boolean;          // Auto-place qualifiers (default: false)
    autoReplaceQualifiers?: boolean;        // Replace if winningSide changes (default: false)
    autoRemoveQualifiers?: boolean;         // Remove if winningSide cleared (default: false)
  }
}

Attributes:

• doubleExitPropagateBye: A double exit (DOUBLE_WALKOVER, DOUBLE_DEFAULT) removes both competitors, so nobody will arrive in the position its loser would have taken in a connected structure. When true — the default — that position becomes a BYE. When false it receives a produced WALKOVER or DEFAULTED instead. Set it to false if you award ranking points by matchUpStatus and need a first-round walkover told apart from a BYE.

• autoPlaceQualifiers: When true, qualifiers are randomly assigned to qualifier positions in the main draw when qualifying completes.

• autoReplaceQualifiers: When true, placed qualifiers will be replaced in target structures if the qualifying matchUp's winningSide is changed.

• autoRemoveQualifiers: When true, placed qualifiers will be removed from target structures if the qualifying matchUp's winningSide is removed.

---

Default Policy

import { fixtures } from 'tods-competition-factory';
const { POLICY_PROGRESSION_DEFAULT } = fixtures.policies;

// Defaults:
// {
//   progression: {
//     doubleExitPropagateBye: true,     // A double exit produces a BYE
//     autoPlaceQualifiers: false,       // Manual qualifier placement
//     autoReplaceQualifiers: false,     // Manual replacement
//     autoRemoveQualifiers: false       // Manual removal
//   }
// }

---

Double-Exit BYE Propagation

BYE Propagation (default: true)

// When a first-round matchUp is a DOUBLE_WALKOVER or DOUBLE_DEFAULT:
// neither competitor advances, and neither is a loser who can be fed into a connected structure
// the position that loser would have taken becomes a BYE, and its opponent advances through it

const byePropagationPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'BYE Propagation',
    doubleExitPropagateBye: true, // Default
  },
};

Within the structure where the double exit happened nothing changes: the next matchUp still receives a produced WALKOVER or DEFAULTED, and whoever arrives opposite it is awarded it. The policy governs only the position in the CONNECTED structure.

Produced Exits (doubleExitPropagateBye: false)

// When a first-round matchUp is a DOUBLE_WALKOVER or DOUBLE_DEFAULT:
// the position its loser would have taken receives a produced WALKOVER or DEFAULTED instead of a BYE
// (may award ranking points, depending on the provider's rules)

const producedExitPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Produced Exits',
    doubleExitPropagateBye: false,
  },
};

tournamentEngine.attachPolicies({
  policyDefinitions: producedExitPolicy,
});

When to turn it off:

• You award ranking points by matchUpStatus and a produced walkover must count where a BYE would not
• Your published results must show that a position was vacated by a walkover rather than by a BYE

USTA (POLICY_PROGRESSION_USTA)

USTA requires a double walkover to produce a walkover in both the structure where it happened and the connected structure where its loser would have appeared. Ranking points are awarded by matchUpStatus, so the produced walkover must not be read as a BYE. This is the behaviour of USTA Tournament Desk (ustatournamentdesk.com, on factory 2.2.32), confirmed with USTA on 2026-10-22.

The factory default changed to doubleExitPropagateBye: true on 2026-09-29, so a USTA tournament has to state the setting. POLICY_PROGRESSION_USTA is POLICY_PROGRESSION_DEFAULT with doubleExitPropagateBye: false and nothing else changed. Attach it beside POLICY_SCORING_USTA, which turns exit propagation on:

import { fixtures } from 'tods-competition-factory';
const { POLICY_PROGRESSION_USTA, POLICY_SCORING_USTA } = fixtures.policies;

tournamentEngine.attachPolicies({
  policyDefinitions: { ...POLICY_SCORING_USTA, ...POLICY_PROGRESSION_USTA },
});

// a DOUBLE_WALKOVER in the main structure:
//   the main structure: the next matchUp receives a produced WALKOVER (under any progression policy)
//   the connected structure: the loser's position receives a produced WALKOVER, not a BYE

---

Automatic Qualifier Placement

Manual Placement (default: false)

// Default: tournament directors manually place qualifiers
const manualPlacement = {
  [POLICY_TYPE_PROGRESSION]: {
    autoPlaceQualifiers: false, // Default
  },
};

// Manual placement workflow:
// 1. Qualifying completes
// 2. TD reviews qualifiers
// 3. TD manually assigns qualifiers to main draw positions

Automatic Placement (autoPlaceQualifiers: true)

// Qualifiers automatically placed when qualifying completes
const autoPlacement = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Auto Qualifier Placement',
    autoPlaceQualifiers: true, // Automatic random assignment
  },
};

tournamentEngine.attachPolicies({
  policyDefinitions: autoPlacement,
});

// Automatic workflow:
// 1. Qualifying completes
// 2. Qualifiers automatically assigned to available qualifier positions
// 3. Random distribution among available qualifier slots

Use Cases:

• Streamlined tournament operations
• Events with many qualifiers
• Automated tournament management systems
• Consistency in qualifier placement

---

Qualifier Replacement and Removal

Replacement on winningSide Change

const replacementPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Auto Replacement',
    autoPlaceQualifiers: true, // Enable automatic placement
    autoReplaceQualifiers: true, // Replace if outcome changes
  },
};

// Scenario:
// 1. Qualifier A wins final qualifying matchUp → placed in main draw
// 2. Referee changes winningSide to Qualifier B → A removed, B placed
// 3. Main draw automatically updated

Removal on winningSide Cleared

const removalPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Auto Removal',
    autoPlaceQualifiers: true,
    autoRemoveQualifiers: true, // Remove if winningSide cleared
  },
};

// Scenario:
// 1. Qualifier A placed in main draw
// 2. Referee clears winningSide from qualifying matchUp
// 3. Qualifier A automatically removed from main draw

Combined Replacement and Removal

const fullAutomation = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Full Qualifier Automation',
    autoPlaceQualifiers: true, // Auto-place when qualifying completes
    autoReplaceQualifiers: true, // Replace if winningSide changes
    autoRemoveQualifiers: true, // Remove if winningSide cleared
  },
};

tournamentEngine.attachPolicies({
  policyDefinitions: fullAutomation,
});

---

Real-World Examples

ITF Event With BYE Propagation

import { policyConstants } from 'tods-competition-factory';
const { POLICY_TYPE_PROGRESSION } = policyConstants;

// ITF rules: first-round walkovers don't award ranking points
const itfProgressionPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'ITF Progression',
    doubleExitPropagateBye: true, // Use BYEs instead of walkovers
    autoPlaceQualifiers: false, // Manual qualifier placement (ITF standard)
  },
};

tournamentEngine.attachPolicies({
  policyDefinitions: itfProgressionPolicy,
});

Automated Tournament System

// Fully automated progression for online tournament platform
const automatedProgressionPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Fully Automated Progression',
    doubleExitPropagateBye: false,
    autoPlaceQualifiers: true,
    autoReplaceQualifiers: true,
    autoRemoveQualifiers: true,
  },
};

// Benefits:
// - No manual intervention needed
// - Real-time updates as qualifying completes
// - Automatic corrections if results change
// - Consistent behavior across all events

Conservative Manual Control

// Tournament director maintains full control
const manualControlPolicy = {
  [POLICY_TYPE_PROGRESSION]: {
    policyName: 'Manual Control',
    doubleExitPropagateBye: false, // Standard walkovers
    autoPlaceQualifiers: false, // Manual placement
    autoReplaceQualifiers: false, // Manual replacement
    autoRemoveQualifiers: false, // Manual removal
  },
};

// Use when:
// - Special considerations for qualifier placement
// - Seeding adjustments needed
// - Complex multi-event scenarios
// - TD preference for manual control

---

Policy Application

Event-Level Progression

// Different progression rules for different events
tournamentEngine.attachPolicies({
  policyDefinitions: {
    [POLICY_TYPE_PROGRESSION]: {
      autoPlaceQualifiers: true,
      autoReplaceQualifiers: true,
    },
  },
  eventId: 'singles-event-id',
});

tournamentEngine.attachPolicies({
  policyDefinitions: {
    [POLICY_TYPE_PROGRESSION]: {
      autoPlaceQualifiers: false, // Manual for doubles
    },
  },
  eventId: 'doubles-event-id',
});

---

Notes

• Default behavior: All qualifier automation disabled; a double exit propagates a BYE to the connected structure (POLICY_PROGRESSION_USTA turns that off)
• doubleExitPropagateBye: Only affects a structure linked to the double exit's own by a loser link (e.g. a consolation, playback or Curtis Consolation). The double exit's own structure produces an exit either way
• autoPlaceQualifiers: Requires qualifier positions defined in main draw
• autoReplaceQualifiers: Only works when autoPlaceQualifiers: true
• autoRemoveQualifiers: Only works when autoPlaceQualifiers: true
• Policies affect progression between linked structures
• Tournament-level policy applies to all events unless overridden
• Event-level policy overrides tournament-level settings
• Automatic placement is random among available qualifier positions
• BYE vs. WALKOVER distinction important for ranking points
• Qualifier replacement preserves draw integrity
• Manual control allows for special seeding considerations

---

Related Concepts

• Draw Structures - Understanding structure types
• Draw Types - Double-exit and qualifying scenarios