Skip to content

English FA

A WordPress plugin that pulls fixtures and results from FA Full-Time for the teams a club registers players to, and publishes them through shortcodes and generated team pages.

It is a companion to Club Player Manager, not part of it, so the two can be installed, upgraded, backed up and removed independently. Everything about a club's FA registrations is this plugin's — the report upload, the registrations themselves, and the teams they name — while players, guardians and squads stay that plugin's. Neither queries the other's tables: this plugin reaches core only through the platform, and core reaches this one only by firing actions it may listen to. See docs/PLATFORM.md.


What it does

  1. Collects a league's Full-Time code snippet. Full-Time's ordinary fixtures/results pages refuse automated requests, but a Code Snippet — the embed FA leagues hand out for other clubs' websites — does not, because it is built to run on a stranger's browser. A snippet already reports every one of the club's teams across every division and age group that league system runs, so one league (one fixtures snippet, one results snippet) is normally all a club needs. The site cannot run a snippet itself — that needs a real browser — so a separate collector (tools/pi-sync, meant to run on a Raspberry Pi on the club's own broadband) fetches it on a schedule and pushes the page in over REST.
  2. Discovers the club's teams from what was collected, rather than being told about them. Set the club's name once (English FA → Settings → Club name); any home or away team in a collected league's matches containing that string is a team of the club's, published then and there — no team to add, rename or keep in sync by hand when a new age group appears.
  3. Publishes them. Shortcodes and blocks for pages you build yourself, plus a generated page per team at /teams/<slug>/, an index at /teams/, and club-wide /teams/fixtures/ and /teams/results/ pages with team and date filters.
  4. Imports the FA Club Player Report. Upload the club's player export (.xlsx). Club Player Manager parses it and saves the players and guardians it owns; the team-registration columns come back here and are stored in this plugin's own table. One workbook, read once, each half landing with the plugin that owns it.
  5. Keeps those registrations. One row per (player, team), keyed on FA Number, editable by hand on the FA Registration screen.

Requirements

  • WordPress 6.9+, PHP 8.2+
  • PHP's DOM extension (bundled with virtually every PHP build) — used to read Full-Time's HTML
  • No Composer dependencies, and no build step
  • A collector on a network Full-Time will serve — see tools/pi-sync/README.md — since the site can never fetch a code snippet itself

Setting up a league

Go to Media → Code Snippets in Full-Time's own admin (you need to be a registered team or league administrator there), generate the fixtures and results snippets for the league, and paste each — the whole snippet, or just the number from its lrcode line — into English FA → Leagues → Add a league. There is no "sync now": a snippet only produces its table once a browser has run it, which tools/pi-sync does on its own schedule and pushes in from there.

Once a league has collected at least once, its screen lists the team names its matches actually mention — compare that list against your club's name in Settings if a team you expect is not appearing; it is almost always a spelling difference, or the team playing in a league system you have not added here.

Shortcodes

[english_fa_fixtures team="U12 Reds" limit="5"]
[english_fa_results  team="U12 Reds" limit="5"]
[english_fa_matches  team="U12 Reds" fixtures="5" results="5"]
[english_fa_teams]
[english_fa_latest_results limit="6"]
[english_fa_next_games days="7"]
  • team accepts the team's name exactly as Full-Time writes it, or its page slug. Leave it out and the shortcode covers every published team, naming each row's team.
  • limit (and fixtures / results) default to the values in English FA → Settings.
  • Matches are listed day by day, not in a table: a heading per day ("Saturday 13 September"), then a row per match with the kick-off time, the opposition, and the score or a status on the right. One column that reads the same on a phone as on a desktop.
  • english_fa_latest_results and english_fa_next_games are club-wide home page lists (also blocks): the latest results that have a score (under 11s left out), and every game from today to the end of the next seven days. Each links to the club-wide /teams/results/ or /teams/fixtures/ page (when the generated pages are on), where every match is listed with a multi-team filter, From / To dates (?team[]=<slug>&from=YYYY-MM-DD&to=YYYY-MM-DD) and quick filters for the next/last week, fortnight and month, and girls / mixed (by linked squad type).
  • show="competition,venue" adds the competition and the Home / Away tag to each row's second line; heading="…" changes or removes the heading.
  • Each result's score is followed by Win, Draw or Loss, from our team's side. One team's results (a shortcode with team, or the team's own page) also get a form strip between the heading and the list: a green W, grey D or red L box for every result this season, whatever limit says, oldest on the left. A result with no score gets neither. The layout and colours come from a small stylesheet whose rules a theme can override. Its colours read the theme's palette first (Club One's action, tint, border and muted, falling back to neutral greens), and can be repointed through --efa-accent, --efa-tint, --efa-line, --efa-muted, --efa-result-won, --efa-result-drawn and --efa-result-lost. A parent's Fixtures page uses the same day-by-day list, with the Yes / No answer under each match on a phone and beside it on a wider screen.

Admin

English FA (top-level menu), all gated on the efa_manage capability — granted to WordPress administrators and to Club Player Manager club admins (cpm_manage_all).

Screen What it is for
Teams Every discovered team, with its squad, how many a side it plays, and its fixture and result counts. A team is not added here — only the squad and the format are set, and those on the team's own screen
Team (hidden) Every one of a discovered team's matches, unlimited — the same content its public page shows, plus a Hide (keep off the public site without deleting it) and a Delete on each; one a collection no longer lists gets a warning icon rather than a section of its own. Above them, the two things about a team that are stored rather than collected: its squad and its match format (how many a side)
Match (hidden) One match, reached from its date on the Team screen: the match's own details, and the club's players who were FA-registered to that team on the day it was played — plus, below them, the team's other registrations, so a player missing from the first list can be explained rather than only noticed. Registered players can be invited to the match, either by ticking them or with Invite All Registered Players; an invitation can be withdrawn the same way, and the same buttons sit above and below the table. The registered players are split across six tabs — Uninvited, Invited (asked, waiting), Available, Selected, Not selected, Not available — which partition the list, so the tab counts add up to the Registered figure. Each tab shows only the buttons that apply to it: the invite buttons on Uninvited, Select to Play on Available and Not selected, Not Selected on Available and Selected, Unselect on Selected and Not selected, and Save Availability and Withdraw Selected on the tabs of players already invited. A tick survives switching tabs, so a button acts on everyone ticked wherever they are. Each row shows the guardian's availability answer and when it last changed, and an admin can set or change it from the same dropdowns. Available players can be ticked and selected to play with Select to Play (anyone ticked who is not available is left out, and the notice says how many); Unselect takes them back out. Not Selected tells an available player's guardian they are not playing (their matches page says "Not selected for this fixture."; no email is sent); those players move to a Not selected tab, and Select to Play or Unselect changes it back. Selected players move to the Selected tab, the Selected tile counts them against the team's format, and the guardian's page shows "Selected to play". A player whose answer changes from available is taken out of the selection automatically. With Selected to play emails switched on in Settings (off by default), guardians get one email each about an hour after the last selection for their children, sent like the invitation email; a player unselected before then is not written to, and nobody is emailed about a match already played
Leagues Add a league's two Full-Time code snippets; see when it was last collected and how many matches it holds
FA Registration Every team registration, filterable by team and status; and the edit screen for one
Guardian Links Each guardian, their children, and the pre-authorised link that shows them their children's match invitations. Read-only; nothing is emailed yet, so a link is copied from here
Import Players Upload an FA Club Player Report (.xlsx); players and guardians go to Club Player Manager, registrations here
Settings Club name (what makes a team "ours"), page address, shortcode defaults, and the shortcode reference

It also draws into three screens it does not own, through extension points core leaves for it:

  • Club Player Manager → Squads → a squad gains a Teams column naming the teams each player on the roster is currently registered to, linking the ones it has discovered matches for. Core offers the column and holds nothing to put in it (cpm_squad_player_columns).
  • Club Player Manager → Squads gains an Age group column — "Under X", where X is the age the squad's oldest date of birth reaches on 31 August of the year the active season ends (cpm_squad_list_columns). Blank with no active season or no start date of birth.
  • Club Player Manager → Players → a player gains that player's Team Registrations card, where core used to draw one itself (cpm_player_detail_cards).

The guardian Fixtures page

A guardian's children's match invitations, with a Yes/No answer on each, live at /account/matches/ — under Club Player Manager's account page, because that is the one place a parent signs in. The account page links to it as Fixtures under "More from the club", and also from each child's own row (cpm_account_child_links), for a child with matches to show: a team with matches collected, or an invitation. That link opens the child's own page, /account/matches/?child=<player id>, which is the same page narrowed to that child (an id that is not one of the signed-in guardian's children is ignored). Signed in, each child's invitations are followed by their teams (EFA_Guardian_Teams): each team linked on English FA → Teams to a squad the child plays for, with a "See all fixtures and results for this team." link to its public page. The page carries no copy of the team's fixtures, so the one list on it is what the child is invited to. A child whose squads have no linked team gets a "No fixtures from the FA yet" line; a child in no squad, or who has left the club, gets nothing. The children's squads come from squad_ids on CPM_Platform::players_for_guardian_email() (platform 3.15); on an older core no teams show. There are two ways onto the page:

  • Signed in (emailed login link or passkey, both core's — CPM_Guardian_Auth). The page recognises the guardian through CPM_Platform::current_guardian_email(); nothing is in the URL. Anybody not signed in is sent to the account page. This is the link core's account page shows under "More from the club".
  • By the link in an invitation or selection email. Since platform 3.16 these carry core's signed-in link (CPM_Platform::guardian_link()) onto the signed-in page: following it signs the parent in to their whole account, as often as they like, for 7 days, like every other club email's link. A dead one shows core's standard expired-link page, which emails a fresh one.
  • By an older invitation link: /account/matches/<token>/, still in inboxes from before 3.16. The token alone lets the guardian see and answer their children's invitations, and never opens a session. It expires 7 days after it was issued; after that the page shows core's expired-link panel (CPM_Platform::expired_link_html()): an "Email me a new link" form that sends a fresh signed-in link to the Fixtures page (same neutral answer whether or not the club holds the address, rate limited by core), and a passkey line on a device that has one. An answer posted from a page whose link has since expired writes nothing and comes back to that page. A guardian who follows one while already signed in as that address is redirected to the plain page.

The token is EFA_Guardian_Link: 8 hex characters of issue time, then an HMAC over the address and that time keyed by the site's auth salt. It carries no address — an email address in a URL is an email address in every server log and Referer header — so resolving runs backwards: resolve() checks the time first, then hashes the club's guardian addresses and compares in constant time. Nothing is stored.

  • A link cannot be revoked on its own, only outlived. The week is what bounds a forwarded or leaked email. Rotating the auth salt kills every link at once; a guardian leaving the club's records stops theirs resolving.
  • The write is kept small. Every answer re-proves the guardian (token, or session if the token has gone stale), re-reads that guardian's children from Club Player Manager rather than trusting the form, and refuses anything but an answer to an invitation that already exists. responded_by records which side set it.
  • Selected children and past fixtures. Once the club selects a child for a match, the Yes / No is replaced by "Selected to play", with a "Withdraw availability" button that asks " has been selected to play, this action will remove them from the fixture." first; it posts No, which takes them off the team. Answers close at the end of the fixture's date (EFA_Guardian_Availability::is_open()): the page stops offering buttons, and the handler refuses a late answer from a page left open, returning efa_answered=closed.
  • Answering never extends a link. The form posts the token back and the guardian is returned to the page with the same token, not a fresh one.
  • Answers are POSTed, never followed as links. A GET that changes state is set off by anything that fetches URLs on a reader's behalf — a mail client scanning links, a browser prefetching.
  • CSRF is covered without a nonce, which a page served to a signed-out parent could not issue usefully anyway: a signed-in answer is resolved only from core's guardian session cookie, and that cookie is samesite=Lax (CPM_Guardian_Auth::set_cookie()), so a browser will not attach it to a cross-site POST — there is no identity for a forged request to act as. The one request Lax still allows, a top-level GET navigation, writes nothing because every field the handler reads comes from $_POST. On the emailed-token path a nonce would add nothing at all: a logged-out visitor's nonce is a function of the action and the 12-hour tick, so anybody can compute one, while the token is unguessable and is the whole authenticator. GuardianAnswerGuardTest holds the handler's half of this. It is the same defence core's own account routes rest on.
  • Old links — the bare, never-expiring ?efa_guardian=<digest> form sent before this — grant nothing and redirect to /account/matches/, i.e. to sign in.

The routes are rewrite rules registered whether or not the generated team pages are on. A site on plain permalinks gets ?efa_matches=1 and ?efa_guardian=<token> on the site root instead. The club's own invitation email wording, if it was saved before this change, still says the link can be used "at any time" — the default now says 7 days.

Invitation emails

Turned off by default. With it on (English FA → Settings), inviting a player emails their guardians, once, as the invitation is made.

  • Every guardian on the child's record is written to, not just the payment contact — either parent answering is better than neither, and each gets their own link, since a link is derived from the address.
  • Only the newly invited are mailed. EFA_Invitations_Repository::invite() returns which players it actually added, so pressing Invite All Registered Players a second time queues nobody who was already invited.
  • It comes from the squad secretary, not from whoever clicked Invite. A fixture secretary, a club admin and a volunteer may all press the button, and a guardian replying wants the person who runs their child's team either way. The sender is resolved from the team → the squad an admin has set for it → that squad's secretary_email, and then:
  • the secretary's own mailbox, when they have connected one through Club Mailer. This needs their WordPress account email to match the address on the squad, so it will often not resolve;
  • otherwise the Invitation from address (default fixtures@lajfc.org), with Reply-To set to the secretary — so the reply still reaches them.

Case 2 is the one to expect, and it is not a degraded path: a consistent, recognisable sender with the right reply address. The admin notice says which address replies will go to. A team with no squad, or a squad with no secretary, still sends — just without a reply address. - Delivery is plain wp_mail(). CPM_Mailer hooks wp_mail() globally for the from-address, the outbound log and the logging-only redirect to the test inbox, and whatever delivers the site's mail (Club Mailer's Elastic Email transport, say) takes over wp_mail() itself, so all of that already applies. Only the addresses cross the platform seam. - Subject and body are editable, with {players} (the children this message is about), {matches} (the list of what they have been invited to, built by the plugin — a club should be editing the sentences around the list, not expressing a loop in a textarea), {count}, {link} and {club}. Blanking either field restores the default.

Batching

Nothing is sent in the request that made the invitations. The invitation row is the queue — notified_at NULL means "this guardian has not been told yet" — and a WP-Cron sweep (EFA_Invite_Queue) drains it. There is no queue table, and the sweep is crash-safe for free: a run that dies half way leaves the rest unstamped for the next tick, and can never re-send what already went, because the stamp is per row.

A guardian gets one email, not one per child per match. Pending rows are grouped and each group becomes a single message listing everything it covers. Groups are keyed on (guardian address, team secretary) rather than the guardian alone: one email can carry one Reply-To, so a parent with children in two squads gets one message per squad, each replying to the right person. That is the right answer, not a compromise — they are two conversations with two different people.

If any of a guardian's children has an unsent invitation made in the last hour, that guardian is not written to at all yet — not about invitations from yesterday, and not about a different squad. Picking a team is not one sitting: a secretary invites most of a squad, hears back about a doubtful player, adds them later. Once an hour passes with nothing new for any of their children, everything outstanding goes at once. A fresh invitation for one guardian never holds another's.

The hold list is read from the whole table, not from the batch's own rows. A batch reads a bounded window oldest-first, so the newest invitations are precisely the ones that fall off the end of it — deciding the hold from the window alone would send a guardian's older invitation without ever seeing their fresh one, and only once a club was busy enough to overflow a batch.

The follow-up run is booked for when the oldest waiting row could be ready, so an hour-long hold costs one tick rather than sixty. A failed send is retried up to MAX_ATTEMPTS and then let go, so a permanently bad address stops being tried. A player with no guardian email is stamped rather than left, because nothing about it will change on the next tick — the gap shows on the Match screen, which is where somebody can fix it.

Selected to play email

When a squad secretary selects available players on the Match screen, their guardians can be told. English FA → Settings → Selected to play emails switches it on (off by default) and holds its own subject and message, with the same placeholders as the invitation ({matches} lists the games each child was picked for). It is sent exactly like the invitation, by EFA_Selection_Queue (the same sweep, run over selection_notified_at): one message per guardian and squad secretary, held until an hour passes with no new selection for any of their children. Only a player still selected is in the queue, so one unselected inside that hour is never written to. A match already played is left out, so switching the email on mid-season does not send a backlog. The two emails keep separate stamps: an invitation email going out never counts as the selection email, or the other way round.

Squad volunteers

A squad can name the volunteers who run it on match day, beside its secretary: any number, each a Manager (may pick the team) or a Coach (may see the squad and its matches, picks nobody). They are added on the squad's own page in Club Player Manager — a Squad volunteers card drawn through core's cpm_squad_detail_cards action — by a club admin or that squad's secretary, and stored in efa_squad_staff (one row per squad and email; adding an email already there changes its name and role).

A volunteer is not a WordPress user. They sign in on the club website exactly as a parent does — the emailed link, then a passkey if they add one — because EFA_Squad_Staff vouches for their address through core's cpm_account_recognised_email filter. Vouching only lets the address sign in; what a volunteer may see and do is checked per squad on every request (EFA_Squad_Staff::role_for() / can_select()). A volunteer for a squad that has since been deleted is neither let in nor shown anything.

Match day pages

Signed in, a volunteer gets a Match day link on their account page (offered to volunteers only), which opens /account/match-day/: for every squad they help with, its upcoming fixtures as cards — date, kick-off, opponent, home or away, venue — each with how its invitations stand (selected, available, no reply, not available). A card opens /account/match-day/<match id>/, the names in each group, with Selected shown against the team's format.

Read-only for now; picking the team from here comes next. The pages are recognised by the sign-in alone (no emailed link reaches them), re-check the squad on every request, and answer a match of another squad — or one the club has hidden — with the same 404 as a match that does not exist. They show players' names and answers only, never a family's contact details. On plain permalinks the same pages are ?efa_matchday=1 and ?efa_matchday_match=<id>.

A team's squad, and its match format

A discovered team has no row of its own — it is a name read live out of a league's collected matches — with exactly two exceptions: which of the club's squads it is, and how many a side its matches are played. Both are stored (wp_efa_team_squads), because both are things about a team that cannot be worked out. Nothing in Full-Time's data says that "Anytown Colts U12 Reds" is the U12 Reds squad, or that it plays 9-a-side; only a person knows.

Set them on the team's own screen (English FA → Teams → a team), each in its own card, where the Teams list also shows both as columns so an unset team is visible rather than quietly having no reply address and no format.

  • The squad decides who a match invitation comes from and who the guardians reply to.
  • The format is one of 3, 5, 7, 9 or 11 a side — the FA's own youth formats, offered as a list rather than typed, so nothing can be stored that nobody plays. It shows on the Match screen, where somebody is deciding how many players to invite, and on the team's public page and the team index. 0 means "not set", which the public pages leave off the page entirely rather than reporting.

Three properties matter:

  • The row outlives the team. Clearing the collected matches, deleting a league, or Full-Time simply not listing a team over the summer all make it vanish from every screen. What is stored stays, so the next collection that lists it again finds its squad and format still set. Nothing deletes one but a person choosing "Not set" — and only clearing both removes the row.
  • The two are set independently. They are saved by different forms, so saving one never overwrites the other, and clearing the squad on a team that plays 9-a-side leaves the 9 behind.
  • It is keyed on the normalised team name, the same normalisation the registrations lookup uses, so it survives Full-Time writing the same team as "… FC" one season and "…" the next.

Data model

Five tables, all wp_efa_*:

Table Holds
efa_leagues One row per league system: its name, its two Full-Time code snippet numbers, and the last collection's outcome
efa_league_matches Every match a league's collected page listed. Matched between collections on team pairing + competition, not match_uid (which hashes in the date, so it changes when a fixture is rescheduled) — see below. A discovered team's fixtures and results are read live from this table — nothing else stores them
efa_player_registrations FA team registrations: one row per (fan_id, team). Keyed on FA Number rather than a player id, so a registration survives its player being deleted and re-imported — and so this table holds no foreign key into Club Player Manager
efa_team_squads What is stored about each discovered team — which of the club's squads it is, and how many a side it plays (players_per_side, 0 for not set): one row per team, keyed on the normalised name. The only stored facts about a team, and the only table nothing but a person ever deletes from — see above
efa_match_invitations Who the squad secretary is asking for a match, and what the guardian said back: one row per (match_id, fan_id), carrying availability, responded_at and responded_by, plus selected_at / selected_by (NULL / 0 = not selected) for the available players the club has picked to play — cleared whenever the answer stops being available — and selection_notified_at / selection_notify_attempts, the selection email's send queue (EFA_Selection_Queue), kept apart from the invitation's notified_at. not_selected_at / not_selected_by (schema 2.7) record an available player the club has marked not selected; at most one of the two is set, and both clear with the answer. The three states a club cares about are "no row" (not asked), "row with blank availability" (asked, waiting) and "row with an answer" — not a fourth value nobody sets. responded_by is guardian or admin rather than a user id, because a guardian has no WordPress account and which side answered is the part anybody asks about

efa_player_registrations: an FA report re-import refreshes it, but a registration corrected by hand is not recoverable, so nothing clears it wholesale.

efa_match_invitations is keyed on FA Number for the same reasons, and cascades on both sides: EFA_Leagues_Repository clears a match's invitations when the match goes (an invitation to a match that no longer exists can never be shown or answered), and EFA_Club_Sync carries them through a player deletion or a duplicate merge exactly as it carries registrations.

Registrations arrived here from Club Player Manager's wp_cpm_player_team_registrations, which this plugin copies on upgrade — see EFA_Schema::adopt_club_registrations(). It is a copy rather than a move, so the two deploys can land in either order and a rollback still finds its data.

How a collection behaves

  • Per (league, source), matched by team pairing + competition. A row already held for that pairing is updated in place — so a reschedule changes kickoff_date/kickoff_time on the same row rather than reading as one match withdrawn and an unrelated one added.
  • Nothing is deleted outright. A pairing a previous collection held that this one does not list at all is stamped missing_since, not removed — Full-Time gives no way to tell "genuinely withdrawn" apart from "a one-off gap in this particular collection", so that call is left to a person: the Team admin screen marks that row with a warning icon rather than treating it any differently, and Hide or Delete is the same action either way. Reappearing in a later collection clears the stamp again. EFA_Discovered_Teams never shows a flagged or hidden row to a visitor — hidden is a separate, admin-only decision a collection never sets or clears itself.
  • Except when the collected page came back empty, which is far more often nothing having been played yet than a fault. That is still reported as a successful collection — only a failed fetch (Full-Time refused the collector, say) is an error.
  • Per feed. Collecting fixtures never touches rows collected from the results feed, and a since-emptied results feed cannot undo a good fixtures collection.
  • Pushed, never pulled. The site has no cron of its own for this — it cannot run a code snippet either way — so nothing happens here until tools/pi-sync posts a page in.

Development

Everything runs from the repository root, where the shared dev tooling lives:

composer test        # both plugins' suites
composer test:efa    # this plugin only
composer lint        # both plugins' phpcs rulesets
composer lint:efa    # this plugin only
composer build:efa   # dist-club-english-fa/club-english-fa-<version>.zip

The suites stub WordPress and run against a real SQLite database (borrowed from the club plugin's test harness — the double is generic and test-only). All SQL must work on SQLite as well as MySQL: no GROUP_CONCAT with ORDER BY, no information_schema, no multi-table UPDATE … JOIN. Do complex grouping in PHP, as EFA_Discovered_Teams::names() does.

Schema changes bump EFA_Schema::VERSION, extend the dbDelta in install() and add a maybe_migrate() block using add_column_if_missing() — dbDelta does not reliably add columns under the SQLite adapter the dev site runs.

Layout

club-english-fa.php                        Bootstrap: constants, require order, hooks
uninstall.php                         Drops every table and option

includes/
  class-efa-schema.php                Table definitions + the migration walk
  class-efa-database.php              Table names + a facade over the repositories
  db/class-efa-leagues-repository.php       Leagues, and their collected matches
  db/class-efa-matches-repository.php       Match identity (match_uid) and type constants — not DB-backed
  db/class-efa-registrations-repository.php FA team registrations
  class-efa-access.php                The efa_manage capability
  class-efa-settings.php              Options: get(), allowlisted save()
  class-efa-snippet.php               Parses/builds a Full-Time code snippet's div id + loader URL
  class-efa-club-sync.php             Listens to Club Player Manager: import, delete, merge
  class-efa-fulltime-client.php       HTTP fetch + the host allowlist (used by Test tools, not a collection)
  class-efa-fulltime-parser.php       Full-Time response -> match rows
  class-efa-sync.php                  A collected league page -> stored match rows
  class-efa-discovered-teams.php      A club's teams, discovered by name from collected matches
  class-efa-rest.php                  The feed list + push-import routes tools/pi-sync calls
  class-efa-view.php                  Match formatting shared by partial-matches.php and the admin
  class-efa-frontend.php              Rewrite rules + the generated pages
  class-efa-shortcodes.php            The four shortcodes
  class-efa-squad-column.php          The FA teams column on Club Player Manager's squad page
  class-efa-squad-age-group.php       The "Under X" squad list column and squad page titles
  class-efa-squad-teams.php           Each squad's teams' fixtures and results on its public page
  admin/                              One handler per screen, plus the orchestrator

templates/                            admin-*.php, frontend-*.php, partial-*.php
assets/css/  assets/js/
tests/Unit/  tests/Integration/  tests/Support/

tools/pi-sync/                        The collector: runs on a machine Full-Time will serve,
                                       posts collected pages to /wp-json/efa/v1/feeds/import

The parser is the piece most likely to need work, because it is the piece reading somebody else's markup. It is deliberately written to the shape of a fixtures table — a date, two team names, and either a score or nothing — rather than to CSS selectors, so a Full-Time redesign does not necessarily break it. Everything it can read is covered in tests/Unit/FullTimeParserTest.php; adding a new feed shape means adding a case there and a branch in the parser, and nothing else.