[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_107":108,"_109":110},"routes/embed.x.$handle.$name.$",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":-5},"handle","amir5","name","dogsspot_puppy_path","path","gads-feed.ts","project",{"_22":45,"_11":12,"_33":46,"_47":-5,"_48":42,"_49":50,"_51":50,"_52":53,"_54":-5,"_55":56,"_57":58,"_59":32,"_60":-5,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71,"_72":-5,"_73":74,"_75":74,"_76":77,"_78":77,"_79":77,"_80":74,"_81":74,"_82":83,"_84":85,"_86":87,"_88":42},"file",{"_22":23,"_11":14,"_24":25,"_26":-5,"_27":28,"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":40,"_41":42,"_43":-5,"_13":44},"permalink","https://www.val.town/x/amir5/dogsspot_puppy_path/code/gads-feed.ts","extension","id","5a89078a-bc83-4a98-857b-bc8acf8b7627","fileId","38abdbe0-98b0-11f1-af03-1607ee4eb77e","parentId","branchId","551774fb-a850-4c9d-94a1-d3509ddcf1b0","branchVersion",1227,"latest",true,"createdAt",["D",1787174750642],"version",6,"fileType","http","content","// THE SCHEDULED CONVERSION FEED. v1.0, 15 Aug 2026.\n//\n// THE CHORE THIS DELETES. Until tonight, somebody had to remember, every week, to open the val\n// endpoint, download a CSV, open Google Ads, find Goals → Conversions → Uploads, and attach the\n// file. The account has already proved what happens to weekly chores here: the last human change\n// to it was 22 Jul 19:21:36 ET, and the 24 days after that returned \"You don't have any changes\n// that match your dates or filters.\" A step that depends on memory is a step that stops.\n//\n// WHAT REPLACES IT. Google Ads' Uploads screen has a Schedules tab that will FETCH a file itself,\n// on a schedule, from one of three sources: Google Sheets, HTTPS, SFTP. Our file already exists at\n// an HTTPS URL. So the whole loop closes by pointing Google at a URL, once, by hand — and then\n// never again. This file is that URL: a stable, cached, unguessable, always-parseable CSV route.\n//\n// WHY IT IS NOT JUST gads.ts WITH A LONGER LEASH. Three differences, each of which is the\n// difference between a thing that runs unattended and a thing that looks like it does:\n//\n// 1. THE SECRET IS IN THE PATH, AND IT IS ITS OWN SECRET.\n// The URL ends in \".csv\" because Google's documented HTTPS setups go out of their way to make\n// it so — Matomo's instructions tell you to append \"&requestType=https&conversion-export.csv\"\n// to a URL that is otherwise all query string, which only makes sense as a file-type sniff on\n// the URL's tail. A path secret gives us a .csv ending for free and needs no query string at\n// all, so nothing depends on Google preserving one.\n// And it is a DIFFERENT secret from the admin key. The URL is pasted into a Google Ads screen\n// where it lives forever, visible to anyone with access to the account. The admin key opens\n// the whole admin surface; this key opens one read-only CSV and nothing else.\n//\n// 2. IT CANNOT SERVE A FILE GOOGLE WILL REJECT.\n// Google fails a scheduled run on a file with headers and no data rows: \"The data type or\n// schema of the data source could not be determined... there is at least one line with valid\n// data.\" A CRM hiccup at the moment Google happens to fetch would do exactly that. So the\n// last good file is cached, and a build that fails OR returns zero rows serves the cache\n// instead of a header-only file. Re-serving last week's rows is free: Google states \"the same\n// conversion won't be imported more than once\" for the same click id + name + time.\n//\n// 3. IT IS BOUNDED IN TIME.\n// The live scan takes ~7s. A scheduled fetcher that waits forever is a scheduled fetcher that\n// one day times out mid-run. The rebuild gets a budget; over it, the cache is served.\n//\n// THE WINDOW, AND WHY 80 DAYS AND NOT 85.\n// Google: \"Offline conversions that were uploaded more than 90 days after the associated last\n// click won't be imported.\" The clock runs from the CLICK, and we do not have the click's\n// timestamp — only the contact's dateAdded, which is at or after it. On this CRM the two are\n// minutes apart (the click lands on a page, the chat or the form makes the contact), but that is\n// an observation, not a guarantee. 80 days of contact age leaves ten days of margin, and because\n// the window moves with the calendar, a row simply stops being emitted before it can start being\n// rejected. Nothing accumulates; nothing needs cleaning up.\n//\n// WHAT THIS STILL CANNOT DO, said plainly rather than left to be discovered:\n// * It cannot create the schedule. Google Ads has no way to do that except a human in the UI,\n// and the Google Ads API route needs a developer token this account does not have.\n// * Nothing here pages anybody. If the schedule is deleted or the fetch starts failing, the\n// evidence is in ?status — it does not come and find you. Every fetch is recorded there with\n// its user-agent and time precisely so that \"is this still running?\" is a question with an\n// answer rather than a shrug.\n// * The two conversion actions it feeds are not account-default goals, so what it uploads is\n// reporting, not bidding, until somebody promotes them.\n\nimport { buildRows, ghlGetter, toCsv, FEED_DAYS, LEAD_NAME, SHOW_NAME, CSV_HEADER } from \"./gads-rows.ts\";\n\nconst BLOB_KEY = \"gads_feed_cache\";\n/** Serve the cache without rebuilding if it is younger than this. Google fetches weekly, so in\n * practice every scheduled fetch rebuilds; this only spares a human clicking twice in a row. */\nconst MAX_AGE_MS = 6 * 3_600_000;\n/** The rebuild's budget. Past it, the cache is served and the status view says the build was slow. */\nconst BUILD_BUDGET_MS = 25_000;\n/** How many fetches to remember. Enough to see a weekly schedule's last three months. */\nconst FETCH_LOG = 14;\nconst FILENAME = \"dogsspot-google-conversions.csv\";\n\ntype FetchNote = {\n at: string;\n ua: string;\n served: string;\n rows: number;\n ms: number;\n /** A Google-owned fetcher, or everything else. Status reads are not logged as file fetches. */\n source?: \"google-schedule\" | \"other\";\n};\n/** One build, recorded whether or not it produced anything. See BUILD_LOG for why. */\ntype BuildNote = {\n at: string;\n ok: boolean;\n rows: number;\n scanned: number;\n clicked: number;\n ms: number;\n error: string;\n pages?: number;\n reachedCutoff?: boolean;\n truncated?: boolean;\n appointmentFailures?: number;\n duplicateRowsDropped?: number;\n unsafeShowTiming?: number;\n futureLeadRows?: number;\n invalidOutcomeTimes?: number;\n};\nexport type Cache = {\n csv: string;\n rows: number;\n builtAt: string;\n days: number;\n scanned: number;\n clicked: number;\n lastBuild: BuildNote;\n fetches: FetchNote[];\n /** Every recent build, empty ones included. */\n builds?: BuildNote[];\n /** High-water marks, so a collapse has something to be a collapse FROM. */\n bestScanned?: number;\n bestClicked?: number;\n /** When a build last produced at least one row. The stored file is FROM this moment, so it is\n * also the age of what Google keeps being handed. */\n lastNonZeroBuildAt?: string | null;\n /** When this feed STARTED falling back to the stored file, or null when it is serving fresh\n * builds. Set once on the first fallback and left alone until a real build serves again, so it\n * measures the length of the outage rather than the time of the last symptom. */\n servingStaleSince?: string | null;\n /** dateAdded of the newest Google-clicked contact the last good build saw. NOT cleared by a build\n * that finds none — that is the whole point: it must go on ageing so the silence becomes loud. */\n newestClickAt?: string | null;\n};\n\nexport type CacheIntegrity = {\n state: \"valid\" | \"missing\" | \"invalid\" | \"unreadable\";\n cache: Cache | null;\n fileUsable: boolean;\n reason: string;\n};\n\n/** Validate stored bytes before they can bypass the CRM rebuild. */\nexport function cacheIntegrity(raw: unknown, nowMs: number = Date.now(), readable = true): CacheIntegrity {\n if (!readable) return { state: \"unreadable\", cache: null, fileUsable: false, reason: \"The feed cache could not be read.\" };\n if (raw == null) return { state: \"missing\", cache: null, fileUsable: false, reason: \"No feed cache exists yet.\" };\n try {\n if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) throw new Error(\"cache is not an object\");\n const c = raw as Cache;\n if (!Number.isInteger(c.rows) || c.rows < 0 || typeof c.csv !== \"string\" || typeof c.builtAt !== \"string\" ||\n !Array.isArray(c.fetches) || !c.lastBuild || typeof c.lastBuild !== \"object\") throw new Error(\"cache fields are malformed\");\n for (const iso of [c.builtAt || null, c.servingStaleSince ?? null, c.lastNonZeroBuildAt ?? null, c.newestClickAt ?? null]) {\n if (iso != null && !Number.isFinite(Date.parse(iso))) throw new Error(\"cache contains an invalid timestamp\");\n }\n if (c.builtAt && Date.parse(c.builtAt) > nowMs + 5 * 60_000) throw new Error(\"cache build timestamp is in the future\");\n if (c.rows === 0) {\n if (c.csv !== \"\" || c.builtAt !== \"\") throw new Error(\"an empty cache claims to hold a file\");\n return { state: \"valid\", cache: c, fileUsable: false, reason: \"Telemetry exists but no valid file has been built.\" };\n }\n if (c.days !== FEED_DAYS) throw new Error(\"cached file was built with a non-production lookback\");\n const lines = c.csv.trimEnd().split(\"\\n\");\n const header = lines.indexOf(CSV_HEADER);\n if (header < 0) throw new Error(\"cached CSV has no Google header\");\n const data = lines.slice(header + 1);\n if (data.length !== c.rows || data.length === 0) throw new Error(\"cached CSV row count does not match metadata\");\n const identities = new Set();\n for (const line of data) {\n const parts = line.split(\",\");\n const unquote = (value: string) => value.startsWith('\"') && value.endsWith('\"') ? value.slice(1, -1) : \"\";\n const clickId = unquote(parts[0] ?? \"\"), conversion = unquote(parts[1] ?? \"\"), time = unquote(parts[2] ?? \"\");\n const amount = Number(parts[3]);\n const rowAt = Date.parse(`${time.replace(\" \", \"T\")}Z`);\n const canonicalTime = Number.isFinite(rowAt) ? new Date(rowAt).toISOString().replace(\"T\", \" \").slice(0, 19) : \"\";\n if (parts.length !== 7 || !/^[A-Za-z0-9_-]{20,200}$/.test(clickId) ||\n (conversion !== LEAD_NAME && conversion !== SHOW_NAME) ||\n !/^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}$/.test(time) ||\n canonicalTime !== time || rowAt > Date.parse(c.builtAt) + 5 * 60_000 ||\n parts[3] === \"\" || !Number.isFinite(amount) || amount < 0 ||\n parts[4] !== \"USD\" || parts[5] !== \"\" || parts[6] !== \"\") {\n throw new Error(\"cached CSV contains an invalid data row\");\n }\n const identity = `${clickId}\\u0000${conversion}\\u0000${time}`;\n if (identities.has(identity)) throw new Error(\"cached CSV contains a duplicate Google conversion identity\");\n identities.add(identity);\n }\n return { state: \"valid\", cache: c, fileUsable: true, reason: \"Cached bytes match their row metadata.\" };\n } catch (e) {\n return { state: \"invalid\", cache: null, fileUsable: false, reason: String(e).replace(/^Error:\\s*/, \"\").slice(0, 180) };\n }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────────────────────────\n// TELLING A QUIET WEEK FROM A BROKEN PIPE\n//\n// THE DEFECT THIS CLOSES. Until 15 Aug 2026, a build that found nothing and a build whose supply had\n// collapsed were the same event here: both returned rows = 0, both served the cache, and — the part\n// that made it invisible — scanned and clicked were only ever written to the blob on a build that\n// produced rows (`if (build.ok && build.rows > 0)`). So if gclid capture broke, ?status went on\n// reporting the healthy scanned/clicked numbers from the last good week, indefinitely, while Google\n// re-imported a stale file it had already de-duped. The feed would look alive for as long as anyone\n// cared to check.\n//\n// Three failures wear the same \"0 rows\" costume and they need completely different responses:\n// * the build is erroring or timing out → the val or the CRM is down; fix the endpoint\n// * the walk reads far fewer contacts than ever → the contacts endpoint or the token changed\n// * contacts read fine, NONE carry a gclid → attribution capture broke; nothing here can fix\n// it, and every day it runs costs recoverable\n// conversions that expire 90 days after the click\n// * everything healthy, just no new bookings → nothing is wrong. This is a quiet week.\n//\n// Only the last one is acceptable, and it is the one the old code reported for all four.\n// ─────────────────────────────────────────────────────────────────────────────────────────────────\nconst BUILD_LOG = 20;\n/** A scan this far below the high-water mark is a collapse, not a slow week. Contact volume moves a\n * few percent week to week (25.2/day over the 30 days to 15 Aug); it does not halve by itself. */\nconst SCAN_COLLAPSE_RATIO = 0.5;\n\n/** What is actually wrong, or null when nothing is. Pure function of the build history. */\nexport function diagnoseSupply(c: Cache | null): { state: string; healthy: boolean; detail: string } {\n const raw = c?.builds?.[0] ?? (c?.lastBuild?.at ? c.lastBuild : null);\n if (!raw) return { state: \"no-builds-yet\", healthy: false, detail: \"This feed has never completed a build.\" };\n // A BUILD RECORDED BEFORE 15 Aug 2026 HAS NO scanned/clicked, because those fields were added the\n // day the supply diagnosis was. Reading them straight put the literal word \"undefined\" into a\n // sentence on a client-facing page — caught live within minutes of the tracking page shipping.\n // A missing figure is not a zero either: zero clicked means \"supply collapsed\", which would be an\n // alarm invented out of an old blob. So they are normalised to null and the wording adapts.\n const known = Number.isFinite(raw.scanned as number) && Number.isFinite(raw.clicked as number);\n const last = { ...raw, scanned: known ? raw.scanned : 0, clicked: known ? raw.clicked : 0 };\n if (!known && raw.ok) {\n return raw.rows > 0\n ? { state: \"ok\", healthy: true, detail: `${raw.rows} outcomes are ready to send. This build predates the supply check, so how many contacts were read is not recorded.` }\n : { state: \"quiet\", healthy: true, detail: \"The last build produced no new rows. It predates the supply check, so nothing more can be said about why.\" };\n }\n if (!last.ok) {\n return { state: \"build-failing\", healthy: false, detail: `The last build did not complete: ${last.error || \"unknown error\"}. Google is being served a cached file.` };\n }\n const best = c?.bestScanned ?? 0;\n if (best > 0 && last.scanned < best * SCAN_COLLAPSE_RATIO) {\n return { state: \"crm-read-shrunk\", healthy: false, detail: `The walk read ${last.scanned} contacts; it has read as many as ${best}. The contacts endpoint, the token or the page cap changed — this is not an advertising problem.` };\n }\n if (last.clicked === 0 && (c?.bestClicked ?? 0) > 0) {\n return { state: \"gclid-supply-collapsed\", healthy: false, detail: `${last.scanned} contacts read and NOT ONE carries a Google click id, against a best of ${c!.bestClicked}. Attribution capture has broken. Conversions expire 90 days after the click, so every day this runs loses recoverable ones.` };\n }\n // Consecutive empty builds. One is a quiet week; a run of them on a live account is not.\n const empties = (c?.builds ?? []).findIndex((b) => b.ok && b.rows > 0);\n const streak = empties === -1 ? (c?.builds ?? []).length : empties;\n if (last.rows === 0 && streak >= 4) {\n return { state: \"empty-streak\", healthy: false, detail: `${streak} consecutive builds have produced no rows while the CRM read fine. Worth a human look even though nothing here is technically broken.` };\n }\n if (last.rows === 0) {\n return { state: \"quiet\", healthy: true, detail: `The CRM read fine (${last.scanned} contacts, ${last.clicked} carrying a click id) and produced no new rows. Nothing is broken; the last good file is being served.` };\n }\n return { state: \"ok\", healthy: true, detail: `${last.rows} rows from ${last.clicked} Google-clicked contacts out of ${last.scanned} read.` };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────────────────────────\n// THE ALARM: \"NOTHING HAPPENED\" AND \"EVERYTHING BROKE\" ARE THE SAME HTTP 200\n//\n// THE DEFECT. When a build returns zero rows this feed serves the last good file, and it is right\n// to: Google fails a scheduled run on a header-only file, and re-serving rows it has already\n// de-duped costs nothing. But the fallback has no clock on it. A total collapse of the gclid supply\n// therefore returns HTTP 200 and a valid CSV forever — byte-identical to a quiet week — while\n// Google cheerfully re-ingests conversions it already has and the real ones expire 90 days after\n// their click. Nothing in the response, the status code or the file distinguishes the two.\n//\n// THE FIX IS NOT TO STOP SERVING THE STALE FILE. A stale file still beats an empty one, on every\n// week where the truth really is \"no new bookings\". Serving behaviour is untouched. What changes is\n// that the CONDITION is now visible and dated, so \"is this still working?\" has an answer.\n//\n// THE TWO THRESHOLDS, and why they are the numbers they are:\n//\n// STALE_ALARM_DAYS = 3 The empty-build fallback persisting beyond three days. Google's schedule\n// here is WEEKLY, so one fallback fetch is ordinary and three days of\n// continuous fallback means two consecutive attempts found nothing.\n//\n// GCLID_SILENCE_ALARM_DAYS = 14 No NEW Google-clicked contact in a fortnight.\n// MEASURED, AND MARGINAL — say so rather than let somebody discover it.\n// The 13 Google-clicked contacts in the CRM on 15 Aug 2026 arrived on\n// 9 May, 3/9/9/10/17/18/23 Jun, 6/13/21/25 Jul, 11 Aug. The gaps between\n// consecutive arrivals run 0,1,1,4,5,6,7,7,8,13,17,25 days. TWO of those\n// twelve gaps are 14 or more, so this threshold WOULD have fired twice in\n// 98 days on traffic that was working perfectly. It is implemented at 14\n// because 14 is what was specified; on the measured arrival rate the\n// honest number is 21 (above the 17-day maximum, below the 25-day outlier\n// that spans the period before our campaigns went live on 22 Jul).\n// One constant, one line, no other change needed.\n//\n// COMPARISONS ARE ASYMMETRIC ON PURPOSE. \"Persisting BEYOND 3 days\" is strictly greater than 3.\n// \"No new contact IN 14 days\" is satisfied AT 14 days — at exactly 14 you have had none for a\n// fortnight, which is the condition, so that one is >=. Both boundaries are pinned by tests.\n// ─────────────────────────────────────────────────────────────────────────────────────────────────\nexport const STALE_ALARM_DAYS = 3;\nexport const GCLID_SILENCE_ALARM_DAYS = 14;\n/** Weekly Google fetch plus two days of slack before the schedule is treated as stalled. */\nexport const SCHEDULE_STALL_DAYS = 9;\n/** One fallback is useful; an indefinitely successful stale upload hides the outage from Google. */\nexport const MAX_STALE_SERVE_DAYS = STALE_ALARM_DAYS;\n/** A weekly file may survive one failed fetch, but not a second week near the 90-day click limit. */\nexport const MAX_CACHED_FILE_AGE_DAYS = 10;\n\nexport type FeedState = {\n state: \"ok\" | \"quiet\" | \"ALARM\";\n why: string;\n reasons: string[];\n lastNonZeroBuildAt: string | null;\n daysSinceNewestGclidContact: number | null;\n newestGclidContactAt: string | null;\n servingStaleSince: string | null;\n daysServingStale: number | null;\n thresholds: { staleDays: number; gclidSilenceDays: number };\n};\n\nconst daysBetween = (fromIso: string | null | undefined, nowMs: number): number | null => {\n if (!fromIso) return null;\n const t = Date.parse(fromIso);\n return Number.isFinite(t) && t <= nowMs + 5 * 60_000 ? Math.max(0, nowMs - t) / 86_400_000 : null;\n};\n\n/**\n * The plain-language verdict. Pure function of the stored state and the clock, so a test can drive\n * every boundary without a network, a blob or a val.\n *\n * ok — a recent build produced rows and they are what Google is being served.\n * quiet — nothing is being produced, and nothing is wrong: no new bookings this week. The stored\n * file is being served and that is the designed behaviour.\n * ALARM — the silence has gone on long enough that it can no longer be read as quiet.\n */\nexport function feedState(c: Cache | null, nowMs: number = Date.now()): FeedState {\n const supply = diagnoseSupply(c);\n const servingStaleSince = c?.servingStaleSince ?? null;\n const daysServingStale = daysBetween(servingStaleSince, nowMs);\n const newestGclidContactAt = c?.newestClickAt ?? null;\n const daysSinceNewestGclidContact = daysBetween(newestGclidContactAt, nowMs);\n const round = (n: number | null) => (n === null ? null : +n.toFixed(2));\n\n const reasons: string[] = [];\n if (daysServingStale !== null && daysServingStale > STALE_ALARM_DAYS) {\n reasons.push(\n `The last good file has been served instead of a fresh build since ${servingStaleSince} — ` +\n `${daysServingStale.toFixed(1)} days, past the ${STALE_ALARM_DAYS}-day limit. Google is re-importing ` +\n `conversions it already has and getting no new ones.`,\n );\n }\n if (daysSinceNewestGclidContact !== null && daysSinceNewestGclidContact >= GCLID_SILENCE_ALARM_DAYS) {\n reasons.push(\n `No new Google-clicked contact since ${newestGclidContactAt} — ${daysSinceNewestGclidContact.toFixed(1)} days, ` +\n `at or past the ${GCLID_SILENCE_ALARM_DAYS}-day limit. Either the ads stopped bringing people in or the CRM ` +\n `stopped recording the click id. Both need a human; only one is an advertising problem.`,\n );\n }\n // A build that is failing, a CRM read that has shrunk, a supply that has gone to zero, or a run\n // of empty builds are already diagnosed above, and each is an alarm in its own right whatever the\n // two clocks say. diagnoseSupply owns \"what is wrong\"; this function owns \"for how long\".\n if (!supply.healthy) reasons.push(supply.detail);\n\n const state: FeedState[\"state\"] = reasons.length ? \"ALARM\" : supply.state === \"ok\" ? \"ok\" : \"quiet\";\n const why = reasons.length\n ? reasons.join(\" \")\n : state === \"ok\"\n ? `The conversion-file supply is current. ${supply.detail}`\n : `Quiet, not broken. ${supply.detail} Nothing has been produced recently, but not for long ` +\n `enough to mean anything is wrong: the limits are ${STALE_ALARM_DAYS} days of serving the stored ` +\n `file and ${GCLID_SILENCE_ALARM_DAYS} days with no new Google-clicked contact.`;\n\n return {\n state,\n why,\n reasons,\n lastNonZeroBuildAt: c?.lastNonZeroBuildAt ?? null,\n daysSinceNewestGclidContact: round(daysSinceNewestGclidContact),\n newestGclidContactAt,\n servingStaleSince,\n daysServingStale: round(daysServingStale),\n thresholds: { staleDays: STALE_ALARM_DAYS, gclidSilenceDays: GCLID_SILENCE_ALARM_DAYS },\n };\n}\n\nasync function sha256Hex(s: string): Promise {\n const b = await crypto.subtle.digest(\"SHA-256\", new TextEncoder().encode(s));\n return [...new Uint8Array(b)].map((x) => x.toString(16).padStart(2, \"0\")).join(\"\");\n}\n/** Constant-time compare against the dedicated feed digest. There is deliberately no source-code\n * fallback and no admin-key bypass: the URL is stored by a third party and must have one narrow,\n * independently rotatable credential. */\nasync function authorised(k: string): Promise {\n if (!k) return false;\n const expected = (Deno.env.get(\"NURTURE_GADS_FEED_SHA256\") ?? \"\").trim().toLowerCase();\n if (!/^[0-9a-f]{64}$/.test(expected)) return false;\n const got = await sha256Hex(k);\n if (got.length !== expected.length) return false;\n let d = 0;\n for (let i = 0; i < got.length; i++) d |= got.charCodeAt(i) ^ expected.charCodeAt(i);\n return d === 0;\n}\n\nasync function ghlToken(): Promise {\n return (Deno.env.get(\"GHL_TOKEN\") ?? \"\").trim();\n}\n\nasync function readCache(): Promise<{ ok: boolean; value: unknown }> {\n try {\n const { blob } = await import(\"https://esm.town/v/std/blob\");\n return { ok: true, value: await blob.getJSON(BLOB_KEY) };\n } catch { return { ok: false, value: null }; }\n}\nasync function writeCache(c: Cache): Promise {\n try {\n const { blob } = await import(\"https://esm.town/v/std/blob\");\n await blob.setJSON(BLOB_KEY, c);\n return true;\n } catch { return false; }\n}\n\n/**\n * Rebuild, under a wall-clock budget.\n *\n * The losing promise is not cancelled — there is nothing to cancel a half-finished set of CRM\n * reads with — it is simply not waited for. That is deliberate: a slow build that finishes after\n * we have already answered costs nothing, and the alternative (waiting) is the failure mode.\n */\nasync function rebuild(days: number): Promise<{\n ok: boolean; rows: number; csv: string; ms: number; error: string; scanned: number;\n clicked: number; newestClickAt: string | null; pages: number; reachedCutoff: boolean;\n truncated: boolean; appointmentFailures: number; duplicateRowsDropped: number;\n unsafeShowTiming: number; futureLeadRows: number; invalidOutcomeTimes: number;\n}> {\n const t0 = Date.now();\n const blank = {\n ok: false, rows: 0, csv: \"\", ms: 0, error: \"\", scanned: 0, clicked: 0,\n newestClickAt: null as string | null, pages: 0, reachedCutoff: false, truncated: false,\n appointmentFailures: 0, duplicateRowsDropped: 0, unsafeShowTiming: 0,\n futureLeadRows: 0, invalidOutcomeTimes: 0,\n };\n try {\n const token = await ghlToken();\n if (!token) return { ...blank, ms: Date.now() - t0, error: \"GHL_TOKEN is not configured\" };\n\n const work = buildRows(ghlGetter(token), { days }).then((b) => {\n const telemetry = {\n rows: b.rows.length, csv: toCsv(b.rows), ms: 0, scanned: b.scanned,\n clicked: b.clicked, newestClickAt: b.newestClickAt, pages: b.pages,\n reachedCutoff: b.reachedCutoff, truncated: b.truncated,\n appointmentFailures: b.appointmentFailures,\n duplicateRowsDropped: b.duplicateRowsDropped,\n unsafeShowTiming: b.unsafeShowTiming.length,\n futureLeadRows: b.futureLeadRows,\n invalidOutcomeTimes: b.invalidOutcomeTimes,\n };\n if (b.truncated) return { ...telemetry, ok: false, error: `CRM walk hit its ${b.pages}-page cap before the cutoff` };\n if (b.appointmentFailures > 0) return { ...telemetry, ok: false, error: `${b.appointmentFailures} appointment read(s) failed; refusing a partial build` };\n if (b.invalidOutcomeTimes > 0) return { ...telemetry, ok: false, error: `${b.invalidOutcomeTimes} paid outcome timestamp(s) were not source-safe` };\n return { ...telemetry, ok: true, error: \"\" };\n });\n const timer = new Promise((res) =>\n setTimeout(() => res({ ...blank, error: `build exceeded ${BUILD_BUDGET_MS}ms` }), BUILD_BUDGET_MS)\n );\n const r = await Promise.race([work, timer]);\n return { ...r, ms: Date.now() - t0 };\n } catch (e) {\n return { ...blank, ms: Date.now() - t0, error: String(e).slice(0, 300) };\n }\n}\n\nconst HOW = {\n once: [\n \"Google Ads → Goals → Conversions → Uploads → the Schedules tab → the blue + button\",\n \"Source: HTTPS. File URL: this URL, ending .csv. Leave username/password blank.\",\n \"Frequency: Weekly. Then Save & preview.\",\n ].join(\" \"),\n needs: `Both conversion actions must already exist, named EXACTLY \"${LEAD_NAME}\" and \"${SHOW_NAME}\", created as Import → CRM/file → conversions from clicks.`,\n watch: \"Add ?status=1 (or /status after the key) to this URL to see when it was last fetched and by what.\",\n};\n\nexport default async function (req: Request): Promise {\n const u = new URL(req.url);\n // The key is the FIRST path segment, with a .csv suffix stripped, or ?k= for a human at a\n // terminal. Anything after it is decoration Google is welcome to keep: /KEY/whatever.csv works,\n // which is what lets the URL end in .csv while carrying no query string at all.\n const segs = u.pathname.split(\"/\").filter(Boolean);\n const fromPath = (segs[0] ?? \"\").replace(/\\.csv$/i, \"\");\n const key = fromPath || (u.searchParams.get(\"k\") ?? \"\");\n if (!(await authorised(key))) {\n // 404 rather than 401: a scanner learns nothing, and Google only ever fetches the right URL.\n return new Response(\"Not found\", { status: 404 });\n }\n if (req.method !== \"GET\" && req.method !== \"HEAD\") return new Response(\"Not found\", { status: 404 });\n\n const wantStatus = /^status/i.test(segs[1] ?? \"\") || u.searchParams.get(\"status\") === \"1\";\n // This is one recurring production feed, not a queryable report. A mutable lookback can replace\n // its cache with a narrow, internally valid file, so the machine route always uses FEED_DAYS.\n const days = FEED_DAYS;\n const ua = (req.headers.get(\"user-agent\") ?? \"\").slice(0, 160);\n const fetchSource: FetchNote[\"source\"] = /google|adsbot/i.test(ua) ? \"google-schedule\" : \"other\";\n const t0 = Date.now();\n\n const read = await readCache();\n const integrity = cacheIntegrity(read.value, t0, read.ok);\n const cache = integrity.cache;\n const cachedRows = cache?.rows ?? 0;\n const ageMs = integrity.fileUsable && cache?.builtAt ? t0 - Date.parse(cache.builtAt) : Infinity;\n const usable = integrity.fileUsable && cachedRows > 0 && Number.isFinite(ageMs) && ageMs >= 0;\n\n // A status read never rebuilds. It is a question about the machine, not a request for the file,\n // and a status page that costs seven seconds of CRM reads is a status page nobody opens.\n if (wantStatus) {\n const last = cache?.fetches?.[0];\n const lastScheduledFetch = cache?.fetches?.find((f) => f.source === \"google-schedule\") ?? null;\n const daysSinceLastScheduledFetch = lastScheduledFetch ? daysBetween(lastScheduledFetch.at, t0) : null;\n const supply = diagnoseSupply(cache);\n const scheduleState = !lastScheduledFetch ? \"not-scheduled\"\n : daysSinceLastScheduledFetch === null ? \"unknown\"\n : daysSinceLastScheduledFetch > SCHEDULE_STALL_DAYS ? \"stalled\" : \"healthy\";\n const state = feedState(cache, t0);\n return Response.json({\n ok: integrity.state === \"valid\" && supply.healthy && state.state !== \"ALARM\" && scheduleState === \"healthy\",\n what: \"Google Ads scheduled offline-conversion feed for The Dogs Spot\",\n // READ THIS FIELD FIRST. \"0 rows\" alone cannot tell a quiet week from a broken pipe; this can.\n supply,\n file: {\n rows: cachedRows,\n builtAt: cache?.builtAt || null,\n ageHours: usable ? +(ageMs / 3_600_000).toFixed(1) : null,\n days: cache?.days ?? null,\n integrity: integrity.state,\n integrityDetail: integrity.reason,\n },\n lastBuild: cache?.lastBuild ?? null,\n recentBuilds: cache?.builds ?? [],\n highWater: { scanned: cache?.bestScanned ?? null, clicked: cache?.bestClicked ?? null },\n lastFetch: last ?? null,\n daysSinceLastFetch: last ? daysBetween(last.at, t0) : null,\n lastScheduledFetch,\n daysSinceLastScheduledFetch: daysSinceLastScheduledFetch === null ? null : +daysSinceLastScheduledFetch.toFixed(2),\n scheduleState,\n scheduleLooksStalled: scheduleState === \"stalled\" ? true : scheduleState === \"healthy\" ? false : null,\n feedState: state,\n fetches: cache?.fetches ?? [],\n how: HOW,\n });\n }\n\n let csv = \"\", served = \"\", rows = cachedRows;\n let build: Awaited> | null = null;\n\n if (usable && ageMs < MAX_AGE_MS) {\n csv = cache!.csv;\n served = \"cache-fresh\";\n } else {\n build = await rebuild(days);\n if (build.ok && build.rows > 0) {\n csv = build.csv;\n rows = build.rows;\n served = \"rebuilt\";\n } else if (usable) {\n // Build failed, or succeeded with nothing in it. Either way the last good file is the right\n // answer: Google de-dupes what it has already seen, and a header-only file is a failed run.\n csv = cache!.csv;\n served = build.ok ? \"cache-empty-build\" : \"cache-build-failed\";\n\n const staleDays = cache?.servingStaleSince ? daysBetween(cache.servingStaleSince, t0) : null;\n const fileAgeDays = ageMs / 86_400_000;\n if ((staleDays !== null && staleDays > MAX_STALE_SERVE_DAYS) || fileAgeDays > MAX_CACHED_FILE_AGE_DAYS) {\n const recorded = await note(cache, {\n at: new Date(t0).toISOString(), ua, served: \"503-stale-cutoff\", rows: 0,\n ms: Date.now() - t0, source: fetchSource,\n }, build, days);\n const suffix = recorded ? \"\" : \"; its failure receipt could not be stored\";\n return new Response(`stored conversion file is too old to serve safely${suffix}\\n`, {\n status: 503,\n headers: { \"Content-Type\": \"text/plain; charset=utf-8\", \"Cache-Control\": \"no-store\", \"X-Content-Type-Options\": \"nosniff\" },\n });\n }\n } else {\n // Nothing good to serve and nothing cached. Fail loudly: a failed run in the Uploads tab is\n // information. A file with no rows is a schema error Google reports as something else.\n const why = build.ok ? \"the scan found no Google-clicked contacts in the window\" : build.error;\n await note(cache, { at: new Date(t0).toISOString(), ua, served: \"503\", rows: 0, ms: Date.now() - t0, source: fetchSource }, build, days);\n return new Response(`no rows to serve: ${why}\\n`, { status: 503, headers: {\n \"Content-Type\": \"text/plain; charset=utf-8\", \"Cache-Control\": \"no-store\", \"X-Content-Type-Options\": \"nosniff\",\n } });\n }\n }\n\n const recorded = await note(cache, {\n at: new Date(t0).toISOString(), ua, served, rows, ms: Date.now() - t0, source: fetchSource,\n }, build, days, csv, rows);\n if (!recorded) {\n return new Response(\"conversion file receipt could not be stored\\n\", { status: 503, headers: {\n \"Content-Type\": \"text/plain; charset=utf-8\", \"Cache-Control\": \"no-store\", \"X-Content-Type-Options\": \"nosniff\",\n } });\n }\n\n return new Response(req.method === \"HEAD\" ? null : csv, {\n headers: {\n \"Content-Type\": \"text/csv; charset=utf-8\",\n \"Content-Disposition\": `attachment; filename=\"${FILENAME}\"`,\n \"Cache-Control\": \"no-store\",\n \"X-Feed-Served\": served,\n \"X-Feed-Rows\": String(rows),\n \"X-Feed-Built-At\": build?.ok && build.rows > 0 ? new Date(t0).toISOString() : (cache?.builtAt ?? \"\"),\n \"X-Feed-Source\": \"GoHighLevel\",\n \"X-Content-Type-Options\": \"nosniff\",\n },\n });\n}\n\n/**\n * Record the fetch, and the build if there was one, in the same blob as the file.\n *\n * WHY THE TELEMETRY IS NOT OPTIONAL. The whole point of this file is that nobody will be watching\n * it. An automation nobody watches and that cannot say when it last ran is indistinguishable from\n * one that stopped in September. Every fetch leaves its user-agent and its timestamp here, so the\n * question \"did Google actually collect this?\" has an answer that is not a guess.\n */\nasync function note(\n prev: Cache | null,\n f: FetchNote,\n build: {\n ok: boolean; rows: number; ms: number; error: string; scanned: number; clicked: number;\n csv: string; newestClickAt?: string | null; pages: number; reachedCutoff: boolean;\n truncated: boolean; appointmentFailures: number; duplicateRowsDropped: number;\n unsafeShowTiming: number; futureLeadRows: number; invalidOutcomeTimes: number;\n } | null,\n days: number,\n csv?: string,\n rows?: number,\n): Promise {\n const base: Cache = prev ?? {\n csv: \"\", rows: 0, builtAt: \"\", days, scanned: 0, clicked: 0,\n lastBuild: { at: \"\", ok: false, rows: 0, scanned: 0, clicked: 0, ms: 0, error: \"\" },\n fetches: [], builds: [], bestScanned: 0, bestClicked: 0,\n lastNonZeroBuildAt: null, servingStaleSince: null, newestClickAt: null,\n };\n const next: Cache = { ...base, fetches: [f, ...(base.fetches ?? [])].slice(0, FETCH_LOG) };\n\n // THE STALE CLOCK. Set on the FIRST fallback and left alone until a real build serves again, so\n // it measures the length of the outage rather than the time of the most recent symptom. Cleared\n // only by \"rebuilt\" — the one served value that means a fresh build actually produced the bytes.\n // \"cache-fresh\" (the under-6h shortcut) deliberately neither sets nor clears it: it is not a\n // fallback, and it cannot occur during one anyway, because builtAt only advances on a build that\n // produced rows. \"503\" does not set it either — nothing stale is being served, the request failed.\n if (f.served === \"rebuilt\") {\n next.servingStaleSince = null;\n } else if (f.served === \"cache-empty-build\" || f.served === \"cache-build-failed\") {\n next.servingStaleSince = base.servingStaleSince ?? f.at;\n }\n if (build) {\n const note: BuildNote = {\n at: f.at, ok: build.ok, rows: build.rows,\n scanned: build.scanned, clicked: build.clicked, ms: build.ms, error: build.error,\n pages: build.pages, reachedCutoff: build.reachedCutoff, truncated: build.truncated,\n appointmentFailures: build.appointmentFailures,\n duplicateRowsDropped: build.duplicateRowsDropped,\n unsafeShowTiming: build.unsafeShowTiming,\n futureLeadRows: build.futureLeadRows,\n invalidOutcomeTimes: build.invalidOutcomeTimes,\n };\n next.lastBuild = note;\n // EVERY build is recorded, empty ones included. This is the whole fix: the old code only wrote\n // scanned/clicked when rows > 0, so a collapse in supply left the last healthy numbers standing\n // and ?status kept reporting them. An empty build is exactly the build worth remembering.\n next.builds = [note, ...(base.builds ?? [])].slice(0, BUILD_LOG);\n // High-water marks only move up, and only on a build that actually completed. A timeout returns\n // zeroes and must not be allowed to reset the baseline a collapse is measured against.\n if (build.ok) {\n next.bestScanned = Math.max(base.bestScanned ?? 0, build.scanned);\n next.bestClicked = Math.max(base.bestClicked ?? 0, build.clicked);\n // THE SILENCE CLOCK, AND WHY IT ONLY EVER MOVES FORWARD.\n //\n // A build that reads the CRM fine and finds NO Google-clicked contact returns null here. If\n // that null were stored, daysSinceNewestGclidContact would go null too and the alarm would\n // disarm itself at the exact moment it was needed — the failure reporting itself as \"no data\".\n // So the stored date is only ever replaced by a NEWER one. On a collapse it stands still and\n // ages, which is what makes fourteen days of silence audible.\n const seen = build.newestClickAt ?? null;\n if (seen && (!base.newestClickAt || Date.parse(seen) > Date.parse(base.newestClickAt))) {\n next.newestClickAt = seen;\n }\n }\n // Only a build that produced rows replaces the stored file. A successful scan that found\n // nothing leaves the last good file exactly where it is.\n if (build.ok && build.rows > 0 && csv) {\n next.csv = csv;\n next.rows = rows ?? build.rows;\n next.builtAt = f.at;\n next.lastNonZeroBuildAt = f.at;\n next.days = days;\n next.scanned = build.scanned;\n next.clicked = build.clicked;\n }\n }\n return writeCache(next);\n}\n","deleted",false,"label",[14],"1bfa6e81-74e1-4c6c-ab32-118304a4ffff",["D",1785429259053],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","Puppy path nurture engine v1.2 — The Dogs Spot","imageUrl","userId","d26e64e6-cd39-4be1-b5b4-1de11cc555f8","pinnedFileId","ad633fec-8e73-11f1-b800-1607ee4eb77e","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","019f56fd-bd59-724f-8163-80ffcf8235dd","tursoName","1bfa6e8174e14c6cab32118304a4ffff","tursoHostname","1bfa6e8174e14c6cab32118304a4ffff-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789519842404],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_9":10,"_106":102},"org",{"_9":10,"_99":100,"_101":102,"_55":56,"_103":104,"_105":42},"branch",{"_35":89,"_11":90,"_22":28,"_91":45,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":-5,"_97":12,"_98":10},"isOwned",1233,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","Amir","avatar","https://lh3.googleusercontent.com/a/ACg8ocILk3bwhcvrzozUWm7gxlKoBm7ZGtsgIkesW3ysOOsJ1rSQuA=s96-c","tier","free","canRestrictVals","profileImageUrl","ctx",{"_82":-5,"_140":141,"_142":143,"_144":145,"_146":42,"_147":42,"_148":42,"_149":32,"_150":-5,"_151":-7,"_152":-7,"_153":63,"_154":42,"_155":42,"_156":-5,"_157":42,"_158":42,"_159":42,"_160":-5},"ENV",{"_111":112,"_113":114,"_115":90,"_116":117,"_118":119,"_120":121,"_122":123,"_124":125,"_126":127,"_128":129,"_130":131,"_132":133,"_134":135,"_136":137,"_138":139},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town","orgs",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]