/* AcquiCup — root app: auth/loading gate, routing, store, X2 modal, tweaks */
const { useState, useEffect, useRef, useMemo } = React;
/* ----------------------------- URL routing -----------------------------
* Every page has a dedicated, shareable URL. The `route` (+ `curMatch`) view
* state mirrors window.location, so each screen is bookmarkable, the browser
* back/forward buttons work, and a match can be linked directly. */
const ROUTE_PATHS = {
dashboard: "/dashboard",
matches: "/matches",
standings: "/standings",
leaderboard: "/leaderboard",
companies: "/companies",
acquiboard: "/acquiboard",
rules: "/rules",
admin: "/admin",
settings: "/settings",
};
// view state -> URL path. The match-detail ("predict") screen carries the
// match id so it can be deep-linked; without a match it falls back to /matches.
function pathFor(route, match) {
if (route === "predict") return match ? "/matches/" + encodeURIComponent(match.id) : "/matches";
// The user-profile page carries the player id so it's deep-linkable; `match` here
// is the selected user object (it has an `.id`). Without one, fall back to the leaderboard.
if (route === "user") return match ? "/user/" + encodeURIComponent(match.id) : "/leaderboard";
// The company-profile page carries the company id so it's deep-linkable; `match` here is
// the selected company object (it has an `.id`). Without one, fall back to the companies board.
if (route === "company") return match ? "/company/" + encodeURIComponent(match.id) : "/companies";
return ROUTE_PATHS[route] || "/dashboard";
}
// URL path -> { route, matchId }. Unknown paths fall back to the dashboard.
function parsePath(pathname) {
const parts = (pathname || "/").split("/").filter(Boolean);
if (parts.length === 0) return { route: "dashboard", matchId: null };
const head = parts[0];
if (head === "matches") {
return parts[1]
? { route: "predict", matchId: decodeURIComponent(parts[1]) }
: { route: "matches", matchId: null };
}
// /user/:id → the player profile page (matchId carries the player id). A bare
// /user with no id is meaningless, so resolve it to the leaderboard.
if (head === "user") {
return parts[1]
? { route: "user", matchId: decodeURIComponent(parts[1]) }
: { route: "leaderboard", matchId: null };
}
// /company/:id → the company profile page (matchId carries the company id). A bare
// /company with no id is meaningless, so resolve it to the companies board.
if (head === "company") {
return parts[1]
? { route: "company", matchId: decodeURIComponent(parts[1]) }
: { route: "companies", matchId: null };
}
if (ROUTE_PATHS[head] && head !== "matches") return { route: head, matchId: null };
// "/login" (auth gate) and anything else resolve to the dashboard once authed.
return { route: "dashboard", matchId: null };
}
const TWEAK_DEFAULTS = /*EDITMODE-BEGIN*/{
"theme": "boardroom",
"accent": "#1E72D6",
"radius": 16
}/*EDITMODE-END*/;
function Modal({ children, onClose, width = 420 }) {
return (
);
}
/* ------------------------- first-run onboarding -------------------------
* A 4-card swipeable carousel shown ONCE to a brand-new player (set by the
* signup wizard via the `acq:newSignup` session flag) and never again. The
* "seen" state persists per Firebase uid in localStorage, so it survives
* reloads and is honoured even if the user only ticks "don't show again". */
const ONBOARD_KEY = (uid) => "acq:onboarded:" + (uid || "anon");
function hasOnboarded(uid) { try { return localStorage.getItem(ONBOARD_KEY(uid)) === "1"; } catch (_) { return false; } }
function markOnboarded(uid) { try { localStorage.setItem(ONBOARD_KEY(uid), "1"); } catch (_) { /* private mode */ } }
// One-shot: a fresh signup drops `acq:newSignup` in sessionStorage; we read+clear it.
function consumeNewSignupFlag() {
try {
const v = sessionStorage.getItem("acq:newSignup");
if (v) sessionStorage.removeItem("acq:newSignup");
return v === "1";
} catch (_) { return false; }
}
function OnboardEmoji({ glyph }) {
return {glyph};
}
function OnboardRow({ glyph, children }) {
return (
{children}
);
}
// The four steps. `fill` matches each glyph's filled/outline icon variant.
const ONBOARD_STEPS = [
{ key: "predict", icon: "target", fill: false, title: "Predict the score" },
{ key: "points", icon: "trophy", fill: true, title: "Points & your X2" },
{ key: "strategy", icon: "bolt", fill: true, title: "Auto-fill strategies" },
{ key: "boards", icon: "building", fill: false, title: "Two leaderboards" },
];
// The four real sign-up strategies, rendered read-only (first one shown selected) —
// reuses the live STRATEGY_OPTIONS data + the same chip styling as StrategyPicker.
function OnboardStrategy() {
const opts = (window.STRATEGY_OPTIONS || []);
return (
);
}
// A real top-5 individual board, built from the live leaderboard data with the SAME
// `.lb` table markup the standings pages use.
function OnboardBoards() {
const A = window.ACQ || {};
const users = [...(A.USERS || [])].sort((a, b) => a.rank - b.rank).slice(0, 5);
return (
Top players
Rank
Player
Pts
{users.map((r) => (
{r.rank}
{userName(r)}{r.you ? " · you" : ""}
{r.isAi && }
{r.points}
))}
);
}
// The right-hand "live example" pane — a real component per step.
function OnboardPreview({ step, sample, finished }) {
if (step === 0) {
return sample ? {}} /> : null;
}
if (step === 1) {
const pm = finished || sample;
if (!pm) return null;
// A settled match shows the earned-points badge (a real "X2 doubled an exact score"
// example); pre-tournament, fall back to an upcoming card flagged X2.
const pred = finished
? { home: finished.homeScore, away: finished.awayScore,
earned: { total: potential(finished, { home: finished.homeScore, away: finished.awayScore }) * 2, isExact: true, outcome: 1 } }
: { home: 2, away: 1 };
return {}} />;
}
if (step === 2) return ;
return ;
}
function OnboardingModal({ uid, onClose, onPredict }) {
const [i, setI] = useState(0);
const [dontShow, setDontShow] = useState(true);
const touchX = useRef(null);
const narrow = useNarrow(720); // desktop → wide two-pane; mobile → single column
// A real UPCOMING fixture (with flags) makes the preview look like the live app —
// prefer an upcoming match so the predict step never shows a finished/live card.
const sample = useMemo(() => {
const ms = (window.ACQ && window.ACQ.MATCHES) || [];
const real = (m) => !isTbd(m) && T(m.home).iso && T(m.away).iso;
return ms.find((m) => m.status === "upcoming" && real(m)) || ms.find(real) || ms[0] || null;
}, []);
// A finished match (if any) powers the points step's "earned" example.
const finished = useMemo(() => {
const ms = (window.ACQ && window.ACQ.MATCHES) || [];
return ms.find((m) => m.status === "finished" && m.homeScore != null && m.awayScore != null) || null;
}, []);
const last = i === ONBOARD_STEPS.length - 1;
const step = ONBOARD_STEPS[i];
const move = (d) => setI((x) => Math.max(0, Math.min(ONBOARD_STEPS.length - 1, x + d)));
function close(action) {
if (dontShow) markOnboarded(uid);
if (action === "predict") onPredict(); else onClose();
}
function onTouchStart(e) { touchX.current = e.touches[0].clientX; }
function onTouchEnd(e) {
if (touchX.current == null) return;
const dx = e.changedTouches[0].clientX - touchX.current;
touchX.current = null;
if (dx < -45 && !last) move(1);
else if (dx > 45 && i > 0) move(-1);
}
// Left-pane copy (the explanatory text); the live example lives in the right pane.
let copy;
if (i === 0) {
copy = Call the exact final score before kickoff. Every pick locks the moment the match starts.;
} else if (i === 1) {
copy = (
Right winner scores points on the board.Nail the exact score = X2 Bonus.Underdog wins pay more than favourites.Use two X2 bonus during the contest.
);
} else if (i === 2) {
copy = In a hurry? Auto-fill every match in one tap with a strategy that matches your style, then tweak any pick before it locks.;
} else {
copy = Climb the player leaderboard, and lift your whole company up the standings with you.;
}
return (
close("skip")} width={narrow ? 440 : 920}>
{/* header */}
Getting started· {i + 1} of {ONBOARD_STEPS.length}
{/* body: copy | live example (swipeable on mobile). Sized to fit — never scrolls. */}
{/* left — heading + copy, left-aligned, vertically centred beside the example */}
{step.title}
{copy}
{/* right — the real component, on a tinted "screen" surface */}
Live example
{/* footer: back · dots · next / done */}
{ONBOARD_STEPS.map((_, d) => (
{last
?
: }
{/* don't-show-again */}
);
}
function App() {
const [t, setTweak] = useTweaks(TWEAK_DEFAULTS);
const tz = useTimezone(); // active display zone — re-renders match dates/times on change
// Derive the initial view from the URL the user actually loaded, so deep
// links (e.g. /matches/m01, /leaderboard) land on the right page.
const initial = parsePath(window.location.pathname);
// A deep-linked match id can't be resolved to a match object until bootstrap
// has populated window.ACQ — remember where the user was headed until then.
const redirectAfterAuthRef = useRef(initial);
// auth / loading gate
const [booted, setBooted] = useState(false);
const [authed, setAuthed] = useState(false);
// True when a restored/redirected Firebase session has NO app profile yet (a Google
// user who hasn't finished onboarding) — the Auth screen opens straight into the
// company/strategy steps instead of clearing the session.
const [pendingGoogleOnboard, setPendingGoogleOnboard] = useState(false);
// Pre-login gate: show the marketing landing page first; a CTA there opens the
// Auth screen in the chosen mode ("signup" from Join, "signin" from Sign in).
// Any deep link skips straight to Auth — including /login itself, so a shared
// /login URL (or a reload while on the auth screen) lands on the sign-in form
// rather than back on the landing page.
const skipLanding = !["/", ""].includes(window.location.pathname);
const [showAuth, setShowAuth] = useState(skipLanding);
const [authMode, setAuthMode] = useState("signin");
const [route, setRoute] = useState(initial.route);
const [curMatch, setCurMatch] = useState(null);
const [predictions, setPredictions] = useState({});
const [x2MatchIds, setX2MatchIds] = useState([]); // up to two doubled matches
const [x2Confirm, setX2Confirm] = useState(null); // matchId pending confirmation
const [toast, setToast] = useState(null);
const [dataVersion, setDataVersion] = useState(0);
const [showOnboarding, setShowOnboarding] = useState(false); // first-run carousel
// On mount: wait for Firebase to restore any persisted session, then bootstrap.
useEffect(() => {
let cancelled = false;
async function boot() {
// Complete any pending Google redirect sign-in (popup fallback) before reading
// the restored session, so a redirect-authenticated user is recognized here.
await API.completeRedirectSignIn().catch(() => {});
const user = await API.authReady(); // resolves with the signed-in user or null
if (cancelled) return;
if (user) {
try {
await API.bootstrap();
if (cancelled) return;
setPredictions({ ...window.ACQ.MY_PREDICTIONS });
setX2MatchIds(window.ACQ.me.x2MatchIds ?? []);
initTimezone(window.ACQ.me && window.ACQ.me.timezone);
setAuthed(true);
setBooted(true);
finishNavigationAfterAuth();
} catch (e) {
if (cancelled) return;
// Signed into Firebase but no app profile. Only a GOOGLE session can finish
// onboarding via the wizard (it has no name/password step) — route Google
// users there and keep the session. Any other provider here is a rare orphaned
// account (e.g. a password signup whose profile write was rolled back); there's
// no self-heal path, so sign out and show the gate.
const noProfile = e && (e.code === "NO_PROFILE" || (e.status === 401 && e.error === "User not found"));
const isGoogleUser = !!(user && user.providerData && user.providerData.some((p) => p && p.providerId === "google.com"));
if (noProfile && isGoogleUser) {
setPendingGoogleOnboard(true);
} else {
await API.clearToken().catch(() => {}); // tear the session down before showing the gate
}
setBooted(true);
}
} else {
setBooted(true);
}
}
boot();
return () => { cancelled = true; };
}, []);
// Browser back/forward: re-derive the view from the URL we just moved to.
useEffect(() => {
function onPop() {
const parsed = parsePath(window.location.pathname);
if (parsed.route === "predict") {
const m = (window.ACQ && window.ACQ.MATCHES)
? window.ACQ.MATCHES.find((x) => String(x.id) === String(parsed.matchId))
: null;
if (m) { setRoute("predict"); setCurMatch(m); }
else { setRoute("matches"); setCurMatch(null); }
} else if (parsed.route === "user") {
// curMatch is reused as the carrier for the selected user; UserPage only
// needs its id, so a minimal {id} is enough when the full row isn't loaded yet.
const u = (window.ACQ && window.ACQ.USERS)
? window.ACQ.USERS.find((x) => String(x.id) === String(parsed.matchId))
: null;
setRoute("user");
setCurMatch(u || (parsed.matchId ? { id: parsed.matchId } : null));
} else if (parsed.route === "company") {
// curMatch is reused as the carrier for the selected company; CompanyPage only
// needs its id, so a minimal {id} is enough when the full row isn't loaded yet.
const c = (window.ACQ && window.ACQ.COMPANY_RANK)
? window.ACQ.COMPANY_RANK.find((x) => String(x.id) === String(parsed.matchId))
: null;
setRoute("company");
setCurMatch(c || (parsed.matchId ? { id: parsed.matchId } : null));
} else {
setRoute(parsed.route);
setCurMatch(null);
}
}
window.addEventListener("popstate", onPop);
return () => window.removeEventListener("popstate", onPop);
}, []);
// While the auth gate is showing, reflect it in the address bar as /login
// (the original destination is preserved in redirectAfterAuthRef). The marketing
// landing keeps the bare "/" — only the Auth screen rewrites to /login.
useEffect(() => {
const onAuth = showAuth || pendingGoogleOnboard;
if (booted && !authed && onAuth && window.location.pathname !== "/login") {
window.history.replaceState({ login: true }, "", "/login");
}
}, [booted, authed, showAuth, pendingGoogleOnboard]);
// scroll top on nav
useEffect(() => { window.scrollTo({ top: 0, behavior: "instant" in window ? "instant" : "auto" }); }, [route, curMatch]);
async function handleAuthed() {
// Caller (Auth) awaits this; rethrow on failure so it can surface the error
// inline rather than leaving the user on a token-but-no-data limbo.
try {
await API.bootstrap();
setPredictions({ ...window.ACQ.MY_PREDICTIONS });
setX2MatchIds(window.ACQ.me.x2MatchIds ?? []);
initTimezone(window.ACQ.me && window.ACQ.me.timezone);
setAuthed(true);
finishNavigationAfterAuth();
// Brand-new signups (the wizard set the one-shot session flag) get the first-run
// tour once; honour a prior "don't show again" / earlier dismissal per uid.
const uid = window.ACQ.me && window.ACQ.me.id;
if (consumeNewSignupFlag() && !hasOnboarded(uid)) setShowOnboarding(true);
} catch (e) {
// NO_PROFILE → authenticated but not onboarded; let the Auth screen branch into
// onboarding (it catches this). Keep matching the legacy string for back-compat.
if (e && (e.code === "NO_PROFILE" || (e.status === 401 && e.error === "User not found"))) {
throw e;
}
await API.clearToken().catch(() => {}); // sign out before surfacing the error
setAuthed(false);
throw e;
}
}
async function refresh() {
await API.bootstrap();
setPredictions({ ...window.ACQ.MY_PREDICTIONS });
setX2MatchIds(window.ACQ.me.x2MatchIds ?? []);
initTimezone(window.ACQ.me && window.ACQ.me.timezone);
setDataVersion((v) => v + 1);
}
// Central navigation: update the URL (so every page is addressable) and the
// matching view state together. `replace` is used to canonicalize on load
// without adding a history entry.
function navigate(r, match, opts) {
const replace = opts && opts.replace;
const path = pathFor(r, match);
const histState = { route: r, matchId: match ? match.id : null };
if (replace) window.history.replaceState(histState, "", path);
else window.history.pushState(histState, "", path);
setRoute(r);
setCurMatch(match || null);
}
function go(r) { navigate(r, null); }
function openMatch(m) { navigate("predict", m); }
// Open a player's public profile page (reached by clicking them on a leaderboard).
function openUser(u) { if (u && u.id != null) navigate("user", u); }
// Open a company's public profile page (reached by clicking a company on a leaderboard).
function openCompany(c) { if (c && c.id != null) navigate("company", c); }
const hrefFor = (r) => pathFor(r, null);
// After bootstrap, send the user to wherever the URL pointed (resolving a
// deep-linked match now that window.ACQ exists, and guarding /admin), and
// canonicalize the address bar (/, /login -> the real page) without a new
// history entry.
function finishNavigationAfterAuth() {
const target = redirectAfterAuthRef.current || { route: "dashboard", matchId: null };
redirectAfterAuthRef.current = null;
let r = target.route;
let m = null;
if (r === "predict") {
m = (window.ACQ.MATCHES || []).find((x) => String(x.id) === String(target.matchId)) || null;
if (!m) r = "matches";
}
if (r === "user") {
// Resolve a deep-linked /user/:id now that window.ACQ exists; UserPage only
// needs the id, so keep a minimal {id} when the standings row isn't found.
m = (window.ACQ.USERS || []).find((x) => String(x.id) === String(target.matchId))
|| (target.matchId ? { id: target.matchId } : null);
if (!m) r = "leaderboard";
}
if (r === "company") {
// Resolve a deep-linked /company/:id now that window.ACQ exists; CompanyPage only
// needs the id, so keep a minimal {id} when the standings row isn't found.
m = (window.ACQ.COMPANY_RANK || []).find((x) => String(x.id) === String(target.matchId))
|| (target.matchId ? { id: target.matchId } : null);
if (!m) r = "companies";
}
if (r === "admin" && !(window.ACQ.me && window.ACQ.me.isAdmin)) r = "dashboard";
if (r === "acquiboard" && !(window.ACQ.me && window.ACQ.me.isAcquisit)) r = "dashboard";
navigate(r, m, { replace: true });
}
async function savePred(id, data) {
// optimistic update for snappiness
setPredictions((p) => ({ ...p, [id]: { ...(p[id] || {}), ...data } }));
try {
await API.savePrediction(id, data);
await refresh();
API.track("save_pick", { match_id: String(id), home: data.home, away: data.away });
flash("Prediction saved");
} catch (e) {
flash((e && e.error) ? e.error : "Couldn't save prediction");
// Roll back the optimistic write: re-sync from the server so a rejected
// save (e.g. the match locked at kickoff → 403) can't leave the card
// showing a false "Saved" state. Best-effort — keep the toast if offline.
try { await refresh(); } catch (_) { /* nothing better to do */ }
}
}
// Bulk: fill every still-editable, not-yet-predicted match from one strategy.
// The server skips locked/placeholder matches and never overwrites a saved
// pick, then we re-sync and report how many blanks were actually filled.
async function applyStrategy(strategy) {
try {
const r = await API.applyStrategy(strategy);
await refresh();
const n = (r && r.applied) || 0;
// Generic confirmation + a per-strategy variant so each can be funneled
// separately in GA (aggressive/safe/random).
API.track("autopredict_confirmation", { strategy: strategy, count: n });
API.track("autopredict_" + strategy + "_confirmation", { count: n });
flash(n ? `Filled ${n} match${n === 1 ? "" : "es"} with your strategy` : "No empty matches to fill");
} catch (e) {
flash((e && e.error) ? e.error : "Couldn't apply the strategy");
}
}
// Bulk: clear every prediction on a still-editable match (locked/finished
// picks are already scored and stay put).
async function clearPredictions() {
try {
const r = await API.clearPredictions();
await refresh();
const n = (r && r.cleared) || 0;
API.track("clear_all_predictions", { count: n });
flash(n ? `Cleared ${n} prediction${n === 1 ? "" : "s"}` : "No predictions to clear");
} catch (e) {
flash((e && e.error) ? e.error : "Couldn't clear predictions");
}
}
// Adding an X2 goes through a confirmation modal; removing one is immediate.
function setX2(matchId) {
if (matchId == null) return;
setX2Confirm(matchId);
}
async function removeX2(matchId) {
if (matchId == null) return;
try {
await API.removeX2(matchId);
await refresh();
flash("X2 removed — you can use it on another match");
} catch (e) {
flash((e && e.error) ? e.error : "Couldn't remove X2");
}
}
async function confirmX2() {
try {
await API.setX2(x2Confirm);
setX2Confirm(null);
await refresh();
flash("X2 locked in — points on this match will double");
} catch (e) {
setX2Confirm(null);
flash((e && e.error) ? e.error : "Couldn't lock in X2");
}
}
async function onLogout() {
// Await sign-out so the Firebase session is actually torn down before we flip
// the UI to the gate — otherwise freshToken() could still authenticate an
// in-flight request as the "logged-out" user.
API.track("signout"); // log while still authenticated, before the session is torn down
await API.clearToken().catch(() => {});
redirectAfterAuthRef.current = { route: "dashboard", matchId: null };
setCurMatch(null);
setAuthed(false);
setRoute("dashboard");
// Land on the marketing homepage (not the /login gate): drop the Auth screen
// and put the bare "/" in the address bar so showLanding renders.
setPendingGoogleOnboard(false);
setShowAuth(false);
window.history.replaceState({}, "", "/");
}
function flash(msg) { setToast(msg); clearTimeout(window.__t); window.__t = setTimeout(() => setToast(null), 2400); }
// apply tweak overrides on a wrapper
const rootStyle = {
"--accent": t.accent,
"--accent-soft": `color-mix(in srgb, ${t.accent} 12%, var(--surface))`,
"--r-lg": t.radius + "px",
"--r-md": Math.max(6, t.radius - 4) + "px",
"--r-xl": (t.radius + 6) + "px",
minHeight: "100vh",
};
// While restoring a session, show a minimal centered loading screen.
if (!booted) {
return (
Loading…
);
}
// Not authed → show the landing page, then Auth. window.ACQ is NOT yet populated,
// so the main app (whose components read window.ACQ during render) must stay
// unmounted. A pending Google onboard always goes straight to the Auth wizard.
if (!authed) {
const showLanding = !showAuth && !pendingGoogleOnboard;
return (
);
}
// Authed: window.ACQ is populated. Safe to read it during render.
const me = window.ACQ.me;
const isAdmin = !!(window.ACQ.me && window.ACQ.me.isAdmin);
const isAcquisit = !!(window.ACQ.me && window.ACQ.me.isAcquisit);
// Maintenance takeover: when an admin has paused the app for an update, ordinary players
// get a full-screen notice instead of the app. Admins are exempt (they keep full access,
// plus a persistent reminder banner below) so they can finish the update while paused.
const cfg = window.ACQ.CONFIG || {};
if (cfg.paused && !isAdmin) {
return (
);
}
const store = { me, predictions, x2MatchIds, savePred, setX2, removeX2, applyStrategy, clearPredictions, openUser, openCompany, dataVersion };
let screen;
if (route === "predict" && curMatch) screen = go("matches")} save={savePred} openX2={setX2} removeX2={removeX2} />;
else if (route === "user") screen = ;
else if (route === "company") screen = ;
else if (route === "dashboard") screen = ;
else if (route === "matches") screen = ;
else if (route === "standings") screen = ;
else if (route === "leaderboard") screen = ;
else if (route === "companies") screen = ;
else if (route === "acquiboard" && isAcquisit) screen = ;
else if (route === "rules") screen = ;
else if (route === "settings") screen = ;
else if (route === "admin" && isAdmin) screen = ;
else screen = ;
// The profile page is reached from the leaderboard, so keep that nav item active.
const navRoute = route === "predict" ? "matches" : route === "user" ? "leaderboard" : route === "company" ? "standings" : route;
return (
You get two X2 bonuses for the whole tournament ({remaining} still available). It doubles every point your {T(m.home).code}–{T(m.away).code} prediction earns — and it can't be moved once the match locks.
{T(m.home).name} vs {T(m.away).name}{fmtMatchDate(m, tz)}
);
})()}
{/* first-run onboarding (new signups only, once) */}
{showOnboarding && (
setShowOnboarding(false)}
onPredict={() => { setShowOnboarding(false); go("matches"); }}
/>
)}
{/* Maintenance reminder — only an admin can be here while paused (non-admins are
taken over above). A persistent strip so the admin never forgets the app is dark. */}
{cfg.paused && isAdmin && (
Maintenance mode is ON — players are paused. You have full access.
)}
{/* toast */}
{toast && (
{toast}
)}
);
}
// Full-screen maintenance takeover shown to non-admin players while the admin has the
// app paused for an update. Built from the app's own primitives (CupMark/Icon) so it
// feels on-brand. `message` is the admin's notice (falls back to default copy); a small
// "Sign out" escape hatch is provided so a player isn't trapped.
function MaintenanceScreen({ message, onLogout }) {
const text = (message && String(message).trim())
|| "AcquiCup is briefly offline for an update. We'll be back shortly — thanks for your patience!";
return (