chore: address review feedback on predicted rating logging (#11)

- align diagnostic endpoint date windows with getNextPDGAUpdateDate
- pass pdgaNumber to initial target-rating calculation for log attribution
- avoid double log when lazy-recompute returns 0
- log full error object in admin endpoint catch

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pdga-ratings",
-  "version": "1.2.10",
+  "version": "1.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pdga-ratings",
-      "version": "1.2.10",
+      "version": "1.4.0",
       "dependencies": {
         "ejs": "^4.0.1",
         "express": "^4.18.2",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdga-ratings",
-  "version": "1.2.10",
+  "version": "1.4.0",
   "description": "PDGA rating scraper and display",
   "main": "server.js",
   "scripts": {

public/css/courses.css

@@ -2,133 +2,461 @@
    Courses Page
    ═══════════════════════════════════════════════════ */
 
-/* ── Controls ─────────────────────────────────── */
+/* ── Action Card (tabs + inputs) ─────────────────── */
 
-.controls {
+.action-card {
+    background: var(--paper);
+    border: 1px solid var(--line-2);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow-card);
+    margin-bottom: 16px;
+}
+
+.action-card-tabs {
     display: flex;
-    justify-content: flex-end;
+    border-bottom: 1px solid var(--line-2);
-    margin-bottom: 20px;
 }
 
-/* ── Search ───────────────────────────────────── */
+.action-tab {
-
+    padding: 12px 18px;
-.search-results-info {
+    background: transparent;
-    text-align: center;
+    border: 0;
-    margin: 10px 0;
+    color: var(--ink-2);
-    color: var(--text-muted);
+    font: 600 14px/1.2 var(--font-sans);
-    font-size: 13px;
+    cursor: pointer;
+    transition: color 120ms;
 }
 
-/* ── Layouts ──────────────────────────────────── */
+.action-tab:hover {
-
+    color: var(--ink);
-.layouts-container {
-    padding: 16px;
 }
 
-.layouts-container h4 {
+.action-tab.is-active {
-    margin: 0 0 12px 0;
+    color: var(--ink);
-    font-size: 13px;
+    box-shadow: inset 0 -2px 0 var(--accent);
-    font-weight: 600;
-    text-transform: uppercase;
-    letter-spacing: 0.04em;
-    color: var(--text-secondary);
 }
 
-.layout-item {
+.action-card-body {
-    padding: 12px 14px;
+    padding: 16px 20px;
-    margin: 4px 0;
+}
-    background: var(--surface-1);
+
+.action-pane[hidden] {
+    display: none;
+}
+
+.action-card-body input[type=text] {
+    width: 100%;
+    height: 40px;
+    padding: 0 14px;
+    border: 1px solid var(--line-2);
     border-radius: var(--radius-sm);
-    border: 1px solid var(--border);
+    background: var(--paper-2);
+    font: 14px/1.2 var(--font-sans);
+}
+
+.action-card-body input[type=text]:focus {
+    outline: none;
+    border-color: var(--accent);
+    box-shadow: 0 0 0 4px color-mix(in oklch, var(--accent) 14%, transparent);
+}
+
+.action-hint {
+    margin: 8px 0 0;
+    font-size: 11.5px;
+    color: var(--ink-3);
+}
+
+.tjing-search-row {
     display: flex;
-    justify-content: space-between;
+    gap: 10px;
     align-items: center;
-    transition: border-color var(--transition), box-shadow var(--transition);
 }
 
-.layout-item:hover {
+.tjing-search-row input[type=text] {
-    border-color: var(--accent-border);
+    flex: 1;
-    box-shadow: var(--shadow-sm);
 }
 
-.layout-name {
+/* ── Buttons ──────────────────────────────────────── */
-    font-weight: 600;
-    color: var(--text-primary);
-    font-size: 14px;
-}
 
-.layout-par {
+/* .btn-primary is defined in shared.css — no override needed here */
-    color: var(--accent);
+
-    font-weight: 700;
+.btn-pill {
-    font-size: 14px;
+    padding: 6px 12px;
-    font-variant-numeric: tabular-nums;
+    background: var(--accent);
+    color: #fff;
+    border: 0;
+    border-radius: 999px;
+    font: 600 12.5px/1 var(--font-sans);
+    cursor: pointer;
+    height: 28px;
     white-space: nowrap;
 }
 
+.btn-pill:disabled {
+    opacity: .6;
+    cursor: default;
+}
+
+/* ── Results bar ─────────────────────────────────── */
+
+.results-bar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 4px;
+    font-variant-numeric: tabular-nums;
+}
+
+.results-count {
+    color: var(--ink-2);
+    font-size: 13px;
+}
+
+.results-count strong {
+    color: var(--ink);
+    font-weight: 600;
+}
+
+.results-link {
+    color: var(--accent);
+    text-decoration: none;
+    font: 500 13.5px/1.2 var(--font-sans);
+}
+
+/* ── Course grid ─────────────────────────────────── */
+
+.course-grid {
+    background: var(--paper);
+    border: 1px solid var(--line-2);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow-card);
+    overflow: hidden;
+}
+
+.course-row {
+    display: grid;
+    grid-template-columns: minmax(280px, 2fr) minmax(140px, 1fr) minmax(140px, 0.9fr) 72px;
+    align-items: center;
+    gap: 14px;
+    padding: 14px 20px;
+    border-bottom: 1px solid var(--line-2);
+    cursor: pointer;
+    transition: background 120ms;
+}
+
+.course-row:hover {
+    background: var(--paper-2);
+}
+
+.course-row.row-open {
+    background: var(--paper-2);
+    box-shadow: inset 3px 0 0 var(--accent);
+}
+
+.course-row[hidden],
+.expanded-content[hidden] {
+    display: none;
+}
+
+.course-row.row-open .icon-chev i {
+    transform: rotate(180deg);
+}
+
+.course-row--header {
+    height: 48px;
+    padding: 0 20px;
+    background: var(--paper-2);
+    border-bottom: 1px solid var(--line);
+    cursor: default;
+}
+
+.course-row--header:hover {
+    background: var(--paper-2);
+}
+
+.course-header-cell {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: var(--ink-3);
+}
+
+.course-cell {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+}
+
+.course-name {
+    font-weight: 600;
+    font-size: 14px;
+    letter-spacing: -0.005em;
+    color: var(--ink);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    display: block;
+}
+
+.course-row:hover .course-name,
+.course-row.row-open .course-name {
+    color: var(--accent);
+}
+
+.course-meta {
+    font-size: 11px;
+    color: var(--ink-3);
+}
+
+.course-city {
+    font-size: 14px;
+    color: var(--ink);
+}
+
+.course-updated {
+    font-family: var(--font-mono);
+    font-feature-settings: "tnum", "zero";
+    font-size: 12.5px;
+    color: var(--ink-3);
+}
+
+.course-actions {
+    display: flex;
+    gap: 4px;
+    justify-content: flex-end;
+}
+
+/* ── Expanded layout panel ───────────────────────── */
+
+.expanded-content {
+    display: none;
+}
+
+.expanded-content.is-open {
+    display: block;
+    animation: expandIn .2s ease;
+}
+
+.expanded-cell {
+    padding: 22px 28px 28px;
+    background: color-mix(in oklch, var(--accent) 4%, var(--paper-2));
+    border-bottom: 1px solid var(--line-2);
+}
+
+/* ── Layout list ─────────────────────────────────── */
+
+.layouts-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    margin-bottom: 12px;
+}
+
+.layouts-kicker {
+    font: 600 11px/1 var(--font-sans);
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: var(--ink-3);
+}
+
+.layouts-count {
+    font-size: 12.5px;
+    color: var(--ink-3);
+}
+
+.layout-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.layout-card {
+    display: flex;
+    justify-content: space-between;
+    align-items: baseline;
+    gap: 14px;
+    padding: 12px 18px;
+    background: var(--paper);
+    border: 1px solid var(--line-2);
+    border-radius: var(--radius-sm);
+    transition: border-color 120ms, box-shadow 120ms;
+}
+
+.layout-card:hover {
+    border-color: var(--line);
+    box-shadow: var(--shadow-card);
+}
+
+.layout-card--inactive {
+    background: transparent;
+    border-style: dashed;
+    opacity: 0.65;
+}
+
+.layout-card--inactive .layout-name {
+    color: var(--ink-2);
+    font-weight: 500;
+}
+
+.layout-info {
+    display: flex;
+    align-items: baseline;
+    gap: 14px;
+    min-width: 0;
+}
+
+.layout-name {
+    font: 600 13.5px/1.2 var(--font-sans);
+    color: var(--ink);
+}
+
+.layout-last-played {
+    font: 12.5px/1 var(--font-mono);
+    color: var(--ink-3);
+}
+
+.layout-never-played {
+    font-size: 12.5px;
+    color: var(--down);
+}
+
+.layout-chips {
+    display: flex;
+    gap: 14px;
+    align-items: center;
+}
+
+.chip {
+    display: inline-flex;
+    align-items: center;
+    padding: 4px 10px;
+    border-radius: 8px;
+    font: 600 12.5px/1 var(--font-mono);
+    font-variant-numeric: tabular-nums;
+}
+
+.chip-par {
+    color: var(--accent);
+    background: color-mix(in oklch, var(--accent) 8%, transparent);
+}
+
+.chip-rating--green {
+    color: var(--rating-tier-high);
+    background: color-mix(in oklch, var(--rating-tier-high) 10%, transparent);
+}
+
+.chip-rating--amber {
+    color: var(--rating-tier-mid);
+    background: color-mix(in oklch, var(--rating-tier-mid) 10%, transparent);
+}
+
+.chip-rating--orange {
+    color: var(--rating-tier-low);
+    background: color-mix(in oklch, var(--rating-tier-low) 10%, transparent);
+}
+
+/* ── Inactive layouts collapsible ────────────────── */
+
+.inactive-layouts {
+    margin-top: 14px;
+    background: var(--paper-2);
+    border: 1px solid var(--line-2);
+    border-radius: var(--radius-sm);
+    overflow: hidden;
+}
+
+.inactive-toggle {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+    padding: 12px 16px;
+    background: transparent;
+    border: 0;
+    font: 500 13.5px/1.2 var(--font-sans);
+    color: var(--ink-2);
+    cursor: pointer;
+}
+
+.inactive-toggle .icon-chev {
+    transition: transform 180ms;
+    display: inline-block;
+}
+
+.inactive-toggle.is-open .icon-chev {
+    transform: rotate(180deg);
+}
+
+.inactive-layouts-body {
+    padding: 0 12px 12px;
+}
+
+.inactive-layouts-body[hidden] {
+    display: none;
+}
+
+
+/* ── Tjing results ───────────────────────────────── */
+
+#tjing-results {
+    margin-top: 12px;
+}
+
+.tjing-result {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 14px;
+    border-bottom: 1px solid var(--line-2);
+}
+
+.tjing-result:last-child {
+    border-bottom: 0;
+}
+
+.tjing-result-info {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    min-width: 0;
+}
+
+.tjing-result-name {
+    font: 600 14px/1.3 var(--font-sans);
+    color: var(--ink);
+}
+
+.tjing-result-address {
+    font-size: 12.5px;
+    color: var(--ink-3);
+}
+
+.tjing-error {
+    color: var(--down);
+    font-size: 13px;
+    padding: 12px 0;
+}
+
+/* ── No-layouts message ──────────────────────────── */
+
 .no-layouts {
     text-align: center;
-    color: var(--text-muted);
+    color: var(--ink-3);
     font-style: italic;
     padding: 24px;
     font-size: 13px;
 }
 
-/* ── Inactive Layouts Accordion ───────────────── */
+/* ── Loading placeholder ─────────────────────────── */
 
-.inactive-layouts-accordion {
+.loading {
-    margin-top: 16px;
+    text-align: center;
-    border: 1px solid var(--border);
+    color: var(--ink-3);
-    border-radius: var(--radius-md);
-    background: var(--surface-2);
-    overflow: hidden;
-}
-
-.accordion-header {
-    padding: 12px 16px;
-    cursor: pointer;
-    user-select: none;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    background: var(--surface-3);
-    transition: background var(--transition);
-}
-
-.accordion-header:hover {
-    background: var(--border);
-}
-
-.accordion-header-text {
-    font-weight: 600;
-    color: var(--text-secondary);
     font-size: 13px;
+    padding: 24px;
 }
-
-.accordion-icon {
-    transition: transform 0.3s ease;
-    color: var(--text-muted);
-    font-size: 12px;
-}
-
-.accordion-icon.expanded {
-    transform: rotate(180deg);
-}
-
-.accordion-content {
-    max-height: 0;
-    overflow: hidden;
-    transition: max-height 0.3s ease-out;
-    padding: 0 12px;
-}
-
-.accordion-content.expanded {
-    max-height: 2000px;
-    padding: 12px;
-    transition: max-height 0.5s ease-in;
-}
-
-.layout-item.inactive {
-    opacity: 0.6;
-    border-style: dashed;
-}
-

public/css/mobile.css

@@ -64,9 +64,6 @@
         display: none;
     }
 
-    /* Hide search result info text on courses (mobile has section-head) */
-    #search-results-info { display: none; }
-
     /* ── Container ──────────────────────────────────── */
 
     .container {

public/css/players.css

@@ -94,82 +94,6 @@
     box-shadow: var(--shadow-lg);
 }
 
-/* ── Debug Icon ───────────────────────────────── */
-
-.debug-icon:hover {
-    opacity: 1 !important;
-    color: var(--accent) !important;
-}
-
-/* ── Debug Modal ──────────────────────────────── */
-
-.debug-modal {
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background: rgba(15, 23, 42, 0.5);
-    backdrop-filter: blur(4px);
-    z-index: 10001;
-    display: none;
-    justify-content: center;
-    align-items: center;
-}
-
-.debug-content {
-    background: var(--surface-1);
-    border-radius: var(--radius-lg);
-    padding: 24px;
-    max-width: 640px;
-    width: 90%;
-    max-height: 80vh;
-    overflow-y: auto;
-    box-shadow: var(--shadow-overlay);
-    position: relative;
-}
-
-.debug-header {
-    font-weight: 700;
-    font-size: 16px;
-    margin-bottom: 16px;
-    color: var(--text-primary);
-    padding-bottom: 12px;
-    border-bottom: 1px solid var(--border);
-}
-
-.debug-log {
-    font-family: var(--font-mono);
-    background: var(--surface-2);
-    border: 1px solid var(--border);
-    border-radius: var(--radius-md);
-    padding: 16px;
-    font-size: 12px;
-    line-height: 1.6;
-    white-space: pre-line;
-    color: var(--text-primary);
-}
-
-.debug-close {
-    position: absolute;
-    top: 12px;
-    right: 16px;
-    font-size: 22px;
-    color: var(--text-muted);
-    cursor: pointer;
-    background: none;
-    border: none;
-    padding: 4px;
-    border-radius: var(--radius-sm);
-    transition: color var(--transition), background var(--transition);
-    line-height: 1;
-}
-
-.debug-close:hover {
-    color: var(--text-primary);
-    background: var(--surface-3);
-}
-
 /* ── Add Player Modal ─────────────────────────── */
 
 .modal {

public/css/shared.css

@@ -34,6 +34,11 @@
     --font-sans: 'Plus Jakarta Sans', system-ui, sans-serif;
     --font-mono: 'JetBrains Mono', ui-monospace, monospace;
 
+    /* ── Rating tier tokens ───────────────────────── */
+    --rating-tier-high:   oklch(0.55 0.15 150);
+    --rating-tier-mid:    oklch(0.55 0.12 100);
+    --rating-tier-low:    oklch(0.55 0.10 50);
+
     /* legacy token aliases — remove as components migrate */
     --surface-0: var(--bg);
     --surface-1: var(--paper);

public/js/courses.js

@@ -1,33 +1,97 @@
-function toggleAccordion(accordionId) {
+// ── Tab switching ──────────────────────────────────
-    const content = document.getElementById(accordionId);
+function initCourseTabs() {
-    const icon = document.getElementById(`${accordionId}-icon`);
+    const tabs = document.querySelectorAll('.action-tab');
+    tabs.forEach(function(tab) {
+        tab.addEventListener('click', function() {
+            tabs.forEach(function(t) {
+                t.classList.remove('is-active');
+                t.setAttribute('aria-selected', 'false');
+            });
+            tab.classList.add('is-active');
+            tab.setAttribute('aria-selected', 'true');
 
-    if (content.classList.contains('expanded')) {
+            document.querySelectorAll('.action-pane').forEach(function(pane) {
-        content.classList.remove('expanded');
+                pane.hidden = true;
-        icon.classList.remove('expanded');
+                pane.classList.remove('is-active');
-    } else {
+            });
-        content.classList.add('expanded');
+
-        icon.classList.add('expanded');
+            const targetId = 'tab-pane-' + tab.dataset.tab;
-    }
+            const pane = document.getElementById(targetId);
+            if (pane) {
+                pane.hidden = false;
+                pane.classList.add('is-active');
+            }
+        });
+    });
 }
 
+// ── Live filter ────────────────────────────────────
+function initCourseLiveFilter() {
+    const input = document.getElementById('course-filter-input');
+    if (!input) return;
+
+    input.addEventListener('input', function() {
+        const q = input.value.toLowerCase().trim();
+        const rows = document.querySelectorAll('.course-row');
+        let visible = 0;
+
+        rows.forEach(function(row) {
+            const name = row.dataset.courseName || '';
+            const city = row.dataset.courseCity || '';
+            const match = !q || name.includes(q) || city.includes(q);
+
+            row.hidden = !match;
+
+            // Keep the expanded content sibling in sync
+            const next = row.nextElementSibling;
+            if (next && next.classList.contains('expanded-content')) {
+                next.hidden = !match;
+            }
+
+            if (match) visible++;
+        });
+
+        const visibleEl = document.getElementById('visible-count');
+        if (visibleEl) visibleEl.textContent = visible;
+    });
+}
+
+// ── Count display ──────────────────────────────────
+function initCourseCounts() {
+    const grid = document.querySelector('.course-grid');
+    const total = grid ? parseInt(grid.dataset.totalCount || '0', 10) : 0;
+    const rows = document.querySelectorAll('.course-row');
+    let visible = 0;
+    rows.forEach(function(r) { if (!r.hidden) visible++; });
+
+    const totalEl = document.getElementById('total-count');
+    const visibleEl = document.getElementById('visible-count');
+    if (totalEl) totalEl.textContent = total;
+    if (visibleEl) visibleEl.textContent = visible || total;
+}
+
+// ── Course row expand/collapse ─────────────────────
 function toggleCourseLayouts(courseId) {
-    const layoutsRow = document.getElementById(`layouts-${courseId}`);
+    const row = document.querySelector('.course-row[data-course-id="' + courseId + '"]');
-    const layoutsContainer = document.getElementById(`layouts-container-${courseId}`);
+    const content = document.getElementById('course-layouts-' + courseId);
+    if (!row || !content) return;
 
-    if (layoutsRow.style.display === 'table-row') {
+    const isOpen = content.classList.contains('is-open');
-        layoutsRow.style.display = 'none';
+
-        return;
+    if (isOpen) {
+        content.classList.remove('is-open');
+        row.classList.remove('row-open');
+    } else {
+        content.classList.add('is-open');
+        row.classList.add('row-open');
+
+        // Lazy-load layouts on first expand
+        const cell = content.querySelector('.expanded-cell');
+        if (cell && cell.dataset.loaded !== 'true') {
+            cell.dataset.loaded = 'true';
+            htmx.ajax('GET', '/partials/course-layouts/' + courseId, { target: cell, swap: 'innerHTML' });
+        }
     }
-
-    layoutsRow.style.display = 'table-row';
-
-    if (layoutsContainer.dataset.loaded === 'true') {
-        return;
-    }
-
-    htmx.ajax('GET', `/partials/course-layouts/${courseId}`, {target: `#layouts-container-${courseId}`, swap: 'innerHTML'});
-    layoutsContainer.dataset.loaded = 'true';
 }
 
 // ── Mobile course card toggle ──────────────────────
@@ -68,10 +132,24 @@ function toggleMobileCourseLayouts(courseId) {
     }
 }
 
+// ── Inactive layouts toggle ────────────────────────
+function toggleInactiveLayouts(btn) {
+    const body = btn.nextElementSibling;
+    if (!body) return;
+
+    const isOpen = btn.classList.contains('is-open');
+    btn.classList.toggle('is-open', !isOpen);
+    btn.setAttribute('aria-expanded', String(!isOpen));
+    body.hidden = isOpen;
+}
+
+// ── Scrape courses ─────────────────────────────────
 async function scrapeCourses() {
     const btn = document.getElementById('scrape-courses-btn');
-    btn.disabled = true;
+    if (btn) {
-    btn.textContent = 'Scraping...';
+        btn.disabled = true;
+        btn.textContent = 'Scraping...';
+    }
 
     try {
         const response = await fetch('/api/scrape-courses', { method: 'POST' });
@@ -79,7 +157,7 @@ async function scrapeCourses() {
 
         if (data.success) {
             alert(data.message);
-            htmx.ajax('GET', '/partials/course-table', '#courses-table');
+            htmx.trigger(document.body, 'refresh');
         } else {
             alert('Failed to scrape courses');
         }
@@ -87,31 +165,33 @@ async function scrapeCourses() {
         console.error('Error scraping courses:', error);
         alert('Error scraping courses');
     } finally {
-        btn.disabled = false;
+        if (btn) {
-        btn.textContent = 'Scrape Courses';
+            btn.disabled = false;
+            btn.textContent = 'Scrape Courses';
+        }
     }
 }
 
-async function scrapeLayouts(courseId, courseName) {
+// ── Scrape layouts for a course ────────────────────
-    const icon = document.querySelector(`#row-${courseId} .refresh-icon`);
+async function scrapeLayouts(courseId, btn) {
-    icon.classList.add('spinning');
+    if (btn) btn.classList.add('spinning');
 
     try {
-        const response = await fetch(`/api/scrape-layouts/${courseId}`, { method: 'POST' });
+        const response = await fetch('/api/scrape-layouts/' + courseId, { method: 'POST' });
         const data = await response.json();
 
         if (response.status === 409) {
             alert(data.message || 'Scrape already in progress for this course. Please wait.');
         } else if (data.success) {
-            const layoutsContainer = document.getElementById(`layouts-container-${courseId}`);
+            // Reload expanded layout content if currently open
-            layoutsContainer.dataset.loaded = 'false';
+            const content = document.getElementById('course-layouts-' + courseId);
-
+            if (content && content.classList.contains('is-open')) {
-            const layoutsRow = document.getElementById(`layouts-${courseId}`);
+                const cell = content.querySelector('.expanded-cell');
-            if (layoutsRow.style.display === 'table-row') {
+                if (cell) {
-                htmx.ajax('GET', `/partials/course-layouts/${courseId}`, {target: `#layouts-container-${courseId}`, swap: 'innerHTML'});
+                    cell.dataset.loaded = 'true';
-                layoutsContainer.dataset.loaded = 'true';
+                    htmx.ajax('GET', '/partials/course-layouts/' + courseId, { target: cell, swap: 'innerHTML' });
+                }
             }
-
             alert(data.message);
         } else {
             alert('Failed to scrape layouts');
@@ -120,6 +200,141 @@ async function scrapeLayouts(courseId, courseName) {
         console.error('Error scraping layouts:', error);
         alert('Error scraping layouts');
     } finally {
-        icon.classList.remove('spinning');
+        if (btn) btn.classList.remove('spinning');
     }
 }
+
+// ── Tjing search ───────────────────────────────────
+async function searchTjing() {
+    const input = document.getElementById('tjing-search-input');
+    const btn = document.getElementById('tjing-search-btn');
+    const container = document.getElementById('tjing-results');
+    if (!input || !container) return;
+
+    const q = input.value.trim();
+    if (!q) return;
+
+    btn.disabled = true;
+
+    // Clear previous results safely
+    while (container.firstChild) {
+        container.removeChild(container.firstChild);
+    }
+
+    try {
+        const response = await fetch('/api/tjing/search?q=' + encodeURIComponent(q));
+        let data;
+        try {
+            data = await response.json();
+        } catch (e) {
+            const errP = document.createElement('p');
+            errP.className = 'tjing-error';
+            errP.textContent = 'Invalid response from server.';
+            container.appendChild(errP);
+            return;
+        }
+
+        if (!response.ok || data.error) {
+            const errP2 = document.createElement('p');
+            errP2.className = 'tjing-error';
+            errP2.textContent = 'Error: ' + (data.error || 'Search failed');
+            container.appendChild(errP2);
+            return;
+        }
+
+        const results = data.results || [];
+        if (results.length === 0) {
+            const noResults = document.createElement('p');
+            noResults.className = 'tjing-error';
+            noResults.textContent = 'No courses found on Tjing.';
+            container.appendChild(noResults);
+            return;
+        }
+
+        results.forEach(function(course) {
+            const item = document.createElement('div');
+            item.className = 'tjing-result';
+
+            const info = document.createElement('div');
+            info.className = 'tjing-result-info';
+
+            const nameSpan = document.createElement('span');
+            nameSpan.className = 'tjing-result-name';
+            nameSpan.textContent = course.name || '';
+
+            const addrSpan = document.createElement('span');
+            addrSpan.className = 'tjing-result-address';
+            addrSpan.textContent = course.address || '';
+
+            info.appendChild(nameSpan);
+            info.appendChild(addrSpan);
+
+            const importBtn = document.createElement('button');
+            importBtn.className = 'btn-pill';
+            importBtn.textContent = 'Import';
+            (function(id, b) {
+                b.addEventListener('click', function() { importFromTjing(id, b); });
+            })(course.id, importBtn);
+
+            item.appendChild(info);
+            item.appendChild(importBtn);
+            container.appendChild(item);
+        });
+    } catch (error) {
+        console.error('Error searching Tjing:', error);
+        const errFallback = document.createElement('p');
+        errFallback.className = 'tjing-error';
+        errFallback.textContent = 'Failed to search Tjing.';
+        container.appendChild(errFallback);
+    } finally {
+        btn.disabled = false;
+    }
+}
+
+// ── Tjing import ───────────────────────────────────
+async function importFromTjing(tjingId, btn) {
+    btn.disabled = true;
+    btn.textContent = 'Importing…';
+
+    try {
+        const response = await fetch('/api/tjing/import/' + encodeURIComponent(tjingId), { method: 'POST' });
+        let data;
+        try {
+            data = await response.json();
+        } catch (e) {
+            btn.textContent = 'Error';
+            btn.disabled = false;
+            return;
+        }
+
+        if (!response.ok || data.error) {
+            btn.textContent = 'Error: ' + (data.error || 'Import failed');
+            btn.disabled = false;
+            return;
+        }
+
+        btn.textContent = 'Imported ✓';
+        // Trigger table reload
+        htmx.trigger(document.body, 'refresh');
+    } catch (error) {
+        console.error('Error importing from Tjing:', error);
+        btn.textContent = 'Failed';
+        btn.disabled = false;
+    }
+}
+
+// ── Init ───────────────────────────────────────────
+function initAll() {
+    initCourseTabs();
+    initCourseLiveFilter();
+    initCourseCounts();
+}
+
+document.addEventListener('DOMContentLoaded', initAll);
+
+document.addEventListener('htmx:afterSwap', function(evt) {
+    if (evt.detail && evt.detail.target && evt.detail.target.id === 'course-table-region') {
+        initCourseLiveFilter();
+        initCourseCounts();
+    }
+});

public/js/players.js

@@ -1,4 +1,3 @@
-const cachedDebugInfo = {};
 let pendingPlayerData = null;
 let openPdgaNumber = null;
 
@@ -186,10 +185,6 @@ async function refreshRoundHistory(pdgaNumber) {
         }
 
         if (data.success) {
-            if (data.debugLog) {
-                cachedDebugInfo[pdgaNumber] = data.debugLog;
-            }
-
             const predictedCell = document.getElementById(`predicted-${pdgaNumber}`);
             if (predictedCell) {
                 const predictedValue = predictedCell.querySelector('.predicted-value');
@@ -234,43 +229,6 @@ async function refreshRatingHistory(pdgaNumber) {
     }
 }
 
-async function showDebugInfo(pdgaNumber) {
-    const modal = document.getElementById('debug-modal');
-    const header = document.getElementById('debug-header');
-    const log = document.getElementById('debug-log');
-
-    const playerNameElement = document.querySelector(`#row-${pdgaNumber} .player-name a`);
-    const playerName = playerNameElement ? playerNameElement.textContent : `PDGA #${pdgaNumber}`;
-
-    header.textContent = `Prediction Calculation Details - ${playerName}`;
-    log.textContent = 'Loading calculation details...';
-    modal.style.display = 'flex';
-
-    try {
-        if (cachedDebugInfo[pdgaNumber]) {
-            log.textContent = cachedDebugInfo[pdgaNumber].join('\n');
-            return;
-        }
-
-        const response = await fetch(`/api/refresh-round-history/${pdgaNumber}`, { method: 'POST' });
-        const data = await response.json();
-
-        if (data.success && data.debugLog) {
-            cachedDebugInfo[pdgaNumber] = data.debugLog;
-            log.textContent = data.debugLog.join('\n');
-        } else {
-            log.textContent = 'No debug information available. Try refreshing the prediction first.';
-        }
-    } catch (error) {
-        console.error('Error fetching debug info:', error);
-        log.textContent = 'Error loading debug information. Please try again.';
-    }
-}
-
-function closeDebugModal(event) {
-    document.getElementById('debug-modal').style.display = 'none';
-}
-
 async function searchAndAddPlayer(event) {
     if (event) event.preventDefault();
     const input = document.getElementById('pdga-number-input');
@@ -712,7 +670,6 @@ async function refreshHistoryThenCalculate(pdgaNumber) {
             return;
         }
 
-        if (data.debugLog) cachedDebugInfo[pdgaNumber] = data.debugLog;
         const predictedCell = document.getElementById('predicted-' + pdgaNumber);
         if (predictedCell) {
             const predictedValue = predictedCell.querySelector('.predicted-value');

src/db.js

@@ -34,6 +34,8 @@ function initializeDatabase() {
           const hasLastRoundUpdate = columns.some(col => col.name === 'last_round_update');
           const hasPredictedRating = columns.some(col => col.name === 'predicted_rating');
           const hasStdDev = columns.some(col => col.name === 'std_dev');
+          const hasExcludedRoundsCount = columns.some(col => col.name === 'excluded_rounds_count');
+          const hasCutoffRating = columns.some(col => col.name === 'cutoff_rating');
 
           if (!hasLastRoundUpdate) {
             logger.info('Adding last_round_update column to players table...');
@@ -58,6 +60,22 @@ function initializeDatabase() {
               else logger.info('Successfully added std_dev column');
             });
           }
+
+          if (!hasExcludedRoundsCount) {
+            logger.info('Adding excluded_rounds_count column to players table...');
+            db.run(`ALTER TABLE players ADD COLUMN excluded_rounds_count INTEGER DEFAULT NULL`, (err) => {
+              if (err) logger.error('Error adding excluded_rounds_count column:', err.message);
+              else logger.info('Successfully added excluded_rounds_count column');
+            });
+          }
+
+          if (!hasCutoffRating) {
+            logger.info('Adding cutoff_rating column to players table...');
+            db.run(`ALTER TABLE players ADD COLUMN cutoff_rating INTEGER DEFAULT NULL`, (err) => {
+              if (err) logger.error('Error adding cutoff_rating column:', err.message);
+              else logger.info('Successfully added cutoff_rating column');
+            });
+          }
         });
       });
 

src/models/course.js

@@ -8,8 +8,14 @@ function saveCourseToDB(courseData) {
        ON CONFLICT(link) DO UPDATE SET name = excluded.name, city = excluded.city, last_updated = datetime('now')`,
       [courseData.name, courseData.link, courseData.city],
       function(err) {
-        if (err) reject(err);
+        if (err) return reject(err);
-        else resolve(this.lastID);
+        // node-sqlite3 leaves lastID = 0 when ON CONFLICT triggers an UPDATE.
+        // Fall back to a SELECT to get the real id in that case.
+        if (this.lastID !== 0) return resolve(this.lastID);
+        db.get('SELECT id FROM courses WHERE link = ?', [courseData.link], (err2, row) => {
+          if (err2) reject(err2);
+          else resolve(row ? row.id : 0);
+        });
       }
     );
   });
@@ -70,10 +76,33 @@ function updateLayoutRating(courseId, layoutName, par, meanRating, ratingCount,
   });
 }
 
+function getOrCreateLayout(courseId, name, par) {
+  return new Promise((resolve, reject) => {
+    db.get(
+      'SELECT id FROM layouts WHERE course_id = ? AND name = ? AND par = ?',
+      [courseId, name, par],
+      (err, row) => {
+        if (err) return reject(err);
+        if (row) return resolve(row.id);
+
+        db.run(
+          'INSERT INTO layouts (course_id, name, par) VALUES (?, ?, ?)',
+          [courseId, name, par],
+          function(err) {
+            if (err) reject(err);
+            else resolve(this.lastID);
+          }
+        );
+      }
+    );
+  });
+}
+
 module.exports = {
   saveCourseToDB,
   getAllCoursesFromDB,
   saveLayoutToDB,
   getLayoutsForCourse,
+  getOrCreateLayout,
   updateLayoutRating
 };

src/models/player.js

@@ -1,5 +1,6 @@
 const { db } = require('../db');
 const { parseDate } = require('../services/rating-calculator');
+const logger = require('../logger');
 
 function getPlayerFromDB(pdgaNumber) {
   return new Promise((resolve, reject) => {
@@ -16,6 +17,7 @@ function getPlayerFromDB(pdgaNumber) {
 
 function savePlayerToDB(playerData) {
   return new Promise((resolve, reject) => {
+    logger.info({ pdgaNumber: playerData.pdgaNumber, name: playerData.name, currentRating: playerData.rating, ratingChange: playerData.ratingChange, resetColumns: ['predicted_rating', 'std_dev', 'excluded_rounds_count', 'cutoff_rating', 'last_round_update'] }, 'INSERT OR REPLACE on players — derived columns will be reset to NULL');
     db.run(
       `INSERT OR REPLACE INTO players (pdga_number, name, current_rating, rating_change, last_updated)
        VALUES (?, ?, ?, ?, datetime('now'))`,
@@ -172,16 +174,28 @@ function saveRoundHistoryToDB(pdgaNumber, roundData, isIncremental = false) {
   });
 }
 
-function savePredictedRatingToDB(pdgaNumber, predictedRating, stdDev = null) {
+function savePredictedRatingToDB(pdgaNumber, predictedRating, stdDev = null, excludedRoundsCount = null, cutoffRating = null, callsite = 'unknown') {
   return new Promise((resolve, reject) => {
-    db.run(
+    db.get('SELECT predicted_rating AS oldValue FROM players WHERE pdga_number = ?', [pdgaNumber], (selectErr, row) => {
-      'UPDATE players SET predicted_rating = ?, std_dev = ? WHERE pdga_number = ?',
+      if (selectErr) return reject(selectErr);
-      [predictedRating, stdDev, pdgaNumber],
+      const oldValue = row ? row.oldValue : null;
-      function(err) {
+
-        if (err) reject(err);
+      db.run(
-        else resolve();
+        'UPDATE players SET predicted_rating = ?, std_dev = ?, excluded_rounds_count = ?, cutoff_rating = ? WHERE pdga_number = ?',
-      }
+        [predictedRating, stdDev, excludedRoundsCount, cutoffRating, pdgaNumber],
-    );
+        function(err) {
+          if (err) return reject(err);
+
+          const logData = { pdgaNumber, oldValue, newValue: predictedRating, callsite };
+          if (predictedRating === 0 && oldValue != null && oldValue > 0) {
+            logger.warn(logData, 'predicted rating overwritten with 0');
+          } else {
+            logger.info(logData, 'predicted rating saved');
+          }
+          resolve();
+        }
+      );
+    });
   });
 }
 

src/routes/courses.js

@@ -1,7 +1,8 @@
 const express = require('express');
 const router = express.Router();
 const { db } = require('../db');
-const { getAllCoursesFromDB, getLayoutsForCourse, updateLayoutRating } = require('../models/course');
+const { getAllCoursesFromDB, getLayoutsForCourse, updateLayoutRating, saveCourseToDB, getOrCreateLayout } = require('../models/course');
+const { searchTjingCourses, getTjingCourse } = require('../scrapers/tjing');
 const { launchBrowser } = require('../scrapers/browser');
 const { layoutEventCache, scrapeCourseDirectory, scrapeCourseLayouts, scrapeEventResults } = require('../scrapers/course-puppeteer');
 const logger = require('../logger');
@@ -11,19 +12,30 @@ const activeScrapes = new Map();
 
 router.get('/partials/course-table', async (req, res) => {
   try {
-    const allCourses = await getAllCoursesFromDB();
+    const oneYearAgo = new Date();
-    const query = req.query.q || '';
+    oneYearAgo.setDate(oneYearAgo.getDate() - 365);
-    let courses = allCourses;
+    const oneYearAgoStr = oneYearAgo.toISOString().slice(0, 10);
 
-    if (query) {
+    const allCourses = await new Promise((resolve, reject) => {
-      const q = query.toLowerCase();
+      db.all(
-      courses = allCourses.filter(c =>
+        `SELECT c.*,
-        c.name.toLowerCase().includes(q) || c.city.toLowerCase().includes(q)
+                COUNT(l.id) AS layoutCount,
+                SUM(CASE WHEN l.last_played >= ? THEN 1 ELSE 0 END) AS activeLayoutCount
+         FROM courses c
+         LEFT JOIN layouts l ON l.course_id = c.id
+         GROUP BY c.id
+         ORDER BY c.name ASC`,
+        [oneYearAgoStr],
+        (err, rows) => {
+          if (err) reject(err);
+          else resolve(rows);
+        }
       );
-    }
+    });
 
-    res.render('../partials/course-table', { courses, query, total: allCourses.length });
+    res.render('../partials/course-table', { courses: allCourses });
   } catch (error) {
+    logger.error({ err: error }, 'Error loading course table');
     res.status(500).send('<p>Error loading courses. Please try again.</p>');
   }
 });
@@ -34,7 +46,7 @@ router.get('/partials/course-layouts/:courseId', async (req, res) => {
     const layouts = await getLayoutsForCourse(courseId);
     res.render('../partials/course-layouts', { layouts, courseId });
   } catch (error) {
-    logger.error('Error loading course layouts:', error.message);
+    logger.error({ err: error }, 'Error loading course layouts');
     res.status(500).send('<div class="no-layouts">Error loading layouts</div>');
   }
 });
@@ -44,7 +56,7 @@ router.get('/api/courses', async (req, res) => {
     const courses = await getAllCoursesFromDB();
     res.json(courses);
   } catch (error) {
-    logger.error('Error fetching courses:', error.message);
+    logger.error({ err: error }, 'Error fetching courses');
     res.status(500).json({ error: 'Failed to fetch courses' });
   }
 });
@@ -55,7 +67,7 @@ router.get('/api/layouts/:courseId', async (req, res) => {
     const layouts = await getLayoutsForCourse(courseId);
     res.json(layouts);
   } catch (error) {
-    logger.error('Error fetching layouts:', error.message);
+    logger.error({ err: error }, 'Error fetching layouts');
     res.status(500).json({ error: 'Failed to fetch layouts' });
   }
 });
@@ -214,7 +226,7 @@ router.post('/api/scrape-layouts/:courseId', async (req, res) => {
               savedCount++;
             }
           } catch (err) {
-            logger.error(`  Error updating layout ${layoutDataResult.name}:`, err.message);
+            logger.error({ err, layoutName: layoutDataResult.name }, 'Error updating layout');
           }
         }
       }
@@ -348,7 +360,7 @@ router.post('/api/scrape-event-results/:courseId', async (req, res) => {
             savedCount++;
           }
         } catch (err) {
-          logger.error(`  Error updating layout ${ld.name}:`, err.message);
+          logger.error({ err, layoutName: ld.name }, 'Error updating layout');
         }
       }
     }
@@ -369,4 +381,53 @@ router.post('/api/scrape-event-results/:courseId', async (req, res) => {
   }
 });
 
+// Search Tjing for courses
+router.get('/api/tjing/search', async (req, res) => {
+  const { q } = req.query;
+  if (!q || q.trim().length === 0) {
+    return res.json({ results: [] });
+  }
+
+  const result = await searchTjingCourses(q.trim());
+  if (result.error) {
+    logger.warn({ q, err: result.error }, 'Tjing search error');
+    return res.status(502).json({ error: result.error });
+  }
+
+  res.json({ results: result.data });
+});
+
+// Import a course from Tjing
+router.post('/api/tjing/import/:tjingId', async (req, res) => {
+  const { tjingId } = req.params;
+
+  const result = await getTjingCourse(tjingId);
+  if (result.error) {
+    logger.warn({ tjingId, err: result.error }, 'Tjing import error');
+    return res.status(502).json({ error: result.error });
+  }
+
+  const courseData = result.data;
+
+  try {
+    const courseId = await saveCourseToDB({
+      name: courseData.name,
+      link: `https://tjing.se/courses/${tjingId}`,
+      city: courseData.address || ''
+    });
+
+    let layoutsImported = 0;
+    for (const layout of courseData.layouts) {
+      await getOrCreateLayout(courseId, layout.name, layout.par);
+      layoutsImported++;
+    }
+
+    logger.info({ courseId, name: courseData.name, layoutsImported }, 'Imported course from Tjing');
+    res.json({ courseId, layoutsImported });
+  } catch (err) {
+    logger.error({ err, tjingId }, 'Failed to save Tjing course to DB');
+    res.status(500).json({ error: 'Failed to save course to database' });
+  }
+});
+
 module.exports = router;

src/routes/players.js

@@ -7,7 +7,7 @@ const { getOfficialRatingHistory, getOptimizedPlayerRounds } = require('../scrap
 const { launchBrowser } = require('../scrapers/browser');
 const { getPlayerDataFromDB, scrapePDGARating, getAllRatingsFromDB, refreshAllPlayersInDB, getPredictedRatingFromDB, formatDisplayDate } = require('../services/player-service');
 const { getTopbarLocals } = require('../services/topbar-service');
-const { calculatePredictedRating } = require('../services/rating-calculator');
+const { calculatePredictedRating, getNextPDGAUpdateDate } = require('../services/rating-calculator');
 const { calculateRequiredAverage } = require('../services/target-rating-calculator');
 const logger = require('../logger');
 
@@ -19,6 +19,7 @@ router.post('/api/refresh-all', async (req, res, next) => {
     return res.status(409).json({ error: 'Refresh already in progress' });
   }
   refreshInProgress = true;
+  logger.info({ pdgaNumber: 'all' }, 'refresh-all triggered — will invoke savePlayerToDB for all players (INSERT OR REPLACE wipes derived columns)');
   try {
     try {
       await refreshAllPlayersInDB();
@@ -253,7 +254,7 @@ router.post('/api/add-player', async (req, res) => {
 router.post('/api/refresh-player/:pdgaNumber', async (req, res) => {
   try {
     const { pdgaNumber } = req.params;
-    logger.info(`Manually refreshing player data for PDGA ${pdgaNumber}`);
+    logger.info({ pdgaNumber }, 'refresh-player triggered — will invoke savePlayerToDB (INSERT OR REPLACE wipes derived columns)');
 
     const html = await fetchPlayerDataHTTP(pdgaNumber);
     const playerData = parsePlayerData(html, pdgaNumber);
@@ -349,48 +350,45 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
 
     const isIncremental = !!sinceDate;
 
-    logger.info(`${isIncremental ? 'Incrementally updating' : 'Fully refreshing'} round history for PDGA ${pdgaNumber}${sinceDate ? ` since ${sinceDate.toDateString()}` : ''}`);
+    logger.info({ pdgaNumber, lastRoundUpdate, isIncremental }, 'refresh-round-history started');
 
     browser = await launchBrowser();
-    
+
     let officialHistory;
     try {
       officialHistory = await getOfficialRatingHistory(browser, pdgaNumber);
       if (officialHistory.length > 0) {
         await saveRatingHistoryToDB(pdgaNumber, officialHistory);
       }
+      logger.info({ pdgaNumber, step: 'official_history_scrape', success: officialHistory.length > 0, count: officialHistory.length }, 'official history scrape completed');
     } catch (historyError) {
-      logger.error('Failed to fetch official history:', historyError.message);
+      logger.warn({ pdgaNumber, step: 'official_history_scrape', success: false, error: historyError.message }, 'official history scrape failed');
       officialHistory = [];
     }
-    
+
     let allRounds = [];
     try {
-      logger.info(`Using optimized approach: /details + new tournaments only for PDGA ${pdgaNumber}...`);
       allRounds = await getOptimizedPlayerRounds(browser, pdgaNumber);
-      
+
       if (allRounds.length > 0) {
         const roundsForDB = allRounds.map(round => ({
           rating: round.rating,
           date: round.date,
           competition: round.competition
         }));
-        
+
         await saveRoundHistoryToDB(pdgaNumber, roundsForDB, false);
-        logger.info(`✓ Saved ${allRounds.length} rounds using optimized approach`);
-        
         await updateLastRoundUpdateDate(pdgaNumber);
-      } else {
-        logger.info('ℹ No rounds found');
       }
+      logger.info({ pdgaNumber, step: 'rounds_scrape_save', success: allRounds.length > 0, count: allRounds.length, lastRoundUpdateTouched: allRounds.length > 0 }, 'rounds scrape and save completed');
     } catch (detailsError) {
-      logger.error('Failed to fetch rounds using optimized approach:', detailsError.message);
+      logger.warn({ pdgaNumber, step: 'rounds_scrape_save', success: false, error: detailsError.message }, 'rounds scrape and save failed');
       allRounds = [];
     }
-    
+
     await browser.close();
     browser = null;
-    
+
     const dbRounds = await getRoundHistoryFromDB(pdgaNumber);
     const roundsForPrediction = dbRounds.map(round => ({
       rating: round.rating,
@@ -398,9 +396,10 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
       competition: round.competition_name
     }));
 
-    const result = calculatePredictedRating(roundsForPrediction);
+    const result = calculatePredictedRating(roundsForPrediction, { pdgaNumber, callsite: 'refresh-round-history' });
+    logger.info({ pdgaNumber, step: 'predicted_calc', rating: result.rating, stdDev: result.stdDev, excludedRoundsCount: result.excludedRoundsCount }, 'predicted rating calculation step completed');
 
-    await savePredictedRatingToDB(pdgaNumber, result.rating, result.stdDev);
+    await savePredictedRatingToDB(pdgaNumber, result.rating, result.stdDev, result.excludedRoundsCount, result.cutoffRating, 'refresh-round-history');
 
     const officialCount = allRounds.filter(r => r.source === 'official').length;
     const newCount = allRounds.filter(r => r.source === 'new').length;
@@ -409,7 +408,8 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
       success: true,
       predictedRating: result.rating,
       stdDev: result.stdDev,
-      debugLog: result.debugLog,
+      excludedRoundsCount: result.excludedRoundsCount,
+      cutoffRating: result.cutoffRating,
       totalRounds: roundsForPrediction.length,
       officialRounds: officialCount,
       newRounds: newCount,
@@ -417,10 +417,8 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
       message: `Used /details (${officialCount} rounds) + new tournaments (${newCount} rounds)`
     });
   } catch (error) {
-    logger.error(`=== Error refreshing round history for PDGA ${pdgaNumber} ===`);
+    logger.error({ pdgaNumber, step: 'unknown_or_orchestration', errorType: error.constructor.name, errorMessage: error.message }, 'refresh-round-history failed');
-    logger.error('Error type:', error.constructor.name);
+
-    logger.error('Error message:', error.message);
-    
     if (browser) {
       try {
         await browser.close();
@@ -428,14 +426,14 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
         logger.error('Error closing browser:', closeError.message);
       }
     }
-    
+
-    res.status(500).json({ 
+    res.status(500).json({
       error: 'Failed to refresh round history',
       details: error.message,
       errorType: error.constructor.name,
       timestamp: new Date().toISOString(),
-      suggestion: error.message.includes('socket hang up') ? 
+      suggestion: error.message.includes('socket hang up') ?
-        'Rate limited by PDGA - try again in a few minutes.' : 
+        'Rate limited by PDGA - try again in a few minutes.' :
         error.message.includes('timeout') ?
         'PDGA pages are loading slowly - try again later.' :
         'Tournament scraping failed - check server logs for details'
@@ -443,6 +441,46 @@ router.post('/api/refresh-round-history/:pdgaNumber', async (req, res) => {
   }
 });
 
+router.get('/api/admin/player-state/:pdgaNumber', async (req, res) => {
+  const { pdgaNumber } = req.params;
+  try {
+    const player = await getPlayerFromDB(pdgaNumber);
+    if (!player) {
+      return res.status(404).json({ error: 'Player not found', pdgaNumber: parseInt(pdgaNumber) });
+    }
+    const rounds = await getRoundHistoryFromDB(pdgaNumber);
+    const cutoff = getNextPDGAUpdateDate();
+    const twelveMonthsAgo = new Date(cutoff); twelveMonthsAgo.setFullYear(cutoff.getFullYear() - 1);
+    const twentyFourMonthsAgo = new Date(cutoff); twentyFourMonthsAgo.setFullYear(cutoff.getFullYear() - 2);
+
+    const roundsInLast12mo = rounds.filter(r => new Date(r.date) >= twelveMonthsAgo).length;
+    const roundsInLast24mo = rounds.filter(r => new Date(r.date) >= twentyFourMonthsAgo).length;
+    const dates = rounds.map(r => r.date).sort();
+
+    res.json({
+      pdgaNumber: player.pdga_number,
+      name: player.name,
+      currentRating: player.current_rating,
+      ratingChange: player.rating_change,
+      predictedRating: player.predicted_rating,
+      stdDev: player.std_dev,
+      excludedRoundsCount: player.excluded_rounds_count,
+      cutoffRating: player.cutoff_rating,
+      lastUpdated: player.last_updated,
+      lastRoundUpdate: player.last_round_update,
+      cutoffDate: cutoff.toISOString(),
+      roundCount: rounds.length,
+      roundsInLast12mo,
+      roundsInLast24mo,
+      oldestRound: dates[0] ?? null,
+      newestRound: dates[dates.length - 1] ?? null
+    });
+  } catch (err) {
+    logger.error({ err, pdgaNumber }, 'admin player-state endpoint failed');
+    res.status(500).json({ error: 'Failed to fetch player state', details: err.message });
+  }
+});
+
 router.post('/api/calculate-target-rating/:pdgaNumber', async (req, res) => {
   const { pdgaNumber } = req.params;
   const pdgaNum = parseInt(pdgaNumber, 10);
@@ -482,7 +520,7 @@ router.post('/api/calculate-target-rating/:pdgaNumber', async (req, res) => {
       competition: r.competition_name
     }));
 
-    const result = calculateRequiredAverage(roundRatings, target, numRounds);
+    const result = calculateRequiredAverage(roundRatings, target, numRounds, pdgaNum);
 
     logger.info(`Target rating calc for PDGA ${pdgaNum}: target=${target} rounds=${numRounds} -> avg=${result.requiredAverage}`);
 

src/scrapers/tjing.js

@@ -0,0 +1,111 @@
+const logger = require('../logger');
+
+const TJING_API = 'https://api.tjing.se/graphql';
+const FETCH_TIMEOUT_MS = 8000;
+
+async function tjingFetch(query) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  let response;
+  try {
+    response = await fetch(TJING_API, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query }),
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      return { error: 'Tjing API request timed out' };
+    }
+    return { error: `Network error: ${err.message}` };
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!response.ok) {
+    return { error: `Tjing API returned ${response.status}` };
+  }
+
+  let data;
+  try {
+    data = await response.json();
+  } catch (err) {
+    return { error: 'Invalid JSON from Tjing API' };
+  }
+
+  if (data.errors && data.errors.length > 0) {
+    return { error: data.errors[0].message };
+  }
+
+  return { data: data.data };
+}
+
+async function searchTjingCourses(searchTerm) {
+  const query = `{
+    courses(first: 10, filter: { search: "${searchTerm.replace(/"/g, '\\"')}" }) {
+      id
+      name
+      address
+      type
+    }
+  }`;
+
+  const result = await tjingFetch(query);
+  if (result.error) return result;
+
+  return { data: result.data.courses || [] };
+}
+
+async function getTjingCourse(courseId) {
+  const query = `{
+    course(courseId: "${courseId.replace(/"/g, '\\"')}") {
+      id
+      name
+      address
+      layouts {
+        id
+        name
+        published
+        latestVersion {
+          holes {
+            number
+            par
+          }
+        }
+      }
+    }
+  }`;
+
+  const result = await tjingFetch(query);
+  if (result.error) return result;
+
+  const course = result.data.course;
+  if (!course) {
+    return { error: 'Course not found' };
+  }
+
+  // Calculate total par per layout from holes
+  const layouts = (course.layouts || [])
+    .filter(l => l.published && l.latestVersion && l.latestVersion.holes.length > 0)
+    .map(l => ({
+      name: l.name,
+      par: l.latestVersion.holes.reduce((sum, h) => sum + h.par, 0),
+      holes: l.latestVersion.holes.length
+    }));
+
+  return {
+    data: {
+      name: course.name,
+      address: course.address,
+      tjingId: course.id,
+      layouts
+    }
+  };
+}
+
+module.exports = {
+  searchTjingCourses,
+  getTjingCourse
+};

src/services/player-service.js

@@ -36,18 +36,32 @@ async function getPlayerDataFromDB(pdgaNumber, { includeMonthlyHistory = true }
   try {
     const cachedPlayer = await getPlayerFromDB(pdgaNumber);
     if (cachedPlayer) {
-      logger.debug(`Loading PDGA ${pdgaNumber} from DB (source of truth)`);
+      logger.debug({ pdgaNumber }, 'Loading player from DB (source of truth)');
 
       let predictedRating = cachedPlayer.predicted_rating;
       let stdDev = cachedPlayer.std_dev;
+      let excludedRoundsCount = cachedPlayer.excluded_rounds_count;
+      let cutoffRating = cachedPlayer.cutoff_rating;
+      let recomputeAttempted = false;
       if (!predictedRating || predictedRating === 0) {
+        recomputeAttempted = true;
+        logger.debug({ pdgaNumber, dbValue: cachedPlayer.predicted_rating }, 'lazy recompute triggered for predicted_rating');
         predictedRating = await getPredictedRatingFromDB(pdgaNumber);
         const updatedPlayer = await getPlayerFromDB(pdgaNumber);
         stdDev = updatedPlayer?.std_dev;
+        excludedRoundsCount = updatedPlayer?.excluded_rounds_count;
+        cutoffRating = updatedPlayer?.cutoff_rating;
+        if (!predictedRating || predictedRating === 0) {
+          logger.info({ pdgaNumber, recomputedValue: predictedRating }, 'lazy recompute did not yield a positive predicted rating');
+        }
       }
 
       const rating = cachedPlayer.current_rating;
       const rawRatingChange = cachedPlayer.rating_change;
+      // Only warn about ≤0 if it wasn't already explained by a failed recompute (which has its own log)
+      if (!recomputeAttempted && predictedRating != null && predictedRating <= 0) {
+        logger.warn({ pdgaNumber, dbValue: predictedRating }, 'predicted rating present but <= 0 in DB without recompute — rendered as empty');
+      }
       const resolvedPredicted = predictedRating > 0 ? predictedRating : null;
       const resolvedStdDev = stdDev > 0 ? stdDev : null;
 
@@ -65,6 +79,8 @@ async function getPlayerDataFromDB(pdgaNumber, { includeMonthlyHistory = true }
         ratingChange,
         predictedRating: resolvedPredicted,
         stdDev: resolvedStdDev,
+        excludedRoundsCount: (excludedRoundsCount != null && excludedRoundsCount >= 0) ? excludedRoundsCount : null,
+        cutoffRating: (cutoffRating != null && cutoffRating > 0) ? cutoffRating : null,
         lastMonthRating,
         // gap between next predicted update and current rating (null when either is missing)
         deltaPredicted: (resolvedPredicted != null && rating != null) ? resolvedPredicted - rating : null,
@@ -134,22 +150,28 @@ async function scrapePDGARating(pdgaNumber, retries = 3) {
 async function getPredictedRatingFromDB(pdgaNumber) {
   try {
     const roundHistory = await getRoundHistoryFromDB(pdgaNumber);
-    if (roundHistory.length > 0) {
+    if (roundHistory.length === 0) {
-      logger.debug(`Using ${roundHistory.length} cached rounds for PDGA ${pdgaNumber} prediction`);
+      logger.info({ pdgaNumber, reason: 'no_round_history_in_db' }, 'predicted recompute returning 0 — no round history available');
-
+      return 0;
-      const roundRatings = roundHistory.map(round => ({
-        rating: round.rating,
-        date: new Date(round.date),
-        competition: round.competition_name || 'Unknown'
-      }));
-
-      const result = calculatePredictedRating(roundRatings);
-
-      await savePredictedRatingToDB(pdgaNumber, result.rating, result.stdDev);
-
-      return result.rating;
     }
-    return 0;
+
+    logger.debug({ pdgaNumber, cachedRounds: roundHistory.length }, 'Using cached rounds for prediction');
+
+    const roundRatings = roundHistory.map(round => ({
+      rating: round.rating,
+      date: new Date(round.date),
+      competition: round.competition_name || 'Unknown'
+    }));
+
+    const result = calculatePredictedRating(roundRatings, { pdgaNumber, callsite: 'getPredictedRatingFromDB' });
+
+    if (result.rating === 0) {
+      logger.warn({ pdgaNumber, roundsInDb: roundHistory.length }, 'predicted recompute returned 0 despite having rounds in DB');
+    }
+
+    await savePredictedRatingToDB(pdgaNumber, result.rating, result.stdDev, result.excludedRoundsCount, result.cutoffRating, 'lazy-recompute');
+
+    return result.rating;
   } catch (err) {
     logger.error(`Error getting predicted rating from DB for ${pdgaNumber}:`, err.message);
     return 0;
@@ -229,6 +251,8 @@ async function getAllRatingsFromDB(progressCallback = null) {
           ratingChange: errorRatingChange,
           predictedRating: null,
           stdDev: null,
+          excludedRoundsCount: null,
+          cutoffRating: null,
           lastMonthRating: (errorRating != null && errorRatingChange != null) ? errorRating - errorRatingChange : null,
           deltaPredicted: null,
           monthlyHistory: [],

src/services/rating-calculator.js

@@ -1,3 +1,5 @@
+const logger = require('../logger');
+
 function parseDate(dateStr) {
   const multiDayMatch = dateStr.match(/^(\d{1,2})(-([A-Za-z]{3}))?(\s+to\s+)(\d{1,2})-([A-Za-z]{3})-(\d{4})$/);
   if (multiDayMatch) {
@@ -79,15 +81,19 @@ function calculateStandardDeviation(ratings) {
   return Math.sqrt(variance);
 }
 
-function calculatePredictedRating(roundRatings) {
+function calculatePredictedRating(roundRatings, context = {}) {
+  const pdgaNumber = context.pdgaNumber ?? null;
+  const callsite = context.callsite ?? 'unknown';
   const debugLog = [];
   debugLog.push('=== PDGA RATING CALCULATION (Following Official Rules) ===');
 
   if (!roundRatings || roundRatings.length === 0) {
     debugLog.push('❌ No rounds provided for prediction');
-    return { rating: 0, debugLog };
+    logger.warn({ pdgaNumber, callsite, reason: 'no_rounds' }, 'predicted rating computed as 0');
+    return { rating: 0, debugLog, excludedRoundsCount: null, cutoffRating: null };
   }
 
+  logger.info({ pdgaNumber, callsite, inputRounds: roundRatings.length }, 'predicted rating calculation started');
   debugLog.push(`📊 Starting with ${roundRatings.length} total rounds`);
 
   const nextUpdateDate = getNextPDGAUpdateDate();
@@ -100,7 +106,8 @@ function calculatePredictedRating(roundRatings) {
 
   if (allSortedRounds.length === 0) {
     debugLog.push('❌ No valid rounds after filtering for update date');
-    return { rating: 0, debugLog };
+    logger.warn({ pdgaNumber, callsite, reason: 'no_rounds_after_date_filter', inputRounds: roundRatings.length, nextUpdateDate: nextUpdateDate.toISOString() }, 'predicted rating computed as 0');
+    return { rating: 0, debugLog, excludedRoundsCount: null, cutoffRating: null };
   }
 
   debugLog.push(`📊 After update date filter: ${allSortedRounds.length} rounds`);
@@ -117,8 +124,9 @@ function calculatePredictedRating(roundRatings) {
   debugLog.push('🗓️  12-MONTH FILTERING:');
   debugLog.push(`✅ Rounds in last 12 months: ${eligibleRounds.length}`);
 
+  let twentyFourMonthsBeforeUpdate = null;
   if (eligibleRounds.length < 8) {
-    const twentyFourMonthsBeforeUpdate = new Date(nextUpdateDate);
+    twentyFourMonthsBeforeUpdate = new Date(nextUpdateDate);
     twentyFourMonthsBeforeUpdate.setFullYear(twentyFourMonthsBeforeUpdate.getFullYear() - 2);
 
     eligibleRounds = allSortedRounds.filter(r => r.date >= twentyFourMonthsBeforeUpdate);
@@ -127,7 +135,8 @@ function calculatePredictedRating(roundRatings) {
 
   if (eligibleRounds.length === 0) {
     debugLog.push('❌ No eligible rounds found');
-    return { rating: 0, debugLog };
+    logger.warn({ pdgaNumber, callsite, reason: 'no_eligible_rounds', afterDateFilter: allSortedRounds.length, twelveMonthCutoff: twelveMonthsBeforeUpdate.toISOString(), twentyFourMonthCutoff: twentyFourMonthsBeforeUpdate ? twentyFourMonthsBeforeUpdate.toISOString() : null }, 'predicted rating computed as 0');
+    return { rating: 0, debugLog, excludedRoundsCount: null, cutoffRating: null };
   }
 
   debugLog.push(`📈 ELIGIBLE ROUNDS: ${eligibleRounds.length}`);
@@ -137,6 +146,8 @@ function calculatePredictedRating(roundRatings) {
 
   let workingRounds = [...eligibleRounds];
   let workingRatings = workingRounds.map(r => r.rating);
+  let excludedRoundsCount = 0;
+  let cutoffRating = null;
 
   if (workingRatings.length >= 7) {
     debugLog.push('🔍 OUTLIER EXCLUSION (≥7 rounds available):');
@@ -160,6 +171,9 @@ function calculatePredictedRating(roundRatings) {
     const stdDevOutliers = workingRatings.filter(rating => rating < stdDevCutoff);
     const hundredPointOutliers = workingRatings.filter(rating => rating < hundredPointCutoff && rating >= stdDevCutoff);
 
+    excludedRoundsCount = stdDevOutliers.length + hundredPointOutliers.length;
+    cutoffRating = Math.round(Math.max(stdDevCutoff, hundredPointCutoff));
+
     if (stdDevOutliers.length > 0) {
       debugLog.push(`   ❌ 2.5σ outliers removed: ${stdDevOutliers.length} rounds`);
       stdDevOutliers.forEach(rating => {
@@ -188,6 +202,8 @@ function calculatePredictedRating(roundRatings) {
       debugLog.push(`   ✅ Using ${filteredRatings.length} rounds after outlier removal`);
     } else {
       debugLog.push(`   ⚠️  Too few rounds after outlier removal (${filteredRatings.length}), keeping all rounds`);
+      excludedRoundsCount = 0;
+      cutoffRating = null;
     }
   } else {
     debugLog.push(`⏭️  OUTLIER EXCLUSION SKIPPED (only ${workingRatings.length} rounds, need ≥7)`);
@@ -228,7 +244,20 @@ function calculatePredictedRating(roundRatings) {
   debugLog.push(`   Final Rating: ${finalRating}`);
   debugLog.push('=== END PDGA CALCULATION ===');
 
-  return { rating: finalRating, stdDev: Math.round(stdDev), debugLog };
+  logger.info({
+    pdgaNumber,
+    callsite,
+    finalRating,
+    inputRounds: roundRatings.length,
+    afterDateFilter: allSortedRounds.length,
+    eligibleRounds: eligibleRounds.length,
+    outlierExclusionApplied: workingRatings.length >= 7,
+    doubleWeightingApplied: workingRatings.length >= 9,
+    excludedRoundsCount,
+    cutoffRating
+  }, 'predicted rating calculated');
+
+  return { rating: finalRating, stdDev: Math.round(stdDev), debugLog, excludedRoundsCount, cutoffRating };
 }
 
 module.exports = { parseDate, getNextPDGAUpdateDate, calculatePredictedRating, calculateStandardDeviation };

src/services/target-rating-calculator.js

@@ -1,14 +1,14 @@
 const { calculatePredictedRating, getNextPDGAUpdateDate } = require('./rating-calculator');
 const logger = require('../logger');
 
-function calculateRequiredAverage(roundRatings, targetRating, numRounds) {
+function calculateRequiredAverage(roundRatings, targetRating, numRounds, pdgaNumber) {
   if (!Array.isArray(roundRatings) || roundRatings.length === 0) {
     const err = new Error('No round history');
     err.code = 'NO_ROUNDS';
     throw err;
   }
 
-  const currentPredicted = calculatePredictedRating(roundRatings).rating;
+  const currentPredicted = calculatePredictedRating(roundRatings, { pdgaNumber, callsite: 'target-rating-calculator' }).rating;
   const nextUpdate = getNextPDGAUpdateDate();
   const syntheticDate = new Date(nextUpdate.getTime() - 24 * 60 * 60 * 1000);
 

views/pages/courses.ejs

@@ -1,43 +1,32 @@
 <% var body = `
-        <div class="card-section">
+<main class="page-courses">
-            <h3>Find Courses</h3>
+  <section class="action-card">
-            <div class="card-section-form">
+    <div class="action-card-tabs" role="tablist">
-                <input
+      <button class="action-tab is-active" role="tab" aria-selected="true" data-tab="find" id="tab-find">Find courses</button>
-                    type="text"
+      <button class="action-tab" role="tab" aria-selected="false" data-tab="tjing" id="tab-tjing">Import from Tjing</button>
-                    class="input"
+    </div>
-                    id="course-search"
+    <div class="action-card-body">
-                    name="q"
+      <div class="action-pane is-active" id="tab-pane-find" role="tabpanel" aria-labelledby="tab-find">
-                    placeholder="Search courses by name or city..."
+        <input type="text" id="course-filter-input" placeholder="Find a course…" autocomplete="off">
-                    hx-get="/partials/course-table"
+        <p class="action-hint">Filters the list below as you type.</p>
-                    hx-trigger="input changed delay:300ms, search"
+      </div>
-                    hx-target="#courses-table"
+      <div class="action-pane" id="tab-pane-tjing" role="tabpanel" aria-labelledby="tab-tjing" hidden>
-                    style="width: 340px;"
+        <div class="tjing-search-row">
-                />
+          <input type="text" id="tjing-search-input" placeholder="Search Tjing courses…" autocomplete="off">
-                <button class="btn" onclick="scrapeCourses()" id="scrape-courses-btn">
+          <button id="tjing-search-btn" class="btn-primary" onclick="searchTjing()">Search Tjing</button>
-                    <i class="fas fa-sync-alt"></i> Scrape Courses
-                </button>
-            </div>
         </div>
+        <p class="action-hint">Find and import Swedish courses from tjing.se.</p>
+        <div id="tjing-results"></div>
+      </div>
+    </div>
+  </section>
 
-        <!-- Mobile tab pill (visible only on mobile via CSS) -->
+  <div class="results-bar">
-        <div class="m-tab-pill">
+    <span class="results-count">Showing <strong id="visible-count">0</strong> of <strong id="total-count">0</strong> courses</span>
-            <button class="m-tab-pill__btn m-tab-pill__btn--active" type="button">Find courses</button>
+  </div>
-            <button class="m-tab-pill__btn m-tab-pill__btn--disabled" type="button" disabled>Import from Tjing</button>
-        </div>
 
-        <!-- Mobile search input (hidden on desktop, shown on mobile via CSS) -->
+  <div id="course-table-region" hx-get="/partials/course-table" hx-trigger="load, refresh from:body" hx-swap="innerHTML"></div>
-        <input
+</main>
-            type="text"
-            class="m-search-input"
-            id="course-search-mobile"
-            name="q"
-            placeholder="Search courses by name or city..."
-            hx-get="/partials/course-table"
-            hx-trigger="input changed delay:300ms, search"
-            hx-target="#courses-table"
-        />
-
-        <div id="courses-table" hx-get="/partials/course-table" hx-trigger="load"></div>
 `; %>
 
 <%- include('../partials/layout', {
@@ -46,4 +35,4 @@
     cssFiles: ['courses.css'],
     jsFiles: ['courses.js'],
     body: body
-}) %>
+}) %>

views/pages/index.ejs

@@ -95,15 +95,6 @@
 `; %>
 
 <% var modals = `
-    <!-- Debug Modal -->
-    <div id="debug-modal" class="debug-modal" onclick="closeDebugModal(event)">
-        <div class="debug-content" onclick="event.stopPropagation()">
-            <button class="debug-close" onclick="closeDebugModal()">&times;</button>
-            <div class="debug-header" id="debug-header">Prediction Calculation Details</div>
-            <div class="debug-log" id="debug-log">Loading...</div>
-        </div>
-    </div>
-
     <!-- Add Player Confirmation Modal -->
     <div id="add-player-modal" class="modal" onclick="closeAddPlayerModal(event)">
         <div class="modal-content" onclick="event.stopPropagation()">

views/partials/course-layouts.ejs

@@ -1,71 +1,67 @@
-<% if (layouts.length === 0) { %>
+<% if (!layouts || layouts.length === 0) { %>
-    <div class="no-layouts">No layouts found. Click the refresh icon to scrape layouts.</div>
+  <div class="no-layouts">No layouts found. Click the refresh button to scrape layouts.</div>
 <% } else {
-    var oneYearAgo = new Date();
+  var oneYearAgo = new Date();
-    oneYearAgo.setDate(oneYearAgo.getDate() - 365);
+  oneYearAgo.setDate(oneYearAgo.getDate() - 365);
-
+  var activeLayouts = [];
-    var activeLayouts = [];
+  var inactiveLayouts = [];
-    var inactiveLayouts = [];
+  layouts.forEach(function(l) {
-
+    if (l.last_played && new Date(l.last_played) >= oneYearAgo) {
-    layouts.forEach(function(layout) {
+      activeLayouts.push(l);
-        if (layout.last_played) {
+    } else {
-            var lastPlayedDate = new Date(layout.last_played);
+      inactiveLayouts.push(l);
-            if (lastPlayedDate >= oneYearAgo) {
+    }
-                activeLayouts.push(layout);
+  });
-            } else {
+  var RATING_TIER_HIGH = 970;
-                inactiveLayouts.push(layout);
+  var RATING_TIER_MID  = 940;
-            }
+  function ratingTier(r) {
-        } else {
+    if (r == null) return null;
-            inactiveLayouts.push(layout);
+    if (r >= RATING_TIER_HIGH) return 'green';
-        }
+    if (r >= RATING_TIER_MID)  return 'amber';
-    });
+    return 'orange';
+  }
 %>
-    <h4>Layouts:</h4>
+<div class="layouts-header">
-
+  <span class="layouts-kicker">LAYOUTS</span>
-    <% if (activeLayouts.length > 0) { %>
+  <span class="layouts-count"><%= activeLayouts.length %> active &middot; <%= inactiveLayouts.length %> inactive</span>
-        <% activeLayouts.forEach(function(layout) {
+</div>
-            var ratingDisplay = layout.mean_rating ?
+<ul class="layout-list">
-                '<span style="color: var(--green); font-weight: 700; margin-left: 10px;">Rating: ' + layout.mean_rating + '</span>' : '';
+  <% activeLayouts.forEach(function(l) { var tier = ratingTier(l.mean_rating); %>
-            var dateDisplay = layout.last_played ?
+    <li class="layout-card layout-card--active">
-                '<span style="color: var(--text-muted); font-size: 12px; margin-left: 10px;">Last played: ' + new Date(layout.last_played).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }) + '</span>' : '';
+      <div class="layout-info">
-        %>
+        <span class="layout-name"><%= l.name %></span>
-            <div class="layout-item">
+        <span class="layout-last-played">Last played: <%= l.last_played %></span>
-                <div>
+      </div>
-                    <span class="layout-name"><%= layout.name %></span>
+      <div class="layout-chips">
-                    <%- dateDisplay %>
+        <span class="chip chip-par">Par <%= l.par %></span>
-                </div>
+        <% if (tier) { %><span class="chip chip-rating chip-rating--<%= tier %>">Rating: <%= Math.round(l.mean_rating) %></span><% } %>
-                <span class="layout-par">Par <%= layout.par %><%- ratingDisplay %></span>
+      </div>
-            </div>
+    </li>
-        <% }); %>
+  <% }); %>
-    <% } %>
+</ul>
-
+<% if (inactiveLayouts.length > 0) { %>
-    <% if (inactiveLayouts.length > 0) { %>
+  <div class="inactive-layouts">
-        <div class="inactive-layouts-accordion">
+    <button class="inactive-toggle" type="button" onclick="toggleInactiveLayouts(this)" aria-expanded="false">
-            <div class="accordion-header" onclick="toggleAccordion('accordion-<%= courseId %>')">
+      <span>Inactive layouts (<%= inactiveLayouts.length %>) — Not played in last year</span>
-                <span class="accordion-header-text">Inactive Layouts (<%= inactiveLayouts.length %>) - Not played in last year</span>
+      <i class="icon-chev fas fa-chevron-down"></i>
-                <span class="accordion-icon" id="accordion-<%= courseId %>-icon">&#9660;</span>
+    </button>
-            </div>
+    <ul class="layout-list inactive-layouts-body" hidden>
-            <div class="accordion-content" id="accordion-<%= courseId %>">
+      <% inactiveLayouts.forEach(function(l) { %>
-                <% inactiveLayouts.forEach(function(layout) {
+        <li class="layout-card layout-card--inactive">
-                    var ratingDisplay = layout.mean_rating ?
+          <div class="layout-info">
-                        '<span style="color: var(--green); font-weight: 700; margin-left: 10px;">Rating: ' + layout.mean_rating + '</span>' : '';
+            <span class="layout-name"><%= l.name %></span>
-                    var dateDisplay = layout.last_played ?
+            <% if (l.last_played) { %>
-                        '<span style="color: var(--text-muted); font-size: 12px; margin-left: 10px;">Last played: ' + new Date(layout.last_played).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' }) + '</span>' :
+              <span class="layout-last-played">Last played: <%= l.last_played %></span>
-                        '<span style="color: var(--red); font-size: 12px; margin-left: 10px;">Never played</span>';
+            <% } else { %>
-                %>
+              <span class="layout-never-played">Never played</span>
-                    <div class="layout-item inactive">
+            <% } %>
-                        <div>
+          </div>
-                            <span class="layout-name"><%= layout.name %></span>
+          <div class="layout-chips">
-                            <%- dateDisplay %>
+            <span class="chip chip-par">Par <%= l.par %></span>
-                        </div>
+          </div>
-                        <span class="layout-par">Par <%= layout.par %><%- ratingDisplay %></span>
+        </li>
-                    </div>
+      <% }); %>
-                <% }); %>
+    </ul>
-            </div>
+  </div>
-        </div>
+<% } %>
-    <% } %>
+<% } %>
-
-    <% if (activeLayouts.length === 0 && inactiveLayouts.length === 0) { %>
-        <div class="no-layouts">No layouts found. Click the refresh icon to scrape layouts.</div>
-    <% } %>
-<% } %>

views/partials/course-table.ejs

@@ -1,47 +1,49 @@
-<div id="search-results-info" class="search-results-info">
+<% if (!courses || courses.length === 0) { %>
-    <% if (typeof query !== 'undefined' && query) { %>
+  <p style="text-align: center; color: var(--ink-3); padding: 40px 0;">No courses found. Use "Import from Tjing" or scrape courses from PDGA.</p>
-        Showing <%= courses.length %> of <%= total %> courses
-    <% } else { %>
-        Showing all <%= courses.length %> courses
-    <% } %>
-</div>
-
-<% if (courses.length === 0) { %>
-    <p>No courses found. Click "Scrape Courses" to load Swedish courses from PDGA.</p>
 <% } else { %>
-    <table>
+<div class="course-grid" data-total-count="<%= courses.length %>">
-        <thead>
+  <div class="course-row course-row--header" role="row">
-            <tr>
+    <div class="course-header-cell">Course</div>
-                <th>Course Name</th>
+    <div class="course-header-cell">City</div>
-                <th class="mobile-hide">City</th>
+    <div class="course-header-cell">Last updated</div>
-                <th class="mobile-hide">Last Updated</th>
+    <div class="course-header-cell"></div>
-                <th>Actions</th>
+  </div>
-            </tr>
+  <% courses.forEach(function(course) {
-        </thead>
+      var layoutCount = course.layoutCount || 0;
-        <tbody>
+      var activeLayoutCount = course.activeLayoutCount || 0;
-            <% courses.forEach(function(course) {
+  %>
-                var lastUpdated = new Date(course.last_updated).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric' });
+    <div class="course-row expandable-row" data-course-id="<%= course.id %>" data-course-name="<%= (course.name || '').toLowerCase() %>" data-course-city="<%= (course.city || '').toLowerCase() %>" onclick="toggleCourseLayouts(<%= course.id %>)">
-            %>
+      <div class="course-cell">
-            <tr id="row-<%= course.id %>" class="expandable-row" onclick="toggleCourseLayouts(<%= course.id %>)">
+        <span class="course-name"><%= course.name %></span>
-                <td>
+        <span class="course-meta">
-                    <a href="<%= course.link %>" target="_blank" onclick="event.stopPropagation()"><%= course.name %></a>
+          <% if (layoutCount > 0) { %>
-                    <div class="mobile-only" style="font-size: 11px; color: #999; margin-top: 2px;"><%= course.city %></div>
+            <% if (activeLayoutCount !== layoutCount) { %>
-                </td>
+              <%= layoutCount %> layouts &middot; <%= activeLayoutCount %> active
-                <td class="mobile-hide"><%= course.city %></td>
+            <% } else { %>
-                <td class="mobile-hide"><%= lastUpdated %></td>
+              <%= layoutCount %> layouts
-                <td>
+            <% } %>
-                    <i class="fas fa-sync-alt refresh-icon" onclick="scrapeLayouts(<%= course.id %>, '<%= course.name.replace(/'/g, "\\'") %>'); event.stopPropagation();" title="Scrape layouts for this course"></i>
+          <% } else { %>
-                </td>
+            No layouts
-            </tr>
+          <% } %>
-            <tr id="layouts-<%= course.id %>" class="expanded-content">
+        </span>
-                <td colspan="4">
+      </div>
-                    <div class="layouts-container" id="layouts-container-<%= course.id %>">
+      <div class="course-city"><%= course.city || '—' %></div>
-                        <div class="no-layouts">Click to load layouts...</div>
+      <div class="course-updated"><%= course.last_updated ? new Date(course.last_updated).toISOString().slice(0,10) : '—' %></div>
-                    </div>
+      <div class="course-actions">
-                </td>
+        <button class="icon-btn refresh-icon" onclick="event.stopPropagation(); scrapeLayouts(<%= course.id %>, this)" title="Refresh layouts" aria-label="Refresh layouts">
-            </tr>
+          <i class="fas fa-sync-alt"></i>
-            <% }); %>
+        </button>
-        </tbody>
+        <button class="icon-btn icon-chev" onclick="event.stopPropagation(); toggleCourseLayouts(<%= course.id %>)" title="Expand row" aria-label="Expand">
-    </table>
+          <i class="fas fa-chevron-down"></i>
-    <%- include('course-cards', { courses: courses, query: locals.query, total: locals.total }) %>
+        </button>
+      </div>
+    </div>
+    <div class="expanded-content" id="course-layouts-<%= course.id %>">
+      <div class="expanded-cell">
+        <div class="loading">Loading layouts…</div>
+      </div>
+    </div>
+  <% }); %>
+</div>
+<%- include('course-cards', { courses: courses, total: courses.length }) %>
 <% } %>

views/partials/player-history.ejs

@@ -36,8 +36,19 @@ const chartPdgaNumber = hasPlayer ? player.pdgaNumber : pdgaNumber;
         <dd><%= player.rating - player.stdDev %>–<%= player.rating + player.stdDev %></dd>
       </div>
       <% } %>
+      <% if (player.excludedRoundsCount != null && player.rating) { %>
+      <div>
+        <dt>Excluded rounds</dt>
+        <dd><%= player.excludedRoundsCount %></dd>
+      </div>
+      <% } %>
+      <% if (player.cutoffRating != null && player.rating) { %>
+      <div>
+        <dt>Cutoff rating</dt>
+        <dd><%= player.cutoffRating %></dd>
+      </div>
+      <% } %>
     </dl>
-    <button class="link-btn" onclick="showDebugInfo(<%= player.pdgaNumber %>)" style="margin-top: 4px;">View calculation details →</button>
   </div>
   <% } %>
 

views/partials/ratings-cards.ejs

@@ -124,6 +124,18 @@ function renderSparkline(values, opts) {
                     <dd><%= player.rating - player.stdDev %>–<%= player.rating + player.stdDev %></dd>
                 </div>
                 <% } %>
+                <% if (player.excludedRoundsCount != null && player.rating) { %>
+                <div>
+                    <dt>Excluded rounds</dt>
+                    <dd><%= player.excludedRoundsCount %></dd>
+                </div>
+                <% } %>
+                <% if (player.cutoffRating != null && player.rating) { %>
+                <div>
+                    <dt>Cutoff rating</dt>
+                    <dd><%= player.cutoffRating %></dd>
+                </div>
+                <% } %>
             </dl>
         </div>
     </div>