[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_293":294,"_295":296},"routes/_app.x.$handle.$name",{"_95":94,"_32":44,"_104":85,"_27":52,"_13":14,"_105":-5,"_11":106,"_107":108,"_109":110,"_111":112,"_113":114,"_20":-5,"_115":-5,"_116":-5,"_117":25,"_118":119,"_120":57,"_121":-5,"_122":-5,"_123":124},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_42":43,"_32":44,"_37":45,"_46":-5,"_47":25,"_48":49,"_50":49,"_51":52,"_53":-5,"_18":54,"_55":31,"_56":57,"_58":-5,"_59":-5,"_60":61,"_62":63,"_64":-5,"_65":-5,"_66":-5,"_67":-5,"_68":69,"_70":69,"_71":72,"_73":72,"_74":72,"_75":69,"_76":69,"_77":78,"_79":80,"_81":82,"_83":25},"version",88,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":28,"_33":34,"_35":36,"_37":38,"_39":14,"_40":41,"_24":25},"previous",{"_30":31,"_32":28,"_33":34,"_35":36},"deleted",false,"deletedHere","path","webhook.ts","latestPath","fileId","b07ce340-886f-11f1-9e2e-1607ee4eb77e","name","fileType","http","content","// webhook.ts -- set this file's trigger to HTTP in the Val Town UI.\n//\n// Routes:\n// POST /webhook/todoist real-time trigger, verified via Todoist's HMAC signature\n// GET /health lightweight uptime check\n// GET / plain status text\n//\n// On a qualifying event this handler can run up to three independent\n// automations:\n// - the execute-label rescan (automation.ts), on the same event set as\n// before\n// - the instant emoji classification (emoji-automation.ts), only when\n// the task in the payload carries the literal \"{emoji}\" marker --\n// or the full emoji sweep, when it carries \"{emoji_all}\" instead\n// - instant habit-completion tracking (habit-automation.ts), on\n// item:completed. Note: item:completed must be enabled under\n// Watched Events for this webhook in the Todoist App Console, or\n// this event will simply never arrive.\n\nimport { runAutomationSafely } from \"./automation.ts\";\nimport {\n hasEmojiAllMarker,\n hasEmojiMarker,\n processInstantEmojiClassification,\n runEmojiSweepSafely,\n} from \"./emoji-automation.ts\";\nimport { processHabitCompletion } from \"./habit-automation.ts\";\n\n// Events that can affect which tasks carry EXECUTE_LABEL or need a due-date rollover.\nconst EXECUTE_LABEL_EVENTS = new Set([\n \"item:added\",\n \"item:updated\",\n \"item:uncompleted\",\n]);\n\n// Events on which it's worth checking a task's content for the {emoji} marker.\nconst EMOJI_MARKER_EVENTS = new Set([\"item:added\", \"item:updated\"]);\n\n// Events that should be checked for habit-completion tracking.\nconst HABIT_COMPLETION_EVENTS = new Set([\"item:completed\"]);\n\nasync function verifyTodoistSignature(\n rawBody: string,\n signatureHeader: string | null,\n): Promise {\n const clientSecret = Deno.env.get(\"TODOIST_CLIENT_SECRET\");\n if (!clientSecret || !signatureHeader) return false;\n\n const key = await crypto.subtle.importKey(\n \"raw\",\n new TextEncoder().encode(clientSecret),\n { name: \"HMAC\", hash: \"SHA-256\" },\n false,\n [\"sign\"],\n );\n const signature = await crypto.subtle.sign(\n \"HMAC\",\n key,\n new TextEncoder().encode(rawBody),\n );\n const bytes = new Uint8Array(signature);\n let binary = \"\";\n for (const b of bytes) binary += String.fromCharCode(b);\n const computed = btoa(binary);\n\n if (computed.length !== signatureHeader.length) return false;\n let diff = 0;\n for (let i = 0; i < computed.length; i++) {\n diff |= computed.charCodeAt(i) ^ signatureHeader.charCodeAt(i);\n }\n return diff === 0;\n}\n\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n\n if (req.method === \"GET\" && url.pathname === \"/health\") {\n return Response.json({\n status: \"ok\",\n time: new Date().toLocaleString(\"en-US\", {\n timeZone: \"Europe/Bucharest\",\n }),\n });\n }\n\n if (req.method === \"GET\" && url.pathname === \"/\") {\n return new Response(\"Todoist Processor is running.\");\n }\n\n if (req.method === \"POST\" && url.pathname === \"/webhook/todoist\") {\n const rawBody = await req.text();\n const signature = req.headers.get(\"X-Todoist-Hmac-SHA256\");\n\n if (!Deno.env.get(\"TODOIST_CLIENT_SECRET\")) {\n console.error(\n \"Webhook: rejected, TODOIST_CLIENT_SECRET is not configured.\",\n );\n return Response.json({ error: \"Server misconfiguration\" }, {\n status: 500,\n });\n }\n\n if (!(await verifyTodoistSignature(rawBody, signature))) {\n console.warn(\n \"Webhook: rejected request with invalid or missing HMAC signature.\",\n );\n return Response.json({ error: \"Invalid signature\" }, { status: 401 });\n }\n\n let payload: Record;\n try {\n payload = rawBody ? JSON.parse(rawBody) : {};\n } catch {\n console.warn(\"Webhook: rejected request with unparsable JSON body.\");\n return Response.json({ error: \"Invalid JSON\" }, { status: 400 });\n }\n\n const eventName = (payload.event_name as string) || \"unknown\";\n const eventData = payload.event_data as\n | Record\n | undefined;\n console.log(\n `Webhook received: event_name=${eventName}` +\n (eventData\n ? `, task_id=${eventData.id ?? \"?\"}, content=${\n JSON.stringify(eventData.content ?? \"?\")\n }`\n : \"\"),\n );\n\n const isExecuteLabelEvent = EXECUTE_LABEL_EVENTS.has(eventName);\n const eventContent = typeof eventData?.content === \"string\"\n ? eventData.content\n : \"\";\n const isEmojiEvent = EMOJI_MARKER_EVENTS.has(eventName);\n const isEmojiAllMarkerEvent = isEmojiEvent &&\n hasEmojiAllMarker(eventContent);\n const isEmojiMarkerEvent = isEmojiEvent && hasEmojiMarker(eventContent);\n const isHabitCompletionEvent = HABIT_COMPLETION_EVENTS.has(eventName);\n\n if (\n !isExecuteLabelEvent && !isEmojiMarkerEvent && !isEmojiAllMarkerEvent &&\n !isHabitCompletionEvent\n ) {\n console.log(`Webhook: ignoring irrelevant event '${eventName}'.`);\n return Response.json({ status: \"ignored\", event_name: eventName });\n }\n\n const results: Record = { event_name: eventName };\n\n if (isExecuteLabelEvent) {\n results.execute_label = await runAutomationSafely(`webhook:${eventName}`);\n }\n\n if (isEmojiAllMarkerEvent) {\n results.emoji_all = await runEmojiSweepSafely(`webhook:${eventName}`);\n } else if (isEmojiMarkerEvent) {\n const taskId = eventData?.id != null ? String(eventData.id) : \"\";\n results.emoji = taskId\n ? await processInstantEmojiClassification(taskId)\n : { status: \"error\", message: \"Webhook payload missing task id.\" };\n }\n\n if (isHabitCompletionEvent) {\n const taskId = eventData?.id != null ? String(eventData.id) : \"\";\n const dueRaw = eventData?.due as { date?: string } | null | undefined;\n const fallbackDueDateStr = dueRaw?.date\n ? dueRaw.date.split(\"T\")[0]\n : null;\n const fallbackLabels = Array.isArray(eventData?.labels)\n ? (eventData!.labels as string[])\n : null;\n\n results.habit = taskId\n ? await processHabitCompletion(taskId, {\n dueDateStr: fallbackDueDateStr,\n labels: fallbackLabels,\n })\n : { status: \"error\", message: \"Webhook payload missing task id.\" };\n }\n\n return Response.json(results);\n }\n\n return Response.json({ error: \"Not found\" }, { status: 404 });\n}","createdAt",["D",1786297788465],"branchVersion","branchId","d5c6d970-01f8-476c-8131-97a3f2dfda37","id","0334be82-201a-42b6-9fc5-d568200d551d","todoist-webhook",["D",1785014870875],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","","imageUrl","e18335fe-6041-4f4c-bba1-4a304afb2a2c","pinnedFileId","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",0,"orgId","019f95b4-236c-7362-a248-36bfd5d26630","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_95":94,"_103":99},"org",{"_95":94,"_96":97,"_98":99,"_18":54,"_100":101,"_102":25},"branch",{"_13":84,"_32":85,"_42":41,"_86":43,"_87":-5,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":44,"_93":94},"isOwned",100,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","alexaiexperiments","handle","displayName","Croitor Emanuel-Alexandru","avatar","https://avatars.githubusercontent.com/u/184514375?v=4","tier","free","canRestrictVals","profileImageUrl","branchName","adoptOrgId",{"_42":43,"_32":44,"_37":289,"_46":-5,"_47":25,"_48":49,"_50":49,"_51":52,"_53":-5,"_18":54,"_55":31,"_56":57,"_58":-5,"_59":-5,"_60":61,"_62":63,"_64":-5,"_65":-5,"_66":-5,"_67":-5,"_68":69,"_70":69,"_71":72,"_73":72,"_74":72,"_75":69,"_76":69,"_77":290,"_79":291,"_81":292,"_83":25},"tree",[240,241,242,243,244,245,246,247,248,249,250,251],"files",[240,241,242,243,244,245,246,247,248,249,250,251],"counts",{"_229":61,"_230":167,"_231":61,"_232":233,"_234":235},"contents",[125,126,127,128,129,130,131,132,133,134,135,136],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_42":221,"_32":222,"_30":223,"_138":-5,"_40":41,"_39":224,"_139":25,"_37":225,"_13":226,"_33":150,"_35":227,"_24":25,"_142":-5,"_27":228},{"_42":213,"_32":214,"_30":215,"_138":-5,"_40":41,"_39":216,"_139":25,"_37":217,"_13":218,"_33":150,"_35":219,"_24":25,"_142":-5,"_27":220},{"_42":207,"_32":208,"_30":209,"_138":-5,"_40":41,"_39":180,"_139":57,"_37":210,"_13":61,"_33":150,"_35":211,"_24":25,"_142":-5,"_27":212},{"_42":200,"_32":201,"_30":202,"_138":-5,"_40":41,"_39":203,"_139":25,"_37":204,"_13":167,"_33":150,"_35":205,"_24":25,"_142":-5,"_27":206},{"_42":192,"_32":193,"_30":194,"_138":-5,"_40":41,"_39":195,"_139":25,"_37":196,"_13":197,"_33":150,"_35":198,"_24":25,"_142":-5,"_27":199},{"_42":184,"_32":185,"_30":186,"_138":-5,"_40":41,"_39":187,"_139":25,"_37":188,"_13":189,"_33":150,"_35":190,"_24":25,"_142":-5,"_27":191},{"_42":177,"_32":178,"_30":179,"_138":-5,"_40":41,"_39":180,"_139":57,"_37":181,"_13":61,"_33":150,"_35":182,"_24":25,"_142":-5,"_27":183},{"_42":170,"_32":171,"_30":172,"_138":-5,"_40":41,"_39":173,"_139":25,"_37":174,"_13":167,"_33":150,"_35":175,"_24":25,"_142":-5,"_27":176},{"_42":162,"_32":163,"_30":164,"_138":-5,"_40":41,"_39":165,"_139":25,"_37":166,"_13":167,"_33":150,"_35":168,"_24":25,"_142":-5,"_27":169},{"_42":153,"_32":154,"_30":155,"_138":-5,"_40":41,"_39":156,"_139":25,"_37":157,"_13":158,"_33":159,"_35":160,"_24":25,"_142":-5,"_27":161},{"_42":144,"_32":145,"_30":146,"_138":-5,"_40":41,"_39":147,"_139":25,"_37":148,"_13":149,"_33":150,"_35":151,"_24":25,"_142":-5,"_27":152},{"_42":137,"_32":28,"_30":31,"_138":-5,"_40":41,"_39":14,"_139":25,"_37":140,"_13":141,"_33":34,"_35":36,"_24":25,"_142":-5,"_27":143},"00e32447-7b8f-4955-aadd-69e45a6ec658","parentId","latest",["D",1786297788465],11,"label",[28],"656b76b3-b6a8-414a-ae7e-e4faf3eeb835","todoist.ts","fa109186-88ed-11f1-987b-1607ee4eb77e",85,["D",1786297526788],23,"script","// todoist.ts\n// Thin fetch-based client for the Todoist REST API (api/v1).\n// https://developer.todoist.com/api/v1/\n//\n// Deliberately dependency-free: no npm SDK, just fetch + the env token.\n// Covers what's needed for all three automations:\n// - \"execute 🌥\" auto-scheduling: GET /tasks (literal `label` match,\n// cursor-paginated) and POST /tasks/{id} to update a due date.\n// - emoji classification: GET /tasks with no filter (all active tasks,\n// used to both find candidates and resolve parent_id chains for the\n// checklist-exclusion check in-memory), GET /tasks/{id} (single task,\n// used by the instant webhook path, including its own parent lookups),\n// and POST /tasks/{id} to prepend the classified emoji to content.\n// - \"habit\" completion tracking (habit-automation.ts): GET /tasks by the\n// `habit` label for the EOD sweep, GET/POST /comments to maintain the\n// monthly log comment on each habit task, and GET\n// /tasks/completed/by_completion_date to look up the due date a task\n// actually had at the moment it was completed (recurring tasks have\n// already had their live due date rolled forward to the *next*\n// occurrence by the time the completion webhook arrives, so the live\n// task can't be trusted for this -- the completed-tasks archive keeps\n// the original snapshot).\n\nconst TODOIST_BASE = \"https://api.todoist.com/api/v1\";\n\nfunction authHeaders(): HeadersInit {\n const token = Deno.env.get(\"TODOIST_API_TOKEN\");\n if (!token) throw new Error(\"TODOIST_API_TOKEN is not set.\");\n return { Authorization: `Bearer ${token}` };\n}\n\nexport interface TodoistDue {\n date: string; // \"YYYY-MM-DD\" or a full ISO datetime string\n is_recurring?: boolean;\n string?: string;\n timezone?: string | null;\n}\n\nexport interface TodoistTask {\n id: string;\n content: string;\n due: TodoistDue | null;\n /** Direct parent task id, or null/absent for a top-level task -- used\n * to walk up the ancestor chain for the 📋-checklist exclusion check. */\n parent_id?: string | null;\n /** Label names on the task, e.g. [\"habit\", \"execute 🌥\"]. */\n labels?: string[] | null;\n [key: string]: unknown;\n}\n\n/** A completed-task record from the /tasks/completed/* archive endpoints.\n * Mirrors TodoistTask but reflects a snapshot at completion time -- in\n * particular `due` here is the due date that was actually completed,\n * which for a recurring task is *not* the same as the live task's due\n * date (that has already been rolled forward to the next occurrence). */\nexport interface TodoistCompletedTask extends TodoistTask {\n completed_at?: string;\n}\n\ninterface PaginatedResponse {\n results: T[];\n next_cursor: string | null;\n}\n\nasync function paginate(\n path: string,\n params: Record,\n): Promise {\n const items: T[] = [];\n let cursor: string | null = null;\n\n do {\n const url = new URL(`${TODOIST_BASE}${path}`);\n for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);\n url.searchParams.set(\"limit\", \"200\");\n if (cursor) url.searchParams.set(\"cursor\", cursor);\n\n const res = await fetch(url.toString(), { headers: authHeaders() });\n if (!res.ok) {\n throw new Error(\n `Todoist GET ${path} failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as PaginatedResponse;\n items.push(...data.results);\n cursor = data.next_cursor;\n } while (cursor);\n\n return items;\n}\n\n/** Mirrors get_tasks(label=...) -- a literal match against a label name, not the filter DSL. */\nexport async function getTasksByLabel(label: string): Promise {\n return paginate(\"/tasks\", { label });\n}\n\n/** All active tasks visible to this token, across every project -- no filter applied.\n * Used by the emoji sweep, which needs to look at everything to find tasks\n * still missing a category label. */\nexport async function getAllActiveTasks(): Promise {\n return paginate(\"/tasks\", {});\n}\n\n/** Fetches a single task fresh from the API. Used by the instant webhook\n * path so it acts on the task's current state rather than trusting a\n * webhook payload snapshot that may be stale or incomplete. */\nexport async function getTask(taskId: string): Promise {\n const res = await fetch(`${TODOIST_BASE}/tasks/${taskId}`, {\n headers: authHeaders(),\n });\n if (!res.ok) {\n throw new Error(\n `Todoist GET /tasks/${taskId} failed: ${res.status} ${await res.text()}`,\n );\n }\n return (await res.json()) as TodoistTask;\n}\n\n/** Paginates the completed-tasks archive endpoints. Kept separate from\n * `paginate()` above because these endpoints' list wrapper key isn't\n * confirmed to be `results` like /tasks -- this defensively accepts\n * either `items` or `results` rather than assuming. */\nasync function paginateCompleted(\n path: string,\n params: Record,\n): Promise {\n const items: TodoistCompletedTask[] = [];\n let cursor: string | null = null;\n\n do {\n const url = new URL(`${TODOIST_BASE}${path}`);\n for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);\n url.searchParams.set(\"limit\", \"200\");\n if (cursor) url.searchParams.set(\"cursor\", cursor);\n\n const res = await fetch(url.toString(), { headers: authHeaders() });\n if (!res.ok) {\n throw new Error(\n `Todoist GET ${path} failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as Record;\n const batch = (data.items ?? data.results ?? []) as TodoistCompletedTask[];\n items.push(...batch);\n cursor = (data.next_cursor as string | null | undefined) ?? null;\n } while (cursor);\n\n return items;\n}\n\n/** Looks up completed task instances by when they were completed (not\n * when they were due). `sinceIso`/`untilIso` must be ISO 8601 datetime\n * strings and the window must be <= 3 months per Todoist's limit --\n * callers here only ever use a narrow recent window right after a\n * completion webhook fires, so that limit is never in practice a\n * concern. Each returned item's `due` field is the due date that\n * instance actually had when it was completed. */\nexport async function getCompletedTasksByCompletionDate(\n sinceIso: string,\n untilIso: string,\n): Promise {\n return paginateCompleted(\"/tasks/completed/by_completion_date\", {\n since: sinceIso,\n until: untilIso,\n });\n}\n\nexport interface TaskUpdateFields {\n due_date?: string;\n content?: string;\n}\n\nexport async function updateTask(\n taskId: string,\n fields: TaskUpdateFields,\n): Promise {\n console.log(\n `[todoist] POST /tasks/${taskId} body=${JSON.stringify(fields)}`,\n );\n\n const res = await fetch(`${TODOIST_BASE}/tasks/${taskId}`, {\n method: \"POST\",\n headers: {\n ...authHeaders(),\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(fields),\n });\n\n const rawText = await res.text();\n console.log(`[todoist] POST /tasks/${taskId} -> ${res.status} ${rawText}`);\n\n if (!res.ok) {\n throw new Error(\n `Todoist update task ${taskId} failed: ${res.status} ${rawText}`,\n );\n }\n\n // The endpoint is documented to echo back the updated task. Some Todoist\n // API versions have returned 204 No Content for updates instead, so this\n // stays defensive rather than assuming a body is always present.\n if (!rawText) return {} as TodoistTask;\n try {\n return JSON.parse(rawText) as TodoistTask;\n } catch {\n console.warn(\n `[todoist] Could not parse JSON response for task ${taskId} update.`,\n );\n return {} as TodoistTask;\n }\n}\n\n// --- Comments -----------------------------------------------------------\n// Used by habit-automation.ts to maintain the one-comment-per-month\n// completion log on each habit task.\n\nexport interface TodoistComment {\n id: string;\n content: string;\n task_id?: string;\n posted_at?: string;\n [key: string]: unknown;\n}\n\n/** All comments on a task, oldest first (server order is not guaranteed,\n * callers should not rely on ordering). */\nexport async function getTaskComments(\n taskId: string,\n): Promise {\n return paginate(\"/comments\", { task_id: taskId });\n}\n\n/** Creates a new comment on a task. */\nexport async function addComment(\n taskId: string,\n content: string,\n): Promise {\n const res = await fetch(`${TODOIST_BASE}/comments`, {\n method: \"POST\",\n headers: {\n ...authHeaders(),\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({ task_id: taskId, content }),\n });\n const rawText = await res.text();\n if (!res.ok) {\n throw new Error(\n `Todoist create comment on task ${taskId} failed: ${res.status} ${rawText}`,\n );\n }\n return JSON.parse(rawText) as TodoistComment;\n}\n\n/** Replaces a comment's content in place (the API has no partial-edit --\n * callers must send the full new content). */\nexport async function updateComment(\n commentId: string,\n content: string,\n): Promise {\n const res = await fetch(`${TODOIST_BASE}/comments/${commentId}`, {\n method: \"POST\",\n headers: {\n ...authHeaders(),\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify({ content }),\n });\n const rawText = await res.text();\n if (!res.ok) {\n throw new Error(\n `Todoist update comment ${commentId} failed: ${res.status} ${rawText}`,\n );\n }\n return JSON.parse(rawText) as TodoistComment;\n}",[145],"f37fca9a-f44b-4b7f-a10d-b658528d3f01","sweep.ts","e8876156-88ed-11f1-bdc3-1607ee4eb77e",75,["D",1785524529202],6,"interval","// sweep.ts -- set this file's trigger to Cron in the Val Town UI, interval: every 15 minutes.\n//\n// Safety net: catches any webhook delivery Todoist failed to make, and\n// guarantees the \"execute 🌥\" 9 PM rollover happens even on a day with zero\n// Todoist activity. 15 minutes is the fastest interval the free plan allows.\n\nimport { runAutomationSafely } from \"./automation.ts\";\nimport { runEmojiSweepSafely } from \"./emoji-automation.ts\";\n\nexport default async function (interval: Interval) {\n console.log(\n `Cron sweep starting. Last run: ${\n interval.lastRunAt?.toISOString() ?? \"never\"\n }`,\n );\n const result = await runAutomationSafely(\"cron\");\n console.log(\"Cron sweep result:\", JSON.stringify(result));\n\n const emojiResult = await runEmojiSweepSafely(\"cron\");\n console.log(\"Cron emoji sweep result:\", JSON.stringify(emojiResult));\n}",[154],"c82053f9-c23c-4f33-9b8e-ebd7ba35e01f","habit-cron.ts","08bfa69a-941a-11f1-b617-1607ee4eb77e",84,["D",1786297504187],2,"// habit-cron.ts -- set this file's trigger to Cron in the Val Town UI.\n//\n// Suggested schedule: every 15 minutes, e.g. \"*/15 * * * *\".\n//\n// runHabitEodSweepSafely() is self-gating (see habit-automation.ts): it\n// only does real work once Bucharest local time has crossed the habit\n// EOD hour, and only once per Bucharest calendar day. That means this\n// cron can fire as often as you like without any risk of double-running\n// the sweep or needing to reason about Val Town's cron timezone vs.\n// Bucharest's DST changes -- a 15-minute cadence just bounds how late\n// the sweep can start after the EOD hour actually ticks over.\n//\n// If you'd rather not run a second Val Town cron val alongside whatever\n// already triggers automation.ts's runAutomationSafely(), you can\n// instead just add a call to runHabitEodSweepSafely(\"cron\") inside that\n// existing cron handler -- it's independent and side-effect-free to\n// call from anywhere.\n\nimport { runHabitEodSweepSafely } from \"./habit-automation.ts\";\n\nexport default async function () {\n const result = await runHabitEodSweepSafely(\"cron\");\n console.log(\"Habit EOD sweep:\", JSON.stringify(result));\n return result;\n}",[163],"aabbeab8-8388-43b2-ae22-e8e9352b75b4","habit-automation.ts","e6e92aa0-9419-11f1-80c0-1607ee4eb77e",81,["D",1786297459164],"// habit-automation.ts\n//\n// Automation #3: completion tracking for tasks carrying the \"habit\"\n// label. Todoist's own Activity Report isn't great for this, so instead\n// each habit task gets a single comment per calendar month that's\n// permanently edited in place as a running log:\n//\n// # August 2026\n// - 08/08 - ✅\n// - 09/08 - ❌\n//\n// Two things feed that log:\n//\n// 1. COMPLETION (instant, webhook-driven): when a habit task is\n// completed, processHabitCompletion() records a ✅ against the due\n// date the task actually had *at the moment it was completed* --\n// not \"today\", and not the live task's due date. This matters\n// because (a) completing a recurring task immediately rolls its due\n// date forward to the next occurrence server-side, before our\n// webhook even fires, and (b) the user may deliberately backdate a\n// habit task and complete it late to record a forgotten day. Both\n// cases mean the live task's due date is the wrong thing to read, so\n// this looks up the actual completed instance via Todoist's\n// completed-tasks archive instead (see resolveCompletedDueDate).\n//\n// 2. FAILURE (daily EOD sweep): processHabitEodSweep() finds habit\n// tasks that are due today or still overdue from an earlier day,\n// records a ❌ against their *current* due date (so backlog gets one\n// entry logged per day it's swept, not silently skipped), and then\n// advances the due date to the next occurrence itself -- so instead\n// of sitting overdue forever, a daily habit reappears as \"today\"\n// (not \"tomorrow\": the next occurrence after a stale due date one\n// day in the past *is* today), a weekly habit jumps to next week,\n// etc. This deliberately does NOT use Todoist's own \"complete\" (it\n// would both wrongly count as a real completion in Todoist's own\n// stats and would fire our own completion webhook, logging a\n// contradictory ✅ for a task that just failed). Instead\n// computeNextOccurrence() parses the task's own recurrence string\n// and does the date math directly, so changing a habit's cadence\n// (daily <-> weekly <-> whatever) just works without reconfiguring\n// anything here.\n//\n// Both paths funnel through upsertHabitLogEntry(), which is idempotent:\n// re-recording the same date with the same status is a no-op, and\n// recording over an existing entry for that date (e.g. the user\n// completes a backdated task that the EOD sweep had already marked ❌)\n// overwrites it rather than duplicating a line. That also makes\n// duplicate webhook deliveries harmless.\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport {\n AutomationResult,\n getBucharestParts,\n ROLLOVER_HOUR,\n withBlobLock,\n} from \"./automation.ts\";\nimport {\n addComment,\n getCompletedTasksByCompletionDate,\n getTask,\n getTaskComments,\n getTasksByLabel,\n TodoistDue,\n TodoistTask,\n updateComment,\n updateTask,\n} from \"./todoist.ts\";\n\nexport const HABIT_LABEL = \"habit\";\n\n// \"End of day\" for habits reuses the same 9 PM Bucharest boundary as the\n// \"execute 🌥\" rollover (see automation.ts) -- change independently here\n// if habits should roll over at a different hour.\nexport const HABIT_EOD_HOUR = ROLLOVER_HOUR;\n\nconst pad = (n: number): string => String(n).padStart(2, \"0\");\n\nfunction bucharestDateStr(now: Date): string {\n const p = getBucharestParts(now);\n return `${p.year}-${pad(p.month)}-${pad(p.day)}`;\n}\n\nfunction sleep(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction extractDueDateStr(task: TodoistTask): string | null {\n if (!task.due || !task.due.date) return null;\n return task.due.date.split(\"T\")[0];\n}\n\n// --- Date-string helpers (all dates here are plain \"YYYY-MM-DD\" local\n// calendar dates, deliberately not Date objects with a timezone, since\n// that's what Todoist's `due.date` and our comment log both use) -------\n\nfunction formatIsoDateUtc(d: Date): string {\n const y = d.getUTCFullYear();\n const m = String(d.getUTCMonth() + 1).padStart(2, \"0\");\n const day = String(d.getUTCDate()).padStart(2, \"0\");\n return `${y}-${m}-${day}`;\n}\n\nfunction addDaysToDateStr(dateStr: string, days: number): string {\n const [y, m, d] = dateStr.split(\"-\").map(Number);\n const dt = new Date(Date.UTC(y, m - 1, d));\n dt.setUTCDate(dt.getUTCDate() + days);\n return formatIsoDateUtc(dt);\n}\n\nfunction addMonthsToDateStr(dateStr: string, months: number): string {\n const [y, m, d] = dateStr.split(\"-\").map(Number);\n const totalMonths = y * 12 + (m - 1) + months;\n const targetY = Math.floor(totalMonths / 12);\n const targetM = ((totalMonths % 12) + 12) % 12; // 0-indexed, always positive\n const daysInTargetMonth = new Date(Date.UTC(targetY, targetM + 1, 0))\n .getUTCDate();\n const clampedDay = Math.min(d, daysInTargetMonth);\n return formatIsoDateUtc(new Date(Date.UTC(targetY, targetM, clampedDay)));\n}\n\nfunction dayOfWeekUtc(dateStr: string): number {\n // 0 = Sunday .. 6 = Saturday\n const [y, m, d] = dateStr.split(\"-\").map(Number);\n return new Date(Date.UTC(y, m - 1, d)).getUTCDay();\n}\n\nfunction isWeekendStr(dateStr: string): boolean {\n const dow = dayOfWeekUtc(dateStr);\n return dow === 0 || dow === 6;\n}\n\n// --- Recurrence parsing: \"next occurrence after this due date\" --------\n//\n// Deliberately anchored on the OLD (possibly stale) due date rather than\n// \"today\" -- see the file header for why. Only covers common English\n// phrasings Todoist's own NLP produces (every day / every N days /\n// every weekday / every week / every N weeks / every month / every N\n// months / every year / every , each optionally with a\n// trailing \"!\"). Anything else is deliberately left alone (returns\n// null) rather than guessed at, so an unrecognized pattern just stays\n// overdue for you to notice and fix by hand instead of silently landing\n// on the wrong date.\n\nexport interface NextOccurrenceResult {\n nextDateStr: string | null;\n reason?: string;\n}\n\nconst WEEKDAY_ABBR: Record = {\n sun: 0,\n mon: 1,\n tue: 2,\n wed: 3,\n thu: 4,\n fri: 5,\n sat: 6,\n};\n\nexport function computeNextOccurrence(\n currentDueDateStr: string,\n due: TodoistDue | null | undefined,\n): NextOccurrenceResult {\n if (!due || !due.is_recurring || !due.string) {\n return { nextDateStr: null, reason: \"task is not recurring\" };\n }\n\n const s = due.string.trim().toLowerCase().replace(/!$/, \"\").trim();\n let m: RegExpExecArray | null;\n\n if (/^every ?day$/.test(s)) {\n return { nextDateStr: addDaysToDateStr(currentDueDateStr, 1) };\n }\n if ((m = /^every (\\d+) days?$/.exec(s))) {\n return {\n nextDateStr: addDaysToDateStr(currentDueDateStr, parseInt(m[1], 10)),\n };\n }\n if (/^every weekday$/.test(s)) {\n let next = addDaysToDateStr(currentDueDateStr, 1);\n while (isWeekendStr(next)) next = addDaysToDateStr(next, 1);\n return { nextDateStr: next };\n }\n if (/^every ?week$/.test(s)) {\n return { nextDateStr: addDaysToDateStr(currentDueDateStr, 7) };\n }\n if ((m = /^every (\\d+) weeks?$/.exec(s))) {\n return {\n nextDateStr: addDaysToDateStr(currentDueDateStr, 7 * parseInt(m[1], 10)),\n };\n }\n if (/^every ?month$/.test(s)) {\n return { nextDateStr: addMonthsToDateStr(currentDueDateStr, 1) };\n }\n if ((m = /^every (\\d+) months?$/.exec(s))) {\n return {\n nextDateStr: addMonthsToDateStr(currentDueDateStr, parseInt(m[1], 10)),\n };\n }\n if (/^every ?year$/.test(s)) {\n return { nextDateStr: addMonthsToDateStr(currentDueDateStr, 12) };\n }\n\n const weekdayList = /^every ([a-z]{3,9}(?:\\s*,\\s*[a-z]{3,9})*)$/.exec(s);\n if (weekdayList) {\n const tokens = weekdayList[1].split(\",\").map((t) => t.trim().slice(0, 3));\n const targetDows = new Set();\n for (const t of tokens) {\n if (t in WEEKDAY_ABBR) targetDows.add(WEEKDAY_ABBR[t]);\n }\n if (targetDows.size > 0) {\n let candidate = addDaysToDateStr(currentDueDateStr, 1);\n for (let i = 0; i < 8; i++) {\n if (targetDows.has(dayOfWeekUtc(candidate))) {\n return { nextDateStr: candidate };\n }\n candidate = addDaysToDateStr(candidate, 1);\n }\n }\n }\n\n return {\n nextDateStr: null,\n reason: `unrecognized recurrence pattern: \"${due.string}\"`,\n };\n}\n\n// --- Monthly comment log ------------------------------------------------\n\nfunction monthHeader(dateStr: string): string {\n const [y, m] = dateStr.split(\"-\").map(Number);\n const monthName = new Date(Date.UTC(y, m - 1, 1)).toLocaleString(\"en-US\", {\n month: \"long\",\n timeZone: \"UTC\",\n });\n return `# ${monthName} ${y}`;\n}\n\nfunction formatEntryDate(dateStr: string): string {\n const [, m, d] = dateStr.split(\"-\");\n return `${d}/${m}`;\n}\n\ninterface ParsedHabitLog {\n header: string;\n entries: Map; // \"DD/MM\" -> status emoji\n}\n\nfunction parseHabitComment(content: string): ParsedHabitLog | null {\n const lines = content.split(\"\\n\").map((l) => l.trim()).filter(Boolean);\n if (lines.length === 0 || !lines[0].startsWith(\"# \")) return null;\n\n const entries = new Map();\n const lineRe = /^-\\s*(\\d{2}\\/\\d{2})\\s*-\\s*(.+)$/;\n for (let i = 1; i < lines.length; i++) {\n const m = lineRe.exec(lines[i]);\n if (m) entries.set(m[1], m[2].trim());\n }\n return { header: lines[0], entries };\n}\n\nfunction renderHabitComment(\n header: string,\n entries: Map,\n): string {\n const sorted = [...entries.entries()].sort((a, b) => {\n const dayA = parseInt(a[0].split(\"/\")[0], 10);\n const dayB = parseInt(b[0].split(\"/\")[0], 10);\n return dayA - dayB;\n });\n return [header, ...sorted.map(([date, status]) => `- ${date} - ${status}`)]\n .join(\"\\n\");\n}\n\n/** Records `status` against `dueDateStr` in the habit task's log comment\n * for that date's month, creating the comment if this is its first\n * entry for that month. Idempotent: a no-op if that date already has\n * that exact status recorded. */\nasync function upsertHabitLogEntry(\n taskId: string,\n dueDateStr: string,\n status: \"✅\" | \"❌\",\n): Promise<{ changed: boolean }> {\n const header = monthHeader(dueDateStr);\n const entryDate = formatEntryDate(dueDateStr);\n\n const comments = await getTaskComments(taskId);\n const existing = comments.find((c) =>\n (c.content ?? \"\").trim().startsWith(header)\n );\n\n if (existing) {\n const parsed = parseHabitComment(existing.content) ??\n { header, entries: new Map() };\n if (parsed.entries.get(entryDate) === status) {\n return { changed: false };\n }\n parsed.entries.set(entryDate, status);\n await updateComment(\n existing.id,\n renderHabitComment(header, parsed.entries),\n );\n return { changed: true };\n }\n\n const entries = new Map([[entryDate, status]]);\n await addComment(taskId, renderHabitComment(header, entries));\n return { changed: true };\n}\n\n// --- Completion tracking (webhook-driven) --------------------------------\n\nfunction habitTaskLockKey(taskId: string): string {\n return `todoist-processor:habit-task-lock:${taskId}`;\n}\n\n/** Finds the due date a just-completed task instance actually had, via\n * the completed-tasks archive (see file header for why the live task\n * can't be used). Archive indexing can lag slightly behind the\n * webhook, so this retries briefly before falling back to whatever due\n * date the webhook payload itself carried, and finally to today's\n * Bucharest date as a last resort. */\nasync function resolveCompletedDueDate(\n taskId: string,\n fallbackDueDateStr: string | null,\n): Promise {\n const now = new Date();\n const since = new Date(now.getTime() - 15 * 60 * 1000).toISOString();\n const until = new Date(now.getTime() + 2 * 60 * 1000).toISOString();\n\n for (let attempt = 0; attempt < 3; attempt++) {\n try {\n const completed = await getCompletedTasksByCompletionDate(since, until);\n const matches = completed.filter((t) => String(t.id) === String(taskId));\n if (matches.length > 0) {\n matches.sort((a, b) =>\n String(b.completed_at ?? \"\").localeCompare(\n String(a.completed_at ?? \"\"),\n )\n );\n const dueDate = matches[0].due?.date;\n if (dueDate) return dueDate.split(\"T\")[0];\n }\n } catch (e) {\n console.warn(\n `[habit] completed-archive lookup failed for task ${taskId} (attempt ${attempt}):`,\n e,\n );\n }\n if (attempt < 2) await sleep(1500);\n }\n\n if (fallbackDueDateStr) {\n console.warn(\n `[habit] Could not confirm completed due date for task ${taskId} via archive; using webhook payload's due date (${fallbackDueDateStr}) instead.`,\n );\n return fallbackDueDateStr;\n }\n\n const todayStr = bucharestDateStr(new Date());\n console.warn(\n `[habit] Could not determine completed due date for task ${taskId}; falling back to today (${todayStr}).`,\n );\n return todayStr;\n}\n\nasync function processHabitCompletionInner(\n taskId: string,\n fallback: { dueDateStr?: string | null; labels?: string[] | null },\n): Promise {\n let labels: string[] | undefined;\n try {\n const task = await getTask(taskId);\n labels = task.labels ?? undefined;\n } catch (e) {\n // Non-recurring tasks disappear from the active-tasks endpoint once\n // completed, so a 404 here is expected -- fall back to whatever\n // labels the webhook payload itself carried.\n console.warn(\n `[habit] Could not fetch task ${taskId} fresh; using webhook payload labels instead:`,\n e,\n );\n labels = fallback.labels ?? undefined;\n }\n\n if (!labels || !labels.includes(HABIT_LABEL)) {\n return { status: \"ignored\", reason: \"task does not carry the habit label\" };\n }\n\n const dueDateStr = await resolveCompletedDueDate(\n taskId,\n fallback.dueDateStr ?? null,\n );\n const { changed } = await upsertHabitLogEntry(taskId, dueDateStr, \"✅\");\n\n return {\n status: \"success\",\n task_id: taskId,\n recorded_date: dueDateStr,\n changed,\n };\n}\n\n/** Entry point for the `item:completed` webhook path. Safe to call for\n * any completed task -- tasks without the habit label are ignored. */\nexport async function processHabitCompletion(\n taskId: string,\n fallback: { dueDateStr?: string | null; labels?: string[] | null } = {},\n): Promise {\n return withBlobLock({\n lockKey: habitTaskLockKey(taskId),\n ttlMs: 20 * 1000,\n trigger: \"webhook:item:completed\",\n run: () => processHabitCompletionInner(taskId, fallback),\n });\n}\n\n// --- EOD failure sweep ----------------------------------------------------\n\nasync function processHabitTaskFailure(\n task: TodoistTask,\n dueDateStr: string,\n): Promise {\n const { changed } = await upsertHabitLogEntry(task.id, dueDateStr, \"❌\");\n const { nextDateStr, reason } = computeNextOccurrence(dueDateStr, task.due);\n\n if (nextDateStr) {\n await updateTask(task.id, { due_date: nextDateStr });\n return {\n status: \"success\",\n logged_changed: changed,\n due_before: dueDateStr,\n due_after: nextDateStr,\n };\n }\n\n return {\n status: \"success\",\n logged_changed: changed,\n left_overdue: true,\n due: dueDateStr,\n reason,\n };\n}\n\nexport async function processHabitEodSweep(): Promise {\n const todayStr = bucharestDateStr(new Date());\n\n let tasks: TodoistTask[];\n try {\n tasks = await getTasksByLabel(HABIT_LABEL);\n } catch (e) {\n console.error(\"Failed to fetch habit tasks for EOD sweep:\", e);\n return { status: \"error\", message: `Failed to fetch habit tasks: ${e}` };\n }\n\n let failedLogged = 0;\n let rescheduled = 0;\n let leftOverdue = 0;\n let skipped = 0;\n let errorCount = 0;\n const logLines: string[] = [];\n const errors: string[] = [];\n\n for (const task of tasks) {\n const dueDateStr = extractDueDateStr(task);\n if (!dueDateStr || dueDateStr > todayStr) continue; // not due yet, nothing to do\n\n try {\n const result = await withBlobLock({\n lockKey: habitTaskLockKey(task.id),\n ttlMs: 20 * 1000,\n trigger: \"eod-sweep\",\n run: () => processHabitTaskFailure(task, dueDateStr),\n });\n\n if (result.status === \"skipped\") {\n skipped++;\n logLines.push(\n `Task ${task.id} ('${task.content}') skipped: a completion was in progress concurrently.`,\n );\n continue;\n }\n if (result.status === \"error\") {\n errorCount++;\n errors.push(`Task ${task.id}: ${result.message}`);\n continue;\n }\n\n failedLogged++;\n if (result.due_after) {\n rescheduled++;\n logLines.push(\n `Task ${task.id} ('${task.content}') ❌ for ${dueDateStr}, rescheduled to ${result.due_after}`,\n );\n } else {\n leftOverdue++;\n logLines.push(\n `Task ${task.id} ('${task.content}') ❌ for ${dueDateStr}, left overdue (${result.reason})`,\n );\n }\n } catch (e) {\n errorCount++;\n errors.push(`Task ${task.id}: ${e}`);\n console.error(`[habit] EOD sweep failed for task ${task.id}:`, e);\n }\n }\n\n return {\n status: \"success\",\n date: todayStr,\n found: tasks.length,\n failed_logged: failedLogged,\n rescheduled,\n left_overdue: leftOverdue,\n skipped,\n failed: errorCount,\n log: logLines,\n errors,\n };\n}\n\n// --- Orchestration: once-per-day gate + shared blob lock -----------------\n\nconst HABIT_SWEEP_LOCK_KEY = \"todoist-processor:habit-eod-sweep-lock\";\nconst HABIT_SWEEP_LOCK_TTL_MS = 3 * 60 * 1000;\nconst HABIT_SWEEP_MARKER_KEY = \"todoist-processor:habit-eod-sweep-marker\";\n\ninterface SweepMarker {\n date: string;\n}\n\n/** Safe to call as often as you like (e.g. every 15 minutes via Cron) --\n * this only actually does anything once Bucharest local time has\n * crossed HABIT_EOD_HOUR, and only once per Bucharest calendar day\n * (tracked via a blob marker), so frequent/imprecise cron firing is\n * both harmless and DST-proof: there's no need to guess Val Town's\n * cron timezone or land the trigger at exactly the right minute. */\nexport async function runHabitEodSweepSafely(\n trigger: string,\n): Promise {\n const now = new Date();\n const parts = getBucharestParts(now);\n\n if (parts.hour < HABIT_EOD_HOUR) {\n return {\n status: \"skipped\",\n trigger,\n message:\n `Not EOD yet (Bucharest hour ${parts.hour} < ${HABIT_EOD_HOUR}).`,\n };\n }\n\n const todayStr = bucharestDateStr(now);\n const marker = (await blob.getJSON(HABIT_SWEEP_MARKER_KEY)) as\n | SweepMarker\n | undefined;\n if (marker?.date === todayStr) {\n return {\n status: \"skipped\",\n trigger,\n message: `Habit EOD sweep already completed today (${todayStr}).`,\n };\n }\n\n const result = await withBlobLock({\n lockKey: HABIT_SWEEP_LOCK_KEY,\n ttlMs: HABIT_SWEEP_LOCK_TTL_MS,\n trigger,\n run: processHabitEodSweep,\n });\n\n if (result.status === \"success\") {\n try {\n await blob.setJSON(\n HABIT_SWEEP_MARKER_KEY,\n { date: todayStr } satisfies SweepMarker,\n );\n } catch (e) {\n console.error(\n \"[habit] Failed to persist EOD sweep marker (sweep still ran successfully):\",\n e,\n );\n }\n }\n\n return result;\n}",[171],"a65f7dd1-2da9-4b39-8556-2688c069ed59","gemini.ts","fb4f0350-8cff-11f1-8a64-1607ee4eb77e",72,["D",1785516648586],"// gemini.ts\n//\n// Dependency-free Gemini REST client (mirrors the style of todoist.ts --\n// no SDK, just fetch). This file knows nothing about Todoist or emoji\n// categories; it only knows how to call generateContent with a given\n// model + key and how to retry across a configured list of models/keys.\n// classifier.ts builds the actual classification prompt on top of this.\n//\n// Retry/cycling behaviour (per spec):\n// 1. Try the current model with key #1.\n// 2. On ANY failure (network error, non-2xx response, or the caller's\n// parseResponse callback rejecting the content as invalid) retry the\n// SAME model with the next key.\n// 3. Once every key has failed for a model, move to the next model and\n// start again from key #1.\n// 4. If every model x key combination fails, throw GeminiExhaustedError\n// with the full attempt log -- callers should surface this rather\n// than swallow it.\n//\n// Timing note: Val Town's free-plan execution timeout is 1 minute per val\n// run (see https://www.val.town/limits), and both the cron sweep and the\n// webhook handler share that ceiling. classifier.ts requests\n// thinkingLevel \"medium\" (see below), which adds real latency on top of\n// a plain non-thinking call -- FETCH_TIMEOUT_MS is set generously enough\n// to let that finish normally rather than falsely timing out a\n// legitimately-in-progress response. In practice, actual failures (bad\n// key, rate limit, quota) return fast because auth/quota checks happen\n// before the model starts reasoning, so a realistic retry chain is much\n// faster than the worst case. But if you configure many keys and Gemini\n// is genuinely hanging (not erroring) on most of them, a full exhaustion\n// chain can still exceed the 60s ceiling -- that's a platform limit this\n// file can't route around. Upgrading to Pro (10 min execution timeout)\n// removes the pressure if that scenario matters to you.\n//\n// Model note: Gemini 3-series models are explicitly tuned around the\n// default temperature of 1.0 -- Google's own docs warn that forcing it\n// lower \"may lead to unexpected behavior, such as looping or degraded\n// performance.\" So unlike a lot of older classification-prompt advice,\n// this file does NOT default temperature to 0; it leaves it unset\n// unless a caller explicitly opts in.\n\nconst GEMINI_BASE = \"https://generativelanguage.googleapis.com/v1beta\";\n\nconst DEFAULT_MODEL_PRIORITY = [\"gemini-3.6-flash\", \"gemini-3.5-flash\"];\n\nconst FETCH_TIMEOUT_MS = 12_000; // per attempt -- generous enough for medium-thinking on a small batch\nconst BASE_BACKOFF_MS = 200;\nconst MAX_BACKOFF_MS = 800;\n\nexport interface GeminiConfig {\n /** Ordered priority list, e.g. [\"gemini-3.6-flash\", \"gemini-3.5-flash\"]. */\n models: string[];\n /** Keys to cycle through, in order, for whichever model is currently active. */\n apiKeys: string[];\n}\n\nexport type ThinkingLevel = \"minimal\" | \"low\" | \"medium\" | \"high\";\n\nexport interface GeminiCallOptions {\n systemInstruction?: string;\n /** Gemini generationConfig.responseSchema -- pass together with responseMimeType. */\n responseSchema?: unknown;\n /** Gemini generationConfig.responseMimeType, e.g. \"application/json\" for a schema-constrained object/array. */\n responseMimeType?: string;\n /** Left unset by default -- see the \"Model note\" above on why this file doesn't default to 0. */\n temperature?: number;\n maxOutputTokens?: number;\n /** generationConfig.thinkingConfig.thinkingLevel. \"medium\" is supported on\n * Flash-tier Gemini 3 models per ai.google.dev/gemini-api/docs/gemini-3.\n * Do not combine with the legacy thinkingBudget field -- Gemini returns\n * a 400 if both are present. */\n thinkingLevel?: ThinkingLevel;\n}\n\nexport interface GeminiAttemptFailure {\n model: string;\n keyIndex: number; // 0-based\n status?: number;\n message: string;\n}\n\nexport class GeminiExhaustedError extends Error {\n attempts: GeminiAttemptFailure[];\n constructor(attempts: GeminiAttemptFailure[]) {\n const detail = attempts\n .map((a) => `${a.model} key#${a.keyIndex + 1}${a.status ? ` (${a.status})` : \"\"}: ${a.message}`)\n .join(\"; \");\n super(`All Gemini models/keys exhausted after ${attempts.length} attempt(s): ${detail}`);\n this.name = \"GeminiExhaustedError\";\n this.attempts = attempts;\n }\n}\n\n/** Reads GEMINI_API_KEYS (comma-separated) and, optionally, GEMINI_MODELS\n * (comma-separated, overrides the built-in priority order) from the\n * environment. Keeping the keys/model order in env vars rather than\n * hardcoded arrays means adding a key or reordering models is a Val Town\n * environment-variable edit, not a code change. */\nexport function loadGeminiConfigFromEnv(): GeminiConfig {\n const keysRaw = Deno.env.get(\"GEMINI_API_KEYS\") ?? \"\";\n const apiKeys = keysRaw.split(\",\").map((k) => k.trim()).filter(Boolean);\n\n const modelsRaw = Deno.env.get(\"GEMINI_MODELS\");\n const models = modelsRaw\n ? modelsRaw.split(\",\").map((m) => m.trim()).filter(Boolean)\n : DEFAULT_MODEL_PRIORITY;\n\n return { apiKeys, models };\n}\n\nfunction sleep(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nasync function callOnce(\n model: string,\n apiKey: string,\n prompt: string,\n options: GeminiCallOptions,\n): Promise {\n const generationConfig: Record = {\n maxOutputTokens: options.maxOutputTokens ?? 200,\n };\n if (options.temperature !== undefined) {\n generationConfig.temperature = options.temperature;\n }\n if (options.responseMimeType) {\n generationConfig.responseMimeType = options.responseMimeType;\n }\n if (options.responseSchema) {\n generationConfig.responseSchema = options.responseSchema;\n }\n if (options.thinkingLevel) {\n generationConfig.thinkingConfig = { thinkingLevel: options.thinkingLevel };\n }\n\n const body: Record = {\n contents: [{ role: \"user\", parts: [{ text: prompt }] }],\n generationConfig,\n };\n if (options.systemInstruction) {\n body.systemInstruction = { parts: [{ text: options.systemInstruction }] };\n }\n\n let res: Response;\n try {\n res = await fetch(`${GEMINI_BASE}/models/${model}:generateContent`, {\n method: \"POST\",\n headers: {\n \"Content-Type\": \"application/json\",\n \"x-goog-api-key\": apiKey,\n },\n body: JSON.stringify(body),\n signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),\n });\n } catch (e) {\n throw new Error(`network error calling ${model}: ${e instanceof Error ? e.message : e}`);\n }\n\n const rawText = await res.text();\n\n if (!res.ok) {\n const err = new Error(`${model} responded ${res.status}: ${rawText.slice(0, 300)}`);\n (err as Error & { status?: number }).status = res.status;\n throw err;\n }\n\n let data: {\n candidates?: { content?: { parts?: { text?: string }[] } }[];\n };\n try {\n data = JSON.parse(rawText);\n } catch {\n throw new Error(`${model} returned unparsable JSON`);\n }\n\n const text = data.candidates?.[0]?.content?.parts?.[0]?.text;\n if (typeof text !== \"string\" || !text.trim()) {\n throw new Error(`${model} returned an empty/unexpected response shape`);\n }\n return text.trim();\n}\n\n/**\n * Calls Gemini with the model x key retry/cycling described above.\n * `parseResponse` both parses AND validates the raw text -- throwing\n * inside it (e.g. because the model didn't return one of the expected\n * values) is treated exactly like a transport failure and advances to\n * the next key/model, so callers get one retry loop that covers both\n * \"Gemini errored\" and \"Gemini answered but the answer was garbage\".\n */\nexport async function callGeminiWithRetry(\n config: GeminiConfig,\n prompt: string,\n parseResponse: (rawText: string) => T,\n options: GeminiCallOptions = {},\n): Promise {\n if (config.models.length === 0) {\n throw new Error(\"GeminiConfig.models is empty -- set GEMINI_MODELS or check DEFAULT_MODEL_PRIORITY.\");\n }\n if (config.apiKeys.length === 0) {\n throw new Error(\"GeminiConfig.apiKeys is empty -- set GEMINI_API_KEYS in the environment.\");\n }\n\n const attempts: GeminiAttemptFailure[] = [];\n let attemptNumber = 0;\n\n for (const model of config.models) {\n for (let keyIndex = 0; keyIndex < config.apiKeys.length; keyIndex++) {\n if (attemptNumber > 0) {\n const backoff = Math.min(BASE_BACKOFF_MS * 2 ** (attemptNumber - 1), MAX_BACKOFF_MS);\n await sleep(backoff);\n }\n attemptNumber++;\n\n const apiKey = config.apiKeys[keyIndex];\n try {\n const rawText = await callOnce(model, apiKey, prompt, options);\n return parseResponse(rawText);\n } catch (e) {\n const status = (e as Error & { status?: number })?.status;\n const message = e instanceof Error ? e.message : String(e);\n attempts.push({ model, keyIndex, status, message });\n console.warn(\n `[gemini] ${model} key#${keyIndex + 1} failed${status ? ` (${status})` : \"\"}: ${message}`,\n );\n }\n }\n }\n\n throw new GeminiExhaustedError(attempts);\n}",[178],"f8243deb-d2de-4ed3-b4a3-0798b10fb8a5","gcal.ts","0681eb9a-88ee-11f1-9e9d-1607ee4eb77e",16,["D",1785069142043],3,"// gcal.ts\n// Minimal Google Calendar client authenticated with a service-account JWT,\n// signed using the Web Crypto API (crypto.subtle) instead of the googleapis\n// or google-auth-library npm packages. This keeps the val dependency-free --\n// nothing here depends on an npm package's Deno/Pyodide compatibility.\n\nconst CALENDAR_SCOPE = \"https://www.googleapis.com/auth/calendar.events\";\nconst TOKEN_URL = \"https://oauth2.googleapis.com/token\";\n\nfunction base64url(bytes: ArrayBuffer | Uint8Array): string {\n const arr = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);\n let str = \"\";\n for (const b of arr) str += String.fromCharCode(b);\n return btoa(str).replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\nfunction pemToArrayBuffer(pem: string): ArrayBuffer {\n const clean = pem\n .replace(/-----BEGIN PRIVATE KEY-----/, \"\")\n .replace(/-----END PRIVATE KEY-----/, \"\")\n .replace(/\\s/g, \"\");\n const binary = atob(clean);\n const bytes = new Uint8Array(binary.length);\n for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);\n return bytes.buffer;\n}\n\ninterface ServiceAccount {\n client_email: string;\n private_key: string;\n}\n\nfunction loadServiceAccount(): ServiceAccount {\n const json = Deno.env.get(\"GOOGLE_CREDENTIALS_JSON\");\n if (!json) throw new Error(\"GOOGLE_CREDENTIALS_JSON is not set.\");\n return JSON.parse(json) as ServiceAccount;\n}\n\nasync function getAccessToken(): Promise {\n const sa = loadServiceAccount();\n const now = Math.floor(Date.now() / 1000);\n\n const header = { alg: \"RS256\", typ: \"JWT\" };\n const claims = {\n iss: sa.client_email,\n scope: CALENDAR_SCOPE,\n aud: TOKEN_URL,\n iat: now,\n exp: now + 3600,\n };\n\n const encoder = new TextEncoder();\n const signingInput = `${base64url(encoder.encode(JSON.stringify(header)))}.` +\n `${base64url(encoder.encode(JSON.stringify(claims)))}`;\n\n const key = await crypto.subtle.importKey(\n \"pkcs8\",\n pemToArrayBuffer(sa.private_key),\n { name: \"RSASSA-PKCS1-v1_5\", hash: \"SHA-256\" },\n false,\n [\"sign\"],\n );\n\n const signature = await crypto.subtle.sign(\n \"RSASSA-PKCS1-v1_5\",\n key,\n encoder.encode(signingInput),\n );\n\n const jwt = `${signingInput}.${base64url(signature)}`;\n\n const res = await fetch(TOKEN_URL, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/x-www-form-urlencoded\" },\n body: new URLSearchParams({\n grant_type: \"urn:ietf:params:oauth:grant-type:jwt-bearer\",\n assertion: jwt,\n }),\n });\n\n if (!res.ok) {\n throw new Error(\n `Google token exchange failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as { access_token: string };\n return data.access_token;\n}\n\nfunction calendarId(): string {\n return Deno.env.get(\"GCAL_CALENDAR_ID\") || \"primary\";\n}\n\nexport function formatIsoDate(d: Date): string {\n const y = d.getUTCFullYear();\n const m = String(d.getUTCMonth() + 1).padStart(2, \"0\");\n const day = String(d.getUTCDate()).padStart(2, \"0\");\n return `${y}-${m}-${day}`;\n}\n\nfunction addDays(d: Date, days: number): Date {\n return new Date(d.getTime() + days * 24 * 60 * 60 * 1000);\n}\n\nfunction eventBody(taskName: string, deadlineDate: Date) {\n return {\n summary: `🚨 ${taskName}`,\n start: { date: formatIsoDate(deadlineDate), timeZone: \"Europe/Bucharest\" },\n end: {\n date: formatIsoDate(addDays(deadlineDate, 1)),\n timeZone: \"Europe/Bucharest\",\n },\n colorId: \"11\", // Tomato / Deep Red\n };\n}\n\ninterface GcalHttpError extends Error {\n status?: number;\n}\n\nexport async function createGcalEvent(\n taskName: string,\n deadlineDate: Date,\n): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events`,\n {\n method: \"POST\",\n headers: {\n Authorization: `Bearer ${token}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(eventBody(taskName, deadlineDate)),\n },\n );\n if (!res.ok) {\n throw new Error(\n `GCal create event failed: ${res.status} ${await res.text()}`,\n );\n }\n const data = (await res.json()) as { id: string };\n return data.id;\n}\n\nexport async function updateGcalEvent(\n eventId: string,\n taskName: string,\n deadlineDate: Date,\n): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events/${encodeURIComponent(eventId)}`,\n {\n method: \"PUT\",\n headers: {\n Authorization: `Bearer ${token}`,\n \"Content-Type\": \"application/json\",\n },\n body: JSON.stringify(eventBody(taskName, deadlineDate)),\n },\n );\n if (!res.ok) {\n const err: GcalHttpError = new Error(\n `GCal update event failed: ${res.status} ${await res.text()}`,\n );\n err.status = res.status;\n throw err;\n }\n}\n\nexport async function deleteGcalEvent(eventId: string): Promise {\n const token = await getAccessToken();\n const res = await fetch(\n `https://www.googleapis.com/calendar/v3/calendars/${\n encodeURIComponent(calendarId())\n }/events/${encodeURIComponent(eventId)}`,\n { method: \"DELETE\", headers: { Authorization: `Bearer ${token}` } },\n );\n // 404/410 mean it's already gone -- safe to ignore, mirrors the Python original.\n if (!res.ok && res.status !== 404 && res.status !== 410) {\n throw new Error(\n `GCal delete event failed: ${res.status} ${await res.text()}`,\n );\n }\n}",[185],"b8c2e299-e26c-4ab9-9686-932327ac79cd","emoji-automation.ts","fb4eb404-8cff-11f1-8a64-1607ee4eb77e",74,["D",1785524509132],1,"// emoji-automation.ts\n//\n// Automation #2: classify every task's content into exactly one of the\n// CATEGORIES (categories.ts) using Gemini (classifier.ts / gemini.ts) and\n// prepend the result to the task's own content (e.g. \"Fix login bug\" ->\n// \"⚒️ Fix login bug\") -- no Todoist label involved.\n//\n// Two entry points share the same classify-then-update step\n// (classifyBatch) so the retry/apply logic only exists once:\n//\n// - processEmojiSweep() / runEmojiSweepSafely(): the cron batch path.\n// Finds every task missing a category emoji, excludes anything under\n// a 📋 checklist, and works through a bounded number of them per\n// tick in batches of BATCH_SIZE (see below).\n// - processInstantEmojiClassification(taskId): the webhook path. Fires\n// when a task is saved with the literal \"{emoji}\" marker in its\n// content, so on-the-spot testing doesn't require waiting for the\n// next cron tick. Calls the exact same classifyBatch with a batch of\n// one. Saving \"{emoji_all}\" instead runs the full sweep on demand.\n//\n// Locking: the cron sweep is wrapped in its own blob lock (same\n// mechanism as automation.ts's execute-label lock, different key) to\n// stop two overlapping cron ticks from re-scanning the same backlog. The\n// instant webhook path deliberately does NOT take that lock -- it only\n// ever touches the one task named in the webhook payload, so the worst\n// case of a rare overlap with an in-flight sweep is a duplicate\n// (harmless, idempotent-ish -- see computeNewContent) classification of\n// that task, and the whole point of the marker is fast, unblocked\n// feedback while testing.\n\nimport {\n getAllActiveTasks,\n getTask,\n TodoistTask,\n updateTask,\n} from \"./todoist.ts\";\nimport {\n CATEGORY_EMOJIS,\n hasEmojiPrefix,\n hasUncompletablePrefix,\n isChecklistRoot,\n stripUncompletablePrefix,\n} from \"./categories.ts\";\nimport { classifyTasksBatch } from \"./classifier.ts\";\nimport { loadGeminiConfigFromEnv } from \"./gemini.ts\";\nimport { AutomationResult, withBlobLock } from \"./automation.ts\";\n\n// Test markers, accepted with either single or double braces because both\n// get typed in practice ({{emoji}} is the natural thing to write, and\n// stripping only the inner {emoji} used to leave a stray \"{}\" behind).\n// {emoji} -> classify just this task, now\n// {emoji_all} -> run the whole cron sweep now, across every task\nexport const EMOJI_MARKER = \"{emoji}\";\nexport const EMOJI_ALL_MARKER = \"{emoji_all}\";\n\nconst EMOJI_MARKER_RE = /\\{{1,2}\\s*emoji\\s*\\}{1,2}/i;\nconst EMOJI_ALL_MARKER_RE = /\\{{1,2}\\s*emoji_all\\s*\\}{1,2}/i;\nconst ANY_MARKER_RE = /\\{{1,2}\\s*emoji(_all)?\\s*\\}{1,2}/i;\nconst ANY_MARKER_GLOBAL_RE = new RegExp(ANY_MARKER_RE.source, \"gi\");\n\nexport function hasEmojiMarker(content: string): boolean {\n return EMOJI_MARKER_RE.test(content);\n}\n\nexport function hasEmojiAllMarker(content: string): boolean {\n return EMOJI_ALL_MARKER_RE.test(content);\n}\n\nfunction stripMarkers(content: string): string {\n if (!ANY_MARKER_RE.test(content)) return content;\n return content.replace(ANY_MARKER_GLOBAL_RE, \"\").replace(/\\s{2,}/g, \" \")\n .trim();\n}\n\n/** Strips any category emoji this automation may have already prepended\n * (defense against double-prefixing if the sweep and an instant\n * classification ever race on the same task -- see the file header). */\nfunction stripAnyExistingCategoryPrefix(content: string): string {\n const trimmed = content.trimStart();\n for (const emoji of CATEGORY_EMOJIS) {\n if (trimmed.startsWith(emoji)) return trimmed.slice(emoji.length).trim();\n }\n return trimmed;\n}\n\nfunction computeNewContent(originalContent: string, emoji: string): string {\n // \"* \" has to stay in first position or Todoist stops treating the task\n // as uncompletable, so the emoji goes after it, not before it.\n const prefix = hasUncompletablePrefix(originalContent) ? \"* \" : \"\";\n const body = stripAnyExistingCategoryPrefix(\n stripMarkers(stripUncompletablePrefix(originalContent)),\n );\n // Guard a task whose *entire* content was the marker (e.g. a bare\n // \"{emoji}\" test task): don't leave the task blank, just the emoji.\n return body ? `${prefix}${emoji} ${body}` : `${prefix}${emoji}`;\n}\n\nasync function applyClassification(\n task: TodoistTask,\n emoji: string,\n): Promise {\n await updateTask(task.id, {\n content: computeNewContent(task.content, emoji),\n });\n}\n\n// --- Checklist-root exclusion --------------------------------------------\n//\n// A task whose content starts with 📋, or that is a child/grandchild/...\n// of one, is reference material (a checklist), not actionable work --\n// it and its whole subtree are skipped. `lookupParent` abstracts over\n// how a parent task is found so the cron sweep (which already has every\n// active task in memory) can do this with zero extra API calls, while\n// the webhook path (which only has the one task) can look parents up\n// live, one at a time.\n\nconst MAX_ANCESTOR_DEPTH = 10;\n\nexport async function isUnderChecklistRoot(\n task: TodoistTask,\n lookupParent: (\n parentId: string,\n ) => TodoistTask | undefined | Promise,\n maxDepth = MAX_ANCESTOR_DEPTH,\n): Promise {\n let parentId = task.parent_id ?? undefined;\n for (let depth = 0; depth < maxDepth && parentId; depth++) {\n const parent = await lookupParent(parentId);\n if (!parent) return false; // can't resolve further -- fail open, don't block classification\n if (isChecklistRoot(parent.content)) return true;\n parentId = parent.parent_id ?? undefined;\n }\n return false;\n}\n\n// --- Shared classify-and-apply step --------------------------------------\n\nexport interface ClassifyOutcome {\n taskId: string;\n emoji: string;\n}\n\nexport interface ClassifyBatchResult {\n applied: ClassifyOutcome[];\n failed: { taskId: string; error: string }[];\n}\n\n/**\n * The one function both the cron sweep and the instant webhook path call:\n * classifies `tasks` (up to BATCH_SIZE of them) in a single Gemini call\n * and applies each result to Todoist. A batch of one task -- exactly\n * what the webhook path passes -- works the same way as a batch of five.\n */\nexport async function classifyBatch(\n tasks: TodoistTask[],\n): Promise {\n const applied: ClassifyOutcome[] = [];\n const failed: { taskId: string; error: string }[] = [];\n if (tasks.length === 0) return { applied, failed };\n\n const config = loadGeminiConfigFromEnv();\n const inputs = tasks.map((t) => ({\n id: t.id,\n content: stripMarkers(stripUncompletablePrefix(t.content)),\n }));\n\n let results: Map;\n try {\n results = await classifyTasksBatch(inputs, config);\n } catch (e) {\n // Whole batch failed (Gemini exhausted, or the response never came\n // back complete/valid after every retry) -- every task in it stays\n // unclassified and will be picked up again on the next sweep/trigger.\n const message = e instanceof Error ? e.message : String(e);\n console.error(\n `[emoji] Batch classification failed for ${tasks.length} task(s): ${message}`,\n );\n for (const t of tasks) failed.push({ taskId: t.id, error: message });\n return { applied, failed };\n }\n\n for (const task of tasks) {\n const emoji = results.get(task.id);\n if (!emoji) {\n // Shouldn't happen -- classifyTasksBatch only resolves once every\n // requested id has a valid emoji -- but never trust silently.\n failed.push({\n taskId: task.id,\n error: \"Gemini response omitted this task id\",\n });\n continue;\n }\n try {\n await applyClassification(task, emoji);\n applied.push({ taskId: task.id, emoji });\n } catch (e) {\n failed.push({\n taskId: task.id,\n error: e instanceof Error ? e.message : String(e),\n });\n }\n }\n\n return { applied, failed };\n}\n\nfunction chunk(items: T[], size: number): T[][] {\n const chunks: T[][] = [];\n for (let i = 0; i < items.length; i += size) {\n chunks.push(items.slice(i, i + size));\n }\n return chunks;\n}\n\nasync function forEachWithConcurrency(\n items: T[],\n limit: number,\n fn: (item: T) => Promise,\n): Promise {\n let nextIndex = 0;\n async function worker() {\n while (true) {\n const i = nextIndex++;\n if (i >= items.length) return;\n await fn(items[i]);\n }\n }\n const workers = Array.from({ length: Math.min(limit, items.length) }, worker);\n await Promise.all(workers);\n}\n\n// --- Cron path: batch sweep ---------------------------------------------\n//\n// Batch size of 5 per your spec. Val Town's free-plan execution timeout\n// is 1 minute per run (shared with whatever else runs in the same cron\n// tick -- see gemini.ts's header comment on timing), so this caps how\n// many batches one tick will attempt; anything past the cap rolls over\n// to the next 15-minute tick automatically (the sweep re-scans\n// everything, so nothing gets lost, just deferred).\n\nconst BATCH_SIZE = 5;\nconst MAX_BATCHES_PER_SWEEP = 2;\nconst SWEEP_BATCH_CONCURRENCY = 2;\n\nexport async function processEmojiSweep(): Promise {\n let allTasks: TodoistTask[];\n try {\n allTasks = await getAllActiveTasks();\n } catch (e) {\n console.error(\"Failed to fetch tasks for emoji sweep:\", e);\n return { status: \"error\", message: `Failed to fetch tasks: ${e}` };\n }\n\n const taskById = new Map(allTasks.map((t) => [t.id, t] as const));\n\n const needsClassification: TodoistTask[] = [];\n let checklistSkipped = 0;\n for (const task of allTasks) {\n if (hasEmojiPrefix(task.content)) continue;\n if (await isUnderChecklistRoot(task, (id) => taskById.get(id))) {\n checklistSkipped++;\n continue;\n }\n needsClassification.push(task);\n }\n\n const allBatches = chunk(needsClassification, BATCH_SIZE);\n const batches = allBatches.slice(0, MAX_BATCHES_PER_SWEEP);\n const processedCount = batches.reduce((n, b) => n + b.length, 0);\n const deferred = needsClassification.length - processedCount;\n\n let updatedCount = 0;\n let errorCount = 0;\n const log: string[] = [];\n const errors: string[] = [];\n\n await forEachWithConcurrency(\n batches,\n SWEEP_BATCH_CONCURRENCY,\n async (batch) => {\n const { applied, failed } = await classifyBatch(batch);\n for (const a of applied) {\n updatedCount++;\n const msg = `Task ${a.taskId} prefixed ${a.emoji}`;\n log.push(msg);\n console.log(`[emoji] ${msg}`);\n }\n for (const f of failed) {\n errorCount++;\n const msg = `Failed to classify task ${f.taskId}: ${f.error}`;\n errors.push(msg);\n console.error(`[emoji] ${msg}`);\n }\n },\n );\n\n return {\n status: \"success\",\n found: needsClassification.length,\n checklist_skipped: checklistSkipped,\n processed: processedCount,\n deferred,\n updated: updatedCount,\n failed: errorCount,\n log,\n errors,\n };\n}\n\nconst EMOJI_LOCK_KEY = \"todoist-processor:emoji-lock\";\nconst EMOJI_LOCK_TTL_MS = 3 * 60 * 1000; // see automation.ts's withBlobLock doc comment\n\nexport async function runEmojiSweepSafely(\n trigger: string,\n): Promise {\n return withBlobLock({\n lockKey: EMOJI_LOCK_KEY,\n ttlMs: EMOJI_LOCK_TTL_MS,\n trigger,\n run: processEmojiSweep,\n });\n}\n\n// --- Webhook path: instant single-task classification -------------------\n\n/**\n * Re-fetches `taskId` (rather than trusting the webhook payload, which\n * may be stale or a partial snapshot) and, if it still carries the\n * {emoji} marker and isn't excluded (already classified, or a checklist\n * item), runs it through the same classifyBatch as the sweep, as a batch\n * of one. Not lock-guarded -- see the file header for why that's fine.\n */\nexport async function processInstantEmojiClassification(\n taskId: string,\n): Promise {\n let task: TodoistTask;\n try {\n task = await getTask(taskId);\n } catch (e) {\n console.error(\n `Failed to fetch task ${taskId} for instant classification:`,\n e,\n );\n return { status: \"error\", message: `Failed to fetch task ${taskId}: ${e}` };\n }\n\n if (!hasEmojiMarker(task.content)) {\n // Re-fetched content no longer has the marker (already handled by a\n // prior delivery, or edited again before we got to it) -- no-op.\n return { status: \"skipped\", message: \"Marker no longer present on task.\" };\n }\n if (hasEmojiPrefix(task.content)) {\n return { status: \"skipped\", message: \"Task already starts with an emoji.\" };\n }\n\n const lookupParent = async (id: string): Promise => {\n try {\n return await getTask(id);\n } catch {\n return undefined;\n }\n };\n if (await isUnderChecklistRoot(task, lookupParent)) {\n return {\n status: \"skipped\",\n message:\n \"Task is under a 📋 checklist -- reference item, not classified.\",\n };\n }\n\n const { applied, failed } = await classifyBatch([task]);\n if (applied.length > 0) {\n console.log(\n `[emoji] Instant classification: task ${applied[0].taskId} prefixed ${\n applied[0].emoji\n }`,\n );\n return { status: \"success\", ...applied[0] };\n }\n const failure = failed[0];\n console.error(\n `[emoji] Instant classification failed for task ${taskId}: ${failure?.error}`,\n );\n return { status: \"error\", message: failure?.error ?? \"unknown error\" };\n}",[193],"a6ea1508-4c62-4607-9168-427a692fbe31","descriptionParser.ts","10475c96-88ee-11f1-ae26-1607ee4eb77e",19,["D",1785069160408],"// descriptionParser.ts\n// Direct port of the Python parse_description() function: separates the\n// GCal Event ID header from the user's actual description text, and cleans\n// up stacked/orphaned headers left behind by older formatting bugs.\n\nexport interface ParsedDescription {\n eventId: string | null;\n cleanDescription: string;\n}\n\nconst FULL_HEADER_PATTERN =\n /^🚨 (?:\\d{1,2}\\s+[A-Za-z]{3}|\\d{2}-\\d{2}-\\d{4}) 🚨\\s+GCal Event Id = ([a-zA-Z0-9_]+)\\s+---\\s*/u;\nconst ORPHANED_ID_PATTERN = /^GCal Event Id = ([a-zA-Z0-9_]+)\\s+---\\s*/u;\nconst OLD_HEADER_PATTERN =\n /^🚨 (?:\\d{1,2}\\s+[A-Za-z]{3}|\\d{2}-\\d{2}-\\d{4}) 🚨\\s*(?:---\\s*)?/u;\n\nexport function parseDescription(desc: string): ParsedDescription {\n if (!desc) return { eventId: null, cleanDescription: \"\" };\n\n let eventId: string | null = null;\n let cleanDesc = desc.trim();\n\n while (true) {\n let match = cleanDesc.match(FULL_HEADER_PATTERN);\n if (match) {\n if (!eventId) eventId = match[1];\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n match = cleanDesc.match(ORPHANED_ID_PATTERN);\n if (match) {\n if (!eventId) eventId = match[1];\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n match = cleanDesc.match(OLD_HEADER_PATTERN);\n if (match) {\n cleanDesc = cleanDesc.slice(match[0].length).trim();\n continue;\n }\n\n break;\n }\n\n return { eventId, cleanDescription: cleanDesc };\n}",[201],"8139d323-038e-4be5-af08-b82510088ef4","classifier.ts","fb4e85d8-8cff-11f1-8a64-1607ee4eb77e",["D",1785516648586],"// classifier.ts\n//\n// Domain glue: turns a batch of tasks' text content into category emoji\n// (categories.ts) using Gemini (gemini.ts). Knows nothing about Todoist\n// task objects, the {emoji} marker, or checklist exclusion -- just\n// \"given these id+content pairs, which emoji does each get\".\n//\n// Batched by design: one Gemini call classifies up to BATCH_SIZE tasks\n// (see emoji-automation.ts) at once, and the model is asked to answer\n// with id + emoji only -- never asked to echo back task content, so a\n// batch's output is a handful of short JSON objects rather than a\n// restatement of everything it was given.\n\nimport { CATEGORIES, CATEGORY_EMOJIS } from \"./categories.ts\";\nimport { callGeminiWithRetry, GeminiConfig } from \"./gemini.ts\";\n\nconst VALID_EMOJIS = CATEGORIES.map((c) => c.emoji);\n\nconst SYSTEM_INSTRUCTION =\n \"You are a strict classifier for a personal to-do list. For each task \" +\n \"given, choose exactly one category and output only its emoji -- never \" +\n \"the category name, never the task content, never any explanation. \" +\n \"If a task is genuinely ambiguous, pick the closest match rather than \" +\n \"omitting it.\";\n\nfunction buildBatchPrompt(tasks: { id: string; content: string }[]): string {\n const categoryLines = CATEGORIES\n .map((c) => `- \"${c.emoji}\" -- ${c.name}: ${c.description}`)\n .join(\"\\n\");\n const taskLines = tasks\n .map((t) => `- id=\"${t.id}\" content=${JSON.stringify(t.content)}`)\n .join(\"\\n\");\n\n return (\n `Categories:\\n${categoryLines}\\n\\n` +\n `Classify each task below into exactly one category. Respond with a ` +\n `JSON array with one object per task: {\"id\": , \"emoji\": }.\\n\\n` +\n `Tasks:\\n${taskLines}`\n );\n}\n\ninterface RawBatchItem {\n id?: unknown;\n emoji?: unknown;\n}\n\n/** Throws (rather than returning a partial result) if the response isn't\n * a clean JSON array, if any item's emoji isn't one of the 13 valid\n * category emoji, or if any requested id is missing from the response.\n * callGeminiWithRetry treats a thrown error here exactly like a\n * transport failure and moves on to the next key/model -- so an\n * incomplete-but-otherwise-valid-looking answer gets a real retry\n * rather than silently shipping partial results. */\nfunction parseBatchResponse(\n rawText: string,\n requestedIds: Set,\n): Map {\n let parsed: unknown;\n try {\n parsed = JSON.parse(rawText);\n } catch {\n throw new Error(\n `batch response was not valid JSON: ${rawText.slice(0, 200)}`,\n );\n }\n if (!Array.isArray(parsed)) {\n throw new Error(\n `batch response was not a JSON array: ${rawText.slice(0, 200)}`,\n );\n }\n\n const result = new Map();\n for (const raw of parsed as RawBatchItem[]) {\n if (typeof raw !== \"object\" || raw === null) continue;\n const { id, emoji } = raw;\n if (typeof id !== \"string\" || typeof emoji !== \"string\") continue;\n if (!requestedIds.has(id)) continue; // ignore ids we didn't ask about\n if (!CATEGORY_EMOJIS.has(emoji)) {\n throw new Error(\n `task ${id}: unrecognized emoji in batch response: ${\n JSON.stringify(emoji)\n }`,\n );\n }\n result.set(id, emoji);\n }\n\n const missing = [...requestedIds].filter((id) => !result.has(id));\n if (missing.length > 0) {\n throw new Error(\n `batch response missing ${missing.length}/${requestedIds.size} requested id(s): ${\n missing.join(\", \")\n }`,\n );\n }\n\n return result;\n}\n\n/**\n * Classifies a batch of up to a few tasks in a single Gemini call,\n * returning a map from task id to category emoji. Retries across every\n * configured model x key combination (see gemini.ts) if the call fails\n * OR if the response comes back incomplete/invalid. Works identically\n * for a \"batch\" of one, which is what the instant webhook path uses --\n * see emoji-automation.ts's classifyBatch, the single shared entry point\n * both the cron sweep and the webhook handler call into.\n */\nexport async function classifyTasksBatch(\n tasks: { id: string; content: string }[],\n config: GeminiConfig,\n): Promise> {\n const prompt = buildBatchPrompt(tasks);\n const requestedIds = new Set(tasks.map((t) => t.id));\n // Generous relative to actual need (each item is ~30-40 tokens of JSON)\n // so a full batch's visible output is never the bottleneck.\n const maxOutputTokens = 100 + 100 * tasks.length;\n\n return await callGeminiWithRetry(\n config,\n prompt,\n (rawText) => parseBatchResponse(rawText, requestedIds),\n {\n systemInstruction: SYSTEM_INSTRUCTION,\n responseMimeType: \"application/json\",\n responseSchema: {\n type: \"array\",\n items: {\n type: \"object\",\n properties: {\n id: { type: \"string\" },\n emoji: { type: \"string\", enum: VALID_EMOJIS },\n },\n required: [\"id\", \"emoji\"],\n propertyOrdering: [\"id\", \"emoji\"],\n },\n },\n thinkingLevel: \"medium\",\n maxOutputTokens,\n },\n );\n}",[208],"811c40ea-89fc-40d8-9163-48c413e8555a","categories.ts","46861880-8ce3-11f1-bc88-1607ee4eb77e",73,["D",1785524487465],5,"// categories.ts\n//\n// The fixed set of top-level categories every task's content gets\n// classified into. `emoji` is the *exact* character(s) prepended to a\n// task's content and checked for to know a task has already been\n// classified. These must match your intent character-for-character\n// (including invisible variation-selector bytes some of these emoji\n// carry) -- if classification or detection ever looks like it's\n// misbehaving, diffing these against what you actually typed is the\n// first thing to check.\n//\n// NOTE: two categories carry a secondary tagging scheme in the source\n// spec that this file does NOT turn into anything extra:\n// - Action is meant to be paired with an energy tag (Deep Work 🔥,\n// Supervision/AI ⚡, or Grunt Work 🧊)\n// - Logistics' description mentions a 🚚 + 🗺️ split\n// The classifier only ever prepends one of the `emoji` values below.\n// Say the word if you'd like the energy sub-tags classified and applied\n// too.\n\nexport interface Category {\n name: string;\n emoji: string; // exact emoji character(s) prepended to task content\n description: string;\n}\n\nexport const CATEGORIES: Category[] = [\n {\n name: \"Action\",\n emoji: \"⚒️\",\n description:\n \"The Work. General execution -- the default for a concrete, doable task.\",\n },\n {\n name: \"JIRA\",\n emoji: \"🎟️\",\n description:\n \"Work Tickets. Technical tasks synced from the professional JIRA project.\",\n },\n {\n name: \"Experiments\",\n emoji: \"🧪\",\n description:\n 'Research Lab. Sandbox testing, hypotheses, \"discovery\" coding.',\n },\n {\n name: \"Evaluate\",\n emoji: \"⚖️\",\n // The source spec gave no elaboration beyond the name for this one --\n // filled in with a minimal, literal reading. Tighten this if\n // classification confuses it with Analysis.\n description: \"Weighing options or making a decision between alternatives.\",\n },\n {\n name: \"Analysis\",\n emoji: \"🧐\",\n description:\n \"Deep Dive. Investigative searching, sourcing, documenting complex info.\",\n },\n {\n name: \"Input\",\n emoji: \"📖\",\n description: \"Consumption. Reading articles, books, documentation.\",\n },\n {\n name: \"Output\",\n emoji: \"✍🏼\",\n description: \"Expression. Writing emails, essays, logs, research drafts.\",\n },\n {\n name: \"Sync\",\n emoji: \"📞\",\n description:\n \"Communicate. Meetings, calls, high-priority outbound messages.\",\n },\n {\n name: \"Logistics\",\n emoji: \"🧭\",\n description:\n \"Navigation. Trip planning, reservations, errand coordination.\",\n },\n {\n name: \"Admin\",\n emoji: \"⚙️\",\n description: \"Maintenance. Digital plumbing, backups, file management.\",\n },\n {\n name: \"Framework\",\n emoji: \"🏗️\",\n description:\n \"Architecture. Structural, uncompletable tasks that hold projects together.\",\n },\n {\n name: \"Milestone\",\n emoji: \"⛳\",\n description: \"Objectives. High-level goals or progress markers.\",\n },\n {\n name: \"Seed\",\n emoji: \"🌱\",\n // Added per your message; \"Seed\" is my best-guess name for this one --\n // rename freely if you had a different word in mind.\n description:\n \"Future Projects. An early-stage idea or seed not yet ready to act on.\",\n },\n];\n\nexport const CATEGORY_EMOJIS: Set = new Set(\n CATEGORIES.map((c) => c.emoji),\n);\n\n/** Manually-applied marker for a checklist/reference task -- NOT one of the\n * 13 classification categories, and never written by this automation.\n * A task under a 📋-prefixed ancestor (or prefixed with 📋 itself) is\n * treated as reference material and skipped entirely. */\nexport const CHECKLIST_ROOT_EMOJI = \"📋\";\n\n/** Todoist marks a task uncompletable with a literal \"* \" at the very\n * start of its content. That's formatting, not text, so every prefix\n * check below looks past it -- and anything this automation writes back\n * has to keep it in first position or the task becomes completable. */\nconst UNCOMPLETABLE_PREFIX_RE = /^\\*\\s+/;\n\nexport function stripUncompletablePrefix(content: string): string {\n return content.trimStart().replace(UNCOMPLETABLE_PREFIX_RE, \"\").trimStart();\n}\n\nexport function hasUncompletablePrefix(content: string): boolean {\n return UNCOMPLETABLE_PREFIX_RE.test(content.trimStart());\n}\n\n/** Deliberately matches ANY emoji, not just the category set: a task that\n * already opens with an emoji was labelled by hand (possibly with one\n * outside this list on purpose) and must be left exactly as it is. */\nconst LEADING_EMOJI_RE = /^\\p{Extended_Pictographic}/u;\n\n/** True if `content` already opens with an emoji of any kind -- meaning it\n * is already classified, hand-tagged, or a 📋 reference container, and in\n * all three cases must not be touched. */\nexport function hasEmojiPrefix(content: string): boolean {\n return LEADING_EMOJI_RE.test(stripUncompletablePrefix(content));\n}\n\n/** True if `content` is a 📋 checklist container. */\nexport function isChecklistRoot(content: string): boolean {\n return stripUncompletablePrefix(content).startsWith(CHECKLIST_ROOT_EMOJI);\n}",[214],"43bd45dc-7cd7-44fb-9735-678b45cd8733","automation.ts","f1eb719c-88ed-11f1-a9fb-1607ee4eb77e",87,["D",1786297559723],15,"// automation.ts\n//\n// Automation #1: auto-schedule any task carrying the \"execute 🌥\" label\n// to be due today (before 9 PM Bucharest time) or tomorrow (from 9 PM\n// onward). runAutomationSafely() wraps it behind a blob-backed lock so a\n// webhook firing at the same moment as the cron backup can never double-\n// process the same tasks. (A plain in-memory lock wouldn't be reliable\n// here: unlike a single gunicorn worker, Val Town may run concurrent\n// invocations on separate isolates that don't share memory, so the lock\n// has to live in shared storage instead.)\n//\n// The locking mechanism (withBlobLock) is generalized below so the emoji\n// classification automation (emoji-automation.ts) can reuse it without\n// duplicating the acquire/release/TTL logic -- see that file for the\n// second lock instance.\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\nimport { getTasksByLabel, TodoistTask, updateTask } from \"./todoist.ts\";\n\nexport const EXECUTE_LABEL = \"execute 🌥\";\nexport const ROLLOVER_HOUR = 21; // 9 PM local time\n\nexport type AutomationResult = Record;\n\n// --- Timezone helpers -------------------------------------------------\n\n/** Returns { year, month, day, hour } for `date`, as observed in Europe/Bucharest. */\nexport function getBucharestParts(date: Date) {\n const fmt = new Intl.DateTimeFormat(\"en-GB\", {\n timeZone: \"Europe/Bucharest\",\n year: \"numeric\",\n month: \"2-digit\",\n day: \"2-digit\",\n hour: \"2-digit\",\n hourCycle: \"h23\",\n });\n const parts = fmt.formatToParts(date);\n const map: Record = {};\n for (const p of parts) map[p.type] = p.value;\n return {\n year: parseInt(map.year, 10),\n month: parseInt(map.month, 10),\n day: parseInt(map.day, 10),\n hour: parseInt(map.hour, 10),\n };\n}\n\nfunction ymdToUtcDate(y: number, m: number, d: number): Date {\n return new Date(Date.UTC(y, m - 1, d));\n}\n\nfunction formatIsoDate(d: Date): string {\n const y = d.getUTCFullYear();\n const m = String(d.getUTCMonth() + 1).padStart(2, \"0\");\n const day = String(d.getUTCDate()).padStart(2, \"0\");\n return `${y}-${m}-${day}`;\n}\n\n/**\n * Returns the date that any task carrying EXECUTE_LABEL should be due on.\n * Before ROLLOVER_HOUR (9 PM) Bucharest time -> today. From ROLLOVER_HOUR\n * onward -> tomorrow. Cron triggers always run in UTC, so this recomputes\n * the real local hour on every call rather than trusting when the caller\n * happened to run -- correct across DST changes with zero extra config.\n */\nexport function getTargetDueDate(now: Date = new Date()): Date {\n const parts = getBucharestParts(now);\n let target = ymdToUtcDate(parts.year, parts.month, parts.day);\n if (parts.hour >= ROLLOVER_HOUR) {\n target = new Date(target.getTime() + 24 * 60 * 60 * 1000);\n }\n return target;\n}\n\nfunction extractDueDateStr(task: TodoistTask): string | null {\n if (!task.due || !task.due.date) return null;\n return task.due.date.split(\"T\")[0];\n}\n\n// --- Automation: \"execute 🌥\" auto-scheduling --------------------------\n\nexport async function processExecuteTodayLabel(): Promise {\n const targetDate = getTargetDueDate();\n const targetDateStr = formatIsoDate(targetDate);\n\n let updatedCount = 0;\n let alreadyCorrectCount = 0;\n let errorCount = 0;\n const errors: string[] = [];\n const logLines: string[] = [];\n\n let matchingTasks: TodoistTask[];\n try {\n matchingTasks = await getTasksByLabel(EXECUTE_LABEL);\n } catch (e) {\n console.error(\"Failed to fetch tasks for execute-label processing:\", e);\n return { status: \"error\", message: `Failed to fetch tasks: ${e}` };\n }\n\n for (const task of matchingTasks) {\n const currentDueStr = extractDueDateStr(task);\n if (currentDueStr === targetDateStr) {\n alreadyCorrectCount++;\n continue;\n }\n\n try {\n await updateTask(task.id, { due_date: targetDateStr });\n updatedCount++;\n const msg =\n `Task ${task.id} ('${task.content}') due date set to ${targetDateStr}`;\n logLines.push(msg);\n console.log(`[${EXECUTE_LABEL}] ${msg}`);\n } catch (e) {\n errorCount++;\n errors.push(`Failed to update task ${task.id}: ${e}`);\n console.error(`[${EXECUTE_LABEL}] Failed to update task ${task.id}:`, e);\n }\n }\n\n return {\n status: \"success\",\n target_date: targetDateStr,\n found: matchingTasks.length,\n updated: updatedCount,\n already_correct: alreadyCorrectCount,\n failed: errorCount,\n log: logLines,\n errors,\n };\n}\n\n// --- Orchestration ------------------------------------------------------\n\nexport async function runAutomation(): Promise {\n return await processExecuteTodayLabel();\n}\n\n// --- Shared blob-backed lock ---------------------------------------------\n//\n// Generalized so any automation can get the same crash-safe locking\n// without reimplementing it: a plain in-memory lock isn't reliable here\n// since Val Town may run concurrent invocations on isolates that don't\n// share memory. TTL is a stale-lock safety valve for a run that crashes\n// (or gets killed by Val Town's execution timeout) mid-way; 3 minutes\n// gives a comfortable 3x margin over the free plan's 1-minute execution\n// ceiling (see https://www.val.town/limits) while still self-healing\n// quickly if a lock is ever left stuck.\n\nexport interface WithBlobLockOptions {\n lockKey: string;\n ttlMs: number;\n trigger: string;\n run: () => Promise;\n}\n\ninterface LockState {\n lockedAt: number;\n trigger: string;\n}\n\nexport async function withBlobLock(\n { lockKey, ttlMs, trigger, run }: WithBlobLockOptions,\n): Promise {\n const existing = (await blob.getJSON(lockKey)) as LockState | undefined;\n const now = Date.now();\n\n if (existing && now - existing.lockedAt < ttlMs) {\n console.warn(\n `Automation run skipped (lock=${lockKey}, trigger=${trigger}): another run is in progress.`,\n );\n return {\n status: \"skipped\",\n trigger,\n message: \"An automation run was already in progress.\",\n };\n }\n\n await blob.setJSON(lockKey, { lockedAt: now, trigger } satisfies LockState);\n\n try {\n console.log(\n `Automation run started (lock=${lockKey}, trigger=${trigger}).`,\n );\n const result = await run();\n result.trigger = trigger;\n console.log(\n `Automation run finished (lock=${lockKey}, trigger=${trigger}).`,\n );\n return result;\n } catch (e) {\n console.error(\n `Automation run failed unexpectedly (lock=${lockKey}, trigger=${trigger}):`,\n e,\n );\n return { status: \"error\", trigger, message: String(e) };\n } finally {\n await blob.delete(lockKey);\n }\n}\n\nconst LOCK_KEY = \"todoist-processor:automation-lock\";\nconst LOCK_TTL_MS = 3 * 60 * 1000;\n\nexport async function runAutomationSafely(\n trigger: string,\n): Promise {\n return withBlobLock({\n lockKey: LOCK_KEY,\n ttlMs: LOCK_TTL_MS,\n trigger,\n run: runAutomation,\n });\n}",[222],"pulls","branches","forks","envVars",{"_236":238,"_239":61},"connections",{"_236":61,"_237":61},"count","unfilledCount",7,"emptyCount",{"_42":221,"_32":222,"_30":223,"_138":-5,"_40":41,"_39":224,"_139":25,"_37":286,"_13":226,"_33":150,"_35":227,"_24":25,"_142":-5,"_253":287,"_27":288},{"_42":213,"_32":214,"_30":215,"_138":-5,"_40":41,"_39":216,"_139":25,"_37":283,"_13":218,"_33":150,"_35":219,"_24":25,"_142":-5,"_253":284,"_27":285},{"_42":207,"_32":208,"_30":209,"_138":-5,"_40":41,"_39":180,"_139":57,"_37":280,"_13":61,"_33":150,"_35":211,"_24":25,"_142":-5,"_253":281,"_27":282},{"_42":200,"_32":201,"_30":202,"_138":-5,"_40":41,"_39":203,"_139":25,"_37":277,"_13":167,"_33":150,"_35":205,"_24":25,"_142":-5,"_253":278,"_27":279},{"_42":192,"_32":193,"_30":194,"_138":-5,"_40":41,"_39":195,"_139":25,"_37":274,"_13":197,"_33":150,"_35":198,"_24":25,"_142":-5,"_253":275,"_27":276},{"_42":184,"_32":185,"_30":186,"_138":-5,"_40":41,"_39":187,"_139":25,"_37":271,"_13":189,"_33":150,"_35":190,"_24":25,"_142":-5,"_253":272,"_27":273},{"_42":177,"_32":178,"_30":179,"_138":-5,"_40":41,"_39":180,"_139":57,"_37":268,"_13":61,"_33":150,"_35":182,"_24":25,"_142":-5,"_253":269,"_27":270},{"_42":170,"_32":171,"_30":172,"_138":-5,"_40":41,"_39":173,"_139":25,"_37":265,"_13":167,"_33":150,"_35":175,"_24":25,"_142":-5,"_253":266,"_27":267},{"_42":162,"_32":163,"_30":164,"_138":-5,"_40":41,"_39":165,"_139":25,"_37":262,"_13":167,"_33":150,"_35":168,"_24":25,"_142":-5,"_253":263,"_27":264},{"_42":153,"_32":154,"_30":155,"_138":-5,"_40":41,"_39":156,"_139":25,"_37":259,"_13":158,"_33":159,"_35":160,"_24":25,"_142":-5,"_253":260,"_27":261},{"_42":144,"_32":145,"_30":146,"_138":-5,"_40":41,"_39":147,"_139":25,"_37":256,"_13":149,"_33":150,"_35":151,"_24":25,"_142":-5,"_253":257,"_27":258},{"_42":137,"_32":28,"_30":31,"_138":-5,"_40":41,"_39":14,"_139":25,"_37":252,"_13":141,"_33":34,"_35":36,"_24":25,"_142":-5,"_253":254,"_27":255},["D",1786297788465],"children",[],[28],["D",1786297526788],[],[145],["D",1785524529202],[],[154],["D",1786297504187],[],[163],["D",1786297459164],[],[171],["D",1785516648586],[],[178],["D",1785069142043],[],[185],["D",1785524509132],[],[193],["D",1785069160408],[],[201],["D",1785516648586],[],[208],["D",1785524487465],[],[214],["D",1786297559723],[],[222],["D",1785014870875],{"_95":94,"_103":99},{"_95":94,"_96":97,"_98":99,"_18":54,"_100":101,"_102":25},{"_13":84,"_32":85,"_42":41,"_86":43,"_87":-5,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":44,"_93":94},"ctx",{"_77":-5,"_122":326,"_327":328,"_329":330,"_331":25,"_332":25,"_333":25,"_334":57,"_335":-5,"_336":-7,"_337":-7,"_338":61,"_339":25,"_340":25,"_341":-5,"_342":25,"_343":25,"_344":25,"_345":-5},"ENV",{"_297":298,"_299":300,"_301":85,"_302":303,"_304":305,"_306":307,"_308":309,"_310":311,"_312":313,"_314":315,"_316":317,"_318":319,"_320":321,"_322":323,"_324":325},"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",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

Diff · v88