[{"_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":22},"handle","amir5","name","dogsspot_puppy_path","path","SOURCE-BUNDLE.part19.txt","project",{"_23":45,"_11":12,"_34":46,"_47":-5,"_48":42,"_49":50,"_51":50,"_52":53,"_54":-5,"_55":56,"_57":58,"_59":33,"_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",{"_23":24,"_11":14,"_25":26,"_27":-5,"_28":29,"_30":31,"_32":33,"_34":35,"_36":37,"_38":17,"_39":40,"_41":42,"_43":-5,"_13":44},"permalink","https://www.val.town/x/amir5/dogsspot_puppy_path/code/SOURCE-BUNDLE.part19.txt","extension","txt","id","83b662df-b224-4ad3-9341-fb9793765199","fileId","2a82aad6-95d0-11f1-9c6a-1607ee4eb77e","parentId","branchId","551774fb-a850-4c9d-94a1-d3509ddcf1b0","branchVersion",1187,"latest",true,"createdAt",["D",1786982917030],"version",9,"fileType","content","THE DOGS SPOT — SOURCE BUNDLE (part 19 of 47)\n\nEVERY source file in this project, engine/ included. Restoring these parts and nothing else gives\nyou a tree that builds, typechecks and runs its own test suite with no network and no val.\n\nengine/ is here as of 14 Aug 2026. It used to be left out because val 1bfa6e81-74e1-4c6c-ab32-118304a4ffff\nholds it, which was true of every engine file except engine/watch.ts: a module the val does not run,\nso it was never deployed, so it lived in one container and nothing else. A reclaim destroyed it.\nscripts/deploy.mjs --check still compares engine/ against the val file by file; that is a second\ncheck on the same files now, not the only copy of them.\n\nRESTORE (needs only node, from an empty folder). Save each part, then run this ON EACH ONE:\n\n node -e 'const fs=require(\"fs\"),p=require(\"path\");const b=fs.readFileSync(process.argv[1],\"utf8\");\n for(const s of b.split(\"\\n=====FILE \").slice(1)){const i=s.indexOf(\" =====\\n\");\n const f=s.slice(0,i),c=s.slice(i+7);fs.mkdirSync(p.dirname(f),{recursive:true});\n fs.writeFileSync(f,c.replace(/\\n$/,\"\"))}' PART.txt\n\nA record named #1, #2, ... is one FILE cut into pieces: concatenate them in order, then\nstrip one trailing newline from the last. scripts/restore.mjs does this for you.\n\nEach part is complete in itself: whole files only, no reassembly, any order.\n\nThen: node scripts/build.mjs (engine/ came out of these parts; nothing to fetch first)\n node scripts/typecheck.mjs\n node tests/run-all.mjs\n node scripts/deploy.mjs --check (pulls nothing, proves the val matches what you restored)\n node tests/negative-controls.mjs (proves the suite above can actually fail)\n\nIN THIS PART (2 of 129 files)\n\n tests/dead-letter.test.mjs 25691 bytes 3b6b0110d704\n\n================================================================================================\n=====FILE tests/dashboard.test.mjs#2 =====\nne of)\\\\b(?:\\\\s+\\\\w+){0,3}\\\\s+(?:${DATA})\\\\b`, \"i\");\n const NUM = /\\b(\\d[\\d,]*|zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty|thirty|forty|fifty|sixty|seventy|eighty|ninety|hundred|thousand)\\b/i;\n const sentences = (t) => String(t ?? \"\").split(/(?<=[.!?])\\s+/);\n // A DATE IS NOT A DENOMINATOR. \"checked on 5 August\" contains a digit and quantifies nothing.\n // [was: a bare NUM test. The canary below is the exact sentence this check exists to catch,\n // and it passed, because of the \"5\" in \"5 August\". A rule that any dated sentence defeats\n // would have been green over every scope claim we ever write, since we date all of them.]\n const MONTH = \"January|February|March|April|May|June|July|August|September|October|November|December\";\n const undated = (s) => String(s)\n .replace(new RegExp(`\\\\b\\\\d{1,2}(st|nd|rd|th)?\\\\s+(${MONTH})\\\\b`, \"gi\"), \" \")\n .replace(new RegExp(`\\\\b(${MONTH})\\\\s+\\\\d{1,2}(st|nd|rd|th)?\\\\b`, \"gi\"), \" \")\n .replace(/\\b\\d{4}-\\d{2}-\\d{2}\\b/g, \" \")\n .replace(/\\b(19|20)\\d{2}\\b/g, \" \");\n const backed = (s) => NUM.test(undated(s));\n\n // The rule must be able to see. If it cannot flag the sentence it was written for, it is decoration.\n const CANARY = \"Every call in your account was checked on 5 August.\";\n ok(CLAIM.test(CANARY) && !backed(CANARY), \"the scope rule can no longer recognise the mistake it exists for\");\n const BACKED = \"Every one of your 5,544 contact records was checked just now.\";\n ok(!(CLAIM.test(BACKED) && !backed(BACKED)), \"the scope rule rejects a claim that names its denominator\");\n const DATED_AND_BACKED = \"All 165 automations were read one by one on 4 August.\";\n ok(!(CLAIM.test(DATED_AND_BACKED) && !backed(DATED_AND_BACKED)), \"a dated sentence with a real count is being flagged\");\n\n const unbacked = [];\n let inspected = 0;\n for (const d of DEC.DECISIONS) {\n for (const c of [{}, FULL_CTX]) {\n for (const s of sentences(DEC.evidenceText(d, c))) {\n inspected++;\n if (CLAIM.test(s) && !backed(s)) unbacked.push(`${d.ref}: ${s.trim().slice(0, 110)}`);\n }\n }\n }\n for (const e of W.SEEDED) {\n for (const s of sentences(e.evidence)) {\n inspected++;\n if (CLAIM.test(s) && !backed(s)) unbacked.push(`${e.at}: ${s.trim().slice(0, 110)}`);\n }\n }\n eq([...new Set(unbacked)], [], \"a 'how we know' sentence sweeps wider than any number in it\");\n return scoped(inspected, \"evidence sentences\");\n});\n// [retired 14 Aug 2026: \"D2b.20 the dry tagging pass is reported, and only when one has actually run\".\n// Its entire subject was K8.extra. K8 was deleted when the system went live, so the guarantee has no\n// subject left. Retired with the card rather than repointed at an unrelated one — a test kept alive by\n// giving it a new subject stops testing what it is named for.]\nheader(\"ROUND 14: A BLOB THIS CARD DID NOT WRITE\");\n\nt(\"D5.21 a malformed stored list never takes the dashboard down\", () => {\n // The card is interpolated into the page's ONE template literal and there is no try/catch between\n // it and the HTTP response, so a throw in here is not a broken card, it is a broken dashboard.\n // Every shape below threw on 7 August, against the real function:\n // rows:{} rows:\"x\" dogs:\"Fido\" windows:\"x\" windows:[null] and a null `day` on the second of two\n // same-state rows — that last one invisible with a single row, because .sort() never calls the\n // comparator on a one-element array, which is why every fixture in this file missed it.\n const base = { ...DEPBLOB };\n const R = DEPBLOB.rows[0];\n const shapes = [\n { rows: {} }, { rows: \"x\" }, { rows: 7 }, { rows: null }, { rows: undefined }, { rows: [null, undefined] },\n { rows: [{ ...R, dogs: \"Fido\" }] }, { rows: [{ ...R, dogs: 3 }] }, { rows: [{ ...R, dogs: { a: 1 } }] },\n { rows: [{ ...R, dogCount: \"1\" }] }, { rows: [{ ...R, dogCount: -1 }] }, { rows: [{ ...R, dogCount: NaN }] },\n { rows: [{ ...R, contactId: \"1\" }, { ...R, contactId: \"2\", day: null }] },\n { rows: [{ ...R, contactId: \"1\" }, { ...R, contactId: \"2\", day: 20261125 }] },\n { rows: [{ ...R, day: undefined, until: undefined }] }, { rows: [{ ...R, state: \"weird\" }] },\n { rows: [{ contactId: \"bare\", day: \"2026-11-25\", state: \"seen\" }] },\n { rows: [{ ...R, name: null }] }, { rows: [{ ...R, name: {} }] }, { rows: [{ ...R, note: { a: 1 } }] },\n { windows: \"Thanksgiving\" }, { windows: [null] }, { windows: [] }, { windows: 5 }, { windows: null },\n { at: \"not-a-date\" }, { at: 12345 }, { at: {} }, { feedDead: \"yes\" }, { sentence: null },\n { calendarsAsked: \"2\" }, { pickupsAsked: null }, { readFailures: \"many\" },\n ];\n for (const s of shapes) {\n let html;\n try { html = DASH.depositCard({ ...base, ...s }, true, noAgo); }\n catch (e) { ok(false, `the card threw on ${JSON.stringify(s).slice(0, 70)}: ${e.message}`); continue; }\n ok(typeof html === \"string\" && html.includes(\"Holiday deposits\"), `no card came back for ${JSON.stringify(s).slice(0, 70)}`);\n ok(!/undefined|NaN|\\[object Object\\]/.test(html), `raw JS leaked onto the page for ${JSON.stringify(s).slice(0, 70)}: ${(html.match(/.{0,40}(undefined|NaN|\\[object Object\\]).{0,20}/) || [])[0]}`);\n }\n return scoped(shapes.length * 2, \"malformed blobs\");\n});\n\nt(\"D5.22 the headline is generated from the rows on this page, so it cannot contradict them\", () => {\n // [was: `esc(dep.sentence)`, printed straight out of the blob. The sentence and the rows are\n // written by the same run so they agree — by convention, guarded nowhere. Handed a blob whose\n // sentence said \"No holiday boarding stays are booked in the deposit windows yet, so there is\n // nothing to check.\", the card printed that directly above three named people worth checking.]\n const rows = [{ ...DEPBLOB.rows[1], name: \"Alice\" }];\n const lie = \"No holiday boarding stays are booked in the deposit windows yet, so there is nothing to check.\";\n const h = DASH.depositCard({ ...DEPBLOB, rows, sentence: lie }, true, noAgo);\n ok(!h.includes(lie), \"the card printed a stored sentence that contradicts the table under it\");\n ok(/Alice/.test(h), \"the row is not on the page at all, so this check is blind\");\n ok(/1 holiday stay is booked/.test(h), `the headline does not describe the one row shown: ${(h.match(/margin:-4px 0 9px\">([^<]*)/) || [])[1]}`);\n // And the counts in the generated headline track the rows for real, over many shapes.\n let checked = 0;\n for (const n of [1, 2, 3, 5]) {\n for (const st of [\"seen\", \"none_seen\", \"partial\", \"could_not_check\"]) {\n const many = Array.from({ length: n }, (_, i) => ({ ...DEPBLOB.rows[0], contactId: `c${i}`, name: `P${i}`, state: st }));\n const card = DASH.depositCard({ ...DEPBLOB, rows: many, sentence: lie, feedDead: false }, true, noAgo);\n const said = Number((card.match(/(\\d+) holiday stays? (?:is|are) booked/) || [])[1] ?? -1);\n eq(said, n, `the headline says ${said} stays where ${n} ${st} rows are rendered`);\n checked++;\n }\n }\n return scoped(3 + checked, \"headline checks\");\n});\n\nt(\"D5.23 a list whose age cannot be read says so, rather than looking fresh\", () => {\n // [was: `Number.isFinite(ageH) && ageH > 36`. An unparseable `at` makes ageH NaN, which is not\n // finite, so the whole staleness banner was skipped — and a list of completely unknown age\n // looked identical at the top of the card to one checked a minute ago. Every row below it is\n // written in the present tense.]\n const h = DASH.depositCard({ ...DEPBLOB, at: \"not-a-date\" }, true, () => \"unknown\");\n ok(/no readable date on this list/i.test(h), \"an unreadable date is silently treated as fresh\");\n const fresh = DASH.depositCard(DEPBLOB, true, noAgo);\n ok(!/no readable date/i.test(fresh), \"a perfectly good timestamp is reported as unreadable\");\n return scoped(2, \"cases\");\n});\n\nt(\"D5.24 a state this code does not recognise is shown as unknown, as one pair\", () => {\n // [was: two independent `??` fallbacks — colour \"#6b7280\" and label \"Worth a look\" — which\n // between them produced a combination that exists nowhere in DEP_STATE: the grey dot reserved\n // for \"Could not check\" beside the orange states' label. A state we cannot read is a state we\n // cannot make a claim about.]\n const allowed = Object.values(DASH.DEP_STATE).map((v) => `${v.color}|${v.label}`);\n for (const junk of [\"weird\", \"\", null, undefined, 0, \"SEEN\", \"none-seen\", \"paid\"]) {\n const h = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], state: junk }] }, true, noAgo);\n const m = h.match(/color:(#[0-9a-f]{6})\">●<\\/span> ([^<]+) {\n // [was: nothing. D5.19 pins the LABEL for each real state and D5.24 pins the colour+label PAIR\n // for junk states, so a render site that hardcoded its own colours for the four real states —\n // a ternary, a palette lookup, a stray constant — kept the whole suite green. Negative control\n // \"the dot colour is chosen at the render site rather than from the allowed set\" walked\n // straight through and said so. This closes it the same way D5.19 closed labels: read the\n // RENDERED page and demand the exact colour|label pair from the one allowed table, one state\n // at a time, all four states.]\n let inspected = 0;\n for (const st of Object.keys(DASH.DEP_STATE)) {\n const h = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], state: st, note: \"n\" }] }, true, noAgo);\n const m = h.match(/color:(#[0-9a-f]{6})\">●<\\/span> ([^<]+) {\n // Her booking form is public: the account already holds a self-service \"help test\" contact with\n // future bookings, so `name` and the dog names are hostile input, not formatting.\n const bidi = \"Kim Refund ‮24.05$ eeF‬\";\n const h = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], name: bidi }] }, true, noAgo);\n ok(!/[‪-‮⁦-⁩]/.test(h), \"a bidi override reached the page, so the cell renders back to front\");\n ok(/Kim Refund/.test(h), \"the name was dropped entirely rather than cleaned\");\n const long = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], name: \"A\".repeat(10_000) }] }, true, noAgo);\n const cell = (long.match(/(A+\\.*)<\\/td>/) || [])[1] ?? \"\";\n ok(cell.length > 20 && cell.length < 200, `a 10,000-character name rendered at ${cell.length} characters, which no phone can lay out`);\n const dogs = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], dogs: [\"B\".repeat(5000)], dogCount: 1 }] }, true, noAgo);\n ok(!/B{500}/.test(dogs), \"a dog name out of the booking form is not capped\");\n // AND THE CAP MUST NOT TOUCH THE CARD'S OWN WRITING. Putting the length cap inside esc() itself\n // cut the generated sentences off at 120 characters, including the one that says this is not a\n // list of people who owe her money. Three tests caught it; this is the one that names it.\n ok(h.includes(\"This is a shortlist to look at rather than a list of people who owe you.\"), \"the card's own sentences are being truncated by the name cap\");\n ok(/does not reach the card system, so it will not show here\\./.test(h), \"the footer sentence is truncated\");\n return scoped(6, \"hostile fields\");\n});\n\nt(\"D5.26 a row with no readable name says so, instead of a blank settled row\", () => {\n // deposits.ts substitutes \"name not readable\" upstream. A blank green \"Payment on file\" row with\n // no name is something Kim can neither act on nor check, and it looks like a customer.\n for (const name of [undefined, null, \"\", \" \", 0]) {\n const h = DASH.depositCard({ ...DEPBLOB, rows: [{ ...DEPBLOB.rows[0], name }] }, true, noAgo);\n ok(/name not readable/.test(h), `a row with name ${JSON.stringify(name)} rendered anonymously`);\n ok(!/<\\/td>/.test(h), \"an empty name cell reached the page\");\n }\n return scoped(10, \"nameless rows\");\n});\n\nt(\"D5.27 a stored list that is not a list is a reading problem, never an empty season\", () => {\n // Filtering a malformed `rows` down to [] and carrying on prints \"No holiday boarding stays are\n // booked\", which is the one thing this card must never say on the strength of something it could\n // not read. Same rule as D5.1, one layer further in.\n for (const junk of [{}, \"x\", 7, true]) {\n const h = DASH.depositCard({ ...DEPBLOB, rows: junk }, true, noAgo);\n ok(/not readable/.test(h), `rows=${JSON.stringify(junk)} was not reported as a reading problem`);\n ok(!/No holiday boarding stays are booked/.test(h), `rows=${JSON.stringify(junk)} was presented as an empty season`);\n ok(!/\\bunpaid\\b|owes|worth checking/i.test(h), \"the unreadable card made a finding about somebody\");\n }\n return scoped(12, \"unreadable lists\");\n});\n\n// =================================================================================================\nheader(\"ROUND 15: THE MODE IS THREE-VALUED, NOT TWO\");\n\nt(\"D6.1 an unknown practice-or-live never renders as practice\", () => {\n // THE SECOND DOOR, 14 Aug 2026. The mode row on this page was gated on `runKnown` and correctly\n // said \"Practice or live: could not check\". The paragraph two rows below it was gated on\n // `stateKnown`, a DIFFERENT read, and reached `practice`, which was `run?.testMode !== false` —\n // a boolean whose default on any unknown was TRUE. So one failed read of the run-state or\n // kill-switch blob, with the sequence empty, printed \"In practice mode ... has never sent to or\n // processed one of your actual inquiries\" on a live system, two lines under the box admitting it\n // could not check. Same false sentence as 11-14 August, different door.\n ok(!/testMode !== false/.test(src), \"the mode is back to a boolean that defaults to practice on an unknown\");\n ok(/const modeKnown = runKnown && typeof run\\?\\.testMode === \"boolean\"/.test(src),\n \"there is no single gate that says whether the mode is known at all\");\n ok(/const practice = modeKnown && run\\.testMode === true/.test(src), \"practice can be true without the mode being known\");\n // Every place the page NAMES the mode has to sit behind that one gate.\n ok(/\\$\\{modeKnown\\s*\\n?\\s*\\? `

/.test(src), \"the practice-or-live row is not gated on modeKnown\");\n ok(/: !modeKnown\\s*\\n?\\s*\\? `There is nobody in the sequence at this moment\\./.test(src),\n \"the empty-sequence paragraph has no unknown branch, so it must pick practice or live\");\n ok(/else if \$!modeKnown\$ problems\\.push/.test(src),\n \"the headline can say everything is normal while the mode row says it could not check\");\n return scoped(6, \"guarantees\");\n});\n\nt(\"D6.2 the unknown-mode words cannot trip the watchdog that reads this page\", () => {\n // watchdog/main.ts fetches this page and fails CRITICAL on any present-tense \"practice mode\"\n // outside the dated-history fence. The new unknown branch talks about the mode, so it has to say\n // so without using that phrase. This is a real constraint, not a style note: getting it wrong\n // emails Amir every hour about a page that is telling the truth.\n const body = src.slice(src.indexOf(\"const html = `\"), fenceB = body.indexOf(\"\");\n ok(fenceA > 0 && fenceB > fenceA, \"the dated-history fence is gone: the watchdog would scan the whole page\");\n const outsideFence = body.slice(0, fenceA) + body.slice(fenceB);\n // The practice branch legitimately contains the phrase; it renders only when the engine SAYS\n // practice, which is exactly when the watchdog's live precondition does not hold. What must not\n // contain it is the unknown branch or the headline's unknown-mode wording.\n const unknownBranch = src.slice(src.indexOf(\": !modeKnown\"), src.indexOf(\": !modeKnown\") + 700);\n ok(unknownBranch.length > 100, \"the unknown branch was not found: this check is reading nothing\");\n ok(!/practice mode/i.test(unknownBranch), \"the unknown-mode paragraph uses the phrase the watchdog alarms on\");\n const headlineUnknown = src.slice(src.indexOf(\"else if (!modeKnown) problems.push\"), src.indexOf(\"else if (!modeKnown) problems.push\") + 200);\n ok(!/practice mode/i.test(headlineUnknown), \"the headline's unknown-mode wording uses the phrase the watchdog alarms on\");\n return scoped(outsideFence.length, \"characters of unfenced page inspected\");\n});\n\n// =================================================================================================\nheader(\"ROUND 16: THE CONTROL PANEL, AS RENDERED\");\n// Nothing in this project rendered engine/api.ts and read it until 14 Aug 2026. Every check on that\n// file was about auth and credentials — worth having, and none of them could see that the page was\n// telling a live client four things that were not true. These render the real function against real\n// shapes and read the words that come out.\n\n// TWO READINGS OF THE SAME FILE, on purpose. codeOnly() blanks string LITERALS as well as\n// comments, so it is the right lens for \"is this code still shaped this way\" and the wrong one for\n// \"does this constant still hold this value\" — under it every string is \"\". Mixing them up gives a\n// check that reads `const X = \"\"` and concludes the constant was deleted.\nconst API_RAW = readFileSync(new URL(\"../engine/api.ts\", import.meta.url), \"utf8\");\nconst API_SRC = codeOnly(API_RAW);\nconst PP_SRC = readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\");\nconst AGO = (m) => new Date(Date.now() - m * 60000).toISOString();\n/** The live payload shape, taken from the val's own JSON on 14 Aug 2026. */\nconst PANEL = {\n run: { ok: true, v: \"1.7.1\", ts: AGO(31), testMode: false },\n contacts: [], killed: false, killedAt: null, testMode: false, runReadOk: true, modeKnown: true,\n engineVersion: \"1.7.1\", lastRunTs: AGO(31), lastRunAgeMin: 31, stale: false,\n counts: { total: 2, active: 1, won: 1, paused: 0, sentToday: 0, testSentToday: 0, failedToday: 0, unreachable: 0, deadLettered: 0 },\n byStatus: { main: 1, done_customer: 1 }, unlabelledStatuses: [], unlabelledEvents: [],\n lastError: null, recent: [], recentRaw: 0, journalTotal: 0, summary: null, watchdog: null,\n};\nconst render = (over = {}) => API.page({ ...PANEL, ...over }, \"KEY\");\n/** Visible words only: no tags, no HTML comments, no stylesheet, no script. */\nconst visible = (h) => h\n .replace(//g, \" \").replace(//g, \" \")\n .replace(//g, \" \").replace(/<[^>]+>/g, \" \")\n .replace(/&/g, \"&\").replace(/"/g, '\"').replace(/'/g, \"'\")\n .replace(/</g, \"<\").replace(/>/g, \">\").replace(/\\s+/g, \" \");\n\nt(\"D7.1 the panel never tells her to do something that does nothing\", () => {\n // [was, shipped and live: \"They stay on this number until somebody fixes the contact details in\n // your CRM.\" Fixing the details changed nothing. Any state entry at all excluded the contact\n // from the enrolment filter, and the only thing that ever cleared one was the 60-day sweep, so\n // the page named an action with no effect and no timescale. A wrong number is embarrassing; an\n // instruction that does nothing costs her an afternoon.]\n ok(!/fixes the contact details in your CRM/.test(API_SRC), \"the instruction that does nothing is back\");\n const h = visible(render({ counts: { ...PANEL.counts, unreachable: 2, deadLettered: 3 } }));\n ok(/2 \\+ 3 = 5/.test(h), \"the two halves are not added up where she can check them\");\n // The order is the load-bearing part: re-admission needs an address or a number PRESENT, so\n // clearing the tag first with an empty record does nothing and looks like the fix not working.\n const iDetails = h.indexOf(\"put a phone number or an email address on their record\");\n const iTag = h.indexOf(\"take that tag off\");\n ok(iDetails > -1 && iTag > -1, \"the steps back are not on the page at all: this check is blind\");\n ok(iDetails < iTag, \"the page tells her to clear the tag before fixing the record, which does nothing\");\n ok(/60 days after it stopped trying/.test(h), \"the page does not say when the count comes down by itself\");\n return scoped(5, \"guarantees\");\n});\n\nt(\"D7.2 the two tag names on the page are the tags the engine actually acts on\", () => {\n // The page tells her to take one tag OFF a record and check another is ON it. api.ts cannot\n // import the engine (that module is the sender), so it carries a second copy of the name. A\n // second copy is a fact that can drift, and a drifted one sends her to edit a tag that decides\n // nothing. Pinned to the engine's own source rather than to a literal typed twice in this file.\n const engineEnrolled = /const TAG_ENROLLED = \"([^\"]+)\"/.exec(PP_SRC);\n const engineSource = /const TAG_SOURCE_SIGNAL = Deno\\.env\\.get\$\"TAG_SOURCE_SIGNAL\"\$ \\|\\| \"([^\"]+)\"/.exec(PP_SRC);\n ok(engineEnrolled && engineSource, \"the engine's tag constants were renamed: this check is reading nothing\");\n const panelEnrolled = /const TAG_ENROLLED = \"([^\"]+)\"/.exec(API_RAW);\n ok(panelEnrolled, \"the panel no longer names the enrolment tag it tells her to remove\");\n eq(panelEnrolled[1], engineEnrolled[1], \"the panel names a different tag from the one the engine excludes on\");\n const panelSource = /const TAG_SOURCE_SIGNAL = Deno\\.env\\.get\$\"TAG_SOURCE_SIGNAL\"\$ \\|\\| \"([^\"]+)\"/.exec(API_RAW);\n ok(panelSource, \"the panel hardcodes the joining tag instead of reading the setting the engine reads\");\n eq(panelSource[1], engineSource[1], \"the panel's fallback joining tag differs from the engine's\");\n const h = visible(render({ counts: { ...PANEL.counts, unreachable: 1, deadLettered: 0 } }));\n ok(h.includes(engineEnrolled[1]) && h.includes(engineSource[1]), \"neither tag name reaches the page she reads\");\n return scoped(6, \"guarantees\");\n});\n\nt(\"D7.2b every status the engine can write has a plain-English name on the panel\", () => {\n // Kim never reads an enum. This has bitten twice: `done_unreachable` and `done_send_failed`\n // arrived in the engine on 14 Aug with no names here and fell through to the raw token, and\n // `done_not_enrolled` arrived the same evening the same way. statusLabel() degrades safely, so\n // nothing looks broken — the page just quietly stops naming a state she is being shown a count\n // of. Read from the ENGINE's own union so a new status cannot arrive unnamed and unnoticed.\n const union = /type PuppyStatus =([\\s\\S]*?);\\n/.exec(PP_SRC);\n ok(union, \"the engine's status union was renamed: this check is reading nothing\");\n // [a-z0-9_], not [a-z_]: `done_soft_21d` has digits in it, and without them this parsed 11 of\n // the 12 literals and quietly stopped covering the one status that has a number in its name.\n const NAME = /\"([a-z][a-z0-9_]*)\"/g;\n const statuses = [...union[1].matchAll(NAME)].map((m) => m[1]);\n // DeadLetterStatus is a reference in that union, not a literal, so pull its members too.\n const dead = /DEAD_LETTER_STATUSES[^=]*=\\s*\\[([^\\]]*)\\]/.exec(readFileSync(new URL(\"../engine/reachability.ts\", import.meta.url), \"utf8\"));\n ok(dead, \"the dead-letter status list was renamed: two statuses would go unchecked\");\n statuses.push(...[...dead[1].matchAll(NAME)].map((m) => m[1]));\n // THIS CHECK FAILS OPEN WITHOUT THE NEXT THREE LINES, which is the failure mode this whole file\n // exists to catch. The union is parsed out of another file by regex, so anything that makes the\n // capture SHORTER — the union collapsed onto one line, a `;` appearing inside it, a status added\n // through a type alias rather than a literal — narrows what is checked while still printing\n // PASS. The scope this test reports would drop from 14 to 2 and nothing would notice, because\n // CHECK_FLOORS is a per-suite aggregate in the tens of thousands. So the count is asserted, and\n // the union's own terminator is asserted, and an under-capturing regex goes red.\n // Raised by the engine's author on 14 Aug 2026, about a test that reads their file.\n ok(/DeadLetterStatus/.test(union[1]),\n \"the status union no longer ends the way this regex assumes, so it may be capturing only part of it\");\n ok(statuses.length >= 14,\n `only ${statuses.length} statuses parsed out of the engine, expected at least 14: the regex is under-capturing, or a status was removed. Either way look, do not lower this number.`);\n const labelBlock = /const STATUS_LABEL: Record = \\{([\\s\\S]*?)\\n\\};/.exec(API_RAW);\n ok(labelBlock, \"STATUS_LABEL was renamed or removed: this check is reading nothing\");\n const unnamed = [...new Set(statuses)].filter((s) => !new RegExp(`\\\\n\\\\s*${s}:`).test(labelBlock[1]));\n eq(unnamed, [], \"the panel would print a raw engine word to Kim for these\");\n return scoped([...new Set(statuses)].length, \"engine statuses checked for a plain-English name\");\n});\n\nt(\"D7.3 the Do Not Disturb instruction names the switch that actually stops everything\", () => {\n // [was: \"switch on Do Not Disturb, the system honors that on its next check, about an hour at\n // most, permanently.\" Wrong twice. Rule 1 of the engine reads the contact's TOP-LEVEL dnd only;\n // the per-channel switches in dndSettings block one channel and let the other keep sending, and\n // this account's live records carry exactly that combination. And the due-first filter spends\n // no call on a contact whose next step is not due, so the switch is not re-read for up to\n // SAFETY_SWEEP_HOURS. Nobody is messaged in the gap, and the sentence was still false.]\n const h = visible(render());\n ok(!/switch on Do Not Disturb, the system honors that on its next check/.test(h), \"the old sentence is back\");\n ok(/main Do Not Disturb/.test(h), \"the page does not say WHICH switch stops everything\");\n ok(/separate Do Not Disturb switches for texts on their own and for emails on their own/.test(h),\n \"the per-channel switches are not disclosed, so she can hit one and think she stopped everything\");\n ok(/turning off texts leaves the emails running/.test(h), \"the page does not say what the per-channel switch fails to do\");\n ok(/within a day at the latest/.test(h), \"the timing is not stated\");\n ok(!/about an hour at most, permanently/.test(h), \"the old timing claim is back\");\n // The honest consolation, which is what makes the delay harmless and has to be said, not implied.\n ok(/the only moment it would message them is the same moment it reads the switch/.test(h),\n \"the page states a delay without saying nobody is messaged inside it\");\n return scoped(7, \"guarantees\");\n});\n\nt(\"D7.4 one repeating line cannot crowd out her history, and the page says it folded them\", () => {\n // The live page on 14 Aug 2026: 39 of \"the last 40 things it did\" were the identical row\n // `not enrolled / live booking already exists`, hourly for two days.\n const rep = (n) => Array.from({ length: n }, (_, i) => ({\n ts: AGO(30 + i * 60), contactId: \"JwnIihtdcd9nwfTSCcl4\", event: \"enroll_refused\", detail: \"live booking already exists\",\n }));\n const journal = [...rep(20), { ts: AGO(30 + 20 * 60), contactId: \"h1sEguI5pPKncyaiTMw0\", event: \"hard_exit\", detail: \"became a customer\" }, ...rep(19).map((r, i) => ({ ...r, ts: AGO(30 + (21 + i) * 60) }))];\n const h = render({ recent: journal, recentRaw: journal.length, journalTotal: journal.length });\n const v = visible(h);\n // The LAST table on the page is the activity list. [was: the first , which is the \"where\n // those people are\" stage table — so this counted one row, passed nothing, and would have\n // reported the fold working while the activity table was still forty identical lines.]\n const bodies = h.match(/[\\s\\S]*?<\\/tbody>/g) || [];\n ok(bodies.length >= 1, \"no table on the page at all: this check is reading nothing\");\n const bodyRows = bodies[bodies.length - 1];\n ok(/enrol|not enrolled/i.test(bodyRows), \"the last table is not the activity list: this check is reading the wrong one\");\n const rowCount = (bodyRows.match(//g) || []).length;\n ok(rowCount === 3, `one repeating condition still fills the table: ${rowCount} rows for ${journal.length} entries`);\n // FOLDED, NOT HIDDEN: the count, both ends of the run, and arithmetic that adds up.\n ok(/The same thing 20 times over/.test(v), \"a folded run does not say how many times it happened\");\n // DERIVED FROM THE FIXTURE, not typed. A typed \"3 + 38 = 41\" is a number that can be wrong in\n // the test while the page is right, and then the fix is to edit the test until it agrees, which\n // is how a check stops checking. This asserts the sum on the page equals the fixture it was\n // handed, whatever that is.\n const sum = /(\\d+) \\+ (\\d+) = (\\d+) entr/.exec(v);\n ok(sum, `no arithmetic on the page at all: ${v.slice(v.indexOf(\"Times are Georgia\"), v.indexOf(\"Times are Georgia\") + 200)}`);\n eq([Number(sum[1]), Number(sum[3])], [rowCount, journal.length], \"the page's rows and total do not match what it was given\");\n eq(Number(sum[1]) + Number(sum[2]), Number(sum[3]), \"the page's own arithmetic does not add up\");\n ok(/Nothing is dropped/.test(v), \"the page folds rows without saying so\");\n // The real thing that was being pushed off the end must survive.\n ok(/left the sequence for good/.test(v), \"the one real event was crowded out by the repeat anyway\");\n // Only CONSECUTIVE identical entries fold: the gap between two runs is part of the story.\n ok((v.match(/The same thing \\d+ times over/g) || []).length === 2, \"two runs split by a real event were merged into one\");\n return scoped(6, \"guarantees\");\n});\n\nt(\"D7.4b a table with nothing repeated says so, and folds nothing\", () => {\n const journal = [\n { ts: AGO(30), contactId: \"a\", event: \"sent\", detail: \"main#1\" },\n { ts: AGO(90), contactId: \"b\", event: \"enrolled\", detail: \"via tag\" },\n ];\n const v = visible(render({ recent: journal, recentRaw: 2, journalTotal: 2 }));\n ok(/Nothing repeated back to back/.test(v), \"a clean table still talks about folding\");\n ok(!/The same thing/.test(v), \"a clean table claims a fold that did not happen\");\n ok(/Everything it has done so far/.test(v), \"a complete short history is described as a window onto a longer one\");\n return scoped(3, \"guarantees\");\n});\n\nt(\"D7.5 the version comes from the engine, and an unread one is not a question mark\", () => {\n // [was: `System version ${esc(d.engineVersion || \"?\")}`. The value was already read from the\n // engine's own record, which is right and stays. Two things were not: a bare number reads as\n // the version of THIS PAGE when it is the version of the system as of its last CHECK, and \"?\"\n // is not a sentence — old, broken and unknown all render identically.]\n ok(!/System version \\$\\{esc\$d\\.engineVersion \\|\\| \"\\?\"\$\\}/.test(API_SRC), \"the bare version footer is back\");\n ok(!/System version 1\\.7/.test(API_SRC), \"a version number is typed into the page\");\n const v = visible(render({ engineVersion: \"9.9.9\", lastRunAgeMin: 5 }));\n ok(/reported itself as version 9\\.9\\.9 on its last check, 5 minutes ago/.test(v), \"the reported version is not shown with when it was reported\");\n ok(/not typed on this page/.test(v), \"the page does not say where the version came from\");\n const unread = visible(render({ engineVersion: null, runReadOk: false, lastRunTs: null, lastRunAgeMin: null, stale: true }));\n ok(/could not read the follow-up system's record just now/.test(unread) && !/\\?/.test(unread.slice(unread.indexOf(\"version\") - 200)),\n \"an unreadable version still renders as a question mark\");\n const never = visible(render({ engineVersion: null, lastRunTs: null, lastRunAgeMin: null, stale: true }));\n ok(/has not recorded a version yet/.test(never), \"never-run and could-not-read render the same\");\n return scoped(6, \"guarantees\");\n});\n\nt(\"D7.6 nothing on the panel shouts, which she asked for on 14 August\", () => {\n const states = [\n {}, { killed: true, killedAt: AGO(2) }, { testMode: true, modeKnown: true },\n { stale: true, lastRunAgeMin: 300 }, { runReadOk: false, modeKnown: false, testMode: null, stale: true },\n { counts: { ...PANEL.counts, failedToday: 2 } },\n { recent: [{ ts: AGO(9), contactId: \"a\", event: \"send_failed\", detail: \"x\" }, { ts: AGO(11), contactId: \"b\", event: \"contact_failed\", detail: \"y\" }], recentRaw: 2, journalTotal: 2 },\n ];\n const shouted = [];\n for (const s of states) {\n for (const w of visible(render(s)).match(/\\b[A-Z][A-Z]+\\b/g) || []) {\n // Acronyms and product names are not shouting. A word she reads as a word is.\n if (![\"CRM\", \"PM\", \"AM\", \"US\", \"UTC\"].includes(w)) shouted.push(w);\n }\n }\n eq([...new Set(shouted)], [], \"the panel is shouting at her again\");\n // And the stylesheet must not put the capitals back after the source has been written in prose.\n ok(!/h2\\{[^}]*text-transform:uppercase/.test(readFileSync(new URL(\"../engine/api.ts\", import.meta.url), \"utf8\")),\n \"the headings are forced back into capitals by the stylesheet\");\n return scoped(states.length, \"panel states\");\n});\n\nt(\"D7.7 no two lines on the panel contradict each other, in any state it can reach\", () => {\n // The shipped contradiction: \"What needs doing today: Nothing ... you can close this page\" sat\n // directly above \"The watchdog flagged 1 thing(s) for Amir to look at.\" Two sentences an inch\n // apart, one saying nothing is outstanding and one naming something outstanding. Reading the\n // whole page in every state it can render found three more of the same shape.\n const wd = (worst) => ({ headline: `The watchdog says ${worst}.`, worst, ts: AGO(20) });\n const states = {\n \"healthy, no watchdog\": {},\n \"healthy, watchdog OK\": { watchdog: wd(\"OK\") },\n \"healthy, watchdog WARNING\": { watchdog: wd(\"WARNING\") },\n \"healthy, watchdog CRITICAL\": { watchdog: wd(\"CRITICAL\") },\n \"stopped by Kim\": { killed: true, killedAt: AGO(2) },\n \"stopped, and in practice\": { killed: true, killedAt: AGO(2), testMode: true },\n \"missed two checks\": { stale: true, lastRunAgeMin: 300 },\n \"never ran\": { stale: true, lastRunTs: null, lastRunAgeMin: null, testMode: null, modeKnown: false, engineVersion: null },\n \"run record unreadable\": { runReadOk: false, modeKnown: false, testMode: null, stale: true, lastRunTs: null, lastRunAgeMin: null, engineVersion: null },\n \"someone replied\": { counts: { ...PANEL.counts, paused: 1 } },\n \"a message failed\": { counts: { ...PANEL.counts, failedToday: 2 } },\n };\n for (const [name, over] of Object.entries(states)) {\n const v = visible(render(over));\n const closeable = /you can close this page/.test(v);\n // 1. \"Close the page\" may not stand next to anything flagged, stopped or unread. Judged from\n // the STATE the page was handed, not from the watchdog's own words: that headline is\n // written in watchdog/main.ts and a check that parses it would be testing someone else's\n // prose and would go green the day they reword it.\n if (closeable) {\n const flagged = over.watchdog && over.watchdog.worst !== \"OK\" && over.watchdog.worst !== \"INFO\";\n ok(!flagged, `${name}: told to close the page while the watchdog line below flags something`);\n ok(!over.killed && !over.stale && over.runReadOk !== false, `${name}: told to close the page while the banner is red`);\n }\n // 2. Real messages may not be described as going out while the system is stopped or silent.\n if (/real messages are going to real people\\./.test(v)) {\n ok(!over.killed && !over.stale, `${name}: says real messages are going out while nothing is running`);\n }\n // 3. A mode that could not be read is never named.\n if (/could not check|not recorded/.test(v)) {\n ok(!/\\bLive\\b:|Practice mode:/.test(v), `${name}: names a mode it also says it could not read`);\n }\n // 4. Every state gives her exactly one answer to \"what needs doing\".\n ok((v.match(/What needs doing today/g) || []).length === 1, `${name}: the day's instruction is not stated exactly once`);\n }\n return scoped(Object.keys(states).length, \"panel states read end to end\");\n});\n\nt(\"D7.8 a failed read of the run record is never rendered as a fact about her system\", () => {\n // api.ts's `get()` swallows a read failure and returns the fallback, so an unreadable run record\n // came back identical to one that had never been written — and the page printed \"This has never\n // recorded a run. Tell Amir.\" about a system that had been running hourly all week.\n ok(/async function read\$key: string\$: Promise>/.test(API_SRC), \"there is no read that reports failure\");\n ok(/read\$\"puppy_run_state\"\$/.test(API_SRC), \"the run record is back on the swallowing reader\");\n ok(/runReadOk: runR\\.ok/.test(API_SRC), \"whether the run record answered is not carried to the page\");\n const v = visible(render({ runReadOk: false, modeKnown: false, testMode: null, stale: true, lastRunTs: null, lastRunAgeMin: null, engineVersion: null }));\n ok(!/has never recorded a run/.test(v), \"a failed read is reported as a system that has never run\");\n ok(/could not read the follow-up system's own record/.test(v), \"a failed read is not named as a failed read\");\n ok(!/Not running/.test(v), \"a failed read is rendered as a verdict about whether the system is running\");\n return scoped(6, \"guarantees\");\n});\n\nt(\"D7.9 every time on the panel is her clock, not the machine's\", () => {\n // Every stamp in the blobs is UTC and Georgia is four hours behind it in August, so a message\n // sent at 4:59 in the afternoon printed as 20:59 in a table she checks against her own inbox.\n const v = visible(render({\n recent: [{ ts: \"2026-08-14T20:59:57.050Z\", contactId: \"a\", event: \"sent\", detail: \"main#1\" }],\n recentRaw: 1, journalTotal: 1, killed: true, killedAt: \"2026-08-14T20:59:45.403Z\",\n }));\n ok(!/20:59/.test(v), \"a raw machine timestamp is on the page\");\n ok(/4:59 PM/.test(v), `the journal time was not converted: ${(v.match(/Aug 14[^.]{0,20}/) || [\"none\"])[0]}`);\n ok(/Georgia time/.test(v), \"times are shown without saying which clock they are on\");\n return scoped(3, \"guarantees\");\n});\n\ndone();\n\n\n=====FILE tests/dead-letter.test.mjs =====\n// DEAD LETTERS: a bounded number of attempts, and a terminal state when they run out.\n// R39, 14 Aug 2026.\n//\n// THE DEFECT THESE TESTS ARE WRITTEN AGAINST, stated as the defect rather than as the fix:\n// the catch on the send path wrote NOTHING to state. dueAt never moved, so the next tick re-derived\n// the identical decision and tried again. Rule 9's 21-day exit is gated on lastMainStepSent, which\n// only advances on the SUCCESS path, so it never timed out. MAX_SENDS_PER_RUN and MAX_SENDS_PER_DAY\n// both read out.sent, which only increments on success, so the retries were uncapped. Measured on\n// the live cadence that is ~24 attempts per contact per day, forever.\n//\n// R-SPIN below drives 200 consecutive ticks and asserts the total. Today's code records 200.\nimport { readFileSync } from \"node:fs\";\nimport {\n decideAction, applyDecision, freshState, MAIN_SEQUENCE, TERMINAL_STATUSES,\n nextFailureState, backoffBar, failCount, sendReceipt, onSendFailure, onDeliveryStatus,\n convoExtras, isDeliveryFailure, failureCounts, maxSendFailures, DEAD_LETTER_TITLE,\n reEnrollable, refusedBefore, deadLetterBody, DEAD_LETTER_STATUSES,\n} from \"../build/engine.js\";\nimport { suite, ok, eq, scoped, codeOnly } from \"./_harness.mjs\";\nconst { t, at, done, header } = suite(\"dead-letter\");\n\nconst T0 = Date.parse(\"2026-08-03T13:00:00Z\"); // Monday, 09:00 America/New_York — window open\nconst HOUR = 3600000;\nconst iso = (ms) => new Date(ms).toISOString();\n\nconst facts = (o = {}) => ({\n now: T0,\n contact: { id: \"c1\", firstName: \"Lisa\", companyName: null, dnd: false, noEmail: false, noPhone: false, ...(o.contact ?? {}) },\n opportunities: [], pupTalkAppt: null, declinedSignal: false,\n hasUnansweredInboundReply: false, conversationCheckFailed: false,\n channelBlocked: { email: false, sms: false }, foreignOutboundAt: null,\n ...o,\n});\nconst SMS_STEP = MAIN_SEQUENCE.findIndex((m) => m.channel === \"sms\");\nconst dueSms = () => ({\n ...freshState(iso(T0 - (MAIN_SEQUENCE[SMS_STEP].offsetHours + 1) * HOUR)),\n status: \"main\", lastMainStepSent: SMS_STEP,\n});\n\n/**\n * The executor, in miniature: the same decide -> send -> persist loop cron() runs, with the network\n * replaced. `catchWrites` false reproduces the pre-fix catch (which wrote nothing) so the regression\n * test can state what today's code does, not only what tomorrow's should.\n */\nfunction drive({ state, ticks, stepMs = HOUR, send, factsFor = () => ({}), catchWrites = true }) {\n let s = state;\n let attempts = 0;\n for (let i = 0; i < ticks; i++) {\n const now = T0 + i * stepMs;\n const d = decideAction(facts({ now, ...factsFor(now, s) }), s);\n if (d.kind === \"send\") {\n attempts++;\n try {\n const resp = send(d, now);\n const step = MAIN_SEQUENCE[d.stepIndex];\n s = { ...applyDecision(d, s, iso(now)), ...sendReceipt(resp, step.channel) };\n } catch (e) {\n if (catchWrites) s = nextFailureState(s, iso(now), String(e)).next;\n // else: exactly the old behaviour — state untouched, so the next tick decides the same thing\n }\n } else {\n s = applyDecision(d, s, iso(now));\n }\n if (TERMINAL_STATUSES.has(s.status)) break;\n }\n return { s, attempts };\n}\n\nheader(\"THE COUNTER: 0 -> 1 -> 2 -> 3 -> TERMINAL\");\n\nt(\"DL-1 three failures dead-letter the contact, and done_send_failed is terminal\", () => {\n eq(maxSendFailures(), 3, \"the default ceiling moved; the rest of this suite assumes 3\");\n let s = { ...freshState(iso(T0)), status: \"main\", lastMainStepSent: SMS_STEP };\n const seen = [];\n for (let i = 1; i <= 3; i++) {\n const r = nextFailureState(s, iso(T0 + i * HOUR), \"422 invalid phone\");\n s = r.next;\n seen.push([failCount(s), s.status, r.dead]);\n }\n eq(seen[0], [1, \"main\", false]);\n eq(seen[1], [2, \"main\", false]);\n eq(seen[2], [3, \"done_send_failed\", true], \"the third failure did not end it: the retries are unbounded\");\n ok(TERMINAL_STATUSES.has(\"done_send_failed\"), \"not terminal, so cron re-evaluates it forever\");\n ok(/3 consecutive send failures/.test(s.exitReason), `exitReason reads: ${s.exitReason}`);\n eq(s.lastFailureReason, \"422 invalid phone\", \"the reason a human needs is not recorded\");\n return scoped(6, \"assertions\");\n});\n\nt(\"DL-2 a failure moves the COUNTER ONLY — never the step, never the pacing clock\", () => {\n // The invariant the success path's own comment sets: state persisted immediately after each\n // successful send, so a mid-run crash must never re-send. A failure must not fake progress either.\n const s0 = { ...dueSms(), lastSentAt: iso(T0 - 50 * HOUR), lastSlowStepSent: 2, lastBranchStepSent: 1 };\n const { next } = nextFailureState(s0, iso(T0), \"500\");\n eq(next.lastMainStepSent, s0.lastMainStepSent, \"a failed send consumed the step\");\n eq(next.lastBranchStepSent, s0.lastBranchStepSent);\n eq(next.lastSlowStepSent, s0.lastSlowStepSent);\n eq(next.lastSentAt, s0.lastSentAt, \"a failed send started the pacing clock\");\n eq(next.enteredAt, s0.enteredAt);\n eq(next.lastCheckedAt, iso(T0), \"the contact was not stamped as looked at\");\n return scoped(6, \"state fields\");\n});\n\nt(\"DL-3 a SUCCESS resets the counter, so an unrelated blip weeks later cannot dead-letter them\", () => {\n // applyDecision spreads ...s, so a stale count survives every later transition unless reset here.\n let s = { ...dueSms(), sendFailures: 2, lastFailureAt: iso(T0 - 9 * HOUR), lastFailureReason: \"500\" };\n eq(failCount(s), 2);\n const d = decideAction(facts({ now: T0 }), s);\n eq(d.kind, \"send\", `produced ${d.kind}: backoff should have expired 9h after 2 failures (4h)`);\n s = { ...applyDecision(d, s, iso(T0)), ...sendReceipt({ messageId: \"msg-1\" }, \"sms\") };\n eq(failCount(s), 0, \"the count survived a successful send: the next single blip dead-letters them\");\n eq(s.lastFailureAt, null);\n eq(s.lastFailureReason, null);\n eq(s.lastMessageId, \"msg-1\", \"the receipt was not captured, so delivery can never be reconciled\");\n // ...and one failure after that is failure number one, not number three.\n eq(nextFailureState(s, iso(T0 + HOUR), \"500\").dead, false, \"a healthy contact was dead-lettered on one blip\");\n return scoped(7, \"assertions\");\n});\n\nt(\"DL-4 garbage counters read as zero rather than as 'dead-letter them'\", () => {\n for (const junk of [undefined, null, NaN, -4, \"3\", {}, \"banana\"]) {\n const n = failCount({ sendFailures: junk });\n ok(n >= 0 && Number.isFinite(n), `failCount(${JSON.stringify(junk)}) = ${n}`);\n }\n eq(failCount({ sendFailures: \"banana\" }), 0);\n eq(failCount({}), 0, \"a pre-v1.9 state blob must deserialize as zero failures, not as broken\");\n return scoped(9, \"counter shapes\");\n});\n\nheader(\"BACKOFF: 2^FAILURES HOURS, AND IT IS THE SEND GATE THAT ENFORCES IT\");\n\nt(\"DL-5 backoff skips at 1h and sends at 5h\", () => {\n const at1h = { ...dueSms(), sendFailures: 2, lastFailureAt: iso(T0 - 1 * HOUR) };\n const d1 = decideAction(facts({ now: T0 }), at1h);\n eq(d1.kind, \"skip\", `produced ${d1.kind}: 1h after 2 failures is inside the 4h backoff`);\n ok(/backoff/.test(d1.reason), `reason was: ${d1.reason}`);\n const at5h = { ...dueSms(), sendFailures: 2, lastFailureAt: iso(T0 - 5 * HOUR) };\n eq(decideAction(facts({ now: T0 }), at5h).kind, \"send\", \"5h after 2 failures the contact is frozen out\");\n return scoped(3, \"gate decisions\");\n});\n\nt(\"DL-6 the curve doubles, zero failures never waits, and a future stamp cannot freeze anyone\", () => {\n eq(backoffBar({ sendFailures: 0, lastFailureAt: iso(T0) }, T0), null, \"a healthy contact was held back\");\n eq(backoffBar({}, T0), null);\n ok(backoffBar({ sendFailures: 1, lastFailureAt: iso(T0 - 1.5 * HOUR) }, T0), \"1 failure should wait 2h\");\n eq(backoffBar({ sendFailures: 1, lastFailureAt: iso(T0 - 2 * HOUR) }, T0), null, \"2h after 1 failure must send\");\n ok(backoffBar({ sendFailures: 3, lastFailureAt: iso(T0 - 7 * HOUR) }, T0), \"3 failures should wait 8h\");\n // Clock skew / a restored blob, mirroring the same guard R27 and the v1.7 min-gap already carry.\n eq(backoffBar({ sendFailures: 2, lastFailureAt: iso(T0 + 400 * HOUR) }, T0), null, \"a future stamp froze the contact\");\n return scoped(6, \"backoff points\");\n});\n\nheader(\"THE SPIN, AS A REGRESSION\");\n\nt(\"R-SPIN 200 consecutive ticks against a sender that always fails: 3 attempts, then terminal\", () => {\n const r = drive({\n state: dueSms(),\n ticks: 200,\n send: () => { throw new Error(\"422 The phone number is not valid\"); },\n });\n ok(r.attempts <= 3, `${r.attempts} send attempts across 200 ticks — the spin is back`);\n eq(r.attempts, 3, \"the ceiling is 3 attempts; anything else means the backoff or the counter moved\");\n ok(TERMINAL_STATUSES.has(r.s.status), `final status ${r.s.status} is not terminal, so it keeps being re-decided`);\n eq(r.s.status, \"done_send_failed\");\n eq(r.s.lastMainStepSent, SMS_STEP, \"a failing send advanced the sequence\");\n return scoped(200, \"simulated ticks\");\n});\n\nt(\"R-SPIN-b and the control: with the OLD catch, the same 200 ticks record 200 attempts\", () => {\n // If this ever stops recording ~200, the driver has stopped reproducing the defect and R-SPIN\n // above is no longer evidence of anything.\n const r = drive({\n state: dueSms(),\n ticks: 200,\n send: () => { throw new Error(\"422 The phone number is not valid\"); },\n catchWrites: false,\n });\n // ~78, not 200: this simulation ticks hourly and the 9-19 send window plus the no-SMS-Sunday rule\n // gate roughly ten of every twenty-four ticks. Every one of those 78 is a real GHL call, a real\n // out.failed that used to be uncapped, and a real CRITICAL watchdog alert.\n ok(r.attempts > 50, `the pre-fix driver only produced ${r.attempts} attempts: it no longer reproduces the spin`);\n ok(r.attempts > 20 * (r.s.lastMainStepSent + 1), \"the failing step was retried a handful of times, not endlessly\");\n ok(!TERMINAL_STATUSES.has(r.s.status), \"the old behaviour terminated on its own, which it never did live\");\n return scoped(2, \"control assertions\");\n});\n\nt(\"R-SPIN-c a PHONELESS contact never reaches the sender at all\", () => {\n let attempted = 0;\n // Neither channel: the live shape for 27 of 35 recent qualifying inquiries.\n const both = drive({\n state: dueSms(), ticks: 200,\n factsFor: () => ({ contact: { noEmail: true, noPhone: true } }),\n send: () => { attempted++; throw new Error(\"422\"); },\n });\n eq(attempted, 0, \"a contact with no email and no phone was handed to the sender\");\n ok(TERMINAL_STATUSES.has(both.s.status), `final status ${both.s.status} is not terminal`);\n eq(both.s.status, \"done_unreachable\");\n // Phone missing but email present: SMS steps skip, email steps still go out.\n const emailOnly = drive({\n state: dueSms(), ticks: 200,\n factsFor: () => ({ contact: { noPhone: true } }),\n send: (d) => {\n const ch = MAIN_SEQUENCE[d.stepIndex].channel;\n if (ch === \"sms\") { attempted++; throw new Error(\"422 no phone\"); }\n return { messageId: \"ok\" };\n },\n });\n eq(attempted, 0, \"an SMS step was attempted for a contact with no phone number\");\n ok(emailOnly.s.lastMainStepSent > SMS_STEP, \"the sequence stalled on the SMS step instead of moving past it\");\n return scoped(200, \"simulated ticks\");\n});\n\nheader(\"THE CEILINGS COUNT ATTEMPTS, NOT SUCCESSES\");\n\nt(\"DL-7 both blast ceilings read failures too, and the day counter counts failed attempts\", () => {\n const src = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n ok(/out\\.sent \\+ out\\.failed >= maxSendsPerRun\$\$/.test(src),\n \"MAX_SENDS_PER_RUN still reads out.sent alone, so failures are uncapped inside a run\");\n ok(/r\\.event === \"sent\" \\|\\| r\\.event === \"send_failed\"/.test(src),\n \"the daily counter still counts successes only, so failures are uncapped across the day\");\n // The SEND arm's catch specifically — pause_reply and soft_exit_21d have `catch (e)` blocks too,\n // and slicing one of those instead would be a check that inspects the wrong code and passes.\n const exec = src.slice(src.lastIndexOf(\"switch (decision.kind)\"));\n const sendArm = exec.slice(exec.indexOf('case \"send\"'), exec.indexOf('case \"skip_step\"'));\n const catchArm = sendArm.slice(sendArm.indexOf(\"} catch (e) {\"));\n ok(catchArm.length > 80, `the send arm's catch was not located (${catchArm.length} chars)`);\n ok(/sentToday\\+\\+/.test(catchArm), \"a failed attempt no longer counts against the daily ceiling\");\n ok(/onSendFailure\\(/.test(catchArm), \"the send catch no longer records the failure at all\");\n ok(!/applyDecision\\(/.test(catchArm), \"the send catch advances the sequence on a message that never went out\");\n return scoped(6, \"ceiling guarantees\");\n});\n\nheader(\"THE CATCH PERSISTS, AND ONLY A CONTACT THAT TRIED EARNS A TASK\");\n\nawait at(\"DL-8 onSendFailure persists immediately, journals, and raises ONE task at the ceiling\", async () => {\n const saves = [];\n const logs = [];\n const rows = [];\n const tasks = [];\n const state = {};\n const fx = {\n state,\n save: async (st) => { saves.push(JSON.parse(JSON.stringify(st))); },\n log: (l) => logs.push(l),\n journal: (c, e, d) => rows.push({ c, e, d }),\n task: async (c, title, body) => { tasks.push({ c, title, body }); },\n };\n state.c1 = { ...dueSms() };\n let dead = false;\n for (let i = 0; i < 3; i++) dead = await onSendFailure(\"c1\", state.c1, new Error(\"500 boom\"), \"main#4\", fx);\n eq(saves.length, 3, \"state was not persisted on every failure, so a mid-run crash loses the count\");\n eq(saves[0].c1.sendFailures, 1, \"the first failure was not persisted\");\n eq(state.c1.status, \"done_send_failed\");\n eq(dead, true);\n eq(rows.filter((r) => r.e === \"send_failed\").length, 3);\n eq(rows.filter((r) => r.e === \"dead_letter\").length, 1, \"the dead letter was journalled the wrong number of times\");\n eq(tasks.length, 1, \"a contact that tried and failed must earn exactly one task\");\n eq(tasks[0].title, DEAD_LETTER_TITLE);\n ok(/main#4/.test(tasks[0].body) && /500 boom/.test(tasks[0].body), \"the task does not say what failed or why\");\n ok(logs.some((l) => /DEAD LETTER/.test(l)), \"the run log never mentions it\");\n return scoped(10, \"assertions\");\n});\n\nawait at(\"DL-9 practice mode writes NO task into the client's real CRM\", async () => {\n const state = { c1: { ...dueSms() } };\n const fx = { state, save: async () => {}, log: () => {}, journal: () => {}, task: null }; // null = TEST_MODE\n for (let i = 0; i < 3; i++) await onSendFailure(\"c1\", state.c1, new Error(\"500\"), \"main#4\", fx);\n eq(state.c1.status, \"done_send_failed\", \"practice mode skipped the accounting as well as the task\");\n const src = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n ok(/task: TEST_MODE \\? null : createTask/.test(src), \"the executor no longer withholds tasks in practice mode\");\n return scoped(2, \"assertions\");\n});\n\nheader(\"DELIVERY: A 2xx FROM GHL MEANT QUEUED, NEVER DELIVERED\");\n\nt(\"DL-10 the receipt captures the id each channel actually returns\", () => {\n eq(sendReceipt({ messageId: \"sms-1\", conversationId: \"cv\" }, \"sms\").lastMessageId, \"sms-1\");\n eq(sendReceipt({ messageId: \"m\", emailMessageId: \"em-1\" }, \"email\").lastMessageId, \"em-1\",\n \"email must reconcile on emailMessageId: the SMS endpoint carries no status for email at all\");\n eq(sendReceipt({ messageId: \"sms-1\" }, \"sms\").lastMessageChannel, \"sms\");\n eq(sendReceipt({}, \"sms\").lastMessageId, null, \"an id was invented from a response that had none\");\n eq(sendReceipt({ messageId: \"x\" }, \"sms\").sendFailures, 0);\n ok(isDeliveryFailure(\"undelivered\") && isDeliveryFailure(\"FAILED\") && !isDeliveryFailure(\"delivered\"));\n ok(!isDeliveryFailure(\"queued\") && !isDeliveryFailure(\"unknown\"), \"an unsettled status was read as a failure\");\n return scoped(7, \"receipt/status shapes\");\n});\n\nawait at(\"DL-11 reconciliation is keyed on OUR message id — never the newest outbound on the thread\", async () => {\n // Chloe, Ava and 165 GHL workflows send into these same conversations. Attributing one of their\n // undelivered messages to this engine would dead-letter a contact who is perfectly reachable.\n const thread = {\n messages: {\n messages: [\n { id: \"someone-elses-newest\", direction: \"outbound\", status: \"undelivered\", body: \"from a workflow\" },\n { id: \"ours-1\", direction: \"outbound\", status: \"delivered\", body: \"from us\" },\n ],\n },\n };\n const st = { lastMessageId: \"ours-1\", lastMessageChannel: \"sms\", lastSentAt: iso(T0 - HOUR) };\n const rx = await convoExtras({ id: \"cv1\", lastMessageDirection: \"outbound\" }, st, async () => thread, \"https://x\", T0);\n eq(rx.deliveryStatus, \"delivered\", \"another system's undelivered was attributed to us\");\n // and when it IS ours that failed, it is reported\n const st2 = { ...st, lastMessageId: \"someone-elses-newest\" };\n eq((await convoExtras({ id: \"cv1\" }, st2, async () => thread, \"https://x\", T0)).deliveryStatus, \"undelivered\");\n // our message not on the page at all -> UNKNOWN, never \"fine\"\n const st3 = { ...st, lastMessageId: \"not-on-this-page\" };\n eq((await convoExtras({ id: \"cv1\" }, st3, async () => thread, \"https://x\", T0)).deliveryStatus, \"unknown\");\n // a read that throws -> UNKNOWN, never \"fine\"\n eq((await convoExtras({ id: \"cv1\" }, st, async () => { throw new Error(\"500\"); }, \"https://x\", T0)).deliveryStatus, \"unknown\");\n return scoped(4, \"reconciliations\");\n});\n\nawait at(\"DL-12 email delivery is read from the email endpoint, which is the only one that has it\", async () => {\n const urls = [];\n const st = { lastMessageId: \"em-9\", lastMessageChannel: \"email\", lastSentAt: iso(T0 - HOUR) };\n const rx = await convoExtras({ id: \"cv1\" }, st, async (u) => { urls.push(u); return { emailMessage: { status: \"opened\" } }; }, \"https://x\", T0);\n eq(rx.deliveryStatus, \"opened\");\n ok(/\\/conversations\\/messages\\/email\\/em-9/.test(urls[0]), `wrong endpoint for email status: ${urls[0]}`);\n ok(!urls.some((u) => /\\/conversations\\/cv1\\/messages/.test(u)),\n \"email status was looked for on the conversation endpoint, which carries none — it would read as unknown forever\");\n return scoped(3, \"assertions\");\n});\n\nawait at(\"DL-13 a send too fresh to have a status is left alone rather than filed as unknown\", async () => {\n let called = 0;\n const st = { lastMessageId: \"ours-1\", lastMessageChannel: \"sms\", lastSentAt: iso(T0 - 30 * 1000) };\n const rx = await convoExtras({ id: \"cv1\" }, st, async () => { called++; return { messages: [] }; }, \"https://x\", T0);\n eq(rx.deliveryStatus, null, \"a 30-second-old send was reconciled, which reads 'queued' for everything\");\n eq(called, 0, \"a pointless extra GHL call was made for every contact on every pass\");\n return scoped(2, \"assertions\");\n});\n\nawait at(\"DL-14 an undelivered message feeds the SAME bounded counter, and is idempotent\", async () => {\n const rows = [];\n const state = { c1: { ...dueSms(), sendFailures: 0, lastMessageId: \"ours-1\", lastMessageChannel: \"sms\" } };\n const fx = { state, save: async () => {}, log: () => {}, journal: (c, e, d) => rows.push({ e, d }), task: async () => {} };\n const r1 = await onDeliveryStatus(\"c1\", state.c1, \"undelivered\", fx);\n eq(r1.stop, true, \"the pass carried on and sent the next step anyway\");\n eq(failCount(r1.s), 1, \"an undelivered message did not count as a failure\");\n eq(r1.s.lastMessageId, null, \"the id survived, so the same failure is counted again every pass\");\n eq(r1.s.lastDeliveryStatus, \"undelivered\");\n // second pass with nothing to reconcile: no double count\n eq(await onDeliveryStatus(\"c1\", r1.s, null, fx), null, \"a pass with nothing to reconcile still did something\");\n // a good delivery clears the id and counts nothing\n const ok2 = await onDeliveryStatus(\"c1\", { ...dueSms(), lastMessageId: \"x\" }, \"delivered\", fx);\n eq(ok2.stop, false);\n eq(failCount(ok2.s), 0);\n eq(ok2.s.lastMessageId, null);\n // unknown is recorded AND surfaced, not quietly treated as success\n const unk = await onDeliveryStatus(\"c1\", { ...dueSms(), lastMessageId: \"x\" }, \"unknown\", fx);\n eq(unk.s.lastDeliveryStatus, \"unknown\");\n eq(unk.stop, false, \"an unreadable status stopped a healthy contact\");\n ok(rows.some((r) => r.e === \"delivery_unknown\"), \"an unreadable delivery status is invisible to everyone\");\n return scoped(11, \"assertions\");\n});\n\nheader(\"THE COUNTS THE SUMMARY NEVER HAD\");\n\nt(\"DL-15 buildSummary now counts what it used to journal and drop on the floor\", () => {\n const j = [\n { event: \"sent\", detail: \"main#1 (email)\" },\n { event: \"send_failed\", detail: \"main#2: 422\" },\n { event: \"send_failed\", detail: \"main#2: 422\" },\n { event: \"dead_letter\", detail: \"main#2 failed 3x\" },\n { event: \"delivery_failed\", detail: \"undelivered (attempt 1 of 3)\" },\n { event: \"delivery_unknown\", detail: \"could not read\" },\n { event: \"enroll_refused\", detail: \"no email address and no phone number on the record\" },\n { event: \"enroll_refused\", detail: \"already a customer\" },\n ];\n const c = failureCounts(j, { done_unreachable: 5, main: 12 });\n eq(c.sendFailures, 2);\n eq(c.deadLettered, 1);\n eq(c.deliveryFailed, 1);\n eq(c.deliveryUnknown, 1);\n // A STANDING COUNT off state, not a running total: refusal at enrolment writes a done_unreachable\n // entry, so counting the journal row too would report every refused contact twice.\n eq(c.unreachable, 5, \"the standing unreachable count is not reaching the summary\");\n eq(failureCounts(j, {}).unreachable, 0, \"enroll_refused rows are being double-counted from the journal\");\n eq(failureCounts([], {}).sendFailures, 0);\n const src = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n ok(/\\.\\.\\.failureCounts\$journal, byStatus\$/.test(src), \"buildSummary stopped publishing the counts\");\n return scoped(8, \"counts\");\n});\n\nheader(\"A DEAD LETTER THAT CAN COME BACK, AND A REFUSAL THAT IS WRITTEN ONCE\");\n\nt(\"DL-16 only a dead letter comes back, and only when the reason stopped being true\", () => {\n const has = { email: \"a@b.c\", phone: \"+15550001111\" };\n const none = { email: null, phone: null };\n const phoneOnly = { email: null, phone: \"+15550001111\" };\n // the two that may\n ok(reEnrollable({ status: \"done_send_failed\" }, has), \"a fixed dead letter still cannot come back\");\n ok(reEnrollable({ status: \"done_unreachable\" }, phoneOnly), \"a number was added and nothing happened\");\n // the five that may NOT, each for its own reason\n ok(!reEnrollable({ status: \"done_customer\" }, has), \"a re-tag resurrected a CUSTOMER\");\n ok(!reEnrollable({ status: \"done_hard_exit\" }, has), \"a re-tag undid an OPT-OUT — the one thing a tag must never do\");\n ok(!reEnrollable({ status: \"done_booked\" }, has), \"a re-tag re-nurtured somebody who booked\");\n ok(!reEnrollable({ status: \"done_branch_complete\" }, has), \"a completed branch was restarted by a tag\");\n ok(!reEnrollable({ status: \"main\" }, has), \"a contact already mid-sequence was re-enrolled from the top\");\n ok(!reEnrollable({ status: \"done_not_enrolled\" }, has), \"a contact refused at enrolment is resurrected by a re-tag\");\n // THE LOOP GUARD. Still no email and no phone = nothing was fixed. Re-admitting them would refuse\n // them again on every single run, which is the journal-eating defect wearing a different hat.\n ok(!reEnrollable({ status: \"done_unreachable\" }, none), \"an unreachable contact is re-admitted and will be re-refused forever\");\n ok(!reEnrollable({ status: \"done_send_failed\" }, none), \"same, on the other dead-letter status\");\n ok(!reEnrollable(null, has) && !reEnrollable(undefined, has), \"a contact with no state at all is not a 'dead letter'\");\n eq(DEAD_LETTER_STATUSES.length, 2, \"the dead-letter set changed; reEnrollable's blast radius changed with it\");\n return scoped(13, \"state/contact pairs\");\n});\n\nt(\"DL-17 a transient refusal is journalled once, and the journal is what remembers it\", () => {\n const J = [\n { contactId: \"a\", event: \"enroll_refused\", detail: \"live booking already exists\" },\n { contactId: \"b\", event: \"enrolled\", detail: \"via tag\" },\n { contactId: \"c\", event: \"enroll_refused\", detail: \"already a customer\" },\n ];\n ok(refusedBefore(J, \"a\", \"live booking already exists\"), \"the repeat guard cannot see its own row\");\n ok(!refusedBefore(J, \"b\", \"live booking already exists\"), \"a different contact's refusal was matched\");\n ok(!refusedBefore(J, \"a\", \"already a customer\"), \"a different REASON was matched, so a new refusal would be silent\");\n ok(!refusedBefore(J, \"c\", \"live booking already exists\"));\n ok(!refusedBefore([], \"a\", \"live booking already exists\"), \"an empty journal reads as already-refused\");\n ok(!refusedBefore(null, \"a\", \"x\") && !refusedBefore(undefined, \"a\", \"x\"), \"a missing journal throws instead of returning false\");\n return scoped(7, \"journal lookups\");\n});\n\nt(\"DL-18 the task tells Kim something that is actually true now\", () => {\n // The shipped sentence read \"...remove the puppy-path-v1 tag and re-tag them\", which produced zero\n // candidates: the state entry, not the tag, was what excluded them. The words and the behaviour are\n // the same fix, so the words are pinned here too.\n const body = deadLetterBody(\"a text message\", 3, \"422 invalid phone\");\n ok(/remove the puppy-path-v1 tag/.test(body), \"the instruction that actually works is no longer given\");\n ok(/fix the contact details first/i.test(body), \"she is not told the details must be fixed FIRST\");\n ok(/no phone number and no email address/i.test(body), \"the case where re-tagging does nothing is not stated\");\n ok(!/^(?!.*fix).*re-tag them\\.$/m.test(body), \"the old bare 're-tag them' sentence is back\");\n ok(body.length > 400 && body.length < 1400, `task body is ${body.length} chars`);\n return scoped(5, \"sentences\");\n});\n\nawait done();\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",{"_36":89,"_11":90,"_23":29,"_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":33,"_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"]