@pickleball/expo-sdk 0.1.1 → 0.2.0

package/dist/match/index.js

@@ -0,0 +1,2456 @@
+import {
+  createDefaultMatchVoiceService
+} from "../chunk-DHDX3ZOO.js";
+import {
+  BTHomeRemoteDeduplicator,
+  DEFAULT_REMOTE_ACTION_MAPPING,
+  HidVolumeGestureRecognizer,
+  RemoteError,
+  decodeBase64Bytes,
+  parseBTHomeV2Advertisement
+} from "../chunk-2JHULJZ7.js";
+import {
+  __require
+} from "../chunk-KFQGP6VL.js";
+
+// src/match/state.ts
+function clonePlayer(player) {
+  return { id: player.id, name: player.name };
+}
+function cloneTeam(team) {
+  return {
+    id: team.id,
+    ...team.name === void 0 ? {} : { name: team.name },
+    ...team.initialServerId === void 0 ? {} : { initialServerId: team.initialServerId },
+    players: team.players.map(clonePlayer)
+  };
+}
+function cloneGame(game) {
+  return { ...game, score: { ...game.score } };
+}
+function cloneSnapshot(snapshot) {
+  return {
+    ...snapshot,
+    teams: { A: cloneTeam(snapshot.teams.A), B: cloneTeam(snapshot.teams.B) },
+    designatedServerByTeam: { ...snapshot.designatedServerByTeam },
+    courtSides: { ...snapshot.courtSides },
+    playerCourts: { ...snapshot.playerCourts },
+    games: snapshot.games.map(cloneGame),
+    gamesWon: { ...snapshot.gamesWon },
+    serve: { ...snapshot.serve },
+    pendingCourtSwitch: snapshot.pendingCourtSwitch ? { ...snapshot.pendingCourtSwitch } : null
+  };
+}
+function valuesEqual(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => valuesEqual(value, right[index]));
+  }
+  if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const leftKeys = Object.keys(leftRecord).sort();
+  const rightKeys = Object.keys(rightRecord).sort();
+  return leftKeys.length === rightKeys.length && leftKeys.every(
+    (key, index) => key === rightKeys[index] && valuesEqual(leftRecord[key], rightRecord[key])
+  );
+}
+
+// src/match/validation.ts
+var TEAM_IDS = ["A", "B"];
+var INPUT_SOURCES = ["local", "remote", "voice", "ble", "system"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertRecord(value, label) {
+  if (!isRecord(value)) throw new TypeError(`${label} must be an object`);
+}
+function assertNonEmptyString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+}
+function assertInteger(value, minimum, maximum, label) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new TypeError(`${label} must be an integer from ${minimum} to ${maximum}`);
+  }
+}
+function isTeamId(value) {
+  return value === "A" || value === "B";
+}
+function isCourtSide(value) {
+  return value === "left" || value === "right";
+}
+function isFormat(value) {
+  return value === "singles" || value === "doubles";
+}
+function isScoringMode(value) {
+  return value === "rally" || value === "sideOut";
+}
+function isSource(value) {
+  return INPUT_SOURCES.some((source) => source === value);
+}
+function assertRecordKeys(value, allowed, label) {
+  if (Object.keys(value).some((key) => !allowed.includes(key))) {
+    throw new TypeError(`${label} contains an unknown field`);
+  }
+}
+function assertPendingSwitch(value) {
+  assertRecord(value, "Pending court switch");
+  if (value.reason === "gameEnd") {
+    if (value.game !== 1 && value.game !== 2) {
+      throw new TypeError("Game-end switch must follow game one or two");
+    }
+  } else if (value.reason === "gameThreeMidpoint") {
+    if (value.game !== 3) throw new TypeError("Midpoint switch must be in game three");
+  } else {
+    throw new TypeError("Invalid pending court switch reason");
+  }
+}
+function assertRuntimeMatchSnapshot(value) {
+  assertRecord(value, "Match snapshot");
+  assertNonEmptyString(value.id, "Match id");
+  if (!isFormat(value.format)) throw new TypeError("Invalid match format");
+  if (!isScoringMode(value.scoringMode)) throw new TypeError("Invalid scoring mode");
+  assertInteger(value.targetScore, 1, 99, "Target score");
+  if (value.bestOf !== 3) throw new TypeError("Match must be best-of-three");
+  if (!isTeamId(value.initialServingTeam)) {
+    throw new TypeError("Invalid initial serving team");
+  }
+  assertInteger(value.sequence, 0, Number.MAX_SAFE_INTEGER, "Match sequence");
+  assertRecord(value.teams, "Teams");
+  assertRecordKeys(value.teams, TEAM_IDS, "Teams");
+  const expectedPlayers = value.format === "singles" ? 1 : 2;
+  const playerIds = /* @__PURE__ */ new Set();
+  const teamPlayerIds = { A: [], B: [] };
+  for (const teamId of TEAM_IDS) {
+    const team = value.teams[teamId];
+    assertRecord(team, `Team ${teamId}`);
+    if (team.id !== teamId || !Array.isArray(team.players) || team.players.length !== expectedPlayers) {
+      throw new TypeError(`Team ${teamId} roster is invalid`);
+    }
+    if (team.name !== void 0) assertNonEmptyString(team.name, `Team ${teamId} name`);
+    for (const rawPlayer of team.players) {
+      assertRecord(rawPlayer, "Player");
+      assertNonEmptyString(rawPlayer.id, "Player id");
+      assertNonEmptyString(rawPlayer.name, "Player name");
+      if (playerIds.has(rawPlayer.id)) throw new TypeError("Player ids must be unique");
+      playerIds.add(rawPlayer.id);
+      teamPlayerIds[teamId].push(rawPlayer.id);
+    }
+    if (team.initialServerId !== void 0 && !teamPlayerIds[teamId].includes(team.initialServerId)) {
+      throw new TypeError(`Team ${teamId} initial server is invalid`);
+    }
+  }
+  assertRecord(value.designatedServerByTeam, "Designated servers");
+  for (const teamId of TEAM_IDS) {
+    if (!teamPlayerIds[teamId].includes(value.designatedServerByTeam[teamId])) {
+      throw new TypeError(`Team ${teamId} designated server is invalid`);
+    }
+  }
+  assertRecord(value.courtSides, "Display court mapping");
+  if (!isTeamId(value.courtSides.left) || !isTeamId(value.courtSides.right) || value.courtSides.left === value.courtSides.right) {
+    throw new TypeError("Display court mapping must contain both teams");
+  }
+  assertRecord(value.playerCourts, "Player court mapping");
+  assertRecordKeys(value.playerCourts, [...playerIds], "Player court mapping");
+  if (Object.keys(value.playerCourts).length !== playerIds.size) {
+    throw new TypeError("Every player must have a court mapping");
+  }
+  for (const playerId of playerIds) {
+    if (!isCourtSide(value.playerCourts[playerId])) {
+      throw new TypeError("Player court mapping contains an invalid side");
+    }
+  }
+  if (value.format === "doubles") {
+    for (const teamId of TEAM_IDS) {
+      const [first, second] = teamPlayerIds[teamId];
+      if (value.playerCourts[first] === value.playerCourts[second]) {
+        throw new TypeError(`Team ${teamId} players must occupy different courts`);
+      }
+    }
+  }
+  if (!Array.isArray(value.games) || value.games.length < 1 || value.games.length > 3) {
+    throw new TypeError("Match games are invalid");
+  }
+  const games = value.games;
+  if (value.currentGame !== games.length) {
+    throw new TypeError("Current game must be the final game snapshot");
+  }
+  const winnerCounts = { A: 0, B: 0 };
+  games.forEach((rawGame, index) => {
+    assertRecord(rawGame, "Game snapshot");
+    if (rawGame.number !== index + 1 || !isTeamId(rawGame.startingServingTeam)) {
+      throw new TypeError("Game identity is invalid");
+    }
+    assertRecord(rawGame.score, "Game score");
+    for (const teamId of TEAM_IDS) {
+      assertInteger(rawGame.score[teamId], 0, value.targetScore, "Game score");
+    }
+    if (rawGame.winner !== null && !isTeamId(rawGame.winner)) {
+      throw new TypeError("Game winner is invalid");
+    }
+    if (isTeamId(rawGame.winner) && rawGame.score[rawGame.winner] !== value.targetScore) {
+      throw new TypeError("Winning game must reach target score");
+    }
+    if (rawGame.winner === null) {
+      if (rawGame.score.A === value.targetScore || rawGame.score.B === value.targetScore) {
+        throw new TypeError("A game at target score must have a winner");
+      }
+    } else {
+      const losingTeam = rawGame.winner === "A" ? "B" : "A";
+      if (rawGame.score[losingTeam] >= value.targetScore) {
+        throw new TypeError("The losing team must remain below target score");
+      }
+    }
+    if (isTeamId(rawGame.winner)) winnerCounts[rawGame.winner] += 1;
+    if (typeof rawGame.midGameSwitchCompleted !== "boolean") {
+      throw new TypeError("Game midpoint switch flag is invalid");
+    }
+    if (rawGame.midGameSwitchCompleted && rawGame.number !== 3) {
+      throw new TypeError("Only game three has a midpoint switch");
+    }
+    if (index < games.length - 1 && rawGame.winner === null) {
+      throw new TypeError("Previous games must have a winner");
+    }
+  });
+  assertRecord(value.gamesWon, "Games won");
+  for (const teamId of TEAM_IDS) {
+    if (value.gamesWon[teamId] !== winnerCounts[teamId]) {
+      throw new TypeError("Games-won total does not match game history");
+    }
+  }
+  assertRecord(value.serve, "Serve state");
+  if (!isTeamId(value.serve.teamId) || !teamPlayerIds[value.serve.teamId].includes(value.serve.playerId) || value.serve.serverNumber !== 1 && value.serve.serverNumber !== 2 || !isCourtSide(value.serve.court)) {
+    throw new TypeError("Serve state is invalid");
+  }
+  if ((value.format === "singles" || value.scoringMode === "rally") && value.serve.serverNumber !== 1) {
+    throw new TypeError("This match mode has one server");
+  }
+  const currentScore = games[value.currentGame - 1].score;
+  const parityCourt = currentScore[value.serve.teamId] % 2 === 0 ? "right" : "left";
+  if ((value.format === "singles" || value.scoringMode === "rally" || value.serve.serverNumber === 1) && value.serve.court !== parityCourt) {
+    throw new TypeError("Server court does not match score parity");
+  }
+  if (value.format === "doubles" && value.playerCourts[value.serve.playerId] !== value.serve.court) {
+    throw new TypeError("Server court does not match player position");
+  }
+  const currentGame2 = games[games.length - 1];
+  if (value.pendingCourtSwitch !== null) {
+    assertPendingSwitch(value.pendingCourtSwitch);
+    const pending = value.pendingCourtSwitch;
+    if (pending.game !== value.currentGame) {
+      throw new TypeError("Pending switch must belong to the current game");
+    }
+    if (pending.reason === "gameEnd" && currentGame2.winner === null) {
+      throw new TypeError("Game-end switch requires a game winner");
+    }
+    if (pending.reason === "gameThreeMidpoint") {
+      const score = currentGame2.score;
+      if (currentGame2.winner !== null || currentGame2.midGameSwitchCompleted !== false || Math.max(score.A, score.B) < Math.ceil(value.targetScore / 2)) {
+        throw new TypeError("Game-three midpoint switch state is invalid");
+      }
+    }
+  }
+  if (value.status === "inProgress") {
+    if (winnerCounts.A >= 2 || winnerCounts.B >= 2) {
+      throw new TypeError("In-progress match cannot already have a match winner");
+    }
+    if (value.winner !== null || value.endReason !== null) {
+      throw new TypeError("In-progress match cannot have terminal metadata");
+    }
+    if (currentGame2.winner !== null && value.pendingCourtSwitch === null) {
+      throw new TypeError("Completed game must await a court switch");
+    }
+  } else if (value.status === "completed") {
+    const matchWinners = TEAM_IDS.filter((teamId) => winnerCounts[teamId] === 2);
+    if (matchWinners.length !== 1 || !isTeamId(value.winner) || matchWinners[0] !== value.winner || value.gamesWon[value.winner] !== 2 || currentGame2.winner !== value.winner || value.endReason !== null || value.pendingCourtSwitch !== null) {
+      throw new TypeError("Completed match state is invalid");
+    }
+  } else if (value.status === "ended") {
+    if (winnerCounts.A >= 2 || winnerCounts.B >= 2 || value.winner !== null || typeof value.endReason !== "string" || value.endReason.trim().length === 0 || value.pendingCourtSwitch !== null) {
+      throw new TypeError("Explicitly ended match state is invalid");
+    }
+  } else {
+    throw new TypeError("Match status is invalid");
+  }
+}
+function assertCorrection(value) {
+  assertRecord(value, "Match correction");
+  assertRecordKeys(value, ["score", "serve", "playerCourts"], "Match correction");
+  if (value.score === void 0 && value.serve === void 0 && value.playerCourts === void 0) {
+    throw new TypeError("Match correction is empty");
+  }
+  if (value.score !== void 0) {
+    assertRecord(value.score, "Corrected score");
+    assertRecordKeys(value.score, TEAM_IDS, "Corrected score");
+    for (const score of Object.values(value.score)) {
+      if (!Number.isInteger(score)) throw new TypeError("Corrected score must be an integer");
+    }
+  }
+  if (value.serve !== void 0) {
+    assertRecord(value.serve, "Corrected serve");
+    if (!isTeamId(value.serve.teamId) || typeof value.serve.playerId !== "string" || value.serve.serverNumber !== 1 && value.serve.serverNumber !== 2 || !isCourtSide(value.serve.court)) {
+      throw new TypeError("Corrected serve is malformed");
+    }
+  }
+  if (value.playerCourts !== void 0) {
+    assertRecord(value.playerCourts, "Corrected player courts");
+    for (const court of Object.values(value.playerCourts)) {
+      if (!isCourtSide(court)) throw new TypeError("Corrected player court is malformed");
+    }
+  }
+}
+function assertRuntimeMatchEvent(value) {
+  assertRecord(value, "Match event");
+  if (value.schemaVersion !== 1) throw new TypeError("Unsupported match event schema");
+  assertNonEmptyString(value.id, "Match event id");
+  assertInteger(value.sequence, 0, Number.MAX_SAFE_INTEGER, "Match event sequence");
+  if (!isSource(value.source)) throw new TypeError("Invalid match event source");
+  switch (value.type) {
+    case "matchCreated":
+      assertRuntimeMatchSnapshot(value.snapshot);
+      break;
+    case "rallyAwarded":
+      if (!isCourtSide(value.displaySide) || !isTeamId(value.winnerTeamId)) {
+        throw new TypeError("Rally event payload is invalid");
+      }
+      break;
+    case "courtSwitchConfirmed":
+      assertPendingSwitch(value.pending);
+      break;
+    case "matchCorrected":
+      assertCorrection(value.correction);
+      break;
+    case "matchEnded":
+      assertNonEmptyString(value.reason, "Match end reason");
+      break;
+    case "matchEventUndone":
+      assertNonEmptyString(value.targetEventId, "Undo target event id");
+      assertRuntimeMatchSnapshot(value.restoredSnapshot);
+      break;
+    default:
+      throw new TypeError("Unknown match event type");
+  }
+}
+
+// src/match/engine.ts
+var DEFAULT_TARGET_SCORE = 11;
+function oppositeTeam(teamId) {
+  return teamId === "A" ? "B" : "A";
+}
+function oppositeSide(side) {
+  return side === "left" ? "right" : "left";
+}
+function serviceSide(score) {
+  return score % 2 === 0 ? "right" : "left";
+}
+function assertNonEmpty(value, label) {
+  if (value.trim().length === 0) throw new TypeError(`${label} must not be empty`);
+}
+function assertCreateInput(input) {
+  assertNonEmpty(input.id, "Match id");
+  if (input.format !== "singles" && input.format !== "doubles") {
+    throw new TypeError("Invalid match format");
+  }
+  if (input.scoringMode !== "rally" && input.scoringMode !== "sideOut") {
+    throw new TypeError("Invalid scoring mode");
+  }
+  const target = input.targetScore ?? DEFAULT_TARGET_SCORE;
+  if (!Number.isInteger(target) || target < 1 || target > 99) {
+    throw new TypeError("Target score must be an integer from 1 to 99");
+  }
+  const expectedPlayers = input.format === "singles" ? 1 : 2;
+  const playerIds = /* @__PURE__ */ new Set();
+  for (const teamId of ["A", "B"]) {
+    const team = input.teams[teamId];
+    if (!team || team.id !== teamId || team.players.length !== expectedPlayers) {
+      throw new TypeError(`Team ${teamId} must have ${expectedPlayers} player(s)`);
+    }
+    if (team.name !== void 0) assertNonEmpty(team.name, `Team ${teamId} name`);
+    for (const player of team.players) {
+      assertNonEmpty(player.id, "Player id");
+      assertNonEmpty(player.name, "Player name");
+      if (playerIds.has(player.id)) throw new TypeError("Player ids must be unique");
+      playerIds.add(player.id);
+    }
+    if (team.initialServerId !== void 0 && !team.players.some((player) => player.id === team.initialServerId)) {
+      throw new TypeError(`Team ${teamId} initial server must belong to the team`);
+    }
+  }
+  if (input.initialServingTeam !== void 0 && input.initialServingTeam !== "A" && input.initialServingTeam !== "B") {
+    throw new TypeError("Invalid initial serving team");
+  }
+}
+function initialPlayerCourts(teams, designatedServerByTeam) {
+  const courts = {};
+  for (const teamId of ["A", "B"]) {
+    teams[teamId].players.forEach((player) => {
+      courts[player.id] = player.id === designatedServerByTeam[teamId] ? "right" : "left";
+    });
+  }
+  return courts;
+}
+function gameNumber(value) {
+  if (value !== 1 && value !== 2 && value !== 3) {
+    throw new TypeError("A best-of-three match cannot have another game");
+  }
+  return value;
+}
+function makeGame(number, startingServingTeam) {
+  return {
+    number,
+    score: { A: 0, B: 0 },
+    startingServingTeam,
+    winner: null,
+    midGameSwitchCompleted: false
+  };
+}
+function initialServe(snapshot, teamId) {
+  const playerId = snapshot.designatedServerByTeam[teamId];
+  return {
+    teamId,
+    playerId,
+    serverNumber: snapshot.format === "doubles" && snapshot.scoringMode === "sideOut" ? 2 : 1,
+    court: snapshot.playerCourts[playerId]
+  };
+}
+function eventIdentity(snapshot) {
+  const sequence = snapshot.sequence + 1;
+  return { schemaVersion: 1, id: `${snapshot.id}:${sequence}`, sequence };
+}
+function createMatch(input, source = "system") {
+  assertCreateInput(input);
+  const teams = { A: cloneTeam(input.teams.A), B: cloneTeam(input.teams.B) };
+  const designatedServerByTeam = {
+    A: teams.A.initialServerId ?? teams.A.players[0].id,
+    B: teams.B.initialServerId ?? teams.B.players[0].id
+  };
+  const playerCourts = initialPlayerCourts(teams, designatedServerByTeam);
+  const initialServingTeam = input.initialServingTeam ?? "A";
+  const base = {
+    id: input.id,
+    format: input.format,
+    scoringMode: input.scoringMode,
+    targetScore: input.targetScore ?? DEFAULT_TARGET_SCORE,
+    bestOf: 3,
+    teams,
+    designatedServerByTeam,
+    initialServingTeam,
+    courtSides: { left: "A", right: "B" },
+    playerCourts,
+    games: [makeGame(1, initialServingTeam)],
+    currentGame: 1,
+    gamesWon: { A: 0, B: 0 },
+    pendingCourtSwitch: null,
+    status: "inProgress",
+    winner: null,
+    endReason: null,
+    sequence: 0
+  };
+  const snapshot = {
+    ...base,
+    serve: initialServe(base, initialServingTeam)
+  };
+  const event = {
+    type: "matchCreated",
+    schemaVersion: 1,
+    id: `${snapshot.id}:0`,
+    sequence: 0,
+    source,
+    input,
+    snapshot: cloneSnapshot(snapshot)
+  };
+  return { snapshot, events: [event] };
+}
+function assertNextEvent(snapshot, event) {
+  if (event.sequence !== snapshot.sequence + 1) {
+    throw new TypeError("Match event sequence is not contiguous");
+  }
+  if (event.id !== `${snapshot.id}:${event.sequence}`) {
+    throw new TypeError("Match event id does not match its sequence");
+  }
+}
+function currentGame(snapshot) {
+  const game = snapshot.games[snapshot.currentGame - 1];
+  if (!game) throw new TypeError("Current game is missing");
+  return game;
+}
+function updateCurrentGame(snapshot, update) {
+  const games = snapshot.games.map(
+    (game, index) => index === snapshot.currentGame - 1 ? update(game) : game
+  );
+  return { ...snapshot, games };
+}
+function playerOnCourt(snapshot, teamId, court) {
+  const player = snapshot.teams[teamId].players.find(
+    (candidate) => snapshot.playerCourts[candidate.id] === court
+  );
+  if (!player) throw new TypeError(`Team ${teamId} has no player on ${court}`);
+  return player.id;
+}
+function swapTeamPlayers(snapshot, teamId) {
+  if (snapshot.format === "singles") return snapshot;
+  const playerCourts = { ...snapshot.playerCourts };
+  for (const player of snapshot.teams[teamId].players) {
+    playerCourts[player.id] = oppositeSide(playerCourts[player.id]);
+  }
+  return { ...snapshot, playerCourts };
+}
+function serveForPossession(snapshot, teamId, serverNumber = 1) {
+  const score = currentGame(snapshot).score[teamId];
+  const court = serviceSide(score);
+  if (snapshot.format === "singles") {
+    return {
+      teamId,
+      playerId: snapshot.teams[teamId].players[0].id,
+      serverNumber: 1,
+      court
+    };
+  }
+  return {
+    teamId,
+    playerId: playerOnCourt(snapshot, teamId, court),
+    serverNumber,
+    court
+  };
+}
+function finishPoint(snapshot, scoringTeam) {
+  if (!scoringTeam) return snapshot;
+  const game = currentGame(snapshot);
+  if (game.score[scoringTeam] < snapshot.targetScore) {
+    if (snapshot.currentGame === 3 && !game.midGameSwitchCompleted && game.score[scoringTeam] >= Math.ceil(snapshot.targetScore / 2)) {
+      return {
+        ...snapshot,
+        pendingCourtSwitch: { reason: "gameThreeMidpoint", game: 3 }
+      };
+    }
+    return snapshot;
+  }
+  let next = updateCurrentGame(snapshot, (value) => ({
+    ...value,
+    winner: scoringTeam
+  }));
+  const gamesWon = {
+    ...next.gamesWon,
+    [scoringTeam]: next.gamesWon[scoringTeam] + 1
+  };
+  next = { ...next, gamesWon };
+  if (gamesWon[scoringTeam] === 2) {
+    return {
+      ...next,
+      status: "completed",
+      winner: scoringTeam,
+      pendingCourtSwitch: null
+    };
+  }
+  return {
+    ...next,
+    pendingCourtSwitch: {
+      reason: "gameEnd",
+      game: next.currentGame
+    }
+  };
+}
+function scorePoint(snapshot, teamId) {
+  return updateCurrentGame(snapshot, (game) => ({
+    ...game,
+    score: { ...game.score, [teamId]: game.score[teamId] + 1 }
+  }));
+}
+function applyRally(snapshot, winnerTeamId) {
+  const servingTeam = snapshot.serve.teamId;
+  let next = snapshot;
+  let scoringTeam = null;
+  if (snapshot.scoringMode === "rally") {
+    scoringTeam = winnerTeamId;
+    next = scorePoint(next, winnerTeamId);
+    if (winnerTeamId === servingTeam) {
+      next = swapTeamPlayers(next, winnerTeamId);
+      next = {
+        ...next,
+        serve: next.format === "singles" ? serveForPossession(next, winnerTeamId) : {
+          ...next.serve,
+          court: next.playerCourts[next.serve.playerId]
+        }
+      };
+    } else {
+      next = { ...next, serve: serveForPossession(next, winnerTeamId) };
+    }
+  } else if (winnerTeamId === servingTeam) {
+    scoringTeam = winnerTeamId;
+    next = scorePoint(next, winnerTeamId);
+    next = swapTeamPlayers(next, winnerTeamId);
+    next = {
+      ...next,
+      serve: next.format === "singles" ? serveForPossession(next, winnerTeamId) : {
+        ...next.serve,
+        court: next.playerCourts[next.serve.playerId]
+      }
+    };
+  } else if (snapshot.format === "singles") {
+    next = { ...next, serve: serveForPossession(next, winnerTeamId) };
+  } else if (snapshot.serve.serverNumber === 1) {
+    const partner = snapshot.teams[servingTeam].players.find(
+      (player) => player.id !== snapshot.serve.playerId
+    );
+    if (!partner) throw new TypeError("Doubles serving partner is missing");
+    next = {
+      ...next,
+      serve: {
+        teamId: servingTeam,
+        playerId: partner.id,
+        serverNumber: 2,
+        court: snapshot.playerCourts[partner.id]
+      }
+    };
+  } else {
+    next = { ...next, serve: serveForPossession(next, winnerTeamId, 1) };
+  }
+  return finishPoint(next, scoringTeam);
+}
+function assertPlayerCourts(snapshot) {
+  const knownIds = new Set(
+    ["A", "B"].flatMap(
+      (teamId) => snapshot.teams[teamId].players.map((player) => player.id)
+    )
+  );
+  for (const [playerId, court] of Object.entries(snapshot.playerCourts)) {
+    if (!knownIds.has(playerId) || court !== "left" && court !== "right") {
+      throw new TypeError("Correction contains an invalid player court");
+    }
+  }
+  if (Object.keys(snapshot.playerCourts).length !== knownIds.size) {
+    throw new TypeError("Every player must have a court mapping");
+  }
+  if (snapshot.format === "doubles") {
+    for (const teamId of ["A", "B"]) {
+      const [first, second] = snapshot.teams[teamId].players;
+      if (snapshot.playerCourts[first.id] === snapshot.playerCourts[second.id]) {
+        throw new TypeError(`Team ${teamId} players must occupy different courts`);
+      }
+    }
+  }
+}
+function assertServe(snapshot, serve) {
+  const teamPlayerIds = snapshot.teams[serve.teamId].players.map((player) => player.id);
+  if (!teamPlayerIds.includes(serve.playerId)) {
+    throw new TypeError("Server must belong to the serving team");
+  }
+  if (serve.serverNumber !== 1 && serve.serverNumber !== 2) {
+    throw new TypeError("Server number must be one or two");
+  }
+  if (snapshot.format === "singles" || snapshot.format === "doubles" && snapshot.scoringMode === "rally") {
+    if (serve.serverNumber !== 1) throw new TypeError("This mode has one server");
+  }
+  const expectedCourt = snapshot.format === "singles" ? serviceSide(currentGame(snapshot).score[serve.teamId]) : snapshot.playerCourts[serve.playerId];
+  if (serve.court !== expectedCourt) {
+    throw new TypeError("Service court does not match score/player position");
+  }
+  if (snapshot.format === "doubles" && (snapshot.scoringMode === "rally" || serve.serverNumber === 1) && serve.court !== serviceSide(currentGame(snapshot).score[serve.teamId])) {
+    throw new TypeError("First server court does not match the serving team score");
+  }
+}
+function applyCorrection(snapshot, correction) {
+  const correctionKeys = Object.keys(correction);
+  if (correctionKeys.length === 0 || correctionKeys.some(
+    (key) => key !== "score" && key !== "serve" && key !== "playerCourts"
+  ) || correction.score === void 0 && correction.serve === void 0 && correction.playerCourts === void 0) {
+    throw new TypeError("Correction must contain a supported patch");
+  }
+  if (snapshot.status !== "inProgress" || snapshot.pendingCourtSwitch) {
+    throw new TypeError("Only an active, unpaused match can be corrected");
+  }
+  let next = cloneSnapshot(snapshot);
+  const previousScore = currentGame(snapshot).score;
+  if (correction.playerCourts) {
+    next = {
+      ...next,
+      playerCourts: { ...next.playerCourts, ...correction.playerCourts }
+    };
+    assertPlayerCourts(next);
+  }
+  if (correction.score) {
+    if (Object.keys(correction.score).some((teamId) => teamId !== "A" && teamId !== "B")) {
+      throw new TypeError("Correction contains an invalid team score");
+    }
+    for (const value of Object.values(correction.score)) {
+      if (!Number.isInteger(value) || value < 0 || value > next.targetScore) {
+        throw new TypeError("Corrected scores must be non-negative integers up to target");
+      }
+    }
+    next = updateCurrentGame(next, (game) => ({
+      ...game,
+      score: { ...game.score, ...correction.score }
+    }));
+    const score2 = currentGame(next).score;
+    if (score2.A === next.targetScore && score2.B === next.targetScore) {
+      throw new TypeError("Both teams cannot have a winning score");
+    }
+  }
+  const correctedServingScore = correction.score?.[snapshot.serve.teamId];
+  const servingTeamCourtsPatched = snapshot.teams[snapshot.serve.teamId].players.some(
+    (player) => correction.playerCourts?.[player.id] !== void 0
+  );
+  if (next.format === "doubles" && correctedServingScore !== void 0 && correctedServingScore % 2 !== previousScore[snapshot.serve.teamId] % 2) {
+    if (servingTeamCourtsPatched) {
+      const hasExpectedRotation = snapshot.teams[snapshot.serve.teamId].players.every(
+        (player) => next.playerCourts[player.id] === oppositeSide(snapshot.playerCourts[player.id])
+      );
+      if (!hasExpectedRotation) {
+        throw new TypeError("Corrected serving positions do not match the score change");
+      }
+    } else {
+      next = swapTeamPlayers(next, snapshot.serve.teamId);
+      next = {
+        ...next,
+        serve: { ...next.serve, court: next.playerCourts[next.serve.playerId] }
+      };
+    }
+  }
+  if (correction.serve) {
+    assertServe(next, correction.serve);
+    next = { ...next, serve: { ...correction.serve } };
+  } else if (correction.playerCourts?.[next.serve.playerId]) {
+    next = {
+      ...next,
+      serve: { ...next.serve, court: next.playerCourts[next.serve.playerId] }
+    };
+  } else if (correction.score && next.format === "singles") {
+    next = { ...next, serve: serveForPossession(next, next.serve.teamId) };
+  }
+  assertServe(next, next.serve);
+  const score = currentGame(next).score;
+  const winningTeam = score.A === next.targetScore ? "A" : score.B === next.targetScore ? "B" : null;
+  const midpoint = Math.ceil(next.targetScore / 2);
+  const midpointTeam = score.A >= midpoint ? "A" : score.B >= midpoint ? "B" : null;
+  return finishPoint(next, winningTeam ?? midpointTeam);
+}
+function applyMatchEvent(snapshot, event) {
+  assertRuntimeMatchSnapshot(snapshot);
+  assertRuntimeMatchEvent(event);
+  if (event.type === "matchCreated") {
+    throw new TypeError("A creation event can only begin an event log");
+  }
+  assertNextEvent(snapshot, event);
+  let next;
+  switch (event.type) {
+    case "rallyAwarded":
+      if (snapshot.status !== "inProgress" || snapshot.pendingCourtSwitch) {
+        throw new TypeError("A paused or terminal match cannot accept a rally");
+      }
+      if (snapshot.courtSides[event.displaySide] !== event.winnerTeamId) {
+        throw new TypeError("Rally display side does not map to its winning team");
+      }
+      next = applyRally(cloneSnapshot(snapshot), event.winnerTeamId);
+      break;
+    case "courtSwitchConfirmed": {
+      if (snapshot.status !== "inProgress" || !snapshot.pendingCourtSwitch || JSON.stringify(snapshot.pendingCourtSwitch) !== JSON.stringify(event.pending)) {
+        throw new TypeError("No matching court switch is pending");
+      }
+      next = {
+        ...cloneSnapshot(snapshot),
+        courtSides: {
+          left: snapshot.courtSides.right,
+          right: snapshot.courtSides.left
+        },
+        pendingCourtSwitch: null
+      };
+      if (event.pending.reason === "gameThreeMidpoint") {
+        next = updateCurrentGame(next, (game) => ({
+          ...game,
+          midGameSwitchCompleted: true
+        }));
+      } else {
+        const nextNumber = gameNumber(snapshot.currentGame + 1);
+        const startingServingTeam = nextNumber % 2 === 1 ? snapshot.initialServingTeam : oppositeTeam(snapshot.initialServingTeam);
+        const playerCourts = initialPlayerCourts(
+          snapshot.teams,
+          snapshot.designatedServerByTeam
+        );
+        const withoutServe = {
+          ...next,
+          playerCourts,
+          games: [...next.games, makeGame(nextNumber, startingServingTeam)],
+          currentGame: nextNumber
+        };
+        next = {
+          ...withoutServe,
+          serve: initialServe(withoutServe, startingServingTeam)
+        };
+      }
+      break;
+    }
+    case "matchCorrected":
+      next = applyCorrection(snapshot, event.correction);
+      break;
+    case "matchEnded":
+      if (snapshot.status !== "inProgress") {
+        throw new TypeError("Match is already terminal");
+      }
+      next = {
+        ...cloneSnapshot(snapshot),
+        status: "ended",
+        winner: null,
+        endReason: event.reason,
+        pendingCourtSwitch: null
+      };
+      break;
+    case "matchEventUndone":
+      if (event.restoredSnapshot.id !== snapshot.id || !event.targetEventId.startsWith(`${snapshot.id}:`)) {
+        throw new TypeError("Undo payload belongs to a different match");
+      }
+      const targetSequence = Number(event.targetEventId.slice(snapshot.id.length + 1));
+      if (!Number.isInteger(targetSequence) || targetSequence < 1 || targetSequence >= event.sequence || event.restoredSnapshot.sequence !== targetSequence - 1) {
+        throw new TypeError("Undo payload has an invalid target lineage");
+      }
+      next = cloneSnapshot(event.restoredSnapshot);
+      break;
+    default:
+      throw new TypeError("Unknown match event type");
+  }
+  const result = { ...next, sequence: event.sequence };
+  assertRuntimeMatchSnapshot(result);
+  return result;
+}
+function awardRally(snapshot, displaySide, source = "local") {
+  if (snapshot.status !== "inProgress" || snapshot.pendingCourtSwitch) return null;
+  if (displaySide !== "left" && displaySide !== "right") {
+    throw new TypeError("Invalid display side");
+  }
+  return {
+    type: "rallyAwarded",
+    ...eventIdentity(snapshot),
+    source,
+    displaySide,
+    winnerTeamId: snapshot.courtSides[displaySide]
+  };
+}
+function confirmCourtSwitch(snapshot, source = "local") {
+  if (snapshot.status !== "inProgress" || !snapshot.pendingCourtSwitch) {
+    throw new TypeError("No court switch is pending");
+  }
+  return {
+    type: "courtSwitchConfirmed",
+    ...eventIdentity(snapshot),
+    source,
+    pending: { ...snapshot.pendingCourtSwitch }
+  };
+}
+function correctMatch(snapshot, correction, source = "local") {
+  const event = {
+    type: "matchCorrected",
+    ...eventIdentity(snapshot),
+    source,
+    correction: {
+      ...correction.score ? { score: { ...correction.score } } : {},
+      ...correction.serve ? { serve: { ...correction.serve } } : {},
+      ...correction.playerCourts ? { playerCourts: { ...correction.playerCourts } } : {}
+    }
+  };
+  applyMatchEvent(snapshot, event);
+  return event;
+}
+function endMatch(snapshot, reason, source = "local") {
+  assertNonEmpty(reason, "End reason");
+  if (snapshot.status !== "inProgress") throw new TypeError("Match is already terminal");
+  return {
+    type: "matchEnded",
+    ...eventIdentity(snapshot),
+    source,
+    reason
+  };
+}
+
+// src/match/replay.ts
+function replayTrace(events) {
+  const [rawCreated, ...remaining] = events;
+  assertRuntimeMatchEvent(rawCreated);
+  if (rawCreated.type !== "matchCreated" || rawCreated.sequence !== 0) {
+    throw new TypeError("A match event log must begin with its creation event");
+  }
+  const created = rawCreated;
+  if (created.id !== `${created.snapshot.id}:0`) {
+    throw new TypeError("Creation event id does not match its snapshot");
+  }
+  const expected = createMatch(
+    {
+      id: created.snapshot.id,
+      format: created.snapshot.format,
+      scoringMode: created.snapshot.scoringMode,
+      targetScore: created.snapshot.targetScore,
+      initialServingTeam: created.snapshot.initialServingTeam,
+      teams: created.snapshot.teams
+    },
+    created.source
+  ).snapshot;
+  if (!valuesEqual(expected, created.snapshot)) {
+    throw new TypeError("Creation snapshot is not a valid initial match state");
+  }
+  let snapshot = cloneSnapshot(created.snapshot);
+  const effectiveEvents = [];
+  let processedEvents = 1;
+  let undoValidations = 0;
+  for (const rawEvent of remaining) {
+    assertRuntimeMatchEvent(rawEvent);
+    const event = rawEvent;
+    if (event.type === "matchEventUndone") {
+      const target = effectiveEvents.at(-1);
+      if (!target || target.event.id !== event.targetEventId) {
+        throw new TypeError("Undo does not target the latest effective match event");
+      }
+      if (!valuesEqual(target.before, event.restoredSnapshot)) {
+        throw new TypeError("Undo snapshot does not match its event lineage");
+      }
+      effectiveEvents.pop();
+      undoValidations += 1;
+    } else {
+      effectiveEvents.push({ event, before: cloneSnapshot(snapshot) });
+    }
+    snapshot = applyMatchEvent(snapshot, event);
+    processedEvents += 1;
+  }
+  return { snapshot, effectiveEvents, processedEvents, undoValidations };
+}
+function replayMatchEvents(events) {
+  return replayTrace(events).snapshot;
+}
+function undoLastMatchEvent(events, source = "local") {
+  const trace = replayTrace(events);
+  const target = trace.effectiveEvents.at(-1);
+  if (!target) return null;
+  const sequence = trace.snapshot.sequence + 1;
+  return {
+    type: "matchEventUndone",
+    schemaVersion: 1,
+    id: `${trace.snapshot.id}:${sequence}`,
+    sequence,
+    source,
+    targetEventId: target.event.id,
+    restoredSnapshot: cloneSnapshot(target.before)
+  };
+}
+
+// src/match/persistence/types.ts
+var MATCH_PERSISTENCE_SCHEMA_VERSION = 1;
+var MatchPersistenceError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.retryable = code === "storage_failure";
+  }
+  name = "MatchPersistenceError";
+  recoverable = true;
+  retryable;
+};
+
+// src/match/persistence/migrations.ts
+var MATCH_SQL_SCHEMA_VERSION = 2;
+var MATCH_SQL_MIGRATIONS = [
+  `CREATE TABLE IF NOT EXISTS match_aggregates (
+    match_id TEXT PRIMARY KEY NOT NULL,
+    schema_version INTEGER NOT NULL CHECK (schema_version = 1),
+    snapshot_json TEXT NOT NULL,
+    snapshot_sequence INTEGER NOT NULL CHECK (snapshot_sequence >= 0),
+    status TEXT NOT NULL CHECK (status IN ('inProgress', 'completed', 'ended')),
+    updated_at INTEGER NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS match_events (
+    match_id TEXT NOT NULL,
+    sequence INTEGER NOT NULL CHECK (sequence >= 0),
+    event_id TEXT NOT NULL UNIQUE,
+    schema_version INTEGER NOT NULL CHECK (schema_version = 1),
+    event_json TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    PRIMARY KEY (match_id, sequence),
+    FOREIGN KEY (match_id) REFERENCES match_aggregates(match_id) ON DELETE RESTRICT
+  )`,
+  `CREATE TABLE IF NOT EXISTS match_active_pointer (
+    slot INTEGER PRIMARY KEY NOT NULL CHECK (slot = 1),
+    match_id TEXT NOT NULL UNIQUE,
+    FOREIGN KEY (match_id) REFERENCES match_aggregates(match_id) ON DELETE RESTRICT
+  )`,
+  `CREATE INDEX IF NOT EXISTS match_aggregates_recent
+    ON match_aggregates(updated_at DESC)`,
+  `CREATE TRIGGER IF NOT EXISTS match_events_no_update
+    BEFORE UPDATE ON match_events
+    BEGIN SELECT RAISE(ABORT, 'match events are immutable'); END`,
+  `CREATE TRIGGER IF NOT EXISTS match_events_no_delete
+    BEFORE DELETE ON match_events
+    BEGIN SELECT RAISE(ABORT, 'match events are immutable'); END`,
+  `CREATE TABLE IF NOT EXISTS remote_binding (
+    slot INTEGER PRIMARY KEY NOT NULL CHECK (slot = 1),
+    device_id TEXT NOT NULL CHECK (length(trim(device_id)) > 0),
+    label TEXT
+  )`
+];
+
+// src/match/persistence/memory-driver.ts
+function cloneState(state) {
+  return {
+    migrationVersion: state.migrationVersion,
+    remoteBinding: state.remoteBinding ? { ...state.remoteBinding } : null,
+    activeMatchId: state.activeMatchId,
+    matches: state.matches.map((row) => ({ ...row })),
+    events: state.events.map((row) => ({ ...row })),
+    nextOrdinal: state.nextOrdinal,
+    ordinals: { ...state.ordinals }
+  };
+}
+var MemoryMatchPersistenceDriver = class {
+  state = {
+    migrationVersion: 0,
+    remoteBinding: null,
+    activeMatchId: null,
+    matches: [],
+    events: [],
+    nextOrdinal: 0,
+    ordinals: {}
+  };
+  eventInsertFailure = null;
+  snapshotUpdateFailure = null;
+  transactionTail = Promise.resolve();
+  async migrate() {
+    this.state.migrationVersion = 2;
+  }
+  async getRemoteBinding() {
+    return this.state.remoteBinding ? { ...this.state.remoteBinding } : null;
+  }
+  async setRemoteBinding(binding) {
+    this.state.remoteBinding = binding ? { ...binding } : null;
+  }
+  getMigrationVersion() {
+    return this.state.migrationVersion;
+  }
+  async transaction(work) {
+    const previous = this.transactionTail;
+    let release;
+    this.transactionTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      const draft = cloneState(this.state);
+      const transaction = {
+        getMatch: async (matchId) => {
+          const row = draft.matches.find(
+            (candidate) => candidate.matchId === matchId
+          );
+          return row ? { ...row } : null;
+        },
+        getEvents: async (matchId) => draft.events.filter((row) => row.matchId === matchId).sort((left, right) => left.sequence - right.sequence).map((row) => ({ ...row })),
+        insertMatch: async (row) => {
+          if (draft.matches.some((candidate) => candidate.matchId === row.matchId)) {
+            throw new Error("match id already exists");
+          }
+          draft.matches.push({ ...row });
+          draft.ordinals[row.matchId] = draft.nextOrdinal;
+          draft.nextOrdinal += 1;
+        },
+        insertEvent: async (row) => {
+          if (this.eventInsertFailure) {
+            const failure = this.eventInsertFailure;
+            this.eventInsertFailure = null;
+            throw failure;
+          }
+          if (draft.events.some(
+            (candidate) => candidate.eventId === row.eventId || candidate.matchId === row.matchId && candidate.sequence === row.sequence
+          )) {
+            throw new Error("event ordering constraint failed");
+          }
+          if (!draft.matches.some((candidate) => candidate.matchId === row.matchId)) {
+            throw new Error("event foreign key constraint failed");
+          }
+          draft.events.push({ ...row });
+        },
+        updateSnapshot: async (matchId, expectedSequence, row) => {
+          if (this.snapshotUpdateFailure) {
+            const failure = this.snapshotUpdateFailure;
+            this.snapshotUpdateFailure = null;
+            throw failure;
+          }
+          const index = draft.matches.findIndex(
+            (candidate) => candidate.matchId === matchId && candidate.snapshotSequence === expectedSequence
+          );
+          if (index < 0) return false;
+          draft.matches[index] = { matchId, ...row };
+          return true;
+        },
+        setActiveMatch: async (matchId) => {
+          if (matchId !== null && !draft.matches.some((candidate) => candidate.matchId === matchId)) {
+            throw new Error("active match foreign key constraint failed");
+          }
+          draft.activeMatchId = matchId;
+        },
+        clearActiveMatch: async (matchId) => {
+          if (draft.activeMatchId === matchId) draft.activeMatchId = null;
+        }
+      };
+      const result = await work(transaction);
+      this.state = draft;
+      return result;
+    } finally {
+      release();
+    }
+  }
+  async readMatch(matchId) {
+    const snapshot = cloneState(this.state);
+    return {
+      match: snapshot.matches.find((candidate) => candidate.matchId === matchId) ?? null,
+      events: snapshot.events.filter((row) => row.matchId === matchId).sort((left, right) => left.sequence - right.sequence)
+    };
+  }
+  async getActiveMatchId() {
+    return this.state.activeMatchId;
+  }
+  async readActiveMatch() {
+    const snapshot = cloneState(this.state);
+    const activeMatchId = snapshot.activeMatchId;
+    if (!activeMatchId) {
+      return { activeMatchId: null, match: null, events: [] };
+    }
+    return {
+      activeMatchId,
+      match: snapshot.matches.find((candidate) => candidate.matchId === activeMatchId) ?? null,
+      events: snapshot.events.filter((row) => row.matchId === activeMatchId).sort((left, right) => left.sequence - right.sequence)
+    };
+  }
+  async readMatchList() {
+    const snapshot = cloneState(this.state);
+    return {
+      matches: snapshot.matches.slice().sort(
+        (left, right) => right.updatedAt - left.updatedAt || snapshot.ordinals[right.matchId] - snapshot.ordinals[left.matchId]
+      ),
+      activeMatchId: snapshot.activeMatchId
+    };
+  }
+  inspect() {
+    return cloneState(this.state);
+  }
+  failNextSnapshotUpdate(error) {
+    this.snapshotUpdateFailure = error;
+  }
+  failNextEventInsert(error) {
+    this.eventInsertFailure = error;
+  }
+  corruptSnapshotJson(matchId, snapshotJson) {
+    this.mutateMatch(matchId, (row) => ({ ...row, snapshotJson }));
+  }
+  corruptEventJson(matchId, sequence, eventJson) {
+    this.mutateEvent(matchId, sequence, (row) => ({ ...row, eventJson }));
+  }
+  corruptEventSchema(matchId, sequence, schemaVersion) {
+    this.mutateEvent(matchId, sequence, (row) => ({ ...row, schemaVersion }));
+  }
+  corruptEventSequence(matchId, sequence) {
+    this.mutateEvent(matchId, 0, (row) => ({ ...row, sequence }));
+  }
+  duplicateEventRow(matchId, sequence) {
+    const row = this.state.events.find(
+      (candidate) => candidate.matchId === matchId && candidate.sequence === sequence
+    );
+    if (!row) throw new Error("event row not found");
+    this.state.events.push({ ...row });
+  }
+  removeEventRow(matchId, sequence) {
+    this.state.events = this.state.events.filter(
+      (row) => row.matchId !== matchId || row.sequence !== sequence
+    );
+  }
+  mutateMatch(matchId, mutation) {
+    const index = this.state.matches.findIndex((row) => row.matchId === matchId);
+    if (index < 0) throw new Error("match row not found");
+    this.state.matches[index] = mutation(this.state.matches[index]);
+  }
+  mutateEvent(matchId, sequence, mutation) {
+    const index = this.state.events.findIndex(
+      (row) => row.matchId === matchId && row.sequence === sequence
+    );
+    if (index < 0) throw new Error("event row not found");
+    this.state.events[index] = mutation(this.state.events[index]);
+  }
+};
+
+// src/match/persistence/sqlite-driver.ts
+var connectionCoordinators = /* @__PURE__ */ new WeakMap();
+function coordinationFor(database) {
+  const existing = connectionCoordinators.get(database);
+  if (existing) return existing;
+  const coordination = {
+    tail: Promise.resolve(),
+    poisoned: null
+  };
+  connectionCoordinators.set(database, coordination);
+  return coordination;
+}
+var mapMatchRow = (row) => ({
+  matchId: row.match_id,
+  schemaVersion: row.schema_version,
+  snapshotJson: row.snapshot_json,
+  snapshotSequence: row.snapshot_sequence,
+  status: row.status,
+  updatedAt: row.updated_at
+});
+var mapEventRow = (row) => ({
+  matchId: row.match_id,
+  sequence: row.sequence,
+  eventId: row.event_id,
+  schemaVersion: row.schema_version,
+  eventJson: row.event_json,
+  createdAt: row.created_at
+});
+function transactionFor(executor) {
+  return {
+    async getMatch(matchId) {
+      const row = await executor.getFirstAsync(
+        "SELECT * FROM match_aggregates WHERE match_id = ?",
+        matchId
+      );
+      return row ? mapMatchRow(row) : null;
+    },
+    async getEvents(matchId) {
+      const rows = await executor.getAllAsync(
+        "SELECT * FROM match_events WHERE match_id = ? ORDER BY sequence ASC",
+        matchId
+      );
+      return rows.map(mapEventRow);
+    },
+    async insertMatch(row) {
+      await executor.runAsync(
+        `INSERT INTO match_aggregates
+          (match_id, schema_version, snapshot_json, snapshot_sequence, status, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?)`,
+        row.matchId,
+        row.schemaVersion,
+        row.snapshotJson,
+        row.snapshotSequence,
+        row.status,
+        row.updatedAt
+      );
+    },
+    async insertEvent(row) {
+      await executor.runAsync(
+        `INSERT INTO match_events
+          (match_id, sequence, event_id, schema_version, event_json, created_at)
+          VALUES (?, ?, ?, ?, ?, ?)`,
+        row.matchId,
+        row.sequence,
+        row.eventId,
+        row.schemaVersion,
+        row.eventJson,
+        row.createdAt
+      );
+    },
+    async updateSnapshot(matchId, expectedSequence, row) {
+      const result = await executor.runAsync(
+        `UPDATE match_aggregates
+          SET schema_version = ?, snapshot_json = ?, snapshot_sequence = ?, status = ?, updated_at = ?
+          WHERE match_id = ? AND snapshot_sequence = ?`,
+        row.schemaVersion,
+        row.snapshotJson,
+        row.snapshotSequence,
+        row.status,
+        row.updatedAt,
+        matchId,
+        expectedSequence
+      );
+      return result.changes === 1;
+    },
+    async setActiveMatch(matchId) {
+      if (matchId === null) {
+        await executor.runAsync("DELETE FROM match_active_pointer WHERE slot = 1");
+        return;
+      }
+      await executor.runAsync(
+        `INSERT INTO match_active_pointer (slot, match_id) VALUES (1, ?)
+          ON CONFLICT(slot) DO UPDATE SET match_id = excluded.match_id`,
+        matchId
+      );
+    },
+    async clearActiveMatch(matchId) {
+      await executor.runAsync(
+        "DELETE FROM match_active_pointer WHERE slot = 1 AND match_id = ?",
+        matchId
+      );
+    }
+  };
+}
+function createExpoSqliteMatchDriver(database) {
+  const coordination = coordinationFor(database);
+  function poisonAfterRollbackFailure(error) {
+    if (!coordination.poisoned) {
+      coordination.poisoned = new MatchPersistenceError(
+        "storage_failure",
+        "The SQLite connection is unusable after rollback failed",
+        { cause: error }
+      );
+    }
+  }
+  async function runSerialized(work) {
+    const previous = coordination.tail;
+    let release;
+    coordination.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      if (coordination.poisoned) throw coordination.poisoned;
+      return await work();
+    } finally {
+      release();
+    }
+  }
+  function runAtomic(begin, work) {
+    return runSerialized(async () => {
+      let began = false;
+      try {
+        await database.execAsync(begin);
+        began = true;
+        const result = await work(transactionFor(database));
+        await database.execAsync("COMMIT");
+        return result;
+      } catch (error) {
+        if (!began) throw error;
+        try {
+          await database.execAsync("ROLLBACK");
+        } catch (rollbackError) {
+          poisonAfterRollbackFailure(rollbackError);
+        }
+        throw error;
+      }
+    });
+  }
+  return {
+    async migrate() {
+      await runSerialized(async () => {
+        await database.execAsync("PRAGMA busy_timeout = 5000");
+        await database.execAsync("PRAGMA foreign_keys = ON");
+        const foreignKeys = await database.getFirstAsync(
+          "PRAGMA foreign_keys"
+        );
+        if (foreignKeys?.foreign_keys !== 1) {
+          throw new MatchPersistenceError(
+            "storage_failure",
+            "SQLite foreign-key enforcement could not be enabled"
+          );
+        }
+        const version = await database.getFirstAsync(
+          "PRAGMA user_version"
+        );
+        if (!version || !Number.isInteger(version.user_version)) {
+          throw new MatchPersistenceError(
+            "storage_failure",
+            "SQLite did not return a valid schema version"
+          );
+        }
+        if (version.user_version > MATCH_SQL_SCHEMA_VERSION) {
+          throw new MatchPersistenceError(
+            "unsupported_schema",
+            "The local match database uses a newer schema version"
+          );
+        }
+        if (version.user_version === MATCH_SQL_SCHEMA_VERSION) return;
+        let began = false;
+        try {
+          await database.execAsync("BEGIN IMMEDIATE");
+          began = true;
+          for (const migration of MATCH_SQL_MIGRATIONS) {
+            await database.execAsync(migration);
+          }
+          await database.execAsync(`PRAGMA user_version = ${MATCH_SQL_SCHEMA_VERSION}`);
+          await database.execAsync("COMMIT");
+        } catch (error) {
+          if (began) {
+            try {
+              await database.execAsync("ROLLBACK");
+            } catch (rollbackError) {
+              poisonAfterRollbackFailure(rollbackError);
+            }
+          }
+          throw error;
+        }
+      });
+    },
+    async transaction(work) {
+      return runAtomic("BEGIN IMMEDIATE", work);
+    },
+    async readMatch(matchId) {
+      return runAtomic("BEGIN", async (reader) => {
+        const [match, events] = await Promise.all([
+          reader.getMatch(matchId),
+          reader.getEvents(matchId)
+        ]);
+        return { match, events };
+      });
+    },
+    async getActiveMatchId() {
+      return runSerialized(async () => {
+        const row = await database.getFirstAsync(
+          "SELECT match_id FROM match_active_pointer WHERE slot = 1"
+        );
+        return row?.match_id ?? null;
+      });
+    },
+    async readActiveMatch() {
+      return runAtomic("BEGIN", async (reader) => {
+        const active = await database.getFirstAsync(
+          "SELECT match_id FROM match_active_pointer WHERE slot = 1"
+        );
+        if (!active) {
+          return { activeMatchId: null, match: null, events: [] };
+        }
+        const [match, events] = await Promise.all([
+          reader.getMatch(active.match_id),
+          reader.getEvents(active.match_id)
+        ]);
+        return { activeMatchId: active.match_id, match, events };
+      });
+    },
+    async readMatchList() {
+      return runAtomic("BEGIN", async () => {
+        const [matches, activeMatch] = await Promise.all([
+          database.getAllAsync(
+            "SELECT * FROM match_aggregates ORDER BY updated_at DESC, rowid DESC"
+          ),
+          database.getFirstAsync(
+            "SELECT match_id FROM match_active_pointer WHERE slot = 1"
+          )
+        ]);
+        return {
+          matches: matches.map(mapMatchRow),
+          activeMatchId: activeMatch?.match_id ?? null
+        };
+      });
+    },
+    async getRemoteBinding() {
+      return runSerialized(async () => {
+        const row = await database.getFirstAsync(
+          "SELECT device_id, label FROM remote_binding WHERE slot = 1"
+        );
+        return row ? { deviceId: row.device_id, ...row.label === null ? {} : { label: row.label } } : null;
+      });
+    },
+    async setRemoteBinding(binding) {
+      return runSerialized(async () => {
+        if (!binding) {
+          await database.runAsync("DELETE FROM remote_binding WHERE slot = 1");
+          return;
+        }
+        await database.runAsync(
+          `INSERT INTO remote_binding (slot, device_id, label) VALUES (1, ?, ?)
+            ON CONFLICT(slot) DO UPDATE SET device_id = excluded.device_id, label = excluded.label`,
+          binding.deviceId,
+          binding.label ?? null
+        );
+      });
+    }
+  };
+}
+
+// src/match/persistence/store.ts
+function asPersistenceError(error) {
+  if (error instanceof MatchPersistenceError) return error;
+  return new MatchPersistenceError(
+    "storage_failure",
+    "The local match database operation failed",
+    { cause: error }
+  );
+}
+function parseJson(json, label) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    throw new MatchPersistenceError("corrupt_data", `${label} contains malformed JSON`, {
+      cause: error
+    });
+  }
+}
+function snapshotRow(snapshot, updatedAt) {
+  return {
+    matchId: snapshot.id,
+    schemaVersion: MATCH_PERSISTENCE_SCHEMA_VERSION,
+    snapshotJson: JSON.stringify(snapshot),
+    snapshotSequence: snapshot.sequence,
+    status: snapshot.status,
+    updatedAt
+  };
+}
+function eventRow(matchId, event, createdAt) {
+  return {
+    matchId,
+    sequence: event.sequence,
+    eventId: event.id,
+    schemaVersion: event.schemaVersion,
+    eventJson: JSON.stringify(event),
+    createdAt
+  };
+}
+function decodePersistedMatch(matchId, row, eventRows) {
+  if (row.schemaVersion !== MATCH_PERSISTENCE_SCHEMA_VERSION || eventRows.some((event) => event.schemaVersion !== MATCH_PERSISTENCE_SCHEMA_VERSION)) {
+    throw new MatchPersistenceError(
+      "unsupported_schema",
+      "The stored match uses an unsupported schema version"
+    );
+  }
+  if (eventRows.length === 0) {
+    throw new MatchPersistenceError("corrupt_data", "The match creation event is missing");
+  }
+  eventRows.forEach((storedEvent, index) => {
+    if (storedEvent.matchId !== matchId || storedEvent.sequence !== index || storedEvent.eventId !== `${matchId}:${index}`) {
+      throw new MatchPersistenceError(
+        "sequence_mismatch",
+        "The stored match event sequence is not contiguous"
+      );
+    }
+  });
+  const events = eventRows.map((storedEvent) => {
+    const value = parseJson(storedEvent.eventJson, "Stored match event");
+    try {
+      assertRuntimeMatchEvent(value);
+    } catch (error) {
+      throw new MatchPersistenceError("corrupt_data", "A stored match event is invalid", {
+        cause: error
+      });
+    }
+    if (value.id !== storedEvent.eventId || value.sequence !== storedEvent.sequence || value.schemaVersion !== storedEvent.schemaVersion) {
+      throw new MatchPersistenceError(
+        "sequence_mismatch",
+        "A stored event does not match its database ordering metadata"
+      );
+    }
+    return value;
+  });
+  let replayed;
+  try {
+    replayed = replayMatchEvents(events);
+  } catch (error) {
+    throw new MatchPersistenceError("corrupt_data", "The stored event log cannot be replayed", {
+      cause: error
+    });
+  }
+  const cachedValue = parseJson(row.snapshotJson, "Stored match snapshot");
+  try {
+    assertRuntimeMatchSnapshot(cachedValue);
+  } catch (error) {
+    throw new MatchPersistenceError("corrupt_data", "The stored match snapshot is invalid", {
+      cause: error
+    });
+  }
+  if (row.matchId !== replayed.id || row.snapshotSequence !== replayed.sequence || row.status !== replayed.status || !valuesEqual(cachedValue, replayed)) {
+    throw new MatchPersistenceError(
+      "snapshot_mismatch",
+      "The snapshot cache does not match the immutable event log"
+    );
+  }
+  return { snapshot: replayed, events };
+}
+async function readPersistedMatch(driver, matchId) {
+  const { match, events } = await driver.readMatch(matchId);
+  return match ? decodePersistedMatch(matchId, match, events) : null;
+}
+function resolveCreateRetry(existing, requested) {
+  if (valuesEqual(existing.events[0], requested.events[0])) {
+    return existing;
+  }
+  throw new MatchPersistenceError(
+    "already_exists",
+    "A different match already uses this match id"
+  );
+}
+function resolveAppendRetry(persisted, currentSnapshot, event) {
+  if (event.sequence !== currentSnapshot.sequence + 1 || event.id !== `${currentSnapshot.id}:${event.sequence}`) {
+    return null;
+  }
+  const existingEvent = persisted.events[event.sequence];
+  if (!existingEvent) return null;
+  let snapshotBeforeEvent;
+  try {
+    snapshotBeforeEvent = replayMatchEvents(persisted.events.slice(0, event.sequence));
+  } catch (error) {
+    throw new MatchPersistenceError(
+      "corrupt_data",
+      "The persisted event prefix cannot be replayed",
+      { cause: error }
+    );
+  }
+  if (!valuesEqual(snapshotBeforeEvent, currentSnapshot)) {
+    throw new MatchPersistenceError(
+      "snapshot_mismatch",
+      "The caller snapshot does not match the event's persisted prefix"
+    );
+  }
+  if (!valuesEqual(existingEvent, event)) {
+    throw new MatchPersistenceError(
+      "conflict",
+      "A different event already exists at this match sequence"
+    );
+  }
+  return persisted;
+}
+function assertMatchListMetadata(row) {
+  if (row.schemaVersion !== MATCH_PERSISTENCE_SCHEMA_VERSION) {
+    throw new MatchPersistenceError(
+      "unsupported_schema",
+      "A stored match summary uses an unsupported schema version"
+    );
+  }
+  if (typeof row.matchId !== "string" || row.matchId.trim().length === 0 || typeof row.snapshotJson !== "string" || !Number.isSafeInteger(row.snapshotSequence) || row.snapshotSequence < 0 || row.status !== "inProgress" && row.status !== "completed" && row.status !== "ended" || !Number.isSafeInteger(row.updatedAt) || row.updatedAt < 0) {
+    throw new MatchPersistenceError(
+      "corrupt_data",
+      "A stored match summary contains invalid metadata"
+    );
+  }
+}
+var MatchEventStore = class {
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.now = options.now ?? Date.now;
+  }
+  initialized = null;
+  now;
+  initialize() {
+    if (!this.initialized) {
+      this.initialized = this.driver.migrate().catch((error) => {
+        this.initialized = null;
+        throw asPersistenceError(error);
+      });
+    }
+    return this.initialized;
+  }
+  async getRemoteBinding() {
+    await this.initialize();
+    if (!this.driver.getRemoteBinding) return null;
+    try {
+      return await this.driver.getRemoteBinding();
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+  }
+  async setRemoteBinding(binding) {
+    if (binding && binding.deviceId.trim().length === 0) {
+      throw new MatchPersistenceError("corrupt_data", "Remote binding identifier cannot be empty");
+    }
+    await this.initialize();
+    if (!this.driver.setRemoteBinding) {
+      throw new MatchPersistenceError("storage_failure", "Remote binding storage is unavailable");
+    }
+    try {
+      await this.driver.setRemoteBinding(binding);
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+  }
+  async createMatch(input, source = "system") {
+    await this.initialize();
+    const created = createMatch(input, source);
+    const timestamp = this.now();
+    try {
+      return await this.driver.transaction(async (transaction) => {
+        const [existingRow, existingEvents] = await Promise.all([
+          transaction.getMatch(created.snapshot.id),
+          transaction.getEvents(created.snapshot.id)
+        ]);
+        if (existingRow) {
+          return resolveCreateRetry(
+            decodePersistedMatch(created.snapshot.id, existingRow, existingEvents),
+            created
+          );
+        }
+        if (existingEvents.length > 0) {
+          throw new MatchPersistenceError(
+            "corrupt_data",
+            "Match events exist without their aggregate"
+          );
+        }
+        await transaction.insertMatch(snapshotRow(created.snapshot, timestamp));
+        await transaction.insertEvent(eventRow(created.snapshot.id, created.events[0], timestamp));
+        await transaction.setActiveMatch(created.snapshot.id);
+        return created;
+      });
+    } catch (error) {
+      if (error instanceof MatchPersistenceError) throw error;
+      try {
+        const existing = await readPersistedMatch(this.driver, created.snapshot.id);
+        if (existing) return resolveCreateRetry(existing, created);
+      } catch (reconciliationError) {
+        if (reconciliationError instanceof MatchPersistenceError) {
+          throw reconciliationError;
+        }
+      }
+      throw asPersistenceError(error);
+    }
+  }
+  async appendEvent(currentSnapshot, event) {
+    await this.initialize();
+    const timestamp = this.now();
+    try {
+      return await this.driver.transaction(async (transaction) => {
+        const [row, eventRows] = await Promise.all([
+          transaction.getMatch(currentSnapshot.id),
+          transaction.getEvents(currentSnapshot.id)
+        ]);
+        if (!row) {
+          throw new MatchPersistenceError("not_found", "The match to update is missing");
+        }
+        const persisted = decodePersistedMatch(currentSnapshot.id, row, eventRows);
+        const retried = resolveAppendRetry(persisted, currentSnapshot, event);
+        if (retried) return retried;
+        if (!valuesEqual(persisted.snapshot, currentSnapshot)) {
+          throw new MatchPersistenceError(
+            "snapshot_mismatch",
+            "The caller snapshot does not match the immutable event log"
+          );
+        }
+        let nextSnapshot;
+        try {
+          nextSnapshot = applyMatchEvent(currentSnapshot, event);
+        } catch (error) {
+          throw new MatchPersistenceError(
+            "sequence_mismatch",
+            "The match event cannot follow the current snapshot",
+            { cause: error }
+          );
+        }
+        await transaction.insertEvent(eventRow(currentSnapshot.id, event, timestamp));
+        const updated = await transaction.updateSnapshot(
+          currentSnapshot.id,
+          currentSnapshot.sequence,
+          snapshotRow(nextSnapshot, timestamp)
+        );
+        if (!updated) {
+          throw new MatchPersistenceError(
+            "sequence_mismatch",
+            "The persisted match sequence changed before this event committed"
+          );
+        }
+        if (currentSnapshot.status !== "inProgress" && nextSnapshot.status === "inProgress") {
+          await transaction.setActiveMatch(currentSnapshot.id);
+        } else if (currentSnapshot.status === "inProgress" && nextSnapshot.status !== "inProgress") {
+          await transaction.clearActiveMatch(currentSnapshot.id);
+        }
+        return {
+          snapshot: nextSnapshot,
+          events: [...persisted.events, event]
+        };
+      });
+    } catch (error) {
+      if (error instanceof MatchPersistenceError) throw error;
+      try {
+        const persisted = await readPersistedMatch(this.driver, currentSnapshot.id);
+        if (persisted) {
+          const retried = resolveAppendRetry(persisted, currentSnapshot, event);
+          if (retried) return retried;
+        }
+      } catch (reconciliationError) {
+        if (reconciliationError instanceof MatchPersistenceError) {
+          throw reconciliationError;
+        }
+      }
+      throw asPersistenceError(error);
+    }
+  }
+  async resumeActiveMatch() {
+    await this.initialize();
+    let activeMatchId;
+    let row;
+    let eventRows;
+    try {
+      ({ activeMatchId, match: row, events: eventRows } = await this.driver.readActiveMatch());
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+    if (!activeMatchId) return null;
+    if (!row) {
+      throw new MatchPersistenceError(
+        "corrupt_data",
+        "The active match pointer has no aggregate"
+      );
+    }
+    const persisted = decodePersistedMatch(activeMatchId, row, eventRows);
+    if (persisted.snapshot.status !== "inProgress") {
+      throw new MatchPersistenceError(
+        "corrupt_data",
+        "The active match pointer targets a non-active match"
+      );
+    }
+    return persisted;
+  }
+  async resumeMatch(matchId) {
+    await this.initialize();
+    let row;
+    let eventRows;
+    try {
+      ({ match: row, events: eventRows } = await this.driver.readMatch(matchId));
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+    if (!row) return null;
+    return decodePersistedMatch(matchId, row, eventRows);
+  }
+  async listMatches() {
+    await this.initialize();
+    try {
+      const { matches, activeMatchId } = await this.driver.readMatchList();
+      matches.forEach(assertMatchListMetadata);
+      const ids = new Set(matches.map((row) => row.matchId));
+      if (ids.size !== matches.length) {
+        throw new MatchPersistenceError(
+          "corrupt_data",
+          "The stored match list contains duplicate match ids"
+        );
+      }
+      if (activeMatchId !== null && !ids.has(activeMatchId)) {
+        throw new MatchPersistenceError(
+          "corrupt_data",
+          "The active match pointer is missing from the stored match list"
+        );
+      }
+      if (activeMatchId !== null && matches.find((row) => row.matchId === activeMatchId)?.status !== "inProgress") {
+        throw new MatchPersistenceError(
+          "corrupt_data",
+          "The active match pointer targets a non-active match summary"
+        );
+      }
+      return matches.map((row) => ({
+        id: row.matchId,
+        sequence: row.snapshotSequence,
+        status: row.status,
+        updatedAt: row.updatedAt,
+        isActive: row.matchId === activeMatchId
+      }));
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+  }
+  async archiveMatch(matchId) {
+    await this.initialize();
+    try {
+      await this.driver.transaction(async (transaction) => {
+        await transaction.clearActiveMatch(matchId);
+      });
+    } catch (error) {
+      throw asPersistenceError(error);
+    }
+  }
+};
+
+// src/match/persistence/default-store.ts
+async function createDefaultMatchEventStore(_databaseName = "pickleball-matches.db") {
+  throw new MatchPersistenceError(
+    "storage_failure",
+    "The default match store requires a native iOS or Android Expo runtime"
+  );
+}
+
+// src/match/provider.tsx
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+
+// src/match/remote/native-service.ts
+function loadNative() {
+  const imported = __require("@pickleball/remote-native");
+  return imported.default ?? imported;
+}
+function createDefaultRemoteService() {
+  let native = null;
+  let disposed = false;
+  const getNative = () => {
+    if (disposed) throw new RemoteError("native_unavailable", "Remote scanner is disposed");
+    try {
+      native ??= loadNative();
+      return native;
+    } catch (cause) {
+      throw new RemoteError(
+        "native_unavailable",
+        "BTHome scanning requires an iOS or Android build with @pickleball/remote-native",
+        { cause }
+      );
+    }
+  };
+  return {
+    start: () => getNative().start(),
+    async stop() {
+      await native?.stop();
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      await native?.destroy();
+      native = null;
+    },
+    subscribeAdvertisement(listener) {
+      const subscription = getNative().addListener("onAdvertisement", listener);
+      return () => subscription.remove();
+    },
+    subscribeState(listener) {
+      const subscription = getNative().addListener("onStateChanged", listener);
+      return () => subscription.remove();
+    },
+    startHidCapture: (options) => getNative().startHidCapture(options),
+    async stopHidCapture() {
+      await native?.stopHidCapture();
+    },
+    subscribeHidVolume(listener) {
+      const subscription = getNative().addListener("onHidVolume", listener);
+      return () => subscription.remove();
+    }
+  };
+}
+
+// src/match/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var NoActiveMatchError = class extends Error {
+  name = "NoActiveMatchError";
+  code = "NO_ACTIVE_MATCH";
+  constructor() {
+    super("No pickleball match is loaded");
+  }
+};
+var INITIAL_REMOTE_STATE = {
+  status: "idle",
+  permission: "unknown",
+  binding: null,
+  candidate: null,
+  lastSeenAt: null,
+  error: null,
+  hidCaptureArmed: false,
+  lastInputSource: null,
+  lastHidEvent: null
+};
+var MatchContext = React.createContext(null);
+function PickleballMatchProvider({
+  children,
+  store,
+  storeFactory,
+  autoResume = true,
+  onError,
+  voiceService,
+  voiceAudioMode = "live",
+  voiceTts,
+  remoteService,
+  remoteOutOfRangeTimeoutMs = 5e3,
+  remoteInputMode = "bthome",
+  remoteActionMapping,
+  hidGestureMapping,
+  consumeHidVolumeKeys = true
+}) {
+  const [snapshot, setSnapshot] = useState(null);
+  const [events, setEvents] = useState([]);
+  const [loading, setLoading] = useState(autoResume);
+  const [error, setError] = useState(null);
+  const [voiceError, setVoiceError] = useState(null);
+  const [audioState, setAudioState] = useState(
+    voiceService?.audioState ?? {
+      route: "system",
+      interrupted: false,
+      disconnectedReason: null
+    }
+  );
+  const [remoteState, setRemoteState] = useState(INITIAL_REMOTE_STATE);
+  const snapshotRef = useRef(null);
+  const eventsRef = useRef([]);
+  const queueRef = useRef(Promise.resolve());
+  const mountedRef = useRef(true);
+  const didAutoResumeRef = useRef(false);
+  const autoResumeOnMountRef = useRef(autoResume);
+  const onErrorRef = useRef(onError);
+  onErrorRef.current = onError;
+  const storeConfigurationRef = useRef({ store, storeFactory });
+  const storePromiseRef = useRef(null);
+  const voiceServiceRef = useRef(voiceService ?? null);
+  const voiceEffectGenerationRef = useRef(0);
+  const remoteServiceRef = useRef(remoteService ?? null);
+  const remoteBindingRef = useRef(null);
+  const remoteScanActiveRef = useRef(false);
+  const remoteLifecycleQueueRef = useRef(Promise.resolve());
+  const remoteUnsubscribersRef = useRef([]);
+  const remoteDedupeRef = useRef(new BTHomeRemoteDeduplicator());
+  const remoteRangeTimerRef = useRef(null);
+  const handleRemoteAdvertisementRef = useRef(() => void 0);
+  const handleRemoteNativeStateRef = useRef(() => void 0);
+  const handleHidVolumeRef = useRef(() => void 0);
+  const handleRemoteMappedActionRef = useRef(() => void 0);
+  const hidGestureRecognizerRef = useRef(null);
+  const resolvedRemoteMapping = useMemo(
+    () => ({ ...DEFAULT_REMOTE_ACTION_MAPPING, ...remoteActionMapping }),
+    [remoteActionMapping]
+  );
+  const reportVoiceError = useCallback((caught) => {
+    const operationError = caught instanceof Error ? caught : new Error("Unknown voice operation failure");
+    if (mountedRef.current) setVoiceError(operationError);
+  }, []);
+  const voiceTtsRef = useRef(voiceTts);
+  const requireVoiceService = useCallback(() => {
+    voiceServiceRef.current ??= createDefaultMatchVoiceService({
+      audioMode: voiceAudioMode,
+      tts: voiceTtsRef.current
+    });
+    return voiceServiceRef.current;
+  }, [voiceAudioMode]);
+  const requireRemoteService = useCallback(() => {
+    remoteServiceRef.current ??= createDefaultRemoteService();
+    return remoteServiceRef.current;
+  }, []);
+  const getStore = useCallback(() => {
+    if (!storePromiseRef.current) {
+      const configuration = storeConfigurationRef.current;
+      const pending = Promise.resolve().then(async () => {
+        const persistence = configuration.store ? configuration.store : configuration.storeFactory ? await configuration.storeFactory() : await createDefaultMatchEventStore();
+        await persistence.initialize();
+        return persistence;
+      });
+      storePromiseRef.current = pending;
+      void pending.catch(() => {
+        if (storePromiseRef.current === pending) storePromiseRef.current = null;
+      });
+    }
+    return storePromiseRef.current;
+  }, []);
+  const publish = useCallback((match) => {
+    snapshotRef.current = match?.snapshot ?? null;
+    eventsRef.current = match?.events ?? [];
+    if (mountedRef.current) {
+      setSnapshot(snapshotRef.current);
+      setEvents(eventsRef.current);
+    }
+  }, []);
+  const enqueue = useCallback((work) => {
+    const run = async () => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        return await work();
+      } catch (caught) {
+        const operationError = caught instanceof Error ? caught : new Error("Unknown match operation failure");
+        if (mountedRef.current) setError(operationError);
+        try {
+          const observerResult = onErrorRef.current?.(operationError);
+          if (observerResult) void Promise.resolve(observerResult).catch(() => void 0);
+        } catch {
+        }
+        throw operationError;
+      } finally {
+        if (mountedRef.current) setLoading(false);
+      }
+    };
+    const result = queueRef.current.then(run, run);
+    queueRef.current = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }, []);
+  const requireSnapshot = useCallback(() => {
+    if (!snapshotRef.current) throw new NoActiveMatchError();
+    return snapshotRef.current;
+  }, []);
+  const commit = useCallback(
+    (makeEvent) => enqueue(async () => {
+      const current = requireSnapshot();
+      const event = makeEvent(current);
+      if (!event) return current;
+      const persistence = await getStore();
+      const committed = await persistence.appendEvent(current, event);
+      publish(committed);
+      if (event.type === "rallyAwarded" || event.type === "courtSwitchConfirmed") {
+        try {
+          requireVoiceService().announce(current, committed.snapshot, event);
+        } catch (voiceFailure) {
+          reportVoiceError(voiceFailure);
+        }
+      }
+      return committed.snapshot;
+    }),
+    [enqueue, getStore, publish, reportVoiceError, requireSnapshot, requireVoiceService]
+  );
+  const createMatchAction = useCallback(
+    (input, source = "local") => enqueue(async () => {
+      const persistence = await getStore();
+      const created = await persistence.createMatch(input, source);
+      publish(created);
+      return created.snapshot;
+    }),
+    [enqueue, getStore, publish]
+  );
+  const resumeMatchAction = useCallback(
+    (matchId) => enqueue(async () => {
+      const persistence = await getStore();
+      const resumed = matchId ? await persistence.resumeMatch(matchId) : await persistence.resumeActiveMatch();
+      publish(resumed);
+      return resumed?.snapshot ?? null;
+    }),
+    [enqueue, getStore, publish]
+  );
+  const awardRallyToSide = useCallback(
+    (side, source = "local") => commit((current) => awardRally(current, side, source)),
+    [commit]
+  );
+  const undo = useCallback(
+    (source = "local") => commit(() => undoLastMatchEvent(eventsRef.current, source)),
+    [commit]
+  );
+  const correctState = useCallback(
+    (correction, source = "local") => commit((current) => correctMatch(current, correction, source)),
+    [commit]
+  );
+  const confirmCourtSwitch2 = useCallback(
+    (source = "local") => commit((current) => confirmCourtSwitch(current, source)),
+    [commit]
+  );
+  const endMatch2 = useCallback(
+    (reason, source = "local") => commit((current) => endMatch(current, reason, source)),
+    [commit]
+  );
+  const runVoiceAction = useCallback(
+    async (action) => {
+      try {
+        setVoiceError(null);
+        await action(requireVoiceService());
+      } catch (caught) {
+        reportVoiceError(caught);
+        throw caught;
+      }
+    },
+    [reportVoiceError, requireVoiceService]
+  );
+  const testSpeaker = useCallback(
+    () => runVoiceAction((service) => service.testSpeaker()),
+    [runVoiceAction]
+  );
+  const replayAnnouncement = useCallback(
+    () => runVoiceAction((service) => service.replayAnnouncement()),
+    [runVoiceAction]
+  );
+  const setVoiceAudioMode = useCallback(
+    (mode) => runVoiceAction(async (service) => {
+      if (!service.configureAudioMode) {
+        throw new Error("The injected voice service cannot change audio mode");
+      }
+      await service.configureAudioMode(mode);
+    }),
+    [runVoiceAction]
+  );
+  const publishRemote = useCallback((update) => {
+    if (mountedRef.current) setRemoteState(update);
+  }, []);
+  const clearRemoteRangeTimer = useCallback(() => {
+    if (remoteRangeTimerRef.current) clearTimeout(remoteRangeTimerRef.current);
+    remoteRangeTimerRef.current = null;
+  }, []);
+  const armRemoteRangeTimer = useCallback(() => {
+    clearRemoteRangeTimer();
+    remoteRangeTimerRef.current = setTimeout(() => {
+      if (!remoteScanActiveRef.current || !remoteBindingRef.current) return;
+      publishRemote((current) => ({ ...current, status: "outOfRange" }));
+    }, remoteOutOfRangeTimeoutMs);
+  }, [clearRemoteRangeTimer, publishRemote, remoteOutOfRangeTimeoutMs]);
+  const bindRemote = useCallback(async (binding) => {
+    if (binding.deviceId.trim().length === 0) throw new Error("Remote identifier cannot be empty");
+    const persistence = await getStore();
+    if (!persistence.setRemoteBinding) throw new Error("Remote binding persistence is unavailable");
+    await persistence.setRemoteBinding(binding);
+    remoteBindingRef.current = binding;
+    remoteDedupeRef.current.clear();
+    publishRemote((current) => ({
+      ...current,
+      binding,
+      candidate: null,
+      status: remoteScanActiveRef.current ? "bound" : "idle",
+      error: null
+    }));
+  }, [getStore, publishRemote]);
+  const unbindRemote = useCallback(async () => {
+    const persistence = await getStore();
+    if (!persistence.setRemoteBinding) throw new Error("Remote binding persistence is unavailable");
+    await persistence.setRemoteBinding(null);
+    remoteBindingRef.current = null;
+    remoteDedupeRef.current.clear();
+    clearRemoteRangeTimer();
+    publishRemote((current) => ({
+      ...current,
+      binding: null,
+      candidate: null,
+      lastSeenAt: null,
+      status: remoteScanActiveRef.current ? "scanning" : "idle",
+      error: null
+    }));
+  }, [clearRemoteRangeTimer, getStore, publishRemote]);
+  const ensureRemoteSubscriptions = useCallback((service) => {
+    if (remoteUnsubscribersRef.current.length > 0) return;
+    remoteUnsubscribersRef.current = [
+      service.subscribeAdvertisement((event) => handleRemoteAdvertisementRef.current(event)),
+      service.subscribeState((event) => handleRemoteNativeStateRef.current(event)),
+      service.subscribeHidVolume((event) => handleHidVolumeRef.current(event))
+    ];
+  }, []);
+  const startRemoteScan = useCallback(() => {
+    const run = remoteLifecycleQueueRef.current.then(async () => {
+      if (remoteScanActiveRef.current) return;
+      const persistence = await getStore();
+      const binding = persistence.getRemoteBinding ? await persistence.getRemoteBinding() : remoteBindingRef.current;
+      remoteBindingRef.current = binding;
+      const service = requireRemoteService();
+      ensureRemoteSubscriptions(service);
+      remoteScanActiveRef.current = true;
+      publishRemote((current) => ({
+        ...current,
+        binding,
+        status: binding ? "bound" : "scanning",
+        error: null
+      }));
+      try {
+        await service.start();
+      } catch (caught) {
+        remoteScanActiveRef.current = false;
+        const failure = caught instanceof RemoteError ? caught : new RemoteError("scan_failed", "Unable to start BTHome scanning", { cause: caught });
+        publishRemote((current) => ({ ...current, status: "idle", error: failure }));
+        throw failure;
+      }
+    });
+    remoteLifecycleQueueRef.current = run.catch(() => void 0);
+    return run;
+  }, [ensureRemoteSubscriptions, getStore, publishRemote, requireRemoteService]);
+  const stopRemoteScan = useCallback(() => {
+    const run = remoteLifecycleQueueRef.current.then(async () => {
+      remoteScanActiveRef.current = false;
+      clearRemoteRangeTimer();
+      remoteDedupeRef.current.clear();
+      await remoteServiceRef.current?.stop();
+      for (const unsubscribe of remoteUnsubscribersRef.current) unsubscribe();
+      remoteUnsubscribersRef.current = [];
+      publishRemote((current) => ({ ...current, status: "idle", candidate: null }));
+    });
+    remoteLifecycleQueueRef.current = run.catch(() => void 0);
+    return run;
+  }, [clearRemoteRangeTimer, publishRemote]);
+  const startHidCapture = useCallback(async () => {
+    if (remoteInputMode === "bthome") throw new Error("HID volume input is disabled by remoteInputMode");
+    hidGestureRecognizerRef.current?.dispose();
+    hidGestureRecognizerRef.current = null;
+    const service = requireRemoteService();
+    ensureRemoteSubscriptions(service);
+    await service.startHidCapture({ consume: consumeHidVolumeKeys });
+    publishRemote((current) => ({ ...current, hidCaptureArmed: true, error: null }));
+  }, [consumeHidVolumeKeys, ensureRemoteSubscriptions, publishRemote, remoteInputMode, requireRemoteService]);
+  const stopHidCapture = useCallback(async () => {
+    hidGestureRecognizerRef.current?.dispose();
+    hidGestureRecognizerRef.current = null;
+    await remoteServiceRef.current?.stopHidCapture();
+    publishRemote((current) => ({ ...current, hidCaptureArmed: false }));
+  }, [publishRemote]);
+  handleRemoteMappedActionRef.current = (mapped) => {
+    const action = mapped === "left" ? awardRallyToSide("left", "remote") : mapped === "right" ? awardRallyToSide("right", "remote") : mapped === "undo" ? undo("remote") : mapped === "announce" ? replayAnnouncement() : null;
+    if (action) void action.catch(() => void 0);
+  };
+  handleHidVolumeRef.current = (event) => {
+    if (!mountedRef.current) return;
+    publishRemote((current) => ({
+      ...current,
+      lastInputSource: "hidVolume",
+      lastHidEvent: event
+    }));
+    if (hidGestureMapping) {
+      hidGestureRecognizerRef.current ??= new HidVolumeGestureRecognizer({
+        ...hidGestureMapping,
+        onGesture: (gesture) => {
+          handleRemoteMappedActionRef.current(hidGestureMapping[gesture] ?? "none");
+        }
+      });
+      hidGestureRecognizerRef.current.push(event);
+      return;
+    }
+    const mapped = event.longPress ? resolvedRemoteMapping.longPress : resolvedRemoteMapping[event.direction];
+    handleRemoteMappedActionRef.current(mapped);
+  };
+  handleRemoteNativeStateRef.current = (nativeState) => {
+    if (!remoteScanActiveRef.current) return;
+    if (nativeState.status === "permission") {
+      const error2 = nativeState.permission === "denied" ? new RemoteError("permission_denied", "Bluetooth scan permission was denied") : nativeState.permission === "restricted" ? new RemoteError("permission_restricted", "Bluetooth access is restricted") : null;
+      publishRemote((current) => ({ ...current, permission: nativeState.permission, error: error2 }));
+      return;
+    }
+    if (nativeState.status === "poweredOff" || nativeState.status === "unavailable") {
+      const error2 = nativeState.status === "poweredOff" ? new RemoteError("bluetooth_powered_off", "Bluetooth is powered off") : new RemoteError("bluetooth_unavailable", "Bluetooth LE is unavailable");
+      publishRemote((current) => ({ ...current, status: nativeState.status, error: error2 }));
+      return;
+    }
+    if (nativeState.status === "error") {
+      publishRemote((current) => ({
+        ...current,
+        error: new RemoteError("scan_failed", nativeState.message)
+      }));
+    }
+  };
+  handleRemoteAdvertisementRef.current = (advertisement) => {
+    if (!remoteScanActiveRef.current) return;
+    let parsed;
+    try {
+      parsed = parseBTHomeV2Advertisement({
+        deviceId: advertisement.deviceId,
+        serviceUuid: advertisement.serviceUuid,
+        serviceData: decodeBase64Bytes(advertisement.serviceData)
+      });
+    } catch {
+      return;
+    }
+    const binding = remoteBindingRef.current;
+    if (!binding) {
+      publishRemote((current) => ({
+        ...current,
+        candidate: {
+          deviceId: advertisement.deviceId,
+          ...advertisement.name ? { label: advertisement.name } : {},
+          rssi: advertisement.rssi,
+          lastSeenAt: advertisement.timestamp
+        }
+      }));
+      return;
+    }
+    if (binding.deviceId !== advertisement.deviceId) return;
+    if (!remoteDedupeRef.current.accept(advertisement.deviceId, parsed, advertisement.timestamp)) return;
+    armRemoteRangeTimer();
+    publishRemote((current) => ({
+      ...current,
+      status: "bound",
+      lastSeenAt: advertisement.timestamp,
+      lastInputSource: "bthome",
+      error: null
+    }));
+    const action = parsed.button.action === "single" ? awardRallyToSide("left", "remote") : parsed.button.action === "double" ? awardRallyToSide("right", "remote") : undo("remote");
+    void action.catch(() => void 0);
+  };
+  useEffect(() => {
+    mountedRef.current = true;
+    if (!didAutoResumeRef.current && autoResumeOnMountRef.current) {
+      didAutoResumeRef.current = true;
+      void resumeMatchAction().catch(() => void 0);
+    }
+    return () => {
+      mountedRef.current = false;
+      remoteScanActiveRef.current = false;
+      hidGestureRecognizerRef.current?.dispose();
+      hidGestureRecognizerRef.current = null;
+      clearRemoteRangeTimer();
+      for (const unsubscribe of remoteUnsubscribersRef.current) unsubscribe();
+      remoteUnsubscribersRef.current = [];
+      const service = remoteServiceRef.current;
+      if (service) {
+        void Promise.resolve().then(async () => {
+          await service.stop();
+          await service.stopHidCapture();
+          await service.dispose();
+        }).catch(() => void 0);
+      }
+    };
+  }, [clearRemoteRangeTimer, resumeMatchAction]);
+  useEffect(() => {
+    const effectGeneration = ++voiceEffectGenerationRef.current;
+    const service = requireVoiceService();
+    const refresh = () => {
+      if (!mountedRef.current) return;
+      setAudioState(service.audioState);
+      if (service.lastError) setVoiceError(service.lastError);
+    };
+    const unsubscribe = service.subscribe(refresh);
+    refresh();
+    void service.initialize().then(refresh).catch(reportVoiceError);
+    return () => {
+      unsubscribe();
+      if (!voiceService) {
+        void Promise.resolve().then(async () => {
+          if (voiceEffectGenerationRef.current === effectGeneration) await service.dispose();
+        }).catch(() => void 0);
+      }
+    };
+  }, [reportVoiceError, requireVoiceService, voiceService]);
+  const value = useMemo(
+    () => ({
+      snapshot,
+      events,
+      loading,
+      error,
+      voiceError,
+      audioState,
+      remoteState,
+      createMatch: createMatchAction,
+      resumeMatch: resumeMatchAction,
+      awardRallyToSide,
+      undo,
+      correctState,
+      confirmCourtSwitch: confirmCourtSwitch2,
+      endMatch: endMatch2,
+      testSpeaker,
+      replayAnnouncement,
+      setVoiceAudioMode,
+      bindRemote,
+      unbindRemote,
+      startRemoteScan,
+      stopRemoteScan,
+      startHidCapture,
+      stopHidCapture
+    }),
+    [
+      snapshot,
+      events,
+      loading,
+      error,
+      voiceError,
+      audioState,
+      remoteState,
+      createMatchAction,
+      resumeMatchAction,
+      awardRallyToSide,
+      undo,
+      correctState,
+      confirmCourtSwitch2,
+      endMatch2,
+      testSpeaker,
+      replayAnnouncement,
+      setVoiceAudioMode,
+      bindRemote,
+      unbindRemote,
+      startRemoteScan,
+      stopRemoteScan,
+      startHidCapture,
+      stopHidCapture
+    ]
+  );
+  return /* @__PURE__ */ jsx(MatchContext.Provider, { value, children });
+}
+function usePickleballMatch() {
+  const value = React.use(MatchContext);
+  if (!value) {
+    throw new Error("usePickleballMatch must be used inside PickleballMatchProvider");
+  }
+  return value;
+}
+export {
+  MATCH_PERSISTENCE_SCHEMA_VERSION,
+  MATCH_SQL_MIGRATIONS,
+  MATCH_SQL_SCHEMA_VERSION,
+  MatchEventStore,
+  MatchPersistenceError,
+  MemoryMatchPersistenceDriver,
+  NoActiveMatchError,
+  PickleballMatchProvider,
+  applyMatchEvent,
+  awardRally,
+  confirmCourtSwitch,
+  correctMatch,
+  createDefaultMatchEventStore,
+  createExpoSqliteMatchDriver,
+  createMatch,
+  endMatch,
+  replayMatchEvents,
+  undoLastMatchEvent,
+  usePickleballMatch
+};