Auction end times, visual flair, and pre-launch cleanup

Auction handling:
- Capture itemEndDate from eBay Browse API and ending_date from ZenMarket
  (Yahoo JP); plumb through results.ends_at column. Permissive ZenMarket
  parser (multiple layouts, JST when offset missing).
- Per-row "Ends" countdown column + "Ending soon" banner on results pages,
  live-ticked by flair.js with urgent/critical tinting under 1h/5m.
- Backfill ends_at for known auctions when their URL reappears in a poll
  (dedup hit no longer drops the new end time).
- Hide ended auctions from result listings by default via
  ResultsQuery.ExcludeEnded; rows stay in the DB.

Visual flair:
- Glassy backdrop-blur v-cards with gradient-mask borders and hover-lift.
- htmx swap fade-in via transient .v-just-swapped class.
- Count-up animation on dashboard stats. All animations gated behind
  prefers-reduced-motion.

eBay condition + region filters (auctions-style scoping):
- items.condition and items.region columns; threaded through item form,
  CreateItem/UpdateItem, scheduler eBay plan input, and previewKey so
  cache invalidates when these change.
- ebay.SearchParams gains conditionIds and itemLocationCountry filters.

Run Now reload + countdown engine:
- Run Now now sets HX-Refresh: true (non-htmx fallback: 303 redirect) so
  the entire results view — best price, chart, badge, last polled —
  reflects the new poll, instead of swapping just one partial.

Pre-launch hardening (P1 set):
- auth.EqualizeLoginTiming on no-such-user branch.
- (*App).serverError centralizes 500s; replaces err.Error() leaks across
  results/settings/items/users/dashboard handlers.
- main.go server: ReadTimeout 30s / WriteTimeout 60s / IdleTimeout 120s
  alongside the existing ReadHeaderTimeout.
- noListFS wrapper blocks static directory listings.
- Credential fields in settings no longer render value=; blank submission
  preserves the saved value, with per-field "Saved in settings / Set in
  config.toml / Not set" status indicator.

Misc:
- -debug flag wires slog to LevelDebug; raw ZenMarket items logged for
  format diagnosis.
- /healthz public endpoint for reverse-proxy probes.
- deploy/veola.service systemd unit template (hardening flags, single
  ReadWritePaths=/var/lib/veola).
- handlers_test.go covers /healthz, setup-gate redirect, auth gate, and
  /login render with httptest + in-memory sqlite.
- best_price_currency on items; templates pick the right symbol per row.
- .gitignore now excludes *.log / veola-debug.log.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

static/js/flair.js

@@ -0,0 +1,130 @@
+// Lightweight visual flourishes:
+//   - count-up animation on [data-countup] elements at page load
+//   - fade-in on htmx swap targets via a transient .v-just-swapped class
+// Respects prefers-reduced-motion by no-oping both effects.
+
+(function () {
+  const prefersReduced =
+    window.matchMedia &&
+    window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+
+  function easeOutCubic(t) {
+    return 1 - Math.pow(1 - t, 3);
+  }
+
+  function animateCount(el) {
+    if (prefersReduced) return;
+    const raw = el.textContent.trim();
+    const m = raw.match(/^(\$|£|€|¥)?(-?[\d,]+(?:\.\d+)?)$/);
+    if (!m) return;
+    const prefix = m[1] || "";
+    const numeric = m[2].replace(/,/g, "");
+    const target = parseFloat(numeric);
+    if (!isFinite(target)) return;
+    const decimals = numeric.includes(".") ? numeric.split(".")[1].length : 0;
+    const format = (v) =>
+      prefix + (decimals > 0 ? v.toFixed(decimals) : Math.floor(v).toString());
+    const duration = 650;
+    const start = performance.now();
+    el.textContent = format(0);
+    function tick(now) {
+      const t = Math.min(1, (now - start) / duration);
+      const v = target * easeOutCubic(t);
+      el.textContent = format(v);
+      if (t < 1) {
+        requestAnimationFrame(tick);
+      } else {
+        el.textContent = format(target);
+      }
+    }
+    requestAnimationFrame(tick);
+  }
+
+  function runCountUps() {
+    document.querySelectorAll("[data-countup]").forEach(animateCount);
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", runCountUps);
+  } else {
+    runCountUps();
+  }
+
+  document.addEventListener("htmx:afterSwap", function (evt) {
+    if (prefersReduced) return;
+    const target = evt.detail && evt.detail.target;
+    if (!target || !target.classList) return;
+    target.classList.add("v-just-swapped");
+    setTimeout(() => target.classList.remove("v-just-swapped"), 400);
+  });
+
+  // Auction countdowns. Each [data-countdown] reads its sibling/ancestor's
+  // data-ends-at ISO timestamp. Above 1h remaining we update once a minute
+  // (text barely changes); inside the last hour we tick every second and tint
+  // urgent / critical so the eye lands on it. Past the end we render "ended"
+  // and stop ticking that node.
+  function formatRemaining(ms) {
+    if (ms <= 0) return { text: "ended", urgent: false, critical: false };
+    const s = Math.floor(ms / 1000);
+    const days = Math.floor(s / 86400);
+    const hours = Math.floor((s % 86400) / 3600);
+    const minutes = Math.floor((s % 3600) / 60);
+    const seconds = s % 60;
+    const urgent = ms < 60 * 60 * 1000;
+    const critical = ms < 5 * 60 * 1000;
+    let text;
+    if (days > 0) text = days + "d " + hours + "h";
+    else if (hours > 0) text = hours + "h " + minutes + "m";
+    else if (minutes > 0) text = minutes + "m " + String(seconds).padStart(2, "0") + "s";
+    else text = seconds + "s";
+    return { text, urgent, critical };
+  }
+
+  function resolveEndsAt(el) {
+    let cur = el;
+    while (cur && cur.dataset && !cur.dataset.endsAt) cur = cur.parentElement;
+    return cur && cur.dataset ? cur.dataset.endsAt : null;
+  }
+
+  function tickCountdown(el, endsAtMs) {
+    const remaining = endsAtMs - Date.now();
+    const f = formatRemaining(remaining);
+    el.textContent = f.text;
+    el.classList.toggle("v-countdown-urgent", f.urgent && !f.critical);
+    el.classList.toggle("v-countdown-critical", f.critical && remaining > 0);
+    el.classList.toggle("v-countdown-ended", remaining <= 0);
+    return remaining;
+  }
+
+  function startCountdowns() {
+    document.querySelectorAll("[data-countdown]").forEach(function (el) {
+      const iso = resolveEndsAt(el);
+      if (!iso) return;
+      const endsAtMs = Date.parse(iso);
+      if (!isFinite(endsAtMs)) return;
+
+      let timer = null;
+      function loop() {
+        const remaining = tickCountdown(el, endsAtMs);
+        if (remaining <= 0) {
+          if (timer) clearTimeout(timer);
+          return;
+        }
+        // Tick every second below an hour, every 30 seconds otherwise. The
+        // long-interval path keeps "3d 4h" from causing constant repaints.
+        const interval = remaining < 60 * 60 * 1000 ? 1000 : 30000;
+        timer = setTimeout(loop, interval);
+      }
+      loop();
+    });
+  }
+
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", startCountdowns);
+  } else {
+    startCountdowns();
+  }
+
+  // After an htmx swap, freshly-inserted countdowns need to be started too.
+  document.addEventListener("htmx:afterSwap", startCountdowns);
+})();