[{"_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.part20.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.part20.txt","extension","txt","id","6e0e4e26-080a-4d27-8f66-437b0767b9ba","fileId","b95e909c-967c-11f1-a0d0-1607ee4eb77e","parentId","branchId","551774fb-a850-4c9d-94a1-d3509ddcf1b0","branchVersion",1189,"latest",true,"createdAt",["D",1786982918913],"version",8,"fileType","content","THE DOGS SPOT — SOURCE BUNDLE (part 20 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 tests/deposits-collect.test.mjs 52788 bytes 1b89f68ae732\n tests/detect.test.mjs 18977 bytes 972a2f2616f8\n\n================================================================================================\n=====FILE tests/deposits-collect.test.mjs =====\n// THE COLLECTOR. The only part of the deposit feature that touches Kim's CRM.\n//\n// Everything here is run against fixtures with a fake `get`, which is the point: the collector\n// takes its network as an argument, so the failure modes that matter — a calendar that does not\n// answer, a notes read that fails, a customer who appears on both calendars — can be produced on\n// demand instead of waited for.\nimport * as D from \"../build/deposits.js\";\nimport { readFileSync } from \"node:fs\";\nimport { suite, ok, eq, scoped, codeOnly } from \"./_harness.mjs\";\n\nconst { t, at, done, header } = suite(\"deposits-collect\");\n\nconst src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\nconst TODAY = \"2026-08-06T12:00:00.000Z\";\n\n// Real rows, trimmed: the recurring Daycare Enzo series, the cancelled test booking, and one\n// customer with three dogs on 25 November.\nconst EV = {\n wS5N8WN4BbzznaLjEg1N: [\n { contactId: \"c-enzo\", title: \"Daycare Enzo \", startTime: \"2026-11-27T09:00:00-05:00\", dateAdded: \"2026-06-01 10:00:00\", appointmentStatus: \"confirmed\", isRecurring: true },\n { contactId: \"c-muss\", title: \"Achilles — Boarding Drop Off\", startTime: \"2026-11-25T09:00:00-05:00\", dateAdded: \"2026-07-20 14:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n { contactId: \"c-muss\", title: \"Ghost — Boarding Drop Off\", startTime: \"2026-11-25T09:00:00-05:00\", dateAdded: \"2026-07-20 14:01:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ],\n ZmmjQJszkRMUltfEbumB: [\n { contactId: \"c-test\", title: \" Boarding Dropoff with Help Test\", startTime: \"2026-12-24T09:00:00-05:00\", dateAdded: \"2026-10-01 10:00:00\", appointmentStatus: \"cancelled\", isRecurring: false },\n { contactId: \"c-flu\", title: \"Fluffy — Boarding Drop Off\", startTime: \"2027-01-01T09:00:00-05:00\", dateAdded: \"2026-08-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ],\n};\nconst NOTES = {\n \"c-muss\": [{ body: \"[Square] +$100.00 payment pay_muss (balance $0.00)\", dateAdded: \"2026-07-20T10:00:00.000Z\" }],\n \"c-flu\": [],\n};\nconst NAMES = { \"c-muss\": { firstName: \"Jeffrey\", lastName: \"Musselwhite\" }, \"c-flu\": { firstName: \"Ann\", lastName: \"Flu\" } };\n\n// A fake CRM. `fail` names the paths that should blow up, so each failure mode is one line.\nfunction io(opts = {}) {\n const calls = [];\n const get = async (path) => {\n calls.push(path);\n // A trailing \"$\" means \"this exact path ending\", so a test can break the name lookup for a\n // contact without also breaking that contact's notes read. Without it D9 would be failing two\n // things and proving neither.\n for (const f of opts.fail ?? []) {\n const hit = f.endsWith(\"$\") ? path.endsWith(f.slice(0, -1)) : path.includes(f);\n if (hit) throw new Error(\"HTTP 500\");\n }\n const cal = /calendarId=([^&]+)/.exec(path);\n if (cal) return { events: EV[cal[1]] ?? [] };\n const notes = /\\/contacts\\/([^/]+)\\/notes/.exec(path);\n if (notes) return { notes: NOTES[notes[1]] ?? [] };\n const c = /\\/contacts\\/([^/?]+)$/.exec(path);\n if (c) return { contact: NAMES[c[1]] ?? {} };\n throw new Error(`unexpected path ${path}`);\n };\n return { get, calls };\n}\n\nheader(\"THE HAPPY PATH\");\n\nawait at(\"D1 both drop-off calendars are asked, not just the one somebody remembers\", async () => {\n // One real customer has bookings on BOTH calendars. Reading one calendar loses half the list.\n const f = io();\n const out = await D.collect(f, TODAY);\n for (const id of [\"wS5N8WN4BbzznaLjEg1N\", \"ZmmjQJszkRMUltfEbumB\"]) {\n ok(f.calls.some((p) => p.includes(`calendarId=${id}`)), `drop-off calendar ${id} was never asked`);\n }\n eq(out.calendarsRead, 2);\n // And the pick-up calendars, which are where the LENGTH of a stay is written down.\n for (const id of [\"1FnbK7pQp1ViZWIzX9SR\", \"bN6wWGJa0qKq0QGRg4CC\"]) {\n ok(f.calls.some((p) => p.includes(`calendarId=${id}`)), `pick-up calendar ${id} was never asked`);\n }\n eq(out.pickupsRead, 2);\n return scoped(4, \"calendars\");\n});\n\nawait at(\"D2 the recurring slot and the cancelled booking never reach Kim's list\", async () => {\n const out = await D.collect(io(), TODAY);\n ok(!out.rows.some((r) => r.contactId === \"c-enzo\"), \"the recurring Daycare slot was listed as a holiday stay\");\n ok(!out.rows.some((r) => r.contactId === \"c-test\"), \"a cancelled booking was listed\");\n eq(out.rows.length, 2, \"the list is not the two real stays\");\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D3 one customer's two dogs are one row, with the customer's name on it\", async () => {\n const out = await D.collect(io(), TODAY);\n const m = out.rows.filter((r) => r.contactId === \"c-muss\");\n eq(m.length, 1);\n eq(m[0].dogs.sort(), [\"Achilles\", \"Ghost\"]);\n eq(m[0].name, \"Jeffrey Musselwhite\");\n // Two dogs at $50 each is $100, and $100 is exactly what is on file, so this stay IS settled.\n // Kim's own money page: \"Holiday boarding — $50 per dog, non-refundable.\"\n eq(m[0].state, \"seen\", \"a payment for exactly the amount due for two dogs did not settle the stay\");\n ok(/2 dogs/.test(m[0].note), `the note does not say how the amount was worked out: ${m[0].note}`);\n return scoped(1, \"row\");\n});\n\nawait at(\"D4 a customer with no payment is worth checking, not accused\", async () => {\n const out = await D.collect(io(), TODAY);\n const f = out.rows.find((r) => r.contactId === \"c-flu\");\n eq(f.state, \"none_seen\");\n ok(/Venmo, Zelle or a cheque/i.test(f.note), \"the other ways of paying are not mentioned\");\n ok(!/\\bcash\\b/i.test(f.note), \"cash is offered as a place to look, and it is not one of her routes\");\n ok(!/unpaid|owes|has not paid/i.test(out.sentence + f.note), \"Kim is being handed an accusation\");\n return scoped(1, \"row\");\n});\n\nawait at(\"D5 each customer is looked up once however many dogs they bring\", async () => {\n // Three dogs is three calendar rows and must not be three CRM lookups: her account is rate\n // limited and this job runs unattended.\n const f = io();\n await D.collect(f, TODAY);\n eq(f.calls.filter((p) => p.includes(\"/notes\")).length, 2, \"notes were fetched more than once per customer\");\n return scoped(2, \"note reads\");\n});\n\nheader(\"WHEN HER CRM MISBEHAVES\");\n\nawait at(\"D6 a notes read that fails stays unknown all the way to the screen\", async () => {\n // THE ONE THAT MATTERS. A 500 on a notes read must not become \"this person has not paid\".\n const out = await D.collect(io({ fail: [\"/notes\"] }), TODAY);\n eq(out.readFailures, 2);\n ok(out.rows.every((r) => r.state === \"could_not_check\"), \"a failed read was reported as a finding\");\n ok(!/unpaid|owes|has not paid/i.test(out.rows.map((r) => r.note).join(\" \")), \"a failed read was worded as non-payment\");\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D7 failed reads do not masquerade as a dead payment feed\", async () => {\n // feedLooksDead() means \"we read everybody and saw no money anywhere\". Counting failures as\n // empty payment lists would trip the kill switch for the wrong reason and hide a real list.\n const out = await D.collect(io({ fail: [\"/notes\"] }), TODAY);\n eq(out.feedDead, false, \"failed reads tripped the dead-feed switch\");\n return scoped(1, \"run\");\n});\n\nawait at(\"D8 a calendar that does not answer is reported, not counted as no bookings\", async () => {\n const out = await D.collect(io({ fail: [\"ZmmjQJszkRMUltfEbumB\"] }), TODAY);\n eq(out.calendarsRead, 1);\n eq(out.calendarsAsked, 2);\n ok(!out.rows.some((r) => r.contactId === \"c-flu\"), \"an unread calendar produced rows anyway\");\n return scoped(1, \"failed calendar\");\n});\n\nawait at(\"D9 a name that cannot be read says so rather than showing an empty row\", async () => {\n const out = await D.collect(io({ fail: [\"/contacts/c-flu$\"] }), TODAY);\n const f = out.rows.find((r) => r.contactId === \"c-flu\");\n ok(f, \"the row vanished because the name lookup failed\");\n ok(f.name.length > 0, \"the row has a blank name, which reads as a bug rather than as a fact\");\n return scoped(1, \"row\");\n});\n\nawait at(\"D10 nothing booked reads as nothing to do\", async () => {\n const empty = { get: async (p) => (p.includes(\"calendarId=\") ? { events: [] } : { notes: [] }) };\n const out = await D.collect(empty, TODAY);\n eq(out.rows.length, 0);\n ok(/nothing to check/i.test(out.sentence), \"an empty holiday season is not described plainly\");\n return scoped(1, \"empty season\");\n});\n\nawait at(\"D19 a stay that boards over Christmas is found from its pick-up, not its drop-off\", async () => {\n // REAL SHAPE: a drop-off appointment is a ten minute handover slot, so its own endTime says\n // nothing about how long the dog stays. Ghost and Chewy really do drop off on 25 November and\n // get collected on the 28th, and only the pick-up calendar knows that. A customer who leaves\n // the day before Christmas week starts was invisible until this.\n const drop = [{ contactId: \"c-xmas\", title: \"Rex — Boarding Drop Off\", startTime: \"2026-12-18T09:00:00-05:00\",\n endTime: \"2026-12-18T09:10:00-05:00\", dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false }];\n const pick = [{ contactId: \"c-xmas\", title: \"Rex — Boarding Pick Up\", startTime: \"2026-12-27T09:00:00-05:00\",\n endTime: \"2026-12-27T09:10:00-05:00\", appointmentStatus: \"confirmed\", isRecurring: false }];\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: drop };\n if (p.includes(\"calendarId=1Fnb\")) return { events: pick };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: [] };\n return { contact: { firstName: \"X\", lastName: \"Mas\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 1, \"a dog boarding across Christmas was invisible because it arrived on the 18th\");\n eq(out.rows[0].day, \"2026-12-18\");\n eq(out.rows[0].until, \"2026-12-27\", \"the stay was recorded as one day long\");\n eq(out.rows[0].window, \"Christmas and New Year\");\n // And without the pick-up calendar it correctly falls back to being invisible rather than wrong.\n const noPick = { get: async (p) => (p.includes(\"calendarId=wS5N\") ? { events: drop } : p.includes(\"calendarId=\") ? { events: [] } : p.includes(\"/notes\") ? { notes: [] } : { contact: {} }) };\n eq((await D.collect(noPick, TODAY)).rows.length, 0);\n return scoped(2, \"stays\");\n});\n\nheader(\"SHAPES THAT USED TO READ AS FINDINGS\");\n\nawait at(\"D13 a 200 with no notes list is unknown, not 'no payment found'\", async () => {\n // A rate-limit soft-fail, a partial payload or a changed response shape all arrive as a 200.\n // Only a THROWN error used to reach could_not_check; anything else rendered as a confident\n // \"No Square payment is on file\" about a customer whose notes were never actually read.\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=\")) return { events: EV[/calendarId=([^&]+)/.exec(p)[1]] ?? [] };\n if (p.includes(\"/notes\")) return {}; // 200, no notes key\n return { contact: { firstName: \"A\", lastName: \"B\" } };\n } };\n const out = await D.collect(io2, TODAY);\n ok(out.rows.length > 0, \"no rows, so this check inspected nothing\");\n ok(out.rows.every((r) => r.state === \"could_not_check\"), \"a 200 without a notes list rendered as a finding about a customer\");\n eq(out.readFailures, 2);\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D14 a 200 with no events list is a calendar that did not answer\", async () => {\n // [was: `d?.events ?? []`. A renamed key or a stale calendarId counted as \"read, and she has no\n // bookings\" — and runCollection would then STORE that empty list over a good one.]\n const io2 = { get: async (p) => (p.includes(\"calendarId=\") ? { ok: true } : { notes: [] }) };\n const out = await D.collect(io2, TODAY);\n eq(out.calendarsRead, 0, \"a response with no events list counted as a calendar successfully read\");\n eq(out.rows.length, 0);\n return scoped(2, \"calendars\");\n});\n\nawait at(\"D15 the notes endpoint is asked exactly the way it will answer\", async () => {\n // HER CRM 422s ON ANY QUERY PARAMETER HERE. A version of this that asked for ?limit=100 shipped\n // and turned every single customer into a failed read; it was caught by running it against her\n // account, not by this suite, because the fixture answered a URL the real CRM refuses.\n const seen = [];\n const io2 = { get: async (p) => {\n seen.push(p);\n if (p.includes(\"calendarId=\")) return { events: EV[/calendarId=([^&]+)/.exec(p)[1]] ?? [] };\n if (p.includes(\"/notes\")) {\n if (p.includes(\"?\")) throw new Error(\"HTTP 422 property limit should not exist\");\n return { notes: NOTES[/\\/contacts\\/([^/]+)\\/notes/.exec(p)[1]] ?? [] };\n }\n return { contact: NAMES[/\\/contacts\\/([^/?]+)$/.exec(p)[1]] ?? {} };\n } };\n const out = await D.collect(io2, TODAY);\n const noteCalls = seen.filter((p) => p.includes(\"/notes\"));\n ok(noteCalls.length > 0, \"no notes call was made, so this check inspected nothing\");\n ok(noteCalls.every((p) => !p.includes(\"?\")), `a query string was sent to an endpoint that rejects them: ${noteCalls[0]}`);\n eq(out.readFailures, 0, \"the notes reads failed\");\n return scoped(noteCalls.length, \"notes calls\");\n});\n\nawait at(\"D16 a notes list at the cap is unknown, not a short list\", async () => {\n // The endpoint takes no paging parameters, so a response at the cap could be complete or could\n // be the first hundred of three hundred. There is no way to tell, and a customer we cannot read\n // must not be reported as a customer with no payment.\n const full = Array.from({ length: 100 }, (_, i) => ({ body: `note ${i}`, dateAdded: \"2026-05-01T00:00:00Z\" }));\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=\")) return { events: EV[/calendarId=([^&]+)/.exec(p)[1]] ?? [] };\n if (p.includes(\"/notes\")) return { notes: full };\n return { contact: { firstName: \"A\", lastName: \"B\" } };\n } };\n const out = await D.collect(io2, TODAY);\n ok(out.rows.every((r) => r.state === \"could_not_check\"), \"a list we cannot prove is complete was reported as a finding\");\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D17 the dead-feed switch looks at this period, not at everything the customer ever paid\", async () => {\n // THE DEFENCE THAT WAS INERT. It compared each customer's WHOLE payment history, so any\n // customer with an old Square note kept it quiet — including the one customer in her account\n // who has Square notes. It could only ever have fired for people who had never paid by card.\n const old = [{ body: \"[Square] +$355.00 payment older (balance $0.00)\", dateAdded: \"2026-01-15T00:00:00.000Z\" }];\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=\")) return { events: EV[/calendarId=([^&]+)/.exec(p)[1]] ?? [] };\n if (p.includes(\"/notes\")) return { notes: old };\n return { contact: { firstName: \"A\", lastName: \"B\" } };\n } };\n const out = await D.collect(io2, TODAY);\n // 2 customers is below the sample floor, so the switch correctly stays quiet here; what this\n // proves is that the OLD payment is not being counted as money seen in this period.\n ok(out.rows.every((r) => r.state === \"none_seen\"), \"a January payment settled a November deposit\");\n ok(out.rows.every((r) => !/other card payment/i.test(r.note)),\n \"a payment six months before the booking was offered to Kim as relevant to this deposit\");\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D18 five quiet customers with old payments still trip the dead-feed switch\", async () => {\n // THE SCOPING THAT MAKES THE SWITCH REAL. Every one of these customers has paid Kim by card\n // before, and none of them has paid anything around the time they booked. That is what a\n // stopped payment feed looks like. Comparing whole payment histories instead would find money\n // on every customer and stay silent through the entire outage.\n const evs = Array.from({ length: 6 }, (_, i) => ({\n contactId: `q${i}`, title: `Dog${i} — Boarding Drop Off`, startTime: \"2026-11-25T09:00:00-05:00\",\n endTime: \"2026-11-27T09:00:00-05:00\", dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false,\n }));\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=\")) return { events: p.includes(\"wS5N\") ? evs : [] };\n if (p.includes(\"/notes\")) return { notes: [{ body: \"[Square] +$200.00 payment old\" + p.slice(-3) + \" (balance $0.00)\", dateAdded: \"2026-02-01T00:00:00.000Z\" }] };\n return { contact: { firstName: \"Q\", lastName: \"Customer\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 6);\n ok(out.feedDead, \"six customers with no payment around their bookings did not trip the dead-feed switch\");\n ok(/payment feed has stopped/.test(out.sentence));\n return scoped(out.rows.length, \"customers\");\n});\n\nawait at(\"D20 one regular with five holiday bookings does not look like a payment outage\", async () => {\n // Her account has a contact with 24 drop-offs. If the kill switch counted BOOKINGS, that one\n // customer paying cash would clear the five-customer floor on their own and suppress the whole\n // card for everybody.\n const evs = [\"23\", \"25\", \"27\"].map((d) => ({\n contactId: \"regular\", title: `Dog${d} — Boarding Drop Off`, startTime: `2026-11-${d}T09:00:00-05:00`,\n dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false,\n })).concat([\"21\", \"28\"].map((d) => ({\n contactId: \"regular\", title: `Dog${d} — Boarding Drop Off`, startTime: `2026-12-${d}T09:00:00-05:00`,\n dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false,\n })));\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: evs };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: [] };\n return { contact: { firstName: \"One\", lastName: \"Regular\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 5, \"the five bookings were not all found, so this check proves nothing\");\n ok(!out.feedDead, \"one customer's five cash-paid bookings were read as her payment system being down\");\n return scoped(out.rows.length, \"bookings for one customer\");\n});\n\nawait at(\"D21 a run where nobody's payments could be read is not stored over a good list\", async () => {\n // The calendars answered, so the empty-collection guard lets it through, and the blob would be\n // replaced by a page of \"could not check\" WITH A FRESH TIMESTAMP: the content gets worse while\n // the page claims to have just been updated. Yesterday's real shortlist is more use than that.\n // codeOnly, not the raw file: a control deleted this guard and left a [was: ...] note\n // quoting it, and the check stayed green on my own explanation of the bug.\n const src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n const guard = src.indexOf('every((r) => r.state === \"could_not_check\")');\n ok(guard > -1, \"there is no guard against storing a collection in which nothing could be checked\");\n ok(guard < src.indexOf(\"setJSON\"), \"the guard does not actually stop the write\");\n // And the collection itself really does produce that shape, so the guard has something to catch.\n const out = await D.collect(io({ fail: [\"/notes\"] }), TODAY);\n ok(out.rows.length > 0 && out.rows.every((r) => r.state === \"could_not_check\"),\n \"the all-unknown case cannot be produced, so the guard is guarding nothing\");\n return scoped(out.rows.length, \"rows\");\n});\n\nawait at(\"D22 a booking with no date does not black out the whole card\", async () => {\n // paymentsNearStay returns a STRUCTURAL empty for a stay with no booking date. Counting that as\n // \"we looked and saw no money\" let one missing field push the sample over the dead-feed floor\n // and suppress the entire list, including a customer whose $50 had been read successfully.\n const evs = [0, 1, 2, 3].map((i) => ({\n contactId: `c${i}`, title: `Dog${i} — Boarding Drop Off`, startTime: \"2026-11-25T09:00:00-05:00\",\n dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false,\n }));\n // The fifth has NO dateAdded, and does have a readable payment.\n evs.push({ contactId: \"c4\", title: \"Dog4 — Boarding Drop Off\", startTime: \"2026-11-25T09:00:00-05:00\",\n appointmentStatus: \"confirmed\", isRecurring: false });\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: evs };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: p.includes(\"c4\") ? [{ body: \"[Square] +$50.00 payment f (balance $0.00)\", dateAdded: \"2026-10-05T00:00:00Z\" }] : [] };\n return { contact: { firstName: \"A\", lastName: \"B\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 5);\n ok(!out.feedDead, \"one booking with a missing date took the whole deposit list off Kim's page\");\n return scoped(out.rows.length, \"stays\");\n});\n\nawait at(\"D23 collecting one dog and boarding another on the same day keeps both stays\", async () => {\n // Real shape: a customer collects on 27 December and re-boards the same day. With a strict\n // \"before the next drop-off\" bound the first stay lost its pick-up, shrank to a single day,\n // stopped overlapping Christmas and vanished — the busiest stay of the season, silently.\n const drops = [\"18\", \"27\"].map((d) => ({\n contactId: \"mia\", title: `Dog — Boarding Drop Off`, startTime: `2026-12-${d}T09:00:00-05:00`,\n dateAdded: \"2026-10-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false }));\n const picks = [\n { contactId: \"mia\", title: \"Dog — Boarding Pick Up\", startTime: \"2026-12-27T09:00:00-05:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n { contactId: \"mia\", title: \"Dog — Boarding Pick Up\", startTime: \"2027-01-03T09:00:00-05:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ];\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: drops };\n if (p.includes(\"calendarId=1Fnb\")) return { events: picks };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: [] };\n return { contact: { firstName: \"Mia\", lastName: \"Reyes\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 2, \"the stay running through Christmas disappeared because its pick-up day was also the next drop-off day\");\n eq(out.rows[0].day, \"2026-12-18\");\n eq(out.rows[0].until, \"2026-12-27\", \"the first stay did not get the pick-up that ends it\");\n return scoped(2, \"stays\");\n});\n\nawait at(\"D24 the collector asks for the period it actually needs, at both ends\", async () => {\n // NOTHING IN 270 ASSERTIONS COULD SEE WHAT PERIOD WAS BEING ASKED FOR. LOOKBACK_DAYS and\n // LOOKAHEAD_DAYS could both be set to zero with no test moving, which is exactly how the\n // drop-off range came to stop short of the pick-up range and blind the next-booking bound for\n // every stay at the end of the season.\n const asked = [];\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=\")) { asked.push(p); return { events: [] }; }\n if (p.includes(\"/notes\")) return { notes: [] };\n return { contact: {} };\n } };\n await D.collect(io2, TODAY);\n const range = (p) => {\n const st = Number(/startTime=(\\d+)/.exec(p)[1]), en = Number(/endTime=(\\d+)/.exec(p)[1]);\n return [new Date(st).toISOString().slice(0, 10), new Date(en).toISOString().slice(0, 10)];\n };\n const drops = asked.filter((p) => /calendarId=(wS5N|Zmmj)/.test(p)).map(range);\n const picks = asked.filter((p) => /calendarId=(1Fnb|bN6w)/.test(p)).map(range);\n ok(drops.length === 2 && picks.length === 2, \"not every calendar was asked, so this check proves nothing\");\n // Reaches BACK before the first window: a stay can start before a holiday and run into it.\n ok(drops.every(([f]) => f < \"2026-11-23\"), `the drop-off query starts inside the window: ${drops[0]}`);\n // Reaches FORWARD past the last window, on BOTH kinds of calendar: the pick-up that ends a New\n // Year stay is in January, and so is the next booking that bounds it.\n ok(picks.every(([, t]) => t > \"2027-01-02\"), `the pick-up query stops at the window edge: ${picks[0]}`);\n ok(drops.every(([, t]) => t > \"2027-01-02\"),\n `the drop-off query stops at the window edge, so a New Year stay has no next booking to bound it: ${drops[0]}`);\n return scoped(4, \"calendar queries\");\n});\n\nawait at(\"D25 a New Year stay does not swallow the next booking's pick-up\", async () => {\n // The consequence of D24's range mismatch, end to end: the dog went home on 2 January and the\n // card said \"Dec 30 to Jan 15\", which also stretched the payment window far enough that a\n // January payment settled the holiday deposit.\n const drops = [\n { contactId: \"ny\", title: \"A — Boarding Drop Off\", startTime: \"2026-12-30T09:00:00-05:00\", dateAdded: \"2026-11-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n { contactId: \"ny\", title: \"A — Boarding Drop Off\", startTime: \"2027-01-10T09:00:00-05:00\", dateAdded: \"2026-11-01 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ];\n const picks = [\n { contactId: \"ny\", title: \"A — Boarding Pick Up\", startTime: \"2027-01-02T09:00:00-05:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n { contactId: \"ny\", title: \"A — Boarding Pick Up\", startTime: \"2027-01-15T09:00:00-05:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ];\n const inRange = (evs, p) => {\n const st = Number(/startTime=(\\d+)/.exec(p)[1]), en = Number(/endTime=(\\d+)/.exec(p)[1]);\n return evs.filter((e) => { const t = Date.parse(e.startTime); return t >= st && t <= en; });\n };\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: inRange(drops, p) };\n if (p.includes(\"calendarId=1Fnb\")) return { events: inRange(picks, p) };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: [{ body: \"[Square] +$50.00 payment jan (balance $0.00)\", dateAdded: \"2027-01-12T00:00:00.000Z\" }] };\n return { contact: { firstName: \"New\", lastName: \"Year\" } };\n } };\n const out = await D.collect(io2, TODAY);\n const ny = out.rows.find((r) => r.day === \"2026-12-30\");\n ok(ny, \"the New Year stay was lost entirely\");\n eq(ny.until, \"2027-01-02\", \"the stay swallowed the pick-up belonging to the 10 January booking\");\n ok(ny.state !== \"seen\", \"a payment made after the dogs went home settled the holiday deposit\");\n return scoped(1, \"stay\");\n});\n\nawait at(\"D26 a season that empties to nothing is held, not written over the real list\", async () => {\n // A renamed calendar answers 200 with an EMPTY events array. That is well formed, so it passes\n // every other guard, and in December it silently replaces her shortlist with \"nothing to check\".\n const src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n ok(/out\\.rows\\.length === 0 && \$prev\\?\\.rows\\?\\.length \\?\\? 0\$ > 0/.test(src),\n \"nothing compares this run against the list already stored\");\n const guard = src.indexOf(\"prev?.rows?.length\");\n ok(guard > -1 && guard < src.indexOf(\"setJSON\"), \"the comparison does not actually stop the write\");\n ok(/force/.test(src), \"there is no way to accept a genuinely empty season\");\n // And the empty-but-well-formed collection really is produced, so the guard has something to catch.\n const io2 = { get: async (p) => (p.includes(\"calendarId=\") ? { events: [] } : p.includes(\"/notes\") ? { notes: [] } : { contact: {} }) };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 0);\n eq(out.calendarsRead, 2, \"an empty-array response should still count as a calendar that answered\");\n return scoped(3, \"guards\");\n});\n\nawait at(\"D27 the collector really does allocate per customer, not stay by stay\", async () => {\n // H48 pins the pure function. NOTHING pinned that the COLLECTOR calls it: reverting one line to\n // `own.map(s => statusFor(s, pays))` put the whole money bug back end to end with 277 assertions\n // still green. This is the end-to-end version, run through collect().\n const drops = [\n { contactId: \"reg\", title: \"Rex — Boarding Drop Off\", startTime: \"2026-11-25T09:00:00-05:00\", dateAdded: \"2026-09-28 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n { contactId: \"reg\", title: \"Rex — Boarding Drop Off\", startTime: \"2026-12-22T09:00:00-05:00\", dateAdded: \"2026-09-28 09:00:00\", appointmentStatus: \"confirmed\", isRecurring: false },\n ];\n const io2 = { get: async (p) => {\n if (p.includes(\"calendarId=wS5N\")) return { events: drops };\n if (p.includes(\"calendarId=\")) return { events: [] };\n if (p.includes(\"/notes\")) return { notes: [{ body: \"[Square] +$50.00 payment onlyfifty (balance $0.00)\", dateAdded: \"2026-10-05T00:00:00Z\" }] };\n return { contact: { firstName: \"One\", lastName: \"Regular\" } };\n } };\n const out = await D.collect(io2, TODAY);\n eq(out.rows.length, 2, \"both bookings should be on the list\");\n eq(out.rows.filter((r) => r.state === \"seen\").length, 1,\n \"one $50 deposit settled both of this customer's holiday stays, so Kim is owed $100 and sees nothing to chase\");\n eq(out.rows[0].state, \"seen\", \"the money should settle the earlier stay\");\n return scoped(2, \"stays\");\n});\n\nawait at(\"D28 a genuinely empty season can be accepted on purpose\", async () => {\n // The renamed-calendar guard holds an empty result back. A season really can empty out, so\n // there has to be a way to say so — and `!force &&` being deleted would make that impossible\n // with nothing noticing.\n const src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n ok(/!force && out\\.rows\\.length === 0/.test(src), \"the empty-season refusal cannot be overridden at all\");\n ok(/runCollection\$force = false, source = \"unknown\"\$/.test(src), \"runCollection takes no force argument\");\n ok(/runCollection\$url\\.searchParams\\.get\\(\"force\"\$ === \"1\", \"endpoint\"\\)/.test(src), \"nothing can actually pass force in\");\n return scoped(3, \"guarantees\");\n});\n\nawait at(\"D29 the refresh gate is a rule that can be tested, not a regex over the engine\", async () => {\n // D29 USED TO BE FOUR VACUOUS ASSERTIONS. It scanned main.ts for the strings \"3600_000\",\n // \"holiday_deposits\", \"runCollection()\" and \"catch\". A sixth adversarial read broke the actual\n // behaviour four different ways and every one stayed green: the comparison flipped so the\n // refresh dies after an hour; the interval multiplied by a thousand so it never runs; the gate\n // pointed at a blob key that does not exist so it runs on EVERY tick; the import pointed at the\n // wrong module so it silently never runs; and the try/catch deleted, satisfied by an unrelated\n // `.catch` 120 characters away. So the rule moved into a pure function and is tested as one.\n eq(D.needsRefresh(null, Date.parse(\"2026-08-06T18:00:00Z\")), true, \"never having collected should refresh\");\n eq(D.needsRefresh(undefined, Date.parse(\"2026-08-06T18:00:00Z\")), true);\n eq(D.needsRefresh(\"not a date\", Date.parse(\"2026-08-06T18:00:00Z\")), true,\n \"an unreadable stamp closed the gate forever instead of opening it\");\n eq(D.needsRefresh(\"2026-08-06T17:59:00Z\", Date.parse(\"2026-08-06T18:00:00Z\")), false, \"it refreshed a minute later\");\n eq(D.needsRefresh(\"2026-08-06T16:59:00Z\", Date.parse(\"2026-08-06T18:00:00Z\")), true, \"an hour-old list was not refreshed\");\n eq(D.needsRefresh(\"2026-08-06T17:00:00Z\", Date.parse(\"2026-08-06T18:00:00Z\")), false, \"exactly an hour is not yet over an hour\");\n eq(D.REFRESH_EVERY_MS, 3_600_000);\n return scoped(7, \"gate decisions\");\n});\n\nawait at(\"D30 the engine calls that rule, and calls it last\", async () => {\n const eng = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n ok(/import\$\"\\.\\/deposits\\.ts\"\$/.test(eng), \"the engine does not import the deposit collector at all\");\n ok(/refreshIfDue\$/.test(eng), \"the engine does not use the shared refresh step\");\n ok(/runCollection\\(false, \"engine\"\$/.test(eng), \"the engine never actually collects, or does not label its runs\");\n ok(/ATTEMPT_KEY/.test(eng), \"the gate reads something other than the attempt stamp, so a failing run retries every tick\");\n const at2 = eng.indexOf(\"runCollection(false, \\\"engine\\\")\");\n const before = eng.slice(Math.max(0, at2 - 700), at2);\n ok(/puppy_run_lock/.test(before) && /saveReport\$out\$/.test(before),\n \"the deposit refresh runs before the follow-up work has finished, saved its report and released its lock\");\n // THE WHOLE BLOCK, EXACTLY. [was: the statement pinned plus \"nothing conditional between the\n // import and it\" — which a tenth review defeated by putting the condition BEFORE the import,\n // and again by wrapping both lines in a function nothing calls. The refresh never fired and\n // 310 assertions stayed green. Pinning one statement can always be routed around; pinning the\n // block cannot. This is deliberately brittle: the block should almost never change, and when\n // it does, changing it here is the point.]\n const BLOCK = [\n \" try {\",\n ' const dep = await import(\"./deposits.ts\");',\n ' await dep.refreshIfDue(() => blob.getJSON(dep.ATTEMPT_KEY) as any, () => dep.runCollection(false, \"engine\"), Date.now());',\n \" } catch (e) { console.log(\\\"deposits refresh skipped\\\", String(e).slice(0, 120)); }\",\n ].join(\"\\n\");\n ok(eng.includes(BLOCK), \"the engine's deposit refresh is not the exact unconditional block it should be\");\n // And it appears ONCE, so a dead copy cannot satisfy the pin while a live conditional one runs.\n eq(eng.split(\"refreshIfDue(\").length - 1, 1, \"the engine has more than one refresh call site\");\n return scoped(8, \"guarantees\")\n});\n\nawait at(\"D31 every one of the four storage refusals is a decision that can be checked\", async () => {\n // [was: three regexes over runCollection's source. runCollection needs val.town's blob module so\n // no test could execute it, and a control that wrapped a guard in `if (false && ...)` left the\n // regex matching and the suite green. The rules live in a pure function now.]\n const good = { at: \"x\", season: 2026, windows: [], sentence: \"\", feedDead: false, readFailures: 0,\n calendarsRead: 2, calendarsAsked: 2, pickupsRead: 2, pickupsAsked: 2,\n rows: [{ contactId: \"a\", name: \"A\", day: \"2026-11-25\", until: \"2026-11-28\", dogs: [], window: \"T\", state: \"none_seen\", amountSeen: 0, note: \"\" }] };\n eq(D.decideStore(good, null).store, true, \"a good collection was refused\");\n eq(D.decideStore({ ...good, calendarsRead: 0 }, null).store, false, \"a run where no calendar answered was stored\");\n const allUnknown = { ...good, rows: good.rows.map((r) => ({ ...r, state: \"could_not_check\" })) };\n eq(D.decideStore(allUnknown, null).store, false, \"a run where nobody could be read was stored over the real list\");\n eq(D.decideStore({ ...good, rows: [] }, good).store, false, \"a run that found nothing overwrote a list that had rows\");\n eq(D.decideStore({ ...good, rows: [] }, good, true).store, true, \"an empty season could not be accepted even on purpose\");\n eq(D.decideStore({ ...good, rows: [] }, null).store, true, \"the very first run on an empty season was refused, so the card never fills in\");\n for (const bad of [{ ...good, calendarsRead: 0 }, allUnknown, { ...good, rows: [] }]) {\n const d = D.decideStore(bad, good);\n ok(d.error && d.error.length > 20, \"a refusal with no reason attached\");\n ok(!/unpaid|owes|has not paid/i.test(d.error), \"a refusal reason that accuses somebody\");\n }\n return scoped(6, \"decisions\");\n});\n\nawait at(\"D32 the collector reads the season on her clock, not on Greenwich\", async () => {\n // H54 pins businessDay in isolation. Nothing pinned that collect() uses it: reverting one call\n // restored the bug with the whole suite green. 8pm ET on 2 January is 3 January in UTC.\n const asked = [];\n const io2 = { get: async (p) => { if (p.includes(\"calendarId=\")) asked.push(p); return p.includes(\"calendarId=\") ? { events: [] } : p.includes(\"/notes\") ? { notes: [] } : { contact: {} }; } };\n const out = await D.collect(io2, \"2027-01-03T01:00:00.000Z\");\n eq(out.season, 2026, \"the season rolled over at 8pm on 2 January, with dogs still in the kennels\");\n ok(out.windows.some((w) => w.name === \"Christmas and New Year\" && w.to === \"2027-01-02\"),\n \"the windows are next year's while this year's stays are still running\");\n return scoped(2, \"windows\");\n});\n\nawait at(\"D33 reading the list reports when it was last ATTEMPTED, and reading does not write\", async () => {\n // \"The list has not moved\" is ambiguous between \"the schedule never tried\" and \"it tried and\n // declined to store\", and those need different fixes. Every observation of the refresh so far\n // has been unable to tell them apart, which is why the wiring has taken all evening to confirm.\n const src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n const read = src.slice(src.indexOf('url.searchParams.get(\"run\") !== \"1\"'), src.indexOf('const r = await runCollection'));\n ok(/lastAttemptAt/.test(read), \"the read route does not report when the refresh last tried\");\n ok(/refreshDueAt/.test(read), \"the read route does not say when the next refresh is due\");\n ok(/getJSON\$ATTEMPT_KEY\$/.test(read), \"the attempt stamp is not read on this route\");\n // AND READING MUST NOT WRITE IT. If a check reset the clock, the check would be the reason the\n // refresh never fired — which is exactly the mistake that made this evening's observations\n // useless: every manual run pushed the gate an hour further out.\n ok(!/setJSON/.test(read), \"the read route writes something, so looking at the list resets the gate\");\n ok(/setJSON\$ATTEMPT_KEY/.test(src.slice(src.indexOf(\"export async function runCollection\"))),\n \"the attempt stamp is never written where the work actually happens\");\n return scoped(5, \"guarantees\");\n});\n\nawait at(\"D34 the refresh records WHICH schedule started it\", async () => {\n // Two schedules can reach runCollection — the engine's interval and deposits-cron.ts — plus a\n // person hitting the endpoint. On 6 August the list refreshed at 20:49:03Z with nobody\n // triggering it: the first autonomous refresh ever observed here, and nothing recorded which of\n // the two did it. \"It works\" and \"which one works\" are different facts, and only one of them\n // tells you what to fix when it stops.\n const src = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n ok(/runCollection\\(force = false, source = \"unknown\"\$/.test(src), \"the refresh does not record who started it\");\n ok(/setJSON\$ATTEMPT_KEY, \\{ at: new Date\\(\$\\.toISOString\$\$, source \\}\\)/.test(src), \"the source is taken and then dropped\");\n ok(/lastAttemptBy/.test(src), \"the source is stored but never reported back\");\n ok(/runCollection\$url\\.searchParams\\.get\\(\"force\"\$ === \"1\", \"endpoint\"\\)/.test(src), \"a manual run is not labelled\");\n const cron = codeOnly(readFileSync(new URL(\"../engine/deposits-cron.ts\", import.meta.url), \"utf8\"));\n ok(/runCollection\$false, \"deposits-cron\"\$/.test(cron), \"the scheduled file does not label its runs\");\n const eng = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n ok(/runCollection\$false, \"engine\"\$/.test(eng), \"the engine does not label its runs\");\n return scoped(6, \"call sites\");\n});\n\nawait at(\"D35 the second scheduled file uses the same gate as the engine\", async () => {\n // It has never been seen firing, but something refreshed the list at 20:49 on 6 August and it is\n // one of the two candidates. Ungated, it would collect on every tick — the exact thing the\n // attempt stamp exists to prevent.\n // BEHAVIOURAL, not a grep. [was: three text checks — that \"needsRefresh(\" appeared, that\n // \"ATTEMPT_KEY\" appeared, and that one came before the other. A mutation that CALLED\n // needsRefresh and threw the answer away, collecting from her CRM on every tick, passed all\n // three. The decision is one shared function now, and this watches it decide.]\n let ran = 0;\n const run = async () => { ran++; return { ok: true }; };\n const fresh = await D.refreshIfDue(async () => ({ at: new Date(Date.now() - 60_000).toISOString() }), run, Date.now());\n eq(fresh.ran, false, \"a list refreshed a minute ago was collected again\");\n const stale = await D.refreshIfDue(async () => ({ at: new Date(Date.now() - 7_200_000).toISOString() }), run, Date.now());\n eq(stale.ran, true, \"a two-hour-old list was not refreshed\");\n const never = await D.refreshIfDue(async () => null, async () => ({ ok: false, error: \"no calendar answered\" }), Date.now());\n eq(never.ran, true, \"a list that has never been collected was not collected\");\n ok(/no calendar answered/.test(never.why), \"a refusal to store is not reported back to whoever asked\");\n eq(ran, 1, \"the gate ran the collection the wrong number of times\");\n // And BOTH schedules go through it, so they cannot drift apart.\n const cron = codeOnly(readFileSync(new URL(\"../engine/deposits-cron.ts\", import.meta.url), \"utf8\"));\n // THE WHOLE STATEMENT, EXACTLY, AND ONLY ONE MENTION OF THE COLLECTOR. [was: a count of\n // \"runCollection(\" plus an ordering regex, which a tenth review defeated three ways: aliasing\n // it (`const always = runCollection`), passing a reader that always returns null so the gate is\n // permanently open, and passing 0 instead of Date.now() so the gate never opens again. All\n // three collected on every tick, or never, with the suite green.]\n const CRON = ' const g = await refreshIfDue(() => blob.getJSON(ATTEMPT_KEY) as any, () => runCollection(false, \"deposits-cron\"), Date.now());';\n ok(cron.includes(CRON), \"the scheduled file's gate is not the exact statement it should be\");\n eq(cron.split(\"runCollection\").length - 1, 2, \"the collector is named somewhere other than the import and the gate\");\n eq(cron.split(\"refreshIfDue\").length - 1, 2, \"the gate is named somewhere other than the import and the call\");\n return scoped(9, \"decisions\");\n});\n\nheader(\"WHAT IT MUST NEVER DO\");\n\nawait at(\"D11 the collector is structurally incapable of changing her account\", async () => {\n // Not a promise in a comment: this is the file that holds the network calls, so it is the file\n // where a write would actually be written.\n ok(!/method:\\s*[\"'`](POST|PUT|PATCH|DELETE)/i.test(src), \"the collector contains a write verb\");\n ok(!/addTag|\\/tags|sendSms|sendEmail|createTask|upsert/.test(src.replace(/BOARDING_CALENDARS/g, \"\")),\n \"the collector reaches something that changes her account\");\n const fetches = src.match(/fetch\$/g) || [];\n eq(fetches.length, 1, \"there is more than one place in this file that can talk to her CRM\");\n ok(/method: \"GET\"/.test(src), \"the single request does not say GET out loud\");\n return scoped(4, \"structural guarantees\");\n});\n\nawait at(\"D12 the refusal to store is wired into the one function that stores\", async () => {\n // [was: two regexes over runCollection's source, which is the weak kind of check this project\n // keeps getting caught by. What the rules DO is tested behaviourally in D31; what is left to\n // check here is that runCollection actually consults them before it writes.]\n const code = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n const decide = code.indexOf(\"decideStore(out, prev, force)\");\n ok(decide > -1, \"runCollection does not consult the storage rules at all\");\n ok(decide < code.lastIndexOf(\"setJSON(BLOB_KEY\"), \"the rules are consulted after the write, which is no guard at all\");\n ok(/if \\(!d\\.store\$ return/.test(code), \"the decision is read and then ignored\");\n return scoped(3, \"guarantees\");\n});\n\nawait at(\"D41 a run that saw fewer calendars than the stored one does not replace it\", async () => {\n // THE SILENT ONE. There are two boarding calendars because a customer can appear on either, and\n // the row list is their union. When one fails — a transient 5xx, a revoked scope, a rename, and\n // there is no retry anywhere in deposits.ts — the partial union passed every other guard and was\n // written straight over the complete one. The customers who only appear on the failed calendar do\n // not become \"could not check\" rows: their bookings were never fetched, so they get no row at\n // all, and vanish off Kim's shortlist under a banner that cannot say who is missing.\n const blob = (o) => ({ at: \"2026-11-01T00:00:00Z\", season: 2026, windows: [], rows: o.rows ?? [{ contactId: \"a\", state: \"none_seen\" }],\n sentence: \"\", feedDead: false, readFailures: 0,\n calendarsRead: o.cr ?? 2, calendarsAsked: o.ca ?? 2, pickupsRead: o.pr ?? 2, pickupsAsked: o.pa ?? 2 });\n const good = blob({});\n eq(D.decideStore(blob({ cr: 1 }), good).store, false, \"a run that read one of two boarding calendars overwrote a complete list\");\n eq(D.decideStore(blob({ pr: 1 }), good).store, false, \"a run that read one of two pick-up calendars overwrote a complete list\");\n eq(D.decideStore(blob({ cr: 1, pr: 1 }), good).store, false, \"a run missing both kinds of calendar overwrote a complete list\");\n ok(/fewer bookings|could not read/.test(D.decideStore(blob({ cr: 1 }), good).error ?? \"\"), \"the refusal does not say why\");\n // NOT a blanket ban on ever storing less. A calendar Kim actually deletes drops `asked` as well\n // as `read`, and that run is complete: 1 of 1 is the whole picture.\n eq(D.decideStore(blob({ cr: 1, ca: 1 }), good).store, true, \"deleting a calendar froze the list permanently\");\n eq(D.decideStore(blob({ cr: 1, ca: 1, pr: 1, pa: 1 }), good).store, true, \"deleting both kinds froze the list permanently\");\n // A run no worse than the stored one still stores, or a degraded list would never recover.\n eq(D.decideStore(blob({ cr: 1 }), blob({ cr: 1 })).store, true, \"a second run with the same calendar still down was refused, so the list can never catch up\");\n eq(D.decideStore(blob({}), blob({ cr: 1 })).store, true, \"a recovered run was refused\");\n // With nothing stored at all, a partial list beats no list: the banner declares it.\n eq(D.decideStore(blob({ cr: 1 }), null).store, true, \"the very first run was refused because one calendar was down, leaving Kim with nothing\");\n // force=1 is Amir's override and must still work.\n eq(D.decideStore(blob({ cr: 1 }), good, true).store, true, \"force=1 no longer overrides\");\n return scoped(10, \"storage decisions\");\n});\n\nawait at(\"D42 both schedules are wired so that the pinned code is actually reachable\", async () => {\n // Ten sabotage routes were walked on 7 August. The existing structural checks caught five. These\n // are the ones they did not: every one leaves every pinned string in place and still switches the\n // refresh off.\n const eng = codeOnly(readFileSync(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\n const cron = codeOnly(readFileSync(new URL(\"../engine/deposits-cron.ts\", import.meta.url), \"utf8\"));\n // 1. The pinned block moved out of the exported function into a dead private one, with a no-op\n // `export default` put back in its place. Substring checks over the whole file stay green.\n // A regex cannot catch this: `export default ... { ... refreshIfDue(` matched straight through\n // a one-line no-op default export into the dead function underneath it. So the body is found\n // by counting braces, which is exact.\n const bodyOf = (src, from) => {\n const open = src.indexOf(\"{\", from);\n if (open < 0) return \"\";\n let depth = 0;\n for (let i = open; i < src.length; i++) {\n if (src[i] === \"{\") depth++;\n else if (src[i] === \"}\" && --depth === 0) return src.slice(open, i + 1);\n }\n return \"\";\n };\n const exported = bodyOf(cron, cron.indexOf(\"export default\"));\n ok(exported.length > 100, \"the scheduled file's default export has no body worth speaking of, so this check is blind\");\n ok(exported.includes(\"refreshIfDue(\"),\n \"the refresh call is not inside the scheduled file's own default export, so val.town's tick never reaches it\");\n // 2. An unconditional early `return` inserted BEFORE the block, leaving the block untouched.\n // TypeScript does not error on unreachable code by default, so typecheck.mjs misses it too.\n // Anchored at the LAST saveReport, not at the top of the run: the run lock legitimately\n // returns early on a tick where another run is already active, and that tick is meant to skip.\n const engBetween = eng.slice(eng.lastIndexOf(\"saveReport(out)\"), eng.indexOf('runCollection(false, \"engine\")'));\n ok(eng.includes(\"saveReport(out)\") && engBetween.length < 600, \"the refresh has drifted away from the end of the run, so this check no longer knows what it is measuring\");\n ok(!/\\breturn\\b/.test(engBetween), \"a return sits between the end of the run and the deposit refresh, which skips it forever with its code left intact\");\n const cronBetween = cron.slice(cron.indexOf(\"export default async function\"), cron.indexOf(\"refreshIfDue(\"));\n ok(cronBetween.length > 20, \"the cron's refresh call was not found, so this check is blind\");\n ok(!/^\\s*return[\\s;]/m.test(cronBetween), \"an early return silently disables the scheduled file while every pinned string stays intact\");\n // 3. The val TYPE. A file deployed as \"script\" instead of \"interval\" never fires at all, and\n // nothing in tests/ read scripts/deploy.mjs before this.\n const deploy = readFileSync(new URL(\"../scripts/deploy.mjs\", import.meta.url), \"utf8\");\n ok(/\"deposits-cron\\.ts\":\\s*\"interval\"/.test(deploy), \"deposits-cron.ts is no longer deployed as a val.town interval, so it never runs\");\n ok(/\"main\\.ts\":\\s*\"interval\"/.test(deploy), \"main.ts is no longer deployed as a val.town interval\");\n return scoped(9, \"sabotage routes\");\n});\n\nawait at(\"D43 the refresh gate is claimed before the work, not after it\", async () => {\n // Two schedules can reach runCollection: the engine's own interval and deposits-cron. refreshIfDue\n // is read-then-act, and val.town's blob store has no compare-and-set, so this CANNOT be made\n // atomic. What it can be, and is, is claimed early: runCollection writes the attempt stamp as its\n // first await, BEFORE the credential, the calendars and the notes. So a tick arriving at any\n // point after that write is gated, and the window in which two ticks can both collect is one\n // blob write wide rather than one whole collection wide.\n //\n // Stated exactly that way because it is what was actually observed. Two callers that read the\n // stamp in the same millisecond DO both collect; that costs a duplicate read-only pass over her\n // CRM and nothing else, since this path cannot write to a customer record. The schedules are\n // hourly and fire on different offsets. This test pins the guarantee that holds, and does not\n // pretend to the one that does not.\n let stamp = { at: new Date(Date.now() - 7_200_000).toISOString() };\n let collections = 0, claimed = 0;\n const readStamp = async () => stamp;\n const run = async () => {\n stamp = { at: new Date().toISOString() }; // runCollection's real first await\n claimed++;\n await new Promise((r) => setTimeout(r, 10)); // the network round trip it stands in for\n collections++;\n return { ok: true };\n };\n const first = D.refreshIfDue(readStamp, run, Date.now());\n await new Promise((r) => setTimeout(r, 1)); // a tick arriving after the claim, mid-collection\n const second = await D.refreshIfDue(readStamp, run, Date.now());\n await first;\n eq(claimed, 1, \"a second schedule ticking DURING a collection started a second one\");\n eq(second.ran, false, \"the second tick was not gated by the stamp the first one had already claimed\");\n eq(collections, 1, \"her CRM was read twice for one refresh\");\n // And the ordering that makes that true, pinned in the source: the stamp is written before the\n // credential is even resolved. If it moved after the collection, everything above still passes\n // on these fakes while the real gate opened for the whole duration of a run.\n const code = codeOnly(readFileSync(new URL(\"../engine/deposits.ts\", import.meta.url), \"utf8\"));\n const body = code.slice(code.indexOf(\"export async function runCollection\"), code.indexOf(\"export default async function\"));\n ok(body.indexOf(\"setJSON(ATTEMPT_KEY\") > -1, \"runCollection no longer stamps the attempt at all\");\n ok(body.indexOf(\"setJSON(ATTEMPT_KEY\") < body.indexOf(\"await token()\"), \"the attempt is stamped after the work starts, so the gate is open for the whole run\");\n ok(body.indexOf(\"setJSON(ATTEMPT_KEY\") < body.indexOf(\"collect(\"), \"the attempt is stamped after her calendars are read\");\n return scoped(6, \"gate checks\");\n});\n\nawait done();\n\n\n\n=====FILE tests/detect.test.mjs =====\n// WHO GETS NINETEEN MONTHS OF MESSAGES.\n// Every case below is a real sentence out of Kim's contact records, or a near miss of one. A false\n// positive here is a person receiving forty-one messages about a puppy they do not have, in her\n// name, so the bar is that the classifier has to be defensible line by line rather than accurate\n// on average.\nimport * as D from \"../build/puppy-detect.js\";\nimport * as S from \"../build/send.js\";\nimport { readFileSync, readdirSync } from \"node:fs\";\nimport { suite, ok, eq, scoped, codeOnly } from \"./_harness.mjs\";\nconst { t, at, done, header } = suite(\"detect\");\n\nheader(\"READING AN AGE\");\n\nt(\"N1 a dog described in years is never read as a puppy, however many months follow\", () => {\n // The bug this file was written to prevent, which the first version still had.\n const cases = [\n [\"Charlie, who is 3 years and 4 months old\", 40],\n [\"3 years and 4 months old\", 40],\n [\"a 3-year-old German Shepherd, Haku\", 36],\n [\"her 2 year old lab\", 24],\n [\"he is 1 year and 6 months\", 18],\n [\"five years old\", 60],\n ];\n for (const [text, months] of cases) eq(D.ageInMonths(text), months, `\"${text}\"`);\n return scoped(cases.length, \"ages in years\");\n});\n\nt(\"N2 weeks and months read correctly and in the right unit\", () => {\n const cases = [\n [\"her 6-week-old Yorkie Poo\", 1.4],\n [\"his 7-8 month old German shepherd mix\", 7],\n [\"about 7 months old\", 7],\n [\"a 10 week old puppy\", 2.3],\n [\"12 weeks old\", 2.8],\n ];\n for (const [text, months] of cases) eq(D.ageInMonths(text), months, `\"${text}\"`);\n return scoped(cases.length, \"ages\");\n});\n\nt(\"N3 no age means null, never a guess and never zero\", () => {\n for (const text of [\"no age here at all\", \"\", \"she has a lovely spaniel\", \"call me back\"]) {\n eq(D.ageInMonths(text), null, `\"${text}\" produced an age from nothing`);\n }\n return scoped(4, \"texts with no age\");\n});\n\nt(\"N4 an age is spoken the way a person would say it\", () => {\n eq(D.sayAge(1.4), \"6 weeks old\");\n eq(D.sayAge(0.23), \"1 week old\");\n eq(D.sayAge(7), \"7 months old\");\n eq(D.sayAge(36), \"3 years old\");\n ok(!/\\d+\\.\\d/.test(D.sayAge(1.4)), \"a decimal month reached the words\");\n return scoped(5, \"renderings\");\n});\n\nheader(\"DECIDING\");\n\nt(\"N5 the three real false positives are all rejected, each for its own reason\", () => {\n const ken = D.classify(\"a\", \"Ken\", \"Ken Anderson was looking to purchase a puppy. He inquired whether The Dogs Spot GA offered puppies for sale. The agent clarified that they do not sell.\");\n eq(ken.confidence, \"no\", `Ken: ${ken.reason}`);\n ok(/buy a puppy/.test(ken.reason), `Ken rejected for the wrong reason: ${ken.reason}`);\n\n const jasmine = D.classify(\"b\", \"Jasmine\", \"Jasmine Campbell reached out to discuss her mixed-breed dog, Charlie, who is 3 years and 4 months old.\");\n eq(jasmine.confidence, \"no\", `Jasmine: ${jasmine.reason}`);\n ok(/3 years old/.test(jasmine.reason), `Jasmine rejected for the wrong reason: ${jasmine.reason}`);\n\n const evelyn = D.classify(\"c\", \"Evelyn\", \"Evelyn Carter was seeking assistance in finding good homes for her older dogs, as she needs to downsize her pack to just Coco and her new puppy.\");\n eq(evelyn.confidence, \"no\", `Evelyn: ${evelyn.reason}`);\n ok(/rehoming/.test(evelyn.reason), `Evelyn rejected for the wrong reason: ${evelyn.reason}`);\n\n // EACH RULE ON ITS OWN. Ken's sentence trips two of the buy-related rules at once, so deleting\n // either one leaves him correctly rejected by the other and a test built only on him stays\n // green while a real guarantee is gone. Found by a negative control, which removed one rule and\n // could not make anything go red. This case trips exactly one.\n const soleBuyer = D.classify(\"d\", \"Someone\", \"She was hoping to buy a puppy from a breeder nearby and asked if we knew of any.\");\n eq(soleBuyer.confidence, \"no\", `a plain buyer: ${soleBuyer.reason}`);\n ok(/buy a puppy/.test(soleBuyer.reason), `wrong reason: ${soleBuyer.reason}`);\n return scoped(4, \"real false positives, each rejected on its own grounds\");\n});\n\nt(\"N6 the obvious yeses are clear, not merely probable\", () => {\n const cases = [\n \"Mrsqueen Chinatoyou was seeking assistance related to her 6-week-old Yorkie Poo.\",\n \"She has a new puppy, 10 weeks old, and wants help with biting.\",\n \"Wants training for her 4 month old puppy.\",\n ];\n for (const c of cases) {\n const v = D.classify(\"x\", \"x\", c);\n eq(v.confidence, \"clear\", `\"${c.slice(0, 50)}\" came back ${v.confidence}: ${v.reason}`);\n }\n return scoped(cases.length, \"clear cases\");\n});\n\nt(\"N7 a guess is labelled a guess and says what is missing\", () => {\n const noAge = D.classify(\"x\", \"x\", \"Dakota Brown was seeking in-person training for her two puppies, Lucky and Smokey.\");\n eq(noAge.confidence, \"probable\");\n ok(/no age is written down/.test(noAge.reason), `does not say what is missing: ${noAge.reason}`);\n const noWord = D.classify(\"x\", \"x\", \"his 7-8 month old German shepherd mix\");\n eq(noWord.confidence, \"probable\");\n ok(/the word puppy is not used/.test(noWord.reason), `does not say what is missing: ${noWord.reason}`);\n return scoped(2, \"hedged cases\");\n});\n\nt(\"N8 an empty record is 'unclear', never 'no'\", () => {\n // \"No\" means we looked and it is not a puppy. \"Unclear\" means there was nothing to look at.\n // Collapsing the two would quietly hide half the contact base behind a confident answer.\n for (const empty of [\"\", \" \", null, undefined]) {\n const v = D.classify(\"x\", \"x\", empty);\n eq(v.confidence, \"unclear\", `${JSON.stringify(empty)} came back ${v.confidence}`);\n ok(/nothing written down/.test(v.reason), v.reason);\n }\n return scoped(4, \"empty records\");\n});\n\nt(\"N9 every verdict explains itself in a sentence a person could act on\", () => {\n const texts = [\n \"purchase a puppy\", \"3 years and 4 months old\", \"6-week-old Yorkie\", \"two puppies\",\n \"7 month old shepherd\", \"\", \"wants boarding for next weekend\", \"rehoming her older dogs\",\n ];\n for (const text of texts) {\n const v = D.classify(\"x\", \"Someone\", text);\n ok(v.reason && v.reason.length > 25, `bare reason for \"${text}\": ${v.reason}`);\n ok(/[.!]$/.test(v.reason), `reason is not a sentence: ${v.reason}`);\n ok(!/\\bnull\\b|\\bundefined\\b|NaN/.test(v.reason), `a stray value reached the reason: ${v.reason}`);\n ok(!/regex|classifier|confidence|boolean|field/i.test(v.reason), `jargon in the reason: ${v.reason}`);\n }\n return scoped(texts.length * 4, \"assertions\");\n});\n\nheader(\"REPORTING ON ITSELF\");\n\nt(\"N10 the summary counts add up and the sentence is generated from them\", () => {\n const vs = [\n D.classify(\"1\", \"a\", \"6 week old puppy\"),\n D.classify(\"2\", \"b\", \"two puppies\"),\n D.classify(\"3\", \"c\", \"\"),\n D.classify(\"4\", \"d\", \"3 year old lab\"),\n ];\n const s = D.summarise(vs, 4);\n eq(s.clear + s.probable + s.unclear + s.no, 4, \"the buckets do not add up to what was scanned\");\n eq(s.scanned, 4);\n const line = D.detectSentence(s);\n ok(line.includes(`${s.clear} are clearly`), \"the sentence does not carry the count it describes\");\n ok(/Nothing has been tagged/.test(line), \"the sentence does not say that nothing was done\");\n return scoped(vs.length, \"verdicts\");\n});\n\nt(\"N11 it admits when it read nothing rather than reporting all clear\", () => {\n const none = D.detectSentence(D.summarise([], 0));\n ok(/nothing to report/.test(none), `an empty scan reads as a result: ${none}`);\n ok(!/0 are clearly/.test(none), \"an empty scan renders as a confident zero\");\n return scoped(2, \"assertions\");\n});\n\nt(\"N12 the blind spot is in the output, not in a footnote\", () => {\n const vs = [D.classify(\"1\", \"a\", \"6 week old puppy\"), D.classify(\"2\", \"b\", \"\"), D.classify(\"3\", \"c\", \"\")];\n const line = D.detectSentence(D.summarise(vs, 3));\n ok(/2 of them have nothing written down/.test(line), `does not surface the unjudgeable: ${line}`);\n return scoped(3, \"verdicts\");\n});\n\nheader(\"IT CANNOT TAG ANYBODY, AND THAT IS STRUCTURAL\");\n\nt(\"N13 the classifier has no way to reach the CRM at all\", () => {\n // Not a promise in a comment: the file has no fetch, no client and no write in it, so there is\n // no path from \"we think this person is a puppy inquiry\" to \"this person has been tagged\"\n // without somebody adding one. That edit would show up here.\n const src = codeOnly(readFileSync(new URL(\"../engine/puppy-detect.ts\", import.meta.url), \"utf8\"));\n const forbidden = [\n [/\\bfetch\\s*\\(/, \"a fetch call\"],\n [/\\bXMLHttpRequest\\b/, \"an XHR\"],\n [/\\baddTag\\b/, \"a call to addTag\"],\n [/method:\\s*[\"'`]POST[\"'`]/i, \"a POST\"],\n [/method:\\s*[\"'`]PUT[\"'`]/i, \"a PUT\"],\n [/method:\\s*[\"'`]DELETE[\"'`]/i, \"a DELETE\"],\n [/leadconnectorhq|services\\.lead/i, \"the CRM's address\"],\n [/\\bsetJSON\\b|\\bblob\\b/, \"a write to storage\"],\n ];\n const found = forbidden.filter(([re]) => re.test(src)).map(([, what]) => what);\n eq(found, [], \"the classifier has grown the ability to change something\");\n ok(src.length > 2000, \"the source read as nearly empty, so this check inspected nothing\");\n return scoped(forbidden.length, \"ways to reach the CRM, none present\");\n});\n\nt(\"N14 the dry scan says outright that it applied nothing\", () => {\n const s = D.dryScan([{ id: \"1\", contactName: \"a\", customFields: [{ id: D.FIELD_INQUIRY_SUMMARY, value: \"6 week old puppy\" }] }], \"2026-08-05T05:00:00.000Z\");\n eq(s.applied, false, \"a scan came back claiming it applied something\");\n eq(s.clearIds, [\"1\"]);\n eq(s.summary.scanned, 1);\n ok(s.at === \"2026-08-05T05:00:00.000Z\", \"the scan does not carry when it ran\");\n return scoped(4, \"assertions\");\n});\n\nt(\"N14b duplicate API rows classify once and input order cannot change the dry proof\", () => {\n const a = { id: \"dup\", contactName: \"Jane\", customFields: [{ id: D.FIELD_INQUIRY_SUMMARY, value: \"8 week old puppy\" }] };\n const b = { id: \"dup\", contactName: \"Jane\", customFields: [{ id: D.FIELD_TRAINING_GOAL, value: \"puppy biting\" }] };\n const z = { id: \"z\", contactName: \"Zed\", customFields: [{ id: D.FIELD_INQUIRY_SUMMARY, value: \"adult dog\" }] };\n const left = D.dryScan([z, a, b], \"t\");\n const right = D.dryScan([b, a, z], \"t\");\n eq(left, right);\n eq(left.summary.scanned, 2, \"the duplicate inflated the population\");\n eq(left.clearIds, [\"dup\"]);\n eq(left.duplicateIds, [\"dup\"]);\n eq(new Set([...left.clearIds, ...left.probableIds]).size, left.clearIds.length + left.probableIds.length);\n return scoped(5, \"dedupe assertions\");\n});\n\nt(\"N15 it carries ids only, never a name or anything the person wrote\", () => {\n // What gets written down every hour should be the minimum that makes the count checkable.\n const s = D.dryScan([{ id: \"abc\", contactName: \"Jane Doe\", customFields: [{ id: D.FIELD_INQUIRY_SUMMARY, value: \"her 8 week old puppy Rex\" }] }], \"t\");\n const blob = JSON.stringify(s);\n ok(!/Jane Doe/.test(blob), \"a name is being stored\");\n ok(!/Rex/.test(blob), \"a dog's name is being stored\");\n ok(!/8 week old/.test(blob), \"what somebody wrote is being stored\");\n ok(/abc/.test(blob), \"the id is missing, so the count cannot be checked against anything\");\n return scoped(4, \"assertions\");\n});\n\nt(\"N16 it reads the real shape the CRM hands back, and shrugs at anything else\", () => {\n eq(D.inquiryText({ customFields: [{ id: D.FIELD_INQUIRY_SUMMARY, value: \"hello\" }] }), \"hello\");\n eq(D.inquiryText({ customFields: [{ id: D.FIELD_TRAINING_GOAL, value: \"stop biting\" }] }), \"stop biting\");\n for (const junk of [null, undefined, {}, { customFields: null }, { customFields: \"nope\" }, 42]) {\n eq(D.inquiryText(junk), \"\", `${JSON.stringify(junk)} produced text from nothing`);\n }\n eq(D.classifyContacts(\"not an array\"), []);\n eq(D.classifyContacts([null, {}, { id: 5 }]), [], \"a contact with no usable id was classified anyway\");\n return scoped(10, \"shapes\");\n});\n\nt(\"N17 a dry pass that stopped running says so instead of showing old numbers as current\", () => {\n const now = Date.parse(\"2026-08-05T05:00:00Z\");\n const at = (h) => new Date(now - h * 3_600_000).toISOString();\n eq(D.scanAgeNote(at(0), now), null, \"a fresh reading is being apologised for\");\n eq(D.scanAgeNote(at(5), now), null, \"within one missed turn is not worth a note\");\n ok(/7 hours ago/.test(D.scanAgeNote(at(7), now) ?? \"\"), \"a stale reading passes as current\");\n ok(/3 days ago/.test(D.scanAgeNote(at(80), now) ?? \"\"), \"a dead scan passes as merely late\");\n ok(/stopped being kept up/.test(D.scanAgeNote(at(80), now) ?? \"\"), \"a dead scan does not say it is dead\");\n eq(D.scanAgeNote(null, now), null, \"a missing timestamp invents an age\");\n eq(D.scanAgeNote(\"not a date\", now), null, \"an unreadable timestamp invents an age\");\n eq(D.scanAgeNote(\"2027-01-01T00:00:00Z\", now), null, \"a future timestamp produced a negative age\");\n return scoped(8, \"assertions\");\n});\n// ---------------------------------------------------------------- the send guard (v1.7, 6 Aug)\n// WHY HERE: this file already owns the \"structurally cannot\" genre (D-N13 above proves the\n// detector cannot reach the CRM). The same discipline now covers the SENDERS: in practice mode\n// they refuse everyone except the sanctioned dummy, inside the function itself, so a future\n// enrollment bug upstream cannot text a real person.\nimport { readFileSync as _rf } from \"node:fs\";\nimport { codeOnly as _co } from \"./_harness.mjs\";\n// 16 Aug: the senders and the guard moved out of puppy_path_v1.1.ts into send.ts, because main.ts\n// was 93 characters under val.town's 80,000 ceiling. G1 and G2 read the file the code is IN, so they\n// follow it. G3 below is new and is the reason the move is safe to make: it checks main.ts still\n// IMPORTS these rather than having quietly grown its own unguarded copies. Without G3, deleting the\n// import and pasting a raw fetch back into main.ts would leave G1 and G2 green on the wrong file.\nconst _sendSrc = _co(_rf(new URL(\"../engine/send.ts\", import.meta.url), \"utf8\"));\nconst _engineSrc = _co(_rf(new URL(\"../engine/puppy_path_v1.1.ts\", import.meta.url), \"utf8\"));\nt(\"G1 both senders open by asserting the send is allowed\", () => {\n const smsBody = _sendSrc.slice(_sendSrc.indexOf(\"function sendSms\"), _sendSrc.indexOf(\"function sendSms\") + 300);\n const emailBody = _sendSrc.slice(_sendSrc.indexOf(\"function sendEmail\"), _sendSrc.indexOf(\"function sendEmail\") + 300);\n ok(/assertSendAllowed\$contactId, \"sms\"\$/.test(smsBody), \"sendSms does not call the guard first\");\n ok(/assertSendAllowed\$contactId, \"email\"\$/.test(emailBody), \"sendEmail does not call the guard first\");\n return scoped(2, \"senders\");\n});\nt(\"G2 the guard fails closed and names practice mode\", () => {\n const g = _sendSrc.slice(_sendSrc.indexOf(\"function assertSendAllowed\"), _sendSrc.indexOf(\"function assertSendAllowed\") + 400);\n ok(/TEST_MODE && contactId !== SANCTIONED_TEST_CONTACT/.test(g), \"guard does not compare against the sanctioned contact\");\n ok(/throw new Error/.test(g), \"guard does not throw\");\n ok(/SANCTIONED_TEST_CONTACT: string \\| null = null/.test(_sendSrc), \"tracker does not start null, so it cannot fail closed\");\n // The mode itself must also start closed. Inside main.ts the guard read a TEST_MODE that was\n // resolved before anything could send. Across a module boundary it is a separate variable, and an\n // engine that forgets to configure it must get practice mode, not a live send to Kim's list.\n ok(/let TEST_MODE = true;/.test(_sendSrc), \"send.ts does not default to practice mode, so an unconfigured import sends live\");\n return scoped(4, \"guard properties\");\n});\nt(\"G3 the engine imports the guarded senders rather than owning any\", () => {\n const imp = _engineSrc.slice(_engineSrc.indexOf('from \"./send.ts\"') - 400, _engineSrc.indexOf('from \"./send.ts\"'));\n for (const name of [\"sendSms\", \"sendEmail\", \"j\", \"configureSend\"]) {\n ok(new RegExp(`\\\\b${name}\\\\b`).test(imp), `the engine does not import ${name} from send.ts`);\n }\n // No local redefinition. `function sendSms` in main.ts would shadow the import and skip the guard.\n ok(!/function sendSms|function sendEmail|function assertSendAllowed/.test(_engineSrc),\n \"the engine declares its own sender or guard, which would bypass send.ts entirely\");\n // And the mode must actually be pushed across the boundary, or send.ts stays closed forever and\n // every live send throws. This is the other half of G2's fail-closed default.\n ok(/configureSend\$TEST_MODE\$/.test(_engineSrc), \"the engine never tells send.ts which mode it is in\");\n return scoped(6, \"wiring\");\n});\n\nt(\"G4 exactly one named sender authority can arm the module\", () => {\n S.configureSend(true);\n eq(S.configuredSenderAuthority(), \"puppy-engine-v1\");\n let refused = \"\";\n try { S.configureSend(false, \"noshow-dispatcher\"); } catch (e) { refused = String(e); }\n ok(/only puppy-engine-v1 may send/.test(refused), refused);\n eq(S.sendModeIsTest(), true, \"a refused authority changed the mode to live before throwing\");\n return scoped(3, \"authority assertions\");\n});\n\nawait at(\"G5 j() cannot bypass the guarded senders, and exact concurrent sends coalesce\", async () => {\n const originalFetch = globalThis.fetch;\n const originalToken = process.env.GHL_TOKEN;\n let calls = 0;\n try {\n process.env.GHL_TOKEN = \"test-only-token\";\n globalThis.fetch = async () => { calls++; return { ok: true, json: async () => ({ ok: true }) }; };\n let refused = \"\";\n try { await S.j(`${S.GHL}/conversations/messages`, \"2021-04-15\", { method: \"POST\" }); }\n catch (e) { refused = String(e); }\n ok(/direct message endpoint refused/.test(refused), refused);\n eq(calls, 0, \"the bypass reached fetch before it was refused\");\n\n let release;\n globalThis.fetch = () => {\n calls++;\n return new Promise((resolve) => { release = () => resolve({ ok: true, json: async () => ({ messageId: \"m1\" }) }); });\n };\n S.configureSend(false);\n const a = S.sendSms(\"contact-1\", \"same body\");\n const b = S.sendSms(\"contact-1\", \"same body\");\n await Promise.resolve();\n eq(calls, 1, \"two identical in-flight sends produced two HTTP requests\");\n release();\n const result = await Promise.all([a, b]);\n eq(result, [{ messageId: \"m1\" }, { messageId: \"m1\" }]);\n S.configureSend(true);\n return scoped(4, \"message IO assertions\");\n } finally {\n globalThis.fetch = originalFetch;\n if (originalToken === undefined) delete process.env.GHL_TOKEN;\n else process.env.GHL_TOKEN = originalToken;\n S.configureSend(true);\n }\n});\n\nt(\"G6 no second engine module imports the send authority\", () => {\n const dir = new URL(\"../engine/\", import.meta.url);\n const users = readdirSync(dir).filter((f) => f.endsWith(\".ts\")).filter((f) => {\n const lines = readFileSync(new URL(f, dir), \"utf8\").split(\"\\n\");\n return lines.some((line) => /^\\s*(?:import|export)\\b.*from [\"']\\.\\/send\\.ts[\"']/.test(line));\n });\n eq(users, [\"puppy_path_v1.1.ts\"]);\n ok(!users.includes(\"planner.ts\"), \"the dry planner acquired sender authority\");\n return scoped(2, \"module authority checks\");\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"]