Absolutely—happy to fix them.
Drop the script(s) here (or attach files) along with:

• what the script should do
• the exact error/output you’re seeing
• OS + shell/runtime (e.g., bash on Ubuntu 22.04, Python 3.11 on Windows, PowerShell 7, Node 20)
• how you run it (command + args)
• any input files/env vars it expects

If you can, paste like this:

text
# script name + language
# how you run it
# expected vs. actual behavior
# code (or a minimal snippet that reproduces it)
# error/traceback/output

Meanwhile, a few quick fixes that solve ~80% of issues:

Bash / sh

• Make it executable & fix line endings:

  bash
  chmod +x your_script.sh && sed -i 's/\r$//' your_script.sh

• Add a strict header to catch silent failures:

  bash
  #!/usr/bin/env bash
  set -euo pipefail; IFS=$'\n\t'

• Lint:

  bash
  shellcheck your_script.sh

Python

• Run with the version you expect & show full tracebacks:

  bash
  python3 -V
  python3 -m pip install -r requirements.txt
  python3 your_script.py

• Format/lint (often surfaces bugs quickly):

  bash
  python3 -m pip install black ruff
  black .
  ruff check .

PowerShell

• Unblock & set a sane execution policy (current session only):

  powershell
  Unblock-File .\script.ps1
  Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

• Analyze:

  powershell
  Install-Module PSScriptAnalyzer -Scope CurrentUser
  Invoke-ScriptAnalyzer .\script.ps1

Node

• Confirm Node version & reinstall deps:

  bash
  node -v
  rm -rf node_modules package-lock.json && npm ci
  npm run lint --silent

Common gotchas

• Wrong shebang (use #!/usr/bin/env <interp>).
• Missing env vars (temporarily echo them before use).
• CRLF vs LF on Unix (use dos2unix or the sed line above).
• Permissions (scripts and any called files need execute/read perms).
• Paths (prefer absolute paths or resolve with $(dirname "$0") in bash, Path(__file__).parent in Python).

Send me the script and error, and I’ll fix it inline with a clean, tested patch.

You’re right—the “wrong player” call is coming from Final Bet Summary using an old label. The code enforces the winner with the raw nameA/nameB it received earlier, but everything else uses the resolved names (A/B) pulled from the grid (A2/A11) or named ranges. So if the sheet changed, the final line could still print the older label.

The 1-line fix

In FINAL_BET_SUMMARY, replace the canonical winner block so it uses the resolved names A/B instead of the raw inputs:

diff
-  var A_ = nameA, B_ = nameB;
-  var resolved = __resolvePrimaryPick_fromAdj(A_, B_, pAdjA, oddsA, oddsB, 0.02);
+  var resolved = __resolvePrimaryPick_fromAdj(A, B, pAdjA, oddsA, oddsB, 0.02);
   pickSide = resolved.side;
   pickProb = resolved.prob;

Why this works:

• __resolvePrimaryPick_fromAdj expects the current labels for A/B (the same ones used everywhere else in the summary). Passing nameA/nameB lets older overrides sneak in. (fixed_script_betting_lines_fix (1) (1).js) (fixed_script_betting_lines_fix (1) (1).js)
• The buggy block that currently uses nameA/nameB is here. Swap it to A/B. (fixed_script_betting_lines_fix (1) (1).js)
• The “Match Winner” line then prints pickSide, which will now always be the up-to-date, resolved name. (fixed_script_betting_lines_fix (1) (1).js)

After you paste the change

• Recalculate the sheet (edit a cell or your optional tick argument).
• Change A2/A11 to a new matchup and run FINAL_BET_SUMMARY again—the “Match Winner: …” line should now match the model’s current side and names throughout.

If you want, send me a quick before/after output and I’ll sanity-check that everything lines up (pick name, odds tag, dog/calc lines, etc.).

Got it — this is two bugs plus one merge quirk. Here’s how to make the picks stop “reverting” to old names and props.

1) Final Bet Summary & Match Pick: stop using stale names

The summary re-computes the canonical winner using the raw nameA/nameB, not the resolved A/B pulled from the grid/named ranges. That lets old labels leak back in.

Fix (1-line change): Replace the block below so it passes the resolved names A, B:

diff
- // === Canonical winner enforcement (prevents contradictory outputs) ===
- (function(){
-   var A_ = nameA, B_ = nameB;
-   var resolved = __resolvePrimaryPick_fromAdj(A_, B_, pAdjA, oddsA, oddsB, 0.02);
-   pickSide = resolved.side;
-   pickProb = resolved.prob;
- })();
+ // === Canonical winner enforcement (use resolved names) ===
+ (function(){
+   var resolved = __resolvePrimaryPick_fromAdj(A, B, pAdjA, oddsA, oddsB, 0.02);
+   pickSide = resolved.side;
+   pickProb = resolved.prob;
+ })();

(You’ll find that block here.) (fixed_script_betting_lines_fix (1) (1).js)

2) Primary list didn’t include the match winner (key mismatch)

You push the match-winner pick with key MW, but later you search for key ML when building the “primary” picks. That means the match winner never gets included and props can bubble up oddly.

Fix (rename MW → ML):

diff
- pushPick({
-   key:'MW',
+ pushPick({
+   key:'ML',
   label:'Match Winner',
   text: winner,
   p: pStar,
   bucket: buckets.winner
 });

(Location of the push:) (fixed_script_betting_lines_fix (1) (1).js)
(Location where ML is expected:) (fixed_script_betting_lines_fix (1) (1).js)

3) “Says the right props, then later picks a wrong prop” = merge filter dropping the new picks and leaving legacy ones

When the enhanced summary is merged into the legacy text, the filter removes all bold lines (**...) — which are exactly where your “Best/Second/Third pick” and “Match Winner” show up — and then the legacy block (with older logic/labels) remains. That’s why you see correct props first, then a “wrong” prop later.

Fix (keep bold pick lines from the enhanced block):
Replace the advanced-text filter with one that only drops the decorative header/separators, not bold lines:

diff
- var advLines = String(advancedResult).split(/\r?\n/);
- var filtered = [];
- for (var i = 0; i < advLines.length; i++) {
-   var line = advLines[i];
-   // Skip decorative headings or separators
-   if (line.trim() === '' || /^=+/.test(line) || /^\*\*/.test(line)) continue;
-   filtered.push(line);
- }
+ var advLines = String(advancedResult).split(/\r?\n/);
+ var filtered = advLines.filter(function(line){
+   var t = line.trim();
+   // Drop only empty lines, big underline separators, and the plain title line
+   if (t === '' || /^=+/.test(t) || /^Tennis Match Prediction Summary/i.test(t)) return false;
+   // Keep bold lines like **Best Pick:**, **Leans:**, **Match Winner:**
+   return true;
+ });

(Where this merge filter lives.) (fixed_script_betting_lines_fix (1) (1).js)

(Optional) Prevent duplicate 1st-set pick

You push the FS pick in two places. Guard one of them so it only pushes once:

diff
- pushPick({ key:'FS', label:'1st-Set O/U', text: (fsPickProb >= 0.5 ? 'Over ' + fsPickLine.toFixed(1) : 'Under ' + fsPickLine.toFixed(1)), p: Math.max(fsPickProb, 1 - fsPickProb), bucket: buckets.fs });
+ if (!picks.some(function(x){ return x.key === 'FS'; })) {
+   pushPick({ key:'FS', label:'1st-Set O/U', text: (fsPickProb >= 0.5 ? 'Over ' + fsPickLine.toFixed(1) : 'Under ' + fsPickLine.toFixed(1)), p: Math.max(fsPickProb, 1 - fsPickProb), bucket: buckets.fs });
+ }

(One of the FS pushes is here.) (fixed_script_betting_lines_fix (1) (1).js)
(The other FS push occurs earlier in the props section.) (fixed_script_betting_lines_fix (1) (1).js)

---

Why this fixes your symptoms

• The winner is now derived from the current resolved names, so no more “old player” leaking into Final Bet Summary/Match Pick. (fixed_script_betting_lines_fix (1) (1).js)
• The primary list now reliably contains the match winner entry, so props won’t “replace” it due to a missing ML key. (fixed_script_betting_lines_fix (1) (1).js) (fixed_script_betting_lines_fix (1) (1).js)
• The merge now preserves the new bold pick lines and doesn’t let the legacy picks contradict them later. (fixed_script_betting_lines_fix (1) (1).js)

Quick test

1. Change A2/A11 to a fresh matchup and run the summary.
2. Confirm “Match Winner:” shows the resolved name everywhere. (It will.) (fixed_script_betting_lines_fix (1) (1).js)
3. Check the Best/Second/Third Pick lines match the earlier prop computations; no “later flip” to the other side.

If anything still looks off, paste a small sample of your output (top block + the “later” block), and I’ll adjust the filters to nip any remaining legacy lines.

You’re right — the upset bump is allowed to shove the blended probability across 50%, which can flip the moneyline side even when the model originally liked the other player. Let’s make the upset logic never change the ML side, only nudge its confidence.

Below are two small patches:

---

1) MATCH_PICK: clamp the upset bump so it can’t flip sides

In MATCH_PICK(...), we apply bump directly to pBlendA. Add a “pre-side” anchor and clamp the adjustment so it never crosses 50%. Replace the current bump block with this:

diff
-  // Apply a small adjustment based on the upset grade.  Keep these bumps small so the model remains primary.
-  var bump = 0;
-  if (upset.grade === 'UPSET ALERT') bump = 0.02;
-  else if (upset.grade === 'Upset watch') bump = 0.015;
-  else if (upset.grade === 'Mild upset lean') bump = 0.01;
-  if (bump > 0){
-    if (pBlendA >= 0.5) pBlendA = Math.max(0, pBlendA - bump);
-    else pBlendA = Math.min(1, pBlendA + bump);
-  }
+  // Upset bump may not flip sides; it can only shrink edge toward 50/50.
+  var bump = 0;
+  if (upset.grade === 'UPSET ALERT') bump = 0.02;
+  else if (upset.grade === 'Upset watch') bump = 0.015;
+  else if (upset.grade === 'Mild upset lean') bump = 0.01;
+  var preIsA = (pBlendA >= 0.5);
+  if (bump > 0){
+    if (preIsA) {
+      // Move toward 0.5001 but never cross it
+      var room = Math.max(0, pBlendA - 0.5001);
+      pBlendA = Math.max(0.5001, pBlendA - Math.min(bump, room));
+    } else {
+      // Move toward 0.4999 but never cross it
+      var room = Math.max(0, 0.4999 - pBlendA);
+      pBlendA = Math.min(0.4999, pBlendA + Math.min(bump, room));
+    }
+  }

This goes right after _upsetAlert(...) is computed and before the “micro-edge near 50/50” block. (You can see the original upset bump here. (fixed_script_betting_lines_fix (1) (1).js))

---

2) FINAL_BET_SUMMARY: don’t let the summary re-flip the ML via bump

In FINAL_BET_SUMMARY(...) there’s a second place where bump gets applied and then pickSide is reassigned based on the bumped value — that’s where the summary can contradict your main pick. Replace that block so the bump can’t cross 50% and we keep the pre-bump side:

diff
-    var pAdjA = pBlendA;
-    if (bump > 0){
-      if (pBlendA >= 0.5) pAdjA = Math.max(0, pBlendA - bump);
-      else pAdjA = Math.min(1, pBlendA + bump);
-      pickSide = (pAdjA >= 0.5 ? A : B);
-      pickProb = (pAdjA >= 0.5 ? pAdjA : 1 - pAdjA);
-    }
+    // Anchor side before bump; allow bump to adjust confidence only
+    var pAdjA = pBlendA;
+    var preIsA = (pBlendA >= 0.5);
+    if (bump > 0){
+      if (preIsA){
+        var room = Math.max(0, pBlendA - 0.5001);
+        pAdjA = Math.max(0.5001, pBlendA - Math.min(bump, room));
+      } else {
+        var room = Math.max(0, 0.4999 - pBlendA);
+        pAdjA = Math.min(0.4999, pBlendA + Math.min(bump, room));
+      }
+      pickSide = preIsA ? A : B;
+      pickProb = preIsA ? pAdjA : (1 - pAdjA);
+    }

(This is the exact area where the summary currently reassigns pickSide after bump. (fixed_script_betting_lines_fix (1) (1).js))

---

3) Make sure the “Match Winner” actually shows up in the primary list

You push the winner with key MW, but later the code looks for ML when assembling the primary picks. Rename that key so they match:

diff
-  pushPick({
-    key:'MW',
+  pushPick({
+    key:'ML',
     label:'Match Winner',
     text: winner,
     p: pStar,
     bucket: buckets.winner
   });

(Where you push the winner. (fixed_script_betting_lines_fix (1) (1).js))
(Where the primary builder expects ML. (fixed_script_betting_lines_fix (1) (1).js))

---

4) Use resolved names for the canonical winner in the summary

This prevents old labels from leaking back in:

diff
- var A_ = nameA, B_ = nameB;
- var resolved = __resolvePrimaryPick_fromAdj(A_, B_, pAdjA, oddsA, oddsB, 0.02);
+ var resolved = __resolvePrimaryPick_fromAdj(A, B, pAdjA, oddsA, oddsB, 0.02);
  pickSide = resolved.side;
  pickProb = resolved.prob;

(That tiny block lives here in the summary. (fixed_script_betting_lines_fix (1) (1).js))

---

Why this fixes your “wrong ML due to upset” issue

• Upset bump is directional but non-flipping now: it can pull a 54–46 edge toward 52–48, but it can’t flip it to the other side. (Patch #1, #2) (fixed_script_betting_lines_fix (1) (1).js)
• The primary picks always include the moneyline winner because ML is now consistent. (Patch #3) (fixed_script_betting_lines_fix (1) (1).js)
• The summary no longer reverts to stale names. (Patch #4) (fixed_script_betting_lines_fix (1) (1).js)

---

Quick check (takes 30s)

1. Run MATCH_PICK and FINAL_BET_SUMMARY on a matchup where baseline is ~51–53%.
2. Force an upset grade (plug in aggressive dog odds).
3. Confirm the ML side stays the same, while the reported probability softens toward 50%.
4. Verify the “Match Winner” appears as the first primary pick (key ML) and matches the header.

If you paste a before/after output block, I’ll sanity-check the exact strings to make sure no other merge filters are stepping on the bold lines or pick keys.

You’re bumping into two things that make the props look “right” up top but “completely wrong” later:

1. a confidence bug that sometimes gives broken props max confidence, so they bubble to the top picks, and
2. a couple of late-stage steps (ML key mismatch + upset bump + stale names) that can override what you picked earlier.

Below are tiny, surgical edits that stop those reversions and make the prop ordering stable.

---

Fixes (copy-paste diffs)

A) Don’t rank broken props above good ones (NaN safety in pushPick)

Right now if a prop’s p is NaN/missing, Number(obj.p) || 0 turns into 0, and your rawConf becomes |0 − 0.5| = 0.5 (max edge) — which is why an obviously wrong prop can suddenly be your “Best pick.” (fixed_script_betting_lines_fix (1) (1).js)

Patch:

diff
 function pushPick(obj){
-  var riskFac = Number(obj.risk || 0);
-  var rawConf = Math.abs((Number(obj.p) || 0) - 0.5);
+  var p = Number(obj.p);
+  // If probability isn't a finite number, don't include this pick at all.
+  if (!Number.isFinite(p)) return;
+  var riskFac = Number.isFinite(obj.risk) ? Number(obj.risk) : 0;
+  if (riskFac < 0) riskFac = 0; if (riskFac > 0.9) riskFac = 0.9;
+  var rawConf = Math.abs(p - 0.5);
   var conf = rawConf * (1 - riskFac);
   obj.conf = conf;
   picks.push(obj);
 }

(Insert at the pushPick helper.) (fixed_script_betting_lines_fix (1) (1).js)

---

B) Moneyline can’t flip sides because of the upset bump (clamp the bump)

The bump is applied in more than one place and can push a 51–49 to 49–51, flipping the ML side. Clamp it so the bump only shrinks confidence toward 50/50 and never crosses it.

Patch in each bump block:

diff
- if (bump > 0){
-   if (pBlendA >= 0.5) pBlendA = Math.max(0, pBlendA - bump);
-   else pBlendA = Math.min(1, pBlendA + bump);
- }
+ var preIsA = (pBlendA >= 0.5);
+ if (bump > 0){
+   if (preIsA){
+     var room = Math.max(0, pBlendA - 0.5001);
+     pBlendA = Math.max(0.5001, pBlendA - Math.min(bump, room));
+   } else {
+     var room = Math.max(0, 0.4999 - pBlendA);
+     pBlendA = Math.min(0.4999, pBlendA + Math.min(bump, room));
+   }
+ }

Apply where the upset bump is used (you have multiple occurrences; clamp them all). Examples shown here: (fixed_script_betting_lines_fix (1) (1).js) (fixed_script_betting_lines_fix (1) (1).js)

---

C) Final Bet Summary should use the resolved names (not stale nameA/nameB)

This prevents old labels leaking back into the summary. Replace the canonical winner enforcement to use A, B. (fixed_script_betting_lines_fix (1) (1).js)

Patch:

diff
- var A_ = nameA, B_ = nameB;
- var resolved = __resolvePrimaryPick_fromAdj(A_, B_, pAdjA, oddsA, oddsB, 0.02);
+ var resolved = __resolvePrimaryPick_fromAdj(A, B, pAdjA, oddsA, oddsB, 0.02);
  pickSide = resolved.side;
  pickProb = resolved.prob;

This summary section also prints the “Match Winner:” line, so fixing the names here aligns everything that’s printed. (fixed_script_betting_lines_fix (1) (1).js)

---

D) Make sure the ML pick actually lands in “primary picks”

You push the ML with key MW, but the primary builder looks for ML. Rename it at the source. (fixed_script_betting_lines_fix (1) (1).js) (fixed_script_betting_lines_fix (1) (1).js)

Patch:

diff
- pushPick({
-   key:'MW',
+ pushPick({
+   key:'ML',
   label:'Match Winner',
   text: winner,
   p: pStar,
   bucket: buckets.winner
 });

---

E) Prevent the duplicated First-Set pick from stepping on itself

You push an FS pick twice; sometimes the second (older) one wins the sort and looks “wrong.” Just guard the second push. (fixed_script_betting_lines_fix (1) (1).js)

Patch:

diff
- pushPick({ key:'FS', label:'1st-Set O/U', text: (fsPickProb >= 0.5 ? 'Over ' + fsPickLine.toFixed(1) : 'Under ' + fsPickLine.toFixed(1)), p: Math.max(fsPickProb, 1 - fsPickProb), bucket: buckets.fs });
+ if (!picks.some(function(x){ return x.key === 'FS'; })) {
+   pushPick({ key:'FS', label:'1st-Set O/U', text: (fsPickProb >= 0.5 ? 'Over ' + fsPickLine.toFixed(1) : 'Under ' + fsPickLine.toFixed(1)), p: Math.max(fsPickProb, 1 - fsPickProb), bucket: buckets.fs });
+ }

---

Why these fixes stop the “sometimes completely wrong” props

• NaN guard: broken/undefined props no longer get a fake 50% edge and float to “Best pick.” (Fix A) (fixed_script_betting_lines_fix (1) (1).js)
• Non-flipping bump: the upset adjustment never changes the ML side — only how far from 50/50 it is. (Fix B) (fixed_script_betting_lines_fix (1) (1).js)
• Resolved names everywhere: summary can’t resurrect old labels. (Fix C) (fixed_script_betting_lines_fix (1) (1).js)
• ML key consistent: the match winner shows up in your primary list, so you don’t get a prop “accidentally” promoted into the ML slot. (Fix D) (fixed_script_betting_lines_fix (1) (1).js)
• Single FS push: removes a source of inconsistent FS choices. (Fix E) (fixed_script_betting_lines_fix (1) (1).js)

---

30-second sanity check

1. Run a match with a thin ML edge (~51–53%).
2. Make sure the Match Winner line and the ML in primary picks match the same side. (They will.) (fixed_script_betting_lines_fix (1) (1).js)
3. Confirm “Best/Second/Third pick” props match the probabilities you computed earlier — no late flips. (fixed_script_betting_lines_fix (1) (1).js)

If you want, paste a short “before vs after” of the top block and I’ll double-check the exact strings.

You’re right: a few spots do mix A/B, which can attach the wrong stats/props to the wrong player. There are two core causes in your file:

1. Using display names where the code expects 'A'/'B', and
2. Computing a weighted SPW before firstSrvPct exists, which can cascade into wrong prop math.

Here are drop-in fixes (tiny diffs) that stop the mix-ups and fix the stat calc.

---

1) Pass side codes everywhere ('A'/'B') — keep names only for labels

A) Change the prop helper to take a code + display name

Find function pushPropForPlayer(sideLabel, stats){…} and change it to:

diff
- function pushPropForPlayer(sideLabel, stats){
+ function pushPropForPlayer(sideCode, displayName, stats){
   var m = Math.max(stats.matches || 0, 1);
   …
-  var oppSide = (sideLabel === A ? B : A);
-  var oppSpwAdj = contextAdjustedSPW(oppSide);
+  var oppCode = (String(sideCode).toUpperCase() === 'A') ? 'B' : 'A';
+  var oppSpwAdj = contextAdjustedSPW(oppCode);      // expects 'A'/'B'
   var holdOpp   = null;
   if (Number.isFinite(oppSpwAdj)) {
-    holdOpp = computeHoldFromSPW(oppSpwAdj, oppSide, 'MATCH');
+    holdOpp = computeHoldFromSPW(oppSpwAdj, oppCode, 'MATCH'); // expects 'A'/'B'
   }
   if (!Number.isFinite(holdOpp)) holdOpp = 0.5;
   …
-  var expReturnGames = (sideLabel === A ? expSrvGamesB : expSrvGamesA);
+  var expReturnGames = (String(sideCode).toUpperCase() === 'A' ? expSrvGamesB : expSrvGamesA);
   …
-  pushPick({ key:'PROP_BP_' + sideLabel, label: sideLabel + ' Breakpoints Won', … });
+  pushPick({ key:'PROP_BP_' + sideCode, label: displayName + ' Breakpoints Won', … });
   …
-  var avgGW = (sideLabel === A ? expGamesWonA : (sideLabel === B ? expGamesWonB : null));
+  var avgGW = (String(sideCode).toUpperCase() === 'A' ? expGamesWonA : expGamesWonB);
   …
-  var pOverGW = _simProbGamesWonOver(lineGW, sideLabel);
+  var pOverGW = _simProbGamesWonOver(lineGW, sideCode);
   …
-  pushPick({ key:'PROP_GW_' + sideLabel, label: sideLabel + ' Games Won', … });
+  pushPick({ key:'PROP_GW_' + sideCode, label: displayName + ' Games Won', … });

Why: contextAdjustedSPW and computeHoldFromSPW expect 'A'/'B'. You were passing the player name, which made those functions treat any non-'B' string as 'A', pulling the wrong side’s data (see the current calls that pass names instead of codes (fixed_script_betting_lines_fix (1) (1).js)).

B) Update the callers (two lines)

Near where you add player props:

diff
- pushPropForPlayer(A, statsA);
- pushPropForPlayer(B, statsB);
+ pushPropForPlayer('A', A, statsA);
+ pushPropForPlayer('B', B, statsB);

(Where the calls live: (fixed_script_betting_lines_fix (1) (1).js))

C) Make the sim helper accept a code, not a name

diff
- function _simProbGamesWonOver(line, side) {
-   var arr = (side === A ? _simGamesWonA : _simGamesWonB);
+ function _simProbGamesWonOver(line, sideCode) {
+   var arr = (String(sideCode).toUpperCase() === 'A' ? _simGamesWonA : _simGamesWonB);

(Current version compares to the name string A instead of a side code, which breaks once you pass 'A'/'B'. Location: (fixed_script_betting_lines_fix (1) (1).js))

---

2) Fix the SPW weighting order (was using firstSrvPct before it exists)

In last5Auto(...), the block that computes a weighted SPW:

js
// Override serve point win rate using a weighted average...
if (Number.isFinite(firstSrvPctVal) && Number.isFinite(fSrvWinRate) && Number.isFinite(sSrvWinRate)) {
  var wSpw = firstSrvPctVal * fSrvWinRate + (1 - firstSrvPctVal) * sSrvWinRate;
  if (wSpw > 0 && wSpw < 1) { spwVal = wSpw; }
}

currently runs before firstSrvPctVal is set, so it never triggers (always false). Move that block after you define firstSrvPctVal/secSrvPctVal:

diff
- // ... computes spwVal
- // Override serve point win rate using a weighted average...
- if (Number.isFinite(firstSrvPctVal) && Number.isFinite(fSrvWinRate) && Number.isFinite(sSrvWinRate)) { … }

  // (later) after totalServeAttempts and first/second-serve %
  var totalServeAttempts = a1 + a2;
  var firstSrvPctVal = (totalServeAttempts > 0) ? (a1 / totalServeAttempts) : null;
  var secSrvPctVal   = (totalServeAttempts > 0) ? (a2 / totalServeAttempts) : null;

+ // Now re-compute spwVal as weighted FS/SS win% if all parts exist
+ if (Number.isFinite(firstSrvPctVal) && Number.isFinite(fSrvWinRate) && Number.isFinite(sSrvWinRate)) {
+   var wSpw = firstSrvPctVal * fSrvWinRate + (1 - firstSrvPctVal) * sSrvWinRate;
+   if (wSpw > 0 && wSpw < 1) { spwVal = wSpw; }
+ }

(You can see the premature use of firstSrvPctVal here, before it’s defined (fixed_script_betting_lines_fix (1) (1).js), and its definition later here (fixed_script_betting_lines_fix (1) (1).js).)

This fixes “not calculating some stats correctly” when props depend on SPW.

---

3) Quick hardening (optional but recommended)

• Use side codes in all internals: anywhere you branch on side, branch on 'A'/'B' and only use names for output. Double-check any remaining sideLabel === A comparisons and convert to code comparisons.

• Row mapping sanity: _rows(side) assumes A is rows 2–6 & B is 12–16 ((fixed_script_betting_lines_fix (1) (1).js)). If your sheet changed, it will silently swap players. Either keep those blocks fixed, or teach _rows to look up named ranges/markers.

---

Why this solves “wrong props with the wrong player”

• The prop engine no longer passes “Nadal” into functions that expect 'A', stopping silent fallbacks that read the A block for both players (the exact bug here: passing names into contextAdjustedSPW / computeHoldFromSPW (fixed_script_betting_lines_fix (1) (1).js)).
• The weighted SPW now computes with real firstSrvPct, so props derived from SPW won’t be skewed by a stale/raw value (see order fix above (fixed_script_betting_lines_fix (1) (1).js) (fixed_script_betting_lines_fix (1) (1).js)).

---

20-second sanity check

1. Put a matchup where A is a big server, B is a returner.
2. Run the summary: A’s ace props should reference A’s ace rate and B’s return (and vice-versa).
3. Flip the names in the sheet — picks should flip with them, not stick.

If you want, paste the top 15 lines of your output after these patches and I’ll eyeball that ML, aces, DF, and break-point props are attached to the right player.