[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_204":205,"_206":207},"routes/_app.x.$handle.$name",{"_96":95,"_32":45,"_105":86,"_27":106,"_13":14,"_107":-5,"_11":108,"_109":110,"_111":112,"_113":114,"_115":116,"_20":-5,"_117":-5,"_118":-5,"_119":25,"_120":121,"_122":58,"_123":-5,"_124":-5,"_125":126},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_43":44,"_32":45,"_38":46,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":-5,"_53":-5,"_18":54,"_55":56,"_57":58,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":79,"_80":81,"_82":83,"_84":25},"version",12,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":28,"_33":34,"_35":37,"_38":39,"_40":14,"_41":42,"_24":25},"previous",{"_30":31,"_32":28,"_33":34,"_35":36},"deleted",false,"deletedHere","path","store.ts","latestPath","fileId","df88630e-a9de-11f1-85b6-1607ee4eb77e","name","fileType","script","content","// Storage for the two things concurrent HTTP requests mutate.\n//\n// The scraped events snapshot stays in blob storage on purpose: cron.ts is its\n// only writer and it replaces the whole document every time, which is exactly\n// what an object store is good at. The taken-list and the SEQUENCE map are a\n// different problem. Both were read-whole, modified in memory and written back,\n// and an object store has no atomic update and no transaction — so two HTTP\n// requests that overlap silently discard one of the two writes. That happened\n// in production: a click was overwritten by a later write, and a key that had\n// been removed came back. It is a property of the primitive, not an ordering\n// bug, so those two moved here. A hide is one INSERT, an unhide is one DELETE,\n// and a sequence bump is one UPSERT — no read-modify-write anywhere.\n//\n// Account-scoped sqlite, not val-scoped (`.../sqlite/main.ts`), for one\n// reason: cron.ts and http.ts must see the same rows, and account scope is\n// true whether those two files are one val or two. It is also the same scope\n// the blob store already has, so nothing about who-can-see-what changes. The\n// docs call account scope legacy but promise it keeps working; switching to\n// val scope later is the single import line below plus nothing else, because\n// row decoding is shape-agnostic (see `col`).\nimport { sqlite } from \"https://esm.town/v/std/sqlite\";\nimport { blob } from \"https://esm.town/v/std/blob\";\n\n// Namespaced: the account-scoped database is shared with every other val on\n// the account, so \"taken\" or \"sequences\" would be a collision waiting to\n// happen.\nconst TAKEN = \"guild_taken\";\nconst SEQ = \"guild_sequences\";\nconst META = \"guild_meta\";\n\n/**\n * The whole point of the migration, spelled out so it cannot drift: hiding a\n * class touches one row and reads nothing first, so two overlapping requests\n * cannot lose one another. OR IGNORE makes a double-submit a no-op rather than\n * an error.\n */\nexport const HIDE_SQL = `INSERT OR IGNORE INTO ${TAKEN} (course_key) VALUES (?)`;\nexport const UNHIDE_SQL = `DELETE FROM ${TAKEN} WHERE course_key = ?`;\n\n/**\n * Account-scoped sqlite returns each row as an array; val-scoped returns an\n * object keyed by column name. Reading both means the import at the top of\n * this file can change without turning every column read into a silent\n * `undefined`.\n */\nexport function col(row: unknown, name: string, index: number): unknown {\n return Array.isArray(row) ? row[index] : (row as Record)[name];\n}\n\n/**\n * Turso can hand integers back as BigInt depending on client config, and both\n * a BigInt and a numeric string coerce cleanly. Anything that does not is a\n * row shape `col` did not understand — a libsql protocol wrapper such as\n * `{type:\"integer\",value:\"4\"}` coerces to NaN. Defaulting to 0 there would map\n * every uid to zero, look like a successful read, and publish `SEQUENCE:0` on\n * every event in /all.ics, which is not a missing update but a poisoned one:\n * subscribers that already hold a higher number ignore every future change.\n * Throwing hands http.ts the 503 it already has for an unreadable store.\n */\nexport function int(v: unknown): number {\n const n = Number(v);\n if (!Number.isFinite(n)) {\n throw new Error(`sequence store returned a non-numeric value (${typeof v})`);\n }\n return n;\n}\n\n/**\n * The same failure one table over, and a worse one, because it cannot even\n * fail loudly on its own: `String(row)` on a shape `col` did not understand\n * yields \"[object Object]\" or \"undefined\", which matches no course key, so\n * /new.ics answers 200 with every hidden class restored and looks exactly like\n * a correct feed. A key that is not a non-empty string is not a key. Exported\n * so the check is testable without a database.\n */\nexport function courseKeyOf(row: unknown): string {\n const v = col(row, \"course_key\", 0);\n if (typeof v !== \"string\" || !v.trim()) {\n throw new Error(`taken-list row did not decode to a course key (${typeof v})`);\n }\n return v;\n}\n\ntype Stmt = { sql: string; args: unknown[] };\n\n/**\n * A daily scrape is several hundred rows and one giant batch is a bad idea.\n * Splitting it costs the all-or-nothing guarantee across chunks, which is fine\n * here: every statement is idempotent, every import insert re-checks the\n * marker inside the statement (see IMPORT_TAKEN_SQL), and the marker rides in\n * the same list as the rows it certifies — so a half-finished import is simply\n * redone, and a marker can never be reached without the rows before it.\n */\nasync function chunked(stmts: Stmt[], size = 200): Promise {\n for (let i = 0; i < stmts.length; i += size) {\n await sqlite.batch(stmts.slice(i, i + size));\n }\n}\n\n// ---------------------------------------------------------------------------\n// Legacy import — pure halves, so they are testable without a database.\n// ---------------------------------------------------------------------------\n\n/**\n * Faithful, deliberately not clever. The live list is known to be wrong (it\n * holds a class the owner never chose and is missing one he did), and it is\n * still not this function's job to have an opinion — he clears it through the\n * app after deploying. Only values that could never have been a course key at\n * all are dropped: non-strings, blanks, and exact duplicates.\n *\n * Absent and unreadable are different answers and must stay different. A\n * missing blob key means there is nothing to import and the step is genuinely\n * done. A value that is present but not a list — `{\"keys\":[...]}`, a bare\n * string from a partial write — means the list exists and we failed to read\n * it; returning `[]` there would import nothing, let the caller mark the step\n * complete, and make the list unrecoverable. So that case throws and the\n * import is retried instead. A JSON `null` counts as absent: `getJSON` gives\n * `undefined` for a missing key, but a store that answered `null` instead\n * would otherwise wedge a fresh val at a permanent 503, and no truncated\n * array parses to `null` anyway.\n */\nexport function normalizeTaken(raw: unknown): string[] {\n if (raw == null) return [];\n if (!Array.isArray(raw)) {\n throw new Error(\n `legacy taken-list is present but not an array (${typeof raw}); ` +\n `refusing to mark the import done over a list that may still exist`,\n );\n }\n const out: string[] = [];\n for (const v of raw) {\n if (typeof v !== \"string\") continue;\n const key = v.trim();\n if (key && !out.includes(key)) out.push(key);\n }\n return out;\n}\n\n/** Same absent-versus-unreadable rule as `normalizeTaken`, same reason. */\nexport function normalizeSequences(raw: unknown): Record {\n const out: Record = {};\n if (raw == null) return out;\n if (typeof raw !== \"object\" || Array.isArray(raw)) {\n throw new Error(\n `legacy sequence map is present but not an object (${typeof raw}); ` +\n `refusing to mark the import done`,\n );\n }\n for (const [uid, v] of Object.entries(raw as Record)) {\n const n = Number(v);\n if (uid && Number.isFinite(n) && n >= 0) out[uid] = Math.floor(n);\n }\n return out;\n}\n\nexport function normalizePrints(raw: unknown): Record {\n const out: Record = {};\n if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) return out;\n for (const [uid, v] of Object.entries(raw as Record)) {\n if (uid && typeof v === \"string\") out[uid] = v;\n }\n return out;\n}\n\n// ---------------------------------------------------------------------------\n// Schema + one-time import\n// ---------------------------------------------------------------------------\n\n/** Resolved once per isolate; concurrent callers await the same promise. */\nlet initialised: Promise | null = null;\n\n/**\n * Called by every exported operation, so a fresh val or a new branch builds\n * its own schema on first use with no manual setup step. On failure the cached\n * promise is dropped so the next request retries rather than inheriting a\n * permanently poisoned isolate.\n */\nexport function init(): Promise {\n if (!initialised) {\n initialised = (async () => {\n await sqlite.batch([\n `CREATE TABLE IF NOT EXISTS ${TAKEN} (course_key TEXT PRIMARY KEY)`,\n `CREATE TABLE IF NOT EXISTS ${SEQ} (\n uid TEXT PRIMARY KEY,\n seq INTEGER NOT NULL DEFAULT 0,\n fingerprint TEXT\n )`,\n `CREATE TABLE IF NOT EXISTS ${META} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,\n ]);\n await importLegacy();\n })().catch((e) => {\n initialised = null;\n throw e;\n });\n }\n return initialised;\n}\n\nconst TAKEN_STEP = \"taken:imported\";\nconst SEQ_STEP = \"sequences:imported\";\n\nasync function imported(step: string): Promise {\n const r = await sqlite.execute({ sql: `SELECT 1 FROM ${META} WHERE key = ?`, args: [step] });\n return r.rows.length > 0;\n}\n\n/**\n * The import inserts, unlike HIDE_SQL, re-check the marker *inside* the\n * statement, and that is the whole point of them.\n *\n * `imported()` and the inserts are separate round trips, so two isolates that\n * cold-start at the same moment can both see no marker. The second one's insert\n * then lands after the first has already imported, written the marker, and\n * served the owner's DELETE — resurrecting a key he just removed. That is the\n * original production bug wearing a different hat, and no amount of batching\n * alone fixes it, because a transaction that never re-reads the marker will\n * happily re-insert rows a committed transaction already retired.\n *\n * Gating each insert on the marker turns the loser of that race into a no-op\n * the instant the winner commits, and appending the marker to the same\n * statement list means the marker is never written ahead of the rows it\n * certifies. The marker, not table-emptiness, remains the gate: nothing here\n * looks at a row count, so the list the owner clears right after deploying\n * stays cleared, including across a cold start.\n */\nexport const IMPORT_TAKEN_SQL = `INSERT OR IGNORE INTO ${TAKEN} (course_key)\n SELECT ? WHERE NOT EXISTS (SELECT 1 FROM ${META} WHERE key = ?)`;\n\nexport const IMPORT_SEQ_SQL = `INSERT OR IGNORE INTO ${SEQ} (uid, seq, fingerprint)\n SELECT ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM ${META} WHERE key = ?)`;\n\nfunction markStmt(step: string): Stmt {\n return {\n sql: `INSERT OR IGNORE INTO ${META} (key, value) VALUES (?, ?)`,\n args: [step, new Date().toISOString()],\n };\n}\n\n/**\n * The marker, not row-emptiness, is what decides this. That distinction is\n * load-bearing: the owner intends to clear the bad list through the app right\n * after deploying, and an emptiness test would read that empty table on the\n * very next request and helpfully restore every entry he just deleted.\n *\n * A blob read that *throws* is a different thing from a blob key that is\n * absent. Absent means there is nothing to import and the step is done. A\n * throw means we do not know, so it propagates: the caller turns it into a\n * 503 and the step is retried next time, rather than marking an empty import\n * as complete and losing the list. A value that is present but not the shape\n * we expect is the third case and behaves like the throw, not like the absent\n * one — see `normalizeTaken`.\n *\n * The marker is never written on its own: it is the last statement of the same\n * list as the rows it certifies, and each of those rows re-checks it, so the\n * check and the write cannot be interleaved by a second isolate.\n */\nasync function importLegacy(): Promise {\n if (!(await imported(TAKEN_STEP))) {\n let raw: unknown;\n try {\n raw = await blob.getJSON(\"taken\");\n } catch (e) {\n throw new Error(`legacy taken-list read failed, import not attempted: ${e}`);\n }\n // Throws on a present-but-unreadable value, before a single statement\n // runs, so no marker is ever written over a list we could not parse.\n const keys = normalizeTaken(raw);\n await chunked([\n ...keys.map((key) => ({ sql: IMPORT_TAKEN_SQL, args: [key, TAKEN_STEP] })),\n markStmt(TAKEN_STEP),\n ]);\n }\n\n if (!(await imported(SEQ_STEP))) {\n let seqRaw: unknown;\n let printRaw: unknown;\n try {\n seqRaw = await blob.getJSON(\"sequences\");\n printRaw = await blob.getJSON(\"prints\");\n } catch (e) {\n throw new Error(`legacy sequence read failed, import not attempted: ${e}`);\n }\n const seqs = normalizeSequences(seqRaw);\n const prints = normalizePrints(printRaw);\n const uids = [...new Set([...Object.keys(seqs), ...Object.keys(prints)])];\n await chunked([\n ...uids.map((uid) => ({\n sql: IMPORT_SEQ_SQL,\n args: [uid, seqs[uid] ?? 0, prints[uid] ?? null, SEQ_STEP],\n })),\n markStmt(SEQ_STEP),\n ]);\n }\n}\n\n// ---------------------------------------------------------------------------\n// Taken list\n// ---------------------------------------------------------------------------\n\nexport async function takenKeys(): Promise {\n await init();\n const r = await sqlite.execute(`SELECT course_key FROM ${TAKEN} ORDER BY course_key`);\n return (r.rows as unknown[]).map(courseKeyOf);\n}\n\nexport async function hide(key: string): Promise {\n await init();\n await sqlite.execute({ sql: HIDE_SQL, args: [key] });\n}\n\nexport async function unhide(key: string): Promise {\n await init();\n await sqlite.execute({ sql: UNHIDE_SQL, args: [key] });\n}\n\n/**\n * Only future offerings of a finished class are dropped. Past events stay, so\n * the calendar remains a record of what you actually did.\n */\nexport function filterTaken(\n events: T[],\n done: string[],\n today: string,\n): T[] {\n const hidden = new Set(done);\n return events.filter((e) => !(e.courseKey && hidden.has(e.courseKey) && e.start >= today));\n}\n\n// ---------------------------------------------------------------------------\n// SEQUENCE map\n// ---------------------------------------------------------------------------\n\nexport interface SeqRow {\n seq: number;\n fingerprint: string | null;\n}\n\n/**\n * Read side for /all.ics and /new.ics: just uid -> seq.\n *\n * An empty table is a valid answer here, not an error, and is deliberately not\n * gated. It occurs in exactly one situation: a val that has never completed a\n * cron run and had no legacy sequences to import — and there `SEQUENCE:0` is\n * the true answer, because no subscriber has ever been handed a higher number\n * for these UIDs. Every other route to an empty read is already covered: a row\n * shape that cannot be decoded throws (see `int`) and http.ts answers 503, a\n * failed `putSequences` leaves yesterday's rows in place rather than none, a\n * legacy blob that cannot be parsed refuses to mark itself imported, and\n * nothing in this file ever deletes from the table. Gating the feed on a\n * non-empty table would trade that correct zero for a 503 on every fresh val\n * until the first nightly scrape lands, which is the worse failure.\n */\nexport async function sequenceMap(): Promise> {\n await init();\n const r = await sqlite.execute(`SELECT uid, seq FROM ${SEQ}`);\n const out: Record = {};\n for (const row of r.rows as unknown[]) {\n out[String(col(row, \"uid\", 0))] = int(col(row, \"seq\", 1));\n }\n return out;\n}\n\n/** Read side for cron: it needs the stored fingerprint to decide on a bump. */\nexport async function sequenceRows(): Promise> {\n await init();\n const r = await sqlite.execute(`SELECT uid, seq, fingerprint FROM ${SEQ}`);\n const out: Record = {};\n for (const row of r.rows as unknown[]) {\n const fp = col(row, \"fingerprint\", 2);\n out[String(col(row, \"uid\", 0))] = {\n seq: int(col(row, \"seq\", 1)),\n fingerprint: fp == null ? null : String(fp),\n };\n }\n return out;\n}\n\n/**\n * Unchanged rule, moved out of cron.ts so it can be tested: bump only when we\n * have a previous fingerprint and it differs. A UID we have never seen, or one\n * stored before fingerprints were kept, starts where it is.\n */\nexport function nextSequence(prev: SeqRow | undefined, fingerprint: string): number {\n const seq = prev?.seq ?? 0;\n const was = prev?.fingerprint;\n return was && was !== fingerprint ? seq + 1 : seq;\n}\n\nexport async function putSequences(\n entries: { uid: string; seq: number; fingerprint: string }[],\n): Promise {\n await init();\n await chunked(entries.map((e) => ({\n sql: `INSERT INTO ${SEQ} (uid, seq, fingerprint) VALUES (?, ?, ?)\n ON CONFLICT(uid) DO UPDATE SET seq = excluded.seq, fingerprint = excluded.fingerprint`,\n args: [e.uid, e.seq, e.fingerprint],\n })));\n}\n","// Storage for the two things concurrent HTTP requests mutate.\n//\n// The scraped events snapshot stays in blob storage on purpose: cron.ts is its\n// only writer and it replaces the whole document every time, which is exactly\n// what an object store is good at. The taken-list and the SEQUENCE map are a\n// different problem. Both were read-whole, modified in memory and written back,\n// and an object store has no atomic update and no transaction — so two HTTP\n// requests that overlap silently discard one of the two writes. That happened\n// in production: a click was overwritten by a later write, and a key that had\n// been removed came back. It is a property of the primitive, not an ordering\n// bug, so those two moved here. A hide is one INSERT, an unhide is one DELETE,\n// and a sequence bump is one UPSERT — no read-modify-write anywhere.\n//\n// Account-scoped sqlite, not val-scoped (`.../sqlite/main.ts`), for one\n// reason: cron.ts and http.ts must see the same rows, and account scope is\n// true whether those two files are one val or two. It is also the same scope\n// the blob store already has, so nothing about who-can-see-what changes. The\n// docs call account scope legacy but promise it keeps working; switching to\n// val scope later is the single import line below plus nothing else, because\n// row decoding is shape-agnostic (see `col`).\nimport { sqlite } from \"https://esm.town/v/std/sqlite\";\nimport { blob } from \"https://esm.town/v/std/blob\";\nimport type { Fullness } from \"./parse.ts\";\n\n// Namespaced: the account-scoped database is shared with every other val on\n// the account, so \"taken\" or \"sequences\" would be a collision waiting to\n// happen.\nconst TAKEN = \"guild_taken\";\nconst SEQ = \"guild_sequences\";\nconst META = \"guild_meta\";\n\n/**\n * The whole point of the migration, spelled out so it cannot drift: hiding a\n * class touches one row and reads nothing first, so two overlapping requests\n * cannot lose one another. OR IGNORE makes a double-submit a no-op rather than\n * an error.\n */\nexport const HIDE_SQL = `INSERT OR IGNORE INTO ${TAKEN} (course_key) VALUES (?)`;\nexport const UNHIDE_SQL = `DELETE FROM ${TAKEN} WHERE course_key = ?`;\n\n/**\n * Account-scoped sqlite returns each row as an array; val-scoped returns an\n * object keyed by column name. Reading both means the import at the top of\n * this file can change without turning every column read into a silent\n * `undefined`.\n */\nexport function col(row: unknown, name: string, index: number): unknown {\n return Array.isArray(row) ? row[index] : (row as Record)[name];\n}\n\n/**\n * Turso can hand integers back as BigInt depending on client config, and both\n * a BigInt and a numeric string coerce cleanly. Anything that does not is a\n * row shape `col` did not understand — a libsql protocol wrapper such as\n * `{type:\"integer\",value:\"4\"}` coerces to NaN. Defaulting to 0 there would map\n * every uid to zero, look like a successful read, and publish `SEQUENCE:0` on\n * every event in /all.ics, which is not a missing update but a poisoned one:\n * subscribers that already hold a higher number ignore every future change.\n * Throwing hands http.ts the 503 it already has for an unreadable store.\n */\nexport function int(v: unknown): number {\n const n = Number(v);\n if (!Number.isFinite(n)) {\n throw new Error(`sequence store returned a non-numeric value (${typeof v})`);\n }\n return n;\n}\n\n/**\n * The same failure one table over, and a worse one, because it cannot even\n * fail loudly on its own: `String(row)` on a shape `col` did not understand\n * yields \"[object Object]\" or \"undefined\", which matches no course key, so\n * /new.ics answers 200 with every hidden class restored and looks exactly like\n * a correct feed. A key that is not a non-empty string is not a key. Exported\n * so the check is testable without a database.\n */\nexport function courseKeyOf(row: unknown): string {\n const v = col(row, \"course_key\", 0);\n if (typeof v !== \"string\" || !v.trim()) {\n throw new Error(`taken-list row did not decode to a course key (${typeof v})`);\n }\n return v;\n}\n\ntype Stmt = { sql: string; args: unknown[] };\n\n/**\n * A daily scrape is several hundred rows and one giant batch is a bad idea.\n * Splitting it costs the all-or-nothing guarantee across chunks, which is fine\n * here: every statement is idempotent, every import insert re-checks the\n * marker inside the statement (see IMPORT_TAKEN_SQL), and the marker rides in\n * the same list as the rows it certifies — so a half-finished import is simply\n * redone, and a marker can never be reached without the rows before it.\n */\nasync function chunked(stmts: Stmt[], size = 200): Promise {\n for (let i = 0; i < stmts.length; i += size) {\n await sqlite.batch(stmts.slice(i, i + size));\n }\n}\n\n// ---------------------------------------------------------------------------\n// Legacy import — pure halves, so they are testable without a database.\n// ---------------------------------------------------------------------------\n\n/**\n * Faithful, deliberately not clever. The live list is known to be wrong (it\n * holds a class the owner never chose and is missing one he did), and it is\n * still not this function's job to have an opinion — he clears it through the\n * app after deploying. Only values that could never have been a course key at\n * all are dropped: non-strings, blanks, and exact duplicates.\n *\n * Absent and unreadable are different answers and must stay different. A\n * missing blob key means there is nothing to import and the step is genuinely\n * done. A value that is present but not a list — `{\"keys\":[...]}`, a bare\n * string from a partial write — means the list exists and we failed to read\n * it; returning `[]` there would import nothing, let the caller mark the step\n * complete, and make the list unrecoverable. So that case throws and the\n * import is retried instead. A JSON `null` counts as absent: `getJSON` gives\n * `undefined` for a missing key, but a store that answered `null` instead\n * would otherwise wedge a fresh val at a permanent 503, and no truncated\n * array parses to `null` anyway.\n */\nexport function normalizeTaken(raw: unknown): string[] {\n if (raw == null) return [];\n if (!Array.isArray(raw)) {\n throw new Error(\n `legacy taken-list is present but not an array (${typeof raw}); ` +\n `refusing to mark the import done over a list that may still exist`,\n );\n }\n const out: string[] = [];\n for (const v of raw) {\n if (typeof v !== \"string\") continue;\n const key = v.trim();\n if (key && !out.includes(key)) out.push(key);\n }\n return out;\n}\n\n/** Same absent-versus-unreadable rule as `normalizeTaken`, same reason. */\nexport function normalizeSequences(raw: unknown): Record {\n const out: Record = {};\n if (raw == null) return out;\n if (typeof raw !== \"object\" || Array.isArray(raw)) {\n throw new Error(\n `legacy sequence map is present but not an object (${typeof raw}); ` +\n `refusing to mark the import done`,\n );\n }\n for (const [uid, v] of Object.entries(raw as Record)) {\n const n = Number(v);\n if (uid && Number.isFinite(n) && n >= 0) out[uid] = Math.floor(n);\n }\n return out;\n}\n\nexport function normalizePrints(raw: unknown): Record {\n const out: Record = {};\n if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) return out;\n for (const [uid, v] of Object.entries(raw as Record)) {\n if (uid && typeof v === \"string\") out[uid] = v;\n }\n return out;\n}\n\n// ---------------------------------------------------------------------------\n// Schema + one-time import\n// ---------------------------------------------------------------------------\n\n/** Resolved once per isolate; concurrent callers await the same promise. */\nlet initialised: Promise | null = null;\n\n/**\n * Called by every exported operation, so a fresh val or a new branch builds\n * its own schema on first use with no manual setup step. On failure the cached\n * promise is dropped so the next request retries rather than inheriting a\n * permanently poisoned isolate.\n */\nexport function init(): Promise {\n if (!initialised) {\n initialised = (async () => {\n await sqlite.batch([\n `CREATE TABLE IF NOT EXISTS ${TAKEN} (course_key TEXT PRIMARY KEY)`,\n `CREATE TABLE IF NOT EXISTS ${SEQ} (\n uid TEXT PRIMARY KEY,\n seq INTEGER NOT NULL DEFAULT 0,\n fingerprint TEXT\n )`,\n `CREATE TABLE IF NOT EXISTS ${META} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,\n ]);\n await importLegacy();\n })().catch((e) => {\n initialised = null;\n throw e;\n });\n }\n return initialised;\n}\n\nconst TAKEN_STEP = \"taken:imported\";\nconst SEQ_STEP = \"sequences:imported\";\n\nasync function imported(step: string): Promise {\n const r = await sqlite.execute({ sql: `SELECT 1 FROM ${META} WHERE key = ?`, args: [step] });\n return r.rows.length > 0;\n}\n\n/**\n * The import inserts, unlike HIDE_SQL, re-check the marker *inside* the\n * statement, and that is the whole point of them.\n *\n * `imported()` and the inserts are separate round trips, so two isolates that\n * cold-start at the same moment can both see no marker. The second one's insert\n * then lands after the first has already imported, written the marker, and\n * served the owner's DELETE — resurrecting a key he just removed. That is the\n * original production bug wearing a different hat, and no amount of batching\n * alone fixes it, because a transaction that never re-reads the marker will\n * happily re-insert rows a committed transaction already retired.\n *\n * Gating each insert on the marker turns the loser of that race into a no-op\n * the instant the winner commits, and appending the marker to the same\n * statement list means the marker is never written ahead of the rows it\n * certifies. The marker, not table-emptiness, remains the gate: nothing here\n * looks at a row count, so the list the owner clears right after deploying\n * stays cleared, including across a cold start.\n */\nexport const IMPORT_TAKEN_SQL = `INSERT OR IGNORE INTO ${TAKEN} (course_key)\n SELECT ? WHERE NOT EXISTS (SELECT 1 FROM ${META} WHERE key = ?)`;\n\nexport const IMPORT_SEQ_SQL = `INSERT OR IGNORE INTO ${SEQ} (uid, seq, fingerprint)\n SELECT ?, ?, ? WHERE NOT EXISTS (SELECT 1 FROM ${META} WHERE key = ?)`;\n\nfunction markStmt(step: string): Stmt {\n return {\n sql: `INSERT OR IGNORE INTO ${META} (key, value) VALUES (?, ?)`,\n args: [step, new Date().toISOString()],\n };\n}\n\n/**\n * The marker, not row-emptiness, is what decides this. That distinction is\n * load-bearing: the owner intends to clear the bad list through the app right\n * after deploying, and an emptiness test would read that empty table on the\n * very next request and helpfully restore every entry he just deleted.\n *\n * A blob read that *throws* is a different thing from a blob key that is\n * absent. Absent means there is nothing to import and the step is done. A\n * throw means we do not know, so it propagates: the caller turns it into a\n * 503 and the step is retried next time, rather than marking an empty import\n * as complete and losing the list. A value that is present but not the shape\n * we expect is the third case and behaves like the throw, not like the absent\n * one — see `normalizeTaken`.\n *\n * The marker is never written on its own: it is the last statement of the same\n * list as the rows it certifies, and each of those rows re-checks it, so the\n * check and the write cannot be interleaved by a second isolate.\n */\nasync function importLegacy(): Promise {\n if (!(await imported(TAKEN_STEP))) {\n let raw: unknown;\n try {\n raw = await blob.getJSON(\"taken\");\n } catch (e) {\n throw new Error(`legacy taken-list read failed, import not attempted: ${e}`);\n }\n // Throws on a present-but-unreadable value, before a single statement\n // runs, so no marker is ever written over a list we could not parse.\n const keys = normalizeTaken(raw);\n await chunked([\n ...keys.map((key) => ({ sql: IMPORT_TAKEN_SQL, args: [key, TAKEN_STEP] })),\n markStmt(TAKEN_STEP),\n ]);\n }\n\n if (!(await imported(SEQ_STEP))) {\n let seqRaw: unknown;\n let printRaw: unknown;\n try {\n seqRaw = await blob.getJSON(\"sequences\");\n printRaw = await blob.getJSON(\"prints\");\n } catch (e) {\n throw new Error(`legacy sequence read failed, import not attempted: ${e}`);\n }\n const seqs = normalizeSequences(seqRaw);\n const prints = normalizePrints(printRaw);\n const uids = [...new Set([...Object.keys(seqs), ...Object.keys(prints)])];\n await chunked([\n ...uids.map((uid) => ({\n sql: IMPORT_SEQ_SQL,\n args: [uid, seqs[uid] ?? 0, prints[uid] ?? null, SEQ_STEP],\n })),\n markStmt(SEQ_STEP),\n ]);\n }\n}\n\n// ---------------------------------------------------------------------------\n// Taken list\n// ---------------------------------------------------------------------------\n\nexport async function takenKeys(): Promise {\n await init();\n const r = await sqlite.execute(`SELECT course_key FROM ${TAKEN} ORDER BY course_key`);\n return (r.rows as unknown[]).map(courseKeyOf);\n}\n\nexport async function hide(key: string): Promise {\n await init();\n await sqlite.execute({ sql: HIDE_SQL, args: [key] });\n}\n\nexport async function unhide(key: string): Promise {\n await init();\n await sqlite.execute({ sql: UNHIDE_SQL, args: [key] });\n}\n\n/**\n * Only future offerings of a finished class are dropped. Past events stay, so\n * the calendar remains a record of what you actually did.\n */\nexport function filterTaken(\n events: T[],\n done: string[],\n today: string,\n): T[] {\n const hidden = new Set(done);\n return events.filter((e) => !(e.courseKey && hidden.has(e.courseKey) && e.start >= today));\n}\n\n// ---------------------------------------------------------------------------\n// SEQUENCE map\n// ---------------------------------------------------------------------------\n\nexport interface SeqRow {\n seq: number;\n fingerprint: string | null;\n}\n\n/**\n * Read side for /all.ics and /new.ics: just uid -> seq.\n *\n * An empty table is a valid answer here, not an error, and is deliberately not\n * gated. It occurs in exactly one situation: a val that has never completed a\n * cron run and had no legacy sequences to import — and there `SEQUENCE:0` is\n * the true answer, because no subscriber has ever been handed a higher number\n * for these UIDs. Every other route to an empty read is already covered: a row\n * shape that cannot be decoded throws (see `int`) and http.ts answers 503, a\n * failed `putSequences` leaves yesterday's rows in place rather than none, a\n * legacy blob that cannot be parsed refuses to mark itself imported, and\n * nothing in this file ever deletes from the table. Gating the feed on a\n * non-empty table would trade that correct zero for a 503 on every fresh val\n * until the first nightly scrape lands, which is the worse failure.\n */\nexport async function sequenceMap(): Promise> {\n await init();\n const r = await sqlite.execute(`SELECT uid, seq FROM ${SEQ}`);\n const out: Record = {};\n for (const row of r.rows as unknown[]) {\n out[String(col(row, \"uid\", 0))] = int(col(row, \"seq\", 1));\n }\n return out;\n}\n\n/** Read side for cron: it needs the stored fingerprint to decide on a bump. */\nexport async function sequenceRows(): Promise> {\n await init();\n const r = await sqlite.execute(`SELECT uid, seq, fingerprint FROM ${SEQ}`);\n const out: Record = {};\n for (const row of r.rows as unknown[]) {\n const fp = col(row, \"fingerprint\", 2);\n out[String(col(row, \"uid\", 0))] = {\n seq: int(col(row, \"seq\", 1)),\n fingerprint: fp == null ? null : String(fp),\n };\n }\n return out;\n}\n\n/**\n * Unchanged rule, moved out of cron.ts so it can be tested: bump only when we\n * have a previous fingerprint and it differs. A UID we have never seen, or one\n * stored before fingerprints were kept, starts where it is.\n */\nexport function nextSequence(prev: SeqRow | undefined, fingerprint: string): number {\n const seq = prev?.seq ?? 0;\n const was = prev?.fingerprint;\n return was && was !== fingerprint ? seq + 1 : seq;\n}\n\nexport async function putSequences(\n entries: { uid: string; seq: number; fingerprint: string }[],\n): Promise {\n await init();\n await chunked(entries.map((e) => ({\n sql: `INSERT INTO ${SEQ} (uid, seq, fingerprint) VALUES (?, ?, ?)\n ON CONFLICT(uid) DO UPDATE SET seq = excluded.seq, fingerprint = excluded.fingerprint`,\n args: [e.uid, e.seq, e.fingerprint],\n })));\n}\n\n// ---------------------------------------------------------------------------\n// Fullness snapshot\n// ---------------------------------------------------------------------------\n//\n// Blob, not a sqlite table, and a separate key rather than a field on each\n// event. Three reasons, in order of weight:\n//\n// 1. The migration at the top of this file was not about sqlite being nicer.\n// It was about read-modify-write: two overlapping HTTP requests editing one\n// JSON document silently discard one of the writes. Fullness has no HTTP\n// mutation path at all — no request ever writes it. cron.ts is the sole\n// writer and it replaces the entire document every run, which is the exact\n// shape the header of this file already calls out as correct for blob.\n// Putting it in sqlite would import the ceremony without the reason.\n// 2. A separate key keeps the `events` document byte-for-byte what it is\n// today. Folding a field into every event would rewrite the one document\n// http.ts's 503 semantics and the previous version's rollback both depend\n// on, to carry data that changes on a different schedule and matters less.\n// 3. Reading it must never be able to fail the page. A sqlite read goes\n// through init(), which builds schema and can reach the legacy taken-list\n// blob — so a fullness read would inherit failure modes belonging to\n// hiding classes. readFullness() deliberately calls neither.\n//\n// The snapshot carries its own fetched-at because a stale answer here is worse\n// than no answer: \"FULL\" on a class that opened up last night sends the owner\n// to a waitlist he does not need, and nothing on the page would show that the\n// claim is a day old. Past its window it is dropped and every event reads\n// \"unknown\", which renders exactly as the page did before this existed.\n\nconst FULLNESS_KEY = \"guild_fullness\";\n\n/**\n * Cron runs daily, so a healthy snapshot is always under 24h old. 26 gives a\n * late or slow run two hours of slack while still expiring one *missed* run\n * rather than showing yesterday's answer as if it were today's.\n */\nexport const FULLNESS_MAX_AGE_MS = 26 * 60 * 60 * 1000;\n\nexport interface FullnessSnapshot {\n fetchedAt: string;\n states: Record;\n}\n\nexport async function putFullness(states: Record): Promise {\n const snap: FullnessSnapshot = { fetchedAt: new Date().toISOString(), states };\n await blob.setJSON(FULLNESS_KEY, snap);\n}\n\n/**\n * The pure half, so the expiry and the shape checks are testable without a\n * store. Unlike normalizeTaken and normalizeSequences, this NEVER throws, and\n * the difference is deliberate rather than an oversight.\n *\n * Those two guard data that cannot be re-derived: refusing to read a garbled\n * taken-list is what stops an import from marking itself done and losing the\n * owner's choices for good. This document is regenerated in full by the next\n * cron run and holds nothing a user typed. Every failure it can have — absent,\n * wrong shape, undatable, expired, junk values — has the same correct answer,\n * which is \"we do not know\", and \"we do not know\" is a state this feature is\n * built to render. Throwing would convert a missing decoration into a 503 on\n * the class list.\n *\n * A timestamp in the future is treated as unusable rather than as\n * indefinitely fresh, so a clock skew cannot pin a stale snapshot open.\n */\nexport function normalizeFullness(raw: unknown, now: number): Record {\n const out: Record = {};\n if (!raw || typeof raw !== \"object\" || Array.isArray(raw)) return out;\n\n const snap = raw as Partial;\n const at = Date.parse(String(snap.fetchedAt ?? \"\"));\n if (!Number.isFinite(at)) return out;\n if (now - at > FULLNESS_MAX_AGE_MS) return out;\n if (at - now > 60 * 60 * 1000) return out;\n\n const states = snap.states;\n if (!states || typeof states !== \"object\" || Array.isArray(states)) return out;\n for (const [id, v] of Object.entries(states as Record)) {\n // A stored \"unknown\" is dropped rather than kept: absent already means\n // unknown, and one spelling of it is enough.\n if (/^\\d+$/.test(id) && (v === \"full\" || v === \"open\")) out[id] = v;\n }\n return out;\n}\n\n/**\n * Never throws, never 503s, never calls init(). An empty map is a complete and\n * honest answer meaning every event is \"unknown\".\n */\nexport async function readFullness(): Promise> {\n try {\n return normalizeFullness(await blob.getJSON(FULLNESS_KEY), Date.now());\n } catch {\n return {};\n }\n}\n","createdAt",["D",1788829781086],"branchVersion","branchId","d824da79-12b4-4503-842c-a4bddb5df6f2","id","344e43c2-1842-48d0-8dbf-76d960b13c0f","guildcalendar",["D",1788654659900],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","1398b500-45f0-4bf4-90e5-f35150473c2e","pinnedFileId","3cdb4b5c-a98a-11f1-9fa3-1607ee4eb77e","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",0,"orgId","01a05927-4c0c-73bc-ab9c-dd245be766a5","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_96":95,"_104":100},"org",{"_96":95,"_97":98,"_99":100,"_18":54,"_101":102,"_103":25},"branch",{"_13":85,"_32":86,"_43":42,"_87":44,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":45,"_94":95},"isOwned",21,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","chotchkies","handle","displayName","Cameron Hotchkies","avatar","https://lh3.googleusercontent.com/a/ACg8ocLqBbiwSyhcuAqhs2fRy8Ap0lqA45YFLtS_JtAKAwjEYuXmcXDR=s96-c","tier","free","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_43":44,"_32":45,"_38":200,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":-5,"_53":-5,"_18":54,"_55":56,"_57":58,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":-5,"_66":-5,"_67":-5,"_68":-5,"_69":70,"_71":70,"_72":73,"_74":73,"_75":73,"_76":70,"_77":70,"_78":201,"_80":202,"_82":203,"_84":25},"tree",[179,180,181,182,183],"files",[179,180,181,182,183],"counts",{"_169":62,"_170":136,"_171":62,"_172":173,"_174":175},"contents",[127,128,129,130,131],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_43":161,"_32":162,"_30":163,"_133":-5,"_41":42,"_40":164,"_134":25,"_38":165,"_13":136,"_33":166,"_35":167,"_24":25,"_137":-5,"_27":168},{"_43":154,"_32":155,"_30":56,"_133":-5,"_41":42,"_40":156,"_134":25,"_38":157,"_13":144,"_33":158,"_35":159,"_24":25,"_137":-5,"_27":160},{"_43":147,"_32":148,"_30":149,"_133":-5,"_41":42,"_40":150,"_134":58,"_38":151,"_13":136,"_33":34,"_35":152,"_24":25,"_137":-5,"_27":153},{"_43":139,"_32":140,"_30":141,"_133":-5,"_41":42,"_40":142,"_134":25,"_38":143,"_13":144,"_33":34,"_35":145,"_24":25,"_137":-5,"_27":146},{"_43":132,"_32":28,"_30":31,"_133":-5,"_41":42,"_40":14,"_134":25,"_38":135,"_13":136,"_33":34,"_35":37,"_24":25,"_137":-5,"_27":138},"bdc8e545-8705-42c3-aec9-60adeb943488","parentId","latest",["D",1788829781086],1,"label",[28],"0997b364-fd38-4980-9423-0b6da9051c93","parse.ts","3c0d9964-a98a-11f1-b3ec-1607ee4eb77e",10,["D",1788829780264],2,"// Parses Guild of Oregon Woodworkers calendar pages (Wild Apricot).\n//\n// The grid markup gives us everything we need inside each event anchor's\n// `title` attribute. Observed shapes:\n//\n// n[9:00 AM]26 Jul 2026, 9:00 AM 1:00 PM\n// Guild Workshop, 7634 SW 34th Ave, Portland, OR 97219\n//\n// y[5:30 PM]1 of 5\n// 27 Jul 2026, 5:30 PM 9:00 PM\n// Guild Studio, 7634 SW 34th Ave, Portland, OR 97219\n//\n// n[]01 Aug 2026\n// Guild Workshop, 7634 SW 34th Ave, Portland, OR 97219\n//\n// n[9:00 AM]26 Jul 2026, 9:00 AM (start time only)\n// n[9:00 AM]26 Jul 2026 - 28 Jul 2026, 9:00 AM 5:00 PM (multi-day span)\n//\n// We parse by pattern rather than by DOM position, so a reskin of their\n// class names won't break us. If Wild Apricot changes the title format\n// itself, the invariant checks in cron.ts will fail loudly.\n\nexport interface GuildEvent {\n id: string;\n name: string;\n cancelled: boolean;\n allDay: boolean;\n /** Floating local datetime, e.g. \"20260726T090000\". Guild time is America/Los_Angeles. */\n start: string;\n end: string | null;\n location: string;\n session: string | null; // \"1 of 5\"\n courseKey: string | null; // set only for EDS-/EDG- classes\n calendar: string;\n url: string;\n}\n\nconst MONTHS: Record = {\n jan: 1, feb: 2, mar: 3, apr: 4, may: 5, jun: 6,\n jul: 7, aug: 8, sep: 9, oct: 10, nov: 11, dec: 12,\n};\n\n/** Wild Apricot double-encodes some titles (\"Dub's Tavern\"), so decode twice. */\nexport function decodeEntities(input: string): string {\n const once = (s: string) =>\n s\n .replace(/&#(\\d+);/g, (_, d) => String.fromCharCode(Number(d)))\n .replace(/"/g, '\"')\n .replace(/'/g, \"'\")\n .replace(/'/g, \"'\")\n .replace(/ /g, \" \")\n .replace(/</g, \"<\")\n .replace(/>/g, \">\")\n .replace(/&/g, \"&\");\n return once(once(input)).trim();\n}\n\n// Second date and second time are both optional: a title may carry one date and\n// one time (\"26 Jul 2026, 9:00 AM\"), or span days (\"26 Jul 2026 - 28 Jul 2026\").\nconst DATE_RE =\n /(\\d{1,2})\\s+([A-Za-z]{3})[a-z]*\\s+(\\d{4})(?:\\s*[-–—]\\s*(\\d{1,2})\\s+([A-Za-z]{3})[a-z]*\\s+(\\d{4}))?(?:\\s*,\\s*(\\d{1,2}:\\d{2}\\s*[AP]M)(?:\\s+(\\d{1,2}:\\d{2}\\s*[AP]M))?)?/i;\n\nconst SESSION_RE = /\\b(\\d+)\\s+of\\s+(\\d+)\\b/i;\n\n/** \"9:00 AM\" -> \"090000\" */\nfunction toClock(t: string): string {\n const m = t.trim().match(/^(\\d{1,2}):(\\d{2})\\s*([AP])M$/i);\n if (!m) throw new Error(`unparsed time: ${t}`);\n let h = Number(m[1]) % 12;\n if (m[3].toUpperCase() === \"P\") h += 12;\n return `${String(h).padStart(2, \"0\")}${m[2]}00`;\n}\n\nfunction toDate(day: string, mon: string, year: string): string {\n const m = MONTHS[mon.slice(0, 3).toLowerCase()];\n if (!m) throw new Error(`unparsed month: ${mon}`);\n return `${year}${String(m).padStart(2, \"0\")}${day.padStart(2, \"0\")}`;\n}\n\n/** \"20260726\" -> \"20260727\" */\nfunction nextDate(yyyymmdd: string): string {\n const d = new Date(\n Number(yyyymmdd.slice(0, 4)),\n Number(yyyymmdd.slice(4, 6)) - 1,\n Number(yyyymmdd.slice(6, 8)) + 1,\n );\n return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, \"0\")}${\n String(d.getDate()).padStart(2, \"0\")\n }`;\n}\n\n/**\n * Cohort tags, in every shape seen so far: \" 26-37\", \" (26-37)\", \"-26-37\",\n * \" 26-37AB\", and any of those with an en/em dash. The leading separator is\n * part of the match so it goes with the tag. Two digits minimum on the left,\n * so \"SHOP 101\" and \"WOODTURNING 1-2\" — where the number is the course name —\n * are left alone.\n */\nexport const COHORT_RE = /(?:\\s+|\\s*[-–—]\\s*)\$?\\d{2,4}[-–—]\\d+[a-z]{0,2}\$?(?![\\w-])/gi;\n\n/**\n * Time-of-day slots: the same class runs \"- MORNING\", \"- AFTERNOON\" and\n * \"- EVENING\", and the owner takes it once. Trailing only, so \"MORNING GLORY\n * CARVING\" keeps its name, and the separator comes off with the word.\n */\nexport const SLOT_RE = /(?:\\s*[-–—]\\s*|\\s+)(?:morning|afternoon|evening)\\s*$/i;\n\n/**\n * Classes are offered in cohorts and time slots: \"CORE TOOL CERTIFICATION -\n * EVENING 26-37\", \"26-38\", \"- AFTERNOON 26-41\" are the same class over and\n * over. Strip both so \"taken\" attaches to the course, not to one occurrence\n * of it.\n */\nexport function courseKeyFor(name: string): string | null {\n if (!/^\\s*ED[SG]\\b/i.test(name)) return null; // only EDS-/EDG- classes are finishable\n return name\n // \"DOVETAIL BOX – MAKE\" and \"DOVETAIL BOX - MAKE\" are one course.\n .replace(/[–—]/g, \"-\")\n // Cohort first: the slot word sits to its left (\"- AFTERNOON 26-41\").\n .replace(COHORT_RE, \"\")\n .replace(SLOT_RE, \"\")\n .replace(/\\s{2,}/g, \" \")\n .trim()\n .toUpperCase();\n}\n\n/** Cancellations live in the event name, not a status field. */\nexport function readCancellation(raw: string): { name: string; cancelled: boolean } {\n const cancelled = /cancell?ed/i.test(raw);\n if (!cancelled) return { name: raw, cancelled };\n const name = raw\n // leading, with a reason: \"CANCELLED due to Weather - Women in the Shop\"\n .replace(/^\\s*cancell?ed\\b[^-–—!.:]*[-–—!.:]\\s*/i, \"\")\n // leading, bare: \"CANCELLED Women in the Shop\"\n .replace(/^\\s*cancell?ed\\b\\s*[-–—:,]?\\s*/i, \"\")\n // trailing: \"Project Build - Afternoon Cancelled due to heat\", and the\n // separator or bracket that introduced it — \"Women in the Shop -\n // CANCELLED\", \"(CANCELLED)\", \"[Cancelled]\" — which otherwise stays behind\n // and corrupts the course key.\n .replace(/\\s*[-–—:,(\\[]?\\s*\\bcancell?ed\\b[^-–—!.:]*[)\\]!.]?\\s*$/i, \"\")\n .trim();\n return { name: name || raw.trim(), cancelled };\n}\n\nconst ANCHOR_RE = /]*)>([\\s\\S]*?)<\\/a>/gi;\n\nexport function parseCalendarPage(html: string, calendar: string): GuildEvent[] {\n const out = new Map();\n\n for (const m of html.matchAll(ANCHOR_RE)) {\n const attrs = m[1];\n const href = attrs.match(/href\\s*=\\s*\"([^\"]*)\"/i)?.[1];\n const title = attrs.match(/title\\s*=\\s*\"([^\"]*)\"/i)?.[1];\n if (!href || !title) continue;\n\n const idMatch = href.match(/event-(\\d+)/);\n if (!idMatch) continue;\n\n const rawName = decodeEntities(m[2].replace(/<[^>]*>/g, \" \").replace(/\\s+/g, \" \"));\n if (!rawName) continue;\n\n const info = decodeEntities(title).replace(/\\r/g, \"\");\n const dm = info.match(DATE_RE);\n if (!dm) continue; // not an event tooltip\n\n const date = toDate(dm[1], dm[2], dm[3]);\n const endDate = dm[4] ? toDate(dm[4], dm[5], dm[6]) : date;\n const allDay = !dm[7];\n const start = allDay ? date : `${date}T${toClock(dm[7])}`;\n let end: string | null = null;\n if (allDay) {\n end = dm[4] ? endDate : null; // date-only, and only for a multi-day span\n } else if (dm[8]) {\n end = `${endDate}T${toClock(dm[8])}`;\n // \"9:00 PM 12:00 AM\" ends the following morning, not before it started.\n if (end <= start) end = `${nextDate(endDate)}T${toClock(dm[8])}`;\n }\n\n const tail = info.slice(dm.index! + dm[0].length);\n const location = tail\n .split(\"\\n\")\n .map((s) => s.trim())\n .filter(Boolean)\n .join(\", \")\n .replace(/^,\\s*/, \"\");\n\n const sm = info.slice(0, dm.index).match(SESSION_RE);\n const { name, cancelled } = readCancellation(rawName);\n\n const ev: GuildEvent = {\n id: idMatch[1],\n name,\n cancelled,\n allDay,\n start,\n end,\n location,\n session: sm ? `${sm[1]} of ${sm[2]}` : null,\n courseKey: courseKeyFor(name),\n calendar,\n url: `https://www.guildoforegonwoodworkers.com/event-${idMatch[1]}`,\n };\n\n // Same event can appear twice on one page (multi-day spans). Last write wins.\n out.set(`${ev.id}:${ev.start}`, ev);\n }\n\n return [...out.values()];\n}\n\n// ---------------------------------------------------------------------------\n// Fullness — the hidden \"Upcoming Events\" widget\n// ---------------------------------------------------------------------------\n\n/**\n * Whether registration is still open, and the third state is the whole point.\n *\n * Wild Apricot deletes the registration block outright once an event has\n * started, so a course with no button is not \"open\" and not \"full\" — it is a\n * question the page stopped answering. Collapsing that to a boolean would\n * paint every past occurrence as bookable. Callers must render \"unknown\" as\n * they rendered everything before this feature existed.\n */\nexport type Fullness = \"full\" | \"open\" | \"unknown\";\n\n/**\n * One registration control, matched whole, from the widget the calendar grid\n * does not show. Verified against the live pages on 2026-09-07:\n *\n * OPEN\n * Register\n *\n * FULL\n * Join waitlist\n *\n * The `_bt` input's class is the deciding capture, because the button is the\n * authority here and the neighbouring \"Spaces left\" counter is not: an event\n * that has already started still advertises \"Spaces left 4\" long after Wild\n * Apricot removed the button (live example on 2026-09-07: event-6756663,\n * started 03 Sep, four spaces \"left\", no registration block at all). The\n * anchor is matched only to carry the event id, which the input does not hold.\n *\n * Note what this does NOT do: it never segments the document into per-event\n * blocks. It does not need to. Every quantifier is a negated class fenced in\n * by the literal that follows it, so the whole thing is one forward scan with\n * no backtracking to speak of — which matters, because the Guild widget is a\n * 21MB string. Measured: 176/176 controls found on 21.4MB in 859ms, 74/74 on\n * 4.6MB in 170ms, both exactly equal to an independent count of the class\n * attribute, so no misses and no false positives.\n */\nconst REGISTRATION_CONTROL_RE =\n /event-(\\d+)\\/(?:Registration|JoinWaitlist)\"[^>]*>[^<]*<\\/a>]*eventRegistrationActions_(?:RegistrationLink|lobJoinWaitlist)_bt\"[^>]*class=\"typeButton (registerButton|joinWaitlistButton)\"/g;\n\n/**\n * Widget HTML in, event id -> state out.\n *\n * Only ids the widget actually answered for appear in the map. An id that is\n * absent is \"unknown\", which keeps the map small (a few dozen keys out of a\n * page with a thousand event links) and, more importantly, keeps \"we did not\n * fetch the widget\" and \"the widget said nothing about this event\" the same\n * answer — because they are the same answer.\n *\n * \"unknown\" is stored explicitly in exactly one case: an id that shows up with\n * both a Register and a Join-waitlist control. That has never been observed\n * (zero overlap across both live widgets), and if it ever happens it is a\n * contradiction, not a tie to break in favour of the last one parsed.\n */\nexport function parseFullnessWidget(html: string): Record {\n const out: Record = {};\n for (const m of html.matchAll(REGISTRATION_CONTROL_RE)) {\n const id = m[1];\n const state: Fullness = m[2] === \"joinWaitlistButton\" ? \"full\" : \"open\";\n const seen = out[id];\n if (seen === undefined) out[id] = state;\n else if (seen !== state) out[id] = \"unknown\";\n }\n return out;\n}\n\n/** The three-state read. Absent, stale-dropped and contradicted all land here. */\nexport function fullnessOf(\n map: Record | undefined,\n id: string,\n): Fullness {\n return map?.[id] ?? \"unknown\";\n}\n",[140],"ee259e8f-8049-46aa-9af6-786d60d03eb7","ics.ts","3c55ca04-a98a-11f1-96d5-1607ee4eb77e",11,["D",1788829780794],"import { type Fullness, fullnessOf, type GuildEvent } from \"./parse.ts\";\n\nexport const TZ = \"America/Los_Angeles\";\n\nfunction esc(s: string): string {\n return s\n .replace(/\\\\/g, \"\\\\\\\\\")\n .replace(/;/g, \"\\\\;\")\n .replace(/,/g, \"\\\\,\")\n .replace(/\\n/g, \"\\\\n\");\n}\n\n/** RFC 5545 wants lines folded at 75 octets. */\nfunction fold(line: string): string {\n const bytes = new TextEncoder().encode(line);\n if (bytes.length <= 75) return line;\n const parts: string[] = [];\n let buf = \"\";\n let len = 0;\n for (const ch of line) {\n const n = new TextEncoder().encode(ch).length;\n if (len + n > (parts.length === 0 ? 75 : 74)) {\n parts.push(buf);\n buf = \"\";\n len = 0;\n }\n buf += ch;\n len += n;\n }\n if (buf) parts.push(buf);\n return parts.join(\"\\r\\n \");\n}\n\nfunction stamp(): string {\n return new Date().toISOString().replace(/[-:]/g, \"\").replace(/\\.\\d{3}/, \"\");\n}\n\nfunction nextDay(yyyymmdd: string): string {\n const d = new Date(\n Number(yyyymmdd.slice(0, 4)),\n Number(yyyymmdd.slice(4, 6)) - 1,\n Number(yyyymmdd.slice(6, 8)) + 1,\n );\n return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, \"0\")}${\n String(d.getDate()).padStart(2, \"0\")\n }`;\n}\n\n/** Content hash — bump SEQUENCE only when something a subscriber would notice changes. */\nexport function fingerprint(ev: GuildEvent): string {\n return [ev.name, ev.start, ev.end, ev.location, ev.cancelled, ev.session].join(\"|\");\n}\n\nfunction toIcsDateTime(v: string): string {\n return v.replace(\"T\", \"T\");\n}\n\nexport interface RenderOpts {\n calName: string;\n /** Base URL of your val, used to link back to the class list. */\n base?: string;\n sequences?: Record;\n /** Event id -> state. Absent, and absent ids, both mean \"unknown\". */\n fullness?: Record;\n}\n\nfunction describe(ev: GuildEvent, o: RenderOpts): string {\n const lines: string[] = [];\n if (ev.session) lines.push(`Session ${ev.session}`);\n // The class list gets orange, an icon and a tooltip. iCalendar has none of\n // those — no colour, no markup, no hover — so a sentence in the body is the\n // only representation that survives the trip to Google and Apple. SUMMARY is\n // left alone on purpose: it is the string every client shows in month view\n // and in notifications, and a state that can flip back tomorrow does not\n // belong in it.\n //\n // Cancelled wins outright. A cancelled session is not \"full\", it is not\n // happening, and STATUS:CANCELLED below already says so.\n if (!ev.cancelled && fullnessOf(o.fullness, ev.id) === \"full\") {\n lines.push(\"This session is full. Registration is closed; a waitlist is open.\");\n }\n if (ev.cancelled) lines.push(\"This session was cancelled by the Guild.\");\n lines.push(ev.url);\n if (ev.courseKey && o.base) {\n // Bare link, never a tokenised one: this body syncs to Google and Apple.\n lines.push(`Taken it? Hide future offerings: ${new URL(\"/\", o.base).toString()}`);\n }\n return lines.join(\"\\n\");\n}\n\n/**\n * RFC 5545 §3.2.19 wants every referenced TZID defined in the same object.\n * Google and Apple resolve the bare IANA name; Outlook/Exchange treats an\n * unresolvable TZID as UTC and shifts everything 7-8 hours.\n */\nconst VTIMEZONE = [\n \"BEGIN:VTIMEZONE\",\n `TZID:${TZ}`,\n `X-LIC-LOCATION:${TZ}`,\n \"BEGIN:DAYLIGHT\",\n \"TZOFFSETFROM:-0800\",\n \"TZOFFSETTO:-0700\",\n \"TZNAME:PDT\",\n \"DTSTART:19700308T020000\",\n \"RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=2SU\",\n \"END:DAYLIGHT\",\n \"BEGIN:STANDARD\",\n \"TZOFFSETFROM:-0700\",\n \"TZOFFSETTO:-0800\",\n \"TZNAME:PST\",\n \"DTSTART:19701101T020000\",\n \"RRULE:FREQ=YEARLY;BYMONTH=11;BYDAY=1SU\",\n \"END:STANDARD\",\n \"END:VTIMEZONE\",\n];\n\nexport function renderIcs(events: GuildEvent[], o: RenderOpts): string {\n const now = stamp();\n const lines: string[] = [\n \"BEGIN:VCALENDAR\",\n \"VERSION:2.0\",\n \"PRODID:-//guild-calendar-bridge//EN\",\n \"CALSCALE:GREGORIAN\",\n \"METHOD:PUBLISH\",\n `X-WR-CALNAME:${esc(o.calName)}`,\n `X-WR-TIMEZONE:${TZ}`,\n ...VTIMEZONE,\n ];\n\n for (const ev of events) {\n const uid = `${ev.id}-${ev.start}@guildoforegonwoodworkers`;\n lines.push(\"BEGIN:VEVENT\");\n lines.push(`UID:${uid}`);\n lines.push(`DTSTAMP:${now}`);\n lines.push(`SEQUENCE:${o.sequences?.[uid] ?? 0}`);\n if (ev.allDay) {\n lines.push(`DTSTART;VALUE=DATE:${ev.start}`);\n // DTEND is exclusive, and ev.end is set only for a multi-day span.\n lines.push(`DTEND;VALUE=DATE:${nextDay(ev.end ?? ev.start)}`);\n } else {\n lines.push(`DTSTART;TZID=${TZ}:${toIcsDateTime(ev.start)}`);\n if (ev.end) lines.push(`DTEND;TZID=${TZ}:${toIcsDateTime(ev.end)}`);\n }\n lines.push(`SUMMARY:${esc(ev.name)}`);\n if (ev.location) lines.push(`LOCATION:${esc(ev.location)}`);\n lines.push(`DESCRIPTION:${esc(describe(ev, o))}`);\n lines.push(`URL:${ev.url}`);\n if (ev.cancelled) lines.push(\"STATUS:CANCELLED\");\n lines.push(`CATEGORIES:${esc(ev.calendar)}`);\n lines.push(\"END:VEVENT\");\n }\n\n lines.push(\"END:VCALENDAR\");\n return lines.map(fold).join(\"\\r\\n\") + \"\\r\\n\";\n}\n",[148],"88adb2ca-b71c-471a-9bf4-4204a122ea51","http.ts",9,["D",1788691013596],"http","import { blob } from \"https://esm.town/v/std/blob\";\nimport { COHORT_RE, SLOT_RE, type GuildEvent } from \"./parse.ts\";\nimport { renderIcs, TZ } from \"./ics.ts\";\nimport { filterTaken, hide, sequenceMap, takenKeys, unhide } from \"./store.ts\";\n\nconst TOKEN = Deno.env.get(\"GUILD_TOKEN\") ?? \"\";\nconst COOKIE = \"guild_auth\";\n\ntype Stored =\n | { ok: true; events: GuildEvent[] }\n | { ok: false; status: number; message: string };\n\n/**\n * Never answer with an empty-but-valid calendar. getJSON returns undefined for\n * a missing key and throws only on a real failure; either way a subscribed\n * client would read zero VEVENTs as \"every event was deleted\", so both cases\n * have to surface as an error instead of as a feed.\n */\nasync function events(): Promise {\n let raw: unknown;\n try {\n raw = await blob.getJSON(\"events\");\n } catch (e) {\n return { ok: false, status: 503, message: `Event store unavailable: ${e}` };\n }\n if (raw == null) {\n return {\n ok: false,\n status: 503,\n message: \"No calendar data yet. cron.ts has not completed a scrape.\",\n };\n }\n if (!Array.isArray(raw) || raw.length === 0) {\n return { ok: false, status: 503, message: \"Event store is empty or malformed.\" };\n }\n return { ok: true, events: raw as GuildEvent[] };\n}\n\nfunction problem(s: { status: number; message: string }): Response {\n return new Response(`${s.message}\\n`, {\n status: s.status,\n headers: { \"content-type\": \"text/plain; charset=utf-8\" },\n });\n}\n\ntype Taken =\n | { ok: true; keys: string[] }\n | { ok: false; status: number; message: string };\n\ntype Sequences =\n | { ok: true; map: Record }\n | { ok: false; status: number; message: string };\n\n/**\n * These two used to swallow every failure and answer with an empty default.\n * For the taken-list that is the worst possible response: /new.ics would serve\n * every class the owner had hidden, and it would look exactly like a correct\n * feed. A store that cannot be read is not the same as a store that is empty —\n * an empty table is a real, valid answer meaning nothing has been hidden yet,\n * while an error has to surface as a 503 the way a missing event store does.\n */\nasync function taken(): Promise {\n try {\n return { ok: true, keys: await takenKeys() };\n } catch (e) {\n return { ok: false, status: 503, message: `Hidden-class store unavailable: ${e}` };\n }\n}\n\n/**\n * Same reasoning, one step weaker: a missing SEQUENCE is not a wrong event, it\n * is an event a subscriber may refuse to update because the number went\n * backwards. Fail rather than publish a feed that quietly resets every\n * counter to zero.\n */\nasync function sequences(): Promise {\n try {\n return { ok: true, map: await sequenceMap() };\n } catch (e) {\n return { ok: false, status: 503, message: `Sequence store unavailable: ${e}` };\n }\n}\n\nfunction ics(body: string, filename: string) {\n return new Response(body, {\n headers: {\n \"content-type\": \"text/calendar; charset=utf-8\",\n \"content-disposition\": `inline; filename=\"${filename}\"`,\n \"cache-control\": \"public, max-age=1800\",\n },\n });\n}\n\n/** Val Town runs in UTC, so \"today\" has to be asked for in Guild time. */\nfunction todayStamp(): string {\n const parts = new Intl.DateTimeFormat(\"en-CA\", {\n timeZone: TZ,\n year: \"numeric\",\n month: \"2-digit\",\n day: \"2-digit\",\n }).formatToParts(new Date());\n const get = (t: string) => parts.find((p) => p.type === t)!.value;\n return `${get(\"year\")}${get(\"month\")}${get(\"day\")}`;\n}\n\n/**\n * The token arrives once as a POSTed form field and immediately becomes a\n * cookie, so it never sits in page HTML, a Location header, browser history,\n * a Referer, a proxy log or a shared link.\n */\nfunction authed(req: Request): boolean {\n if (!TOKEN) return false;\n for (const part of (req.headers.get(\"cookie\") ?? \"\").split(\";\")) {\n const eq = part.indexOf(\"=\");\n if (eq < 0) continue;\n if (part.slice(0, eq).trim() !== COOKIE) continue;\n return decodeURIComponent(part.slice(eq + 1).trim()) === TOKEN;\n }\n return false;\n}\n\n/** One place for the cookie flags, so login and logout can never drift apart. */\nfunction cookie(value: string, maxAge: number): string {\n return `${COOKIE}=${value}; Path=/; Max-Age=${maxAge}; HttpOnly; Secure; SameSite=Strict`;\n}\n\nfunction esc(s: string) {\n return s.replace(/[&<>\"]/g, (c) =>\n ({ \"&\": \"&\", \"<\": \"<\", \">\": \">\", '\"': \""\" }[c]!));\n}\n\nconst CSS = `\n:root{--paper:#fbfbf8;--ink:#1d1d1a;--muted:#6f736c;--rule:#e0e0d8;--fir:#2f5d3f}\n*{box-sizing:border-box}\nbody{margin:0;background:var(--paper);color:var(--ink);\n font:16px/1.5 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif;\n padding:1.5rem 1.25rem 4rem;max-width:38rem;margin-inline:auto}\nh1{font-size:1.35rem;font-weight:650;margin:0 0 .25rem}\np.sub{color:var(--muted);margin:0 0 2rem;font-size:.9rem}\nh2{font-size:.95rem;font-weight:650;margin:2rem 0 .5rem;padding-bottom:.4rem;\n border-bottom:1px solid var(--rule)}\nul{list-style:none;margin:0;padding:0}\nli{display:flex;gap:1rem;align-items:baseline;justify-content:space-between;\n padding:.85rem 0;border-bottom:1px solid var(--rule)}\n.name{flex:1;min-width:0}\n.when{display:block;color:var(--muted);font-size:.8rem;margin-top:.15rem}\n.act{flex-shrink:0;color:var(--fir);text-decoration:none;font-size:.85rem;\n font-family:inherit;background:none;cursor:pointer;\n border:1px solid var(--fir);border-radius:2px;padding:.45rem .7rem;min-height:44px;\n display:inline-flex;align-items:center}\n.act:focus-visible{outline:2px solid var(--fir);outline-offset:2px}\nli>form{flex-shrink:0;margin:0}\nli.done .name{color:var(--muted)}\nli.done .act{color:var(--muted);border-color:var(--rule)}\n.empty{color:var(--muted);padding:.85rem 0}\ncode{background:#eeeee6;padding:.15rem .35rem;border-radius:2px;font-size:.85em}\n.feeds{margin:0 0 1rem;font-size:.9rem;color:var(--muted)}\nform.login{max-width:20rem;margin:0}\nform.login label{display:block;font-size:.85rem;color:var(--muted);margin:0 0 .35rem}\nform.login input{width:100%;font:inherit;color:var(--ink);background:#fff;\n border:1px solid var(--rule);border-radius:2px;padding:.5rem .6rem;min-height:44px}\nform.login input:focus-visible{outline:2px solid var(--fir);outline-offset:2px}\nform.login .act{margin-top:1rem}\np.error{color:#8c2f2f;font-size:.9rem;margin:0 0 1rem}\nform.logout{margin:2.5rem 0 0}\n`;\n\n/**\n * A POSTed field, unlike a query string, stays out of browser history, Referer\n * headers and request logs. The field is never re-populated on a failed try, so\n * a wrong (or right) guess is not echoed back into the HTML.\n */\nfunction loginPage(failed: boolean): Response {\n return new Response(\n `\n\nGuild classes\n

Guild classes

\n${failed ? '

Incorrect password.

' : \"\"}\n\n`,\n {\n status: failed ? 401 : 200,\n headers: { \"content-type\": \"text/html; charset=utf-8\" },\n },\n );\n}\n\nfunction pretty(key: string, all: GuildEvent[]): string {\n const ev = all.find((e) => e.courseKey === key);\n // Same strips as courseKeyFor, in the same order, so the label matches the key.\n return ev ? ev.name.replace(COHORT_RE, \"\").replace(SLOT_RE, \"\").trim() : key;\n}\n\n/**\n * Sort key for a display name: \"EDG-Fundamentals\" and \"EDG - Fundamentals\"\n * are the same course, but a hyphen and a space sort apart under plain ASCII\n * comparison. Collapsing every separator to a space and folding case groups\n * siblings regardless of which punctuation the scrape happened to keep — the\n * displayed text itself is never touched.\n */\nexport function sortKey(name: string): string {\n return name.replace(/[-–—]/g, \" \").replace(/\\s+/g, \" \").trim().toLowerCase();\n}\n\n/** Alphabetical by display name, using the normalized key above. */\nexport function compareNames(a: string, b: string): number {\n return sortKey(a).localeCompare(sortKey(b));\n}\n\n/**\n * \"Coming up\" is a schedule, not a list: it has to read chronologically or\n * the soonest class ends up buried under whatever course starts with an\n * early letter. A course with no next occurrence sorts last; two courses\n * landing on the same day tie-break on the normalized name so the order is\n * deterministic instead of tracking scrape order.\n */\nexport function compareUpcoming(\n a: { name: string; nextDay: string | null },\n b: { name: string; nextDay: string | null },\n): number {\n if (a.nextDay !== b.nextDay) {\n if (a.nextDay == null) return 1;\n if (b.nextDay == null) return -1;\n return a.nextDay < b.nextDay ? -1 : 1;\n }\n return compareNames(a.name, b.name);\n}\n\nfunction page(all: GuildEvent[], done: string[], origin: string): Response {\n const today = todayStamp();\n const upcoming = all.filter((e) => e.courseKey && e.start >= today && !e.cancelled);\n\n const keys = [...new Set(upcoming.map((e) => e.courseKey!))];\n\n // Earliest occurrence's floating-local start, e.g. \"20260909T170000\" or\n // the all-day \"20260801\"; null when nothing for this key is upcoming.\n const nextStart = (k: string): string | null =>\n upcoming.filter((x) => x.courseKey === k).sort((a, b) =>\n a.start.localeCompare(b.start)\n )[0]?.start ?? null;\n\n // Calendar day only (first 8 chars), so two courses starting at different\n // times on the same day still count as a tie for sorting purposes.\n const nextDay = (k: string): string | null => nextStart(k)?.slice(0, 8) ?? null;\n\n const nextDate = (k: string) => {\n const s = nextStart(k);\n if (!s) return \"\";\n const d = new Date(\n Number(s.slice(0, 4)),\n Number(s.slice(4, 6)) - 1,\n Number(s.slice(6, 8)),\n );\n return d.toLocaleDateString(\"en-US\", { month: \"short\", day: \"numeric\" });\n };\n\n // A POST, not a link: link prefetchers and mail scanners fire GETs, and were\n // silently marking classes taken.\n const button = (k: string, isDone: boolean) =>\n ``;\n\n const row = (k: string) => {\n const isDone = done.includes(k);\n return `

${esc(pretty(k, all))}\n next on ${esc(nextDate(k))}\n ${button(k, isDone)}

`;\n };\n\n // The schedule: soonest class first. Both sort inputs are computed once per\n // key rather than inside the comparator — pretty() and nextDay() each scan\n // the whole event list, and a comparator runs O(n log n) times. Same\n // comparator, same values, same input order, so the resulting order is\n // unchanged; only the number of scans is.\n const open = keys.filter((k) => !done.includes(k))\n .map((k) => ({ k, name: pretty(k, all), nextDay: nextDay(k) }))\n .sort(compareUpcoming)\n .map((e) => e.k);\n // Lookup lists, not schedules: name order, not date order.\n const hidden = keys.filter((k) => done.includes(k)).sort((a, b) =>\n compareNames(pretty(a, all), pretty(b, all))\n );\n const orphans = done.filter((k) => !keys.includes(k)).sort((a, b) =>\n compareNames(pretty(a, all), pretty(b, all))\n );\n\n return new Response(\n `\n\nGuild classes\n

Guild classes

Hide a class and it drops out of your filtered feed. Everything still shows in the full one.

Subscribe: ${esc(origin)}/new.ics · full: ${\n esc(origin)\n }/all.ics

Coming up

Nothing scheduled.

\n${\n hidden.length\n ? `

Hidden

${hidden.map(row).join(\"\")}`\n : \"\"\n }\n${\n orphans.length\n ? `

Hidden, not currently offered

${esc(pretty(k, all))}\n ${button(k, true)}

`\n : \"\"\n }\n\n`,\n { headers: { \"content-type\": \"text/html; charset=utf-8\" } },\n );\n}\n\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n const origin = url.origin;\n\n if (url.pathname === \"/all.ics\") {\n const stored = await events();\n if (!stored.ok) return problem(stored);\n const seq = await sequences();\n if (!seq.ok) return problem(seq);\n return ics(\n renderIcs(stored.events, {\n calName: \"Guild of Oregon Woodworkers\",\n base: origin,\n sequences: seq.map,\n }),\n \"guild-all.ics\",\n );\n }\n\n if (url.pathname === \"/new.ics\") {\n const stored = await events();\n if (!stored.ok) return problem(stored);\n const done = await taken();\n if (!done.ok) return problem(done);\n const seq = await sequences();\n if (!seq.ok) return problem(seq);\n return ics(\n renderIcs(filterTaken(stored.events, done.keys, todayStamp()), {\n calName: \"Guild classes (filtered)\",\n base: origin,\n sequences: seq.map,\n }),\n \"guild-new.ics\",\n );\n }\n\n // POST-only for the same reason the mutations are: a GET-triggered login or\n // logout is something a prefetcher or a mail scanner can fire on its own.\n if (url.pathname === \"/login\") {\n if (req.method !== \"POST\") {\n return new Response(\"Use POST.\", { status: 405, headers: { allow: \"POST\" } });\n }\n const supplied = String((await req.formData()).get(\"token\") ?? \"\");\n if (!TOKEN || supplied !== TOKEN) return loginPage(true);\n return new Response(null, {\n status: 303,\n headers: {\n location: \"/\",\n \"set-cookie\": cookie(encodeURIComponent(TOKEN), 31536000),\n },\n });\n }\n\n if (url.pathname === \"/logout\") {\n if (req.method !== \"POST\") {\n return new Response(\"Use POST.\", { status: 405, headers: { allow: \"POST\" } });\n }\n return new Response(null, {\n status: 303,\n headers: { location: \"/\", \"set-cookie\": cookie(\"\", 0) },\n });\n }\n\n if (url.pathname === \"/taken\" || url.pathname === \"/untaken\") {\n if (req.method !== \"POST\") {\n return new Response(\"Use POST.\", { status: 405, headers: { allow: \"POST\" } });\n }\n if (!authed(req)) return new Response(\"Wrong or missing token.\", { status: 403 });\n\n const key = String((await req.formData()).get(\"key\") ?? \"\");\n if (!key) return new Response(\"Missing key.\", { status: 400 });\n\n // One row, no read first. The old code read the whole list, edited it in\n // memory and wrote it all back, so a second request that overlapped the\n // first threw one of the two changes away.\n try {\n if (url.pathname === \"/taken\") await hide(key);\n else await unhide(key);\n } catch (e) {\n // Never redirect as though the click landed: a 303 to \"/\" after a failed\n // write shows the old list back and reads as success.\n return problem({ status: 503, message: `Could not save that change: ${e}` });\n }\n\n // Redirect after POST so a refresh doesn't re-submit.\n return new Response(null, { status: 303, headers: { location: \"/\" } });\n }\n\n if (url.pathname === \"/\") {\n if (!authed(req)) return loginPage(false);\n const stored = await events();\n if (!stored.ok) return problem(stored);\n const done = await taken();\n if (!done.ok) return problem(done);\n return page(stored.events, done.keys, origin);\n }\n\n return new Response(\"Not found\", { status: 404 });\n}\n",[155],"d3ca271e-87d4-4712-92e4-d1f13bc95196","cron.ts","3ca78ed4-a98a-11f1-9871-1607ee4eb77e",8,["D",1788691013100],"interval","import { blob } from \"https://esm.town/v/std/blob\";\nimport { parseCalendarPage, type GuildEvent } from \"./parse.ts\";\nimport { fingerprint } from \"./ics.ts\";\nimport { nextSequence, putSequences, sequenceRows } from \"./store.ts\";\n\nconst HOST = \"https://www.guildoforegonwoodworkers.com\";\n\n// /Main-Shop-Events-Calendar is deliberately omitted: it requires a Wild\n// Apricot login, and an anonymous request gets redirected to a login page\n// that returns HTTP 200 — so it'd silently contribute zero events forever.\n// Most of its events already appear on the Guild calendar, tagged `shop`.\nconst CALENDARS = [\n { path: \"/Guild-Calendar\", name: \"Guild\" },\n { path: \"/Education-Calendar\", name: \"Education\" },\n];\n\nconst MONTHS_BACK = 1;\nconst MONTHS_AHEAD = 6;\n\nfunction monthUrls(path: string): string[] {\n const urls: string[] = [];\n const now = new Date();\n for (let i = -MONTHS_BACK; i <= MONTHS_AHEAD; i++) {\n const d = new Date(now.getFullYear(), now.getMonth() + i, 1);\n const sel = `${d.getMonth() + 1}/1/${d.getFullYear()}`;\n urls.push(\n `${HOST}${path}?EventViewMode=1&EventListViewMode=2&SelectedDate=${\n encodeURIComponent(sel)\n }&CalendarViewType=1`,\n );\n }\n return urls;\n}\n\nconst sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));\n\nexport async function scrape(): Promise {\n const seen = new Map();\n\n for (const cal of CALENDARS) {\n for (const url of monthUrls(cal.path)) {\n const res = await fetch(url, {\n headers: { \"user-agent\": \"guild-calendar-bridge (personal ics feed)\" },\n });\n if (!res.ok) throw new Error(`${res.status} fetching ${url}`);\n const html = await res.text();\n for (const ev of parseCalendarPage(html, cal.name)) {\n seen.set(`${ev.id}:${ev.start}`, ev);\n }\n await sleep(400); // be a polite guest\n }\n }\n\n return [...seen.values()].sort((a, b) => a.start.localeCompare(b.start));\n}\n\n/**\n * Fail loudly rather than quietly publishing an empty calendar.\n * The Guild runs open shop most days, so a near-empty result means\n * their markup changed, not that nothing is scheduled.\n */\nfunction check(events: GuildEvent[]) {\n const problems: string[] = [];\n if (events.length < 100) problems.push(`only ${events.length} events parsed`);\n\n const today = new Date();\n const soon = new Date(today.getTime() + 7 * 864e5);\n const fmt = (d: Date) =>\n `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, \"0\")}${\n String(d.getDate()).padStart(2, \"0\")\n }`;\n const upcoming = events.filter((e) => e.start >= fmt(today) && e.start <= fmt(soon));\n if (upcoming.length === 0) problems.push(\"no events in the next 7 days\");\n\n const located = events.filter((e) => e.location).length;\n if (located / events.length < 0.5) problems.push(\"most events missing a location\");\n\n const classes = events.filter((e) => e.courseKey).length;\n if (classes === 0) problems.push(\"no EDS/EDG classes recognised\");\n\n if (problems.length) {\n throw new Error(`calendar scrape looks wrong: ${problems.join(\"; \")}`);\n }\n}\n\nexport default async function () {\n const events = await scrape();\n check(events);\n\n // The snapshot the site actually serves goes first, and on its own. It\n // depends on nothing but the scrape that check() just approved, while\n // everything below it touches a different store and can throw for reasons\n // that have nothing to do with today's events — the sequence read reaches\n // sqlite, and through init() the legacy taken-list blob. Writing the\n // snapshot after that meant one transient error on an unrelated key cost a\n // full day of stale events. Now it costs a day of SEQUENCE bookkeeping,\n // which the next run repairs by itself.\n await blob.setJSON(\"events\", events);\n\n // Bump SEQUENCE for anything whose details changed, so clients update\n // in place instead of duplicating. The counter and the fingerprint that\n // justifies it now share one row per UID, written as one UPSERT each.\n // Reading the whole table first is safe here in a way it never was in\n // http.ts: cron is the only writer, and it runs once a day.\n const prev = await sequenceRows();\n\n const rows: { uid: string; seq: number; fingerprint: string }[] = [];\n const prints: Record = {};\n const sequences: Record = {};\n\n for (const ev of events) {\n const uid = `${ev.id}-${ev.start}@guildoforegonwoodworkers`;\n const fp = fingerprint(ev);\n const seq = nextSequence(prev[uid], fp);\n rows.push({ uid, seq, fingerprint: fp });\n prints[uid] = fp;\n sequences[uid] = seq;\n }\n\n await putSequences(rows);\n // Nothing reads these two any more. They are still written so that the\n // previous version of this val stays a working rollback target instead of\n // one that would restore day-old SEQUENCE numbers and stall every client.\n // Safe to keep only because cron is their sole writer — the same dual write\n // on the taken-list would reintroduce exactly the bug this change removes.\n await blob.setJSON(\"prints\", prints);\n await blob.setJSON(\"sequences\", sequences);\n await blob.setJSON(\"lastRun\", { at: new Date().toISOString(), count: events.length });\n\n return `${events.length} events`;\n}\n",[162],"pulls","branches","forks","envVars",{"_176":136,"_178":62},"connections",{"_176":62,"_177":62},"count","unfilledCount","emptyCount",{"_43":161,"_32":162,"_30":163,"_133":-5,"_41":42,"_40":164,"_134":25,"_38":197,"_13":136,"_33":166,"_35":167,"_24":25,"_137":-5,"_185":198,"_27":199},{"_43":154,"_32":155,"_30":56,"_133":-5,"_41":42,"_40":156,"_134":25,"_38":194,"_13":144,"_33":158,"_35":159,"_24":25,"_137":-5,"_185":195,"_27":196},{"_43":147,"_32":148,"_30":149,"_133":-5,"_41":42,"_40":150,"_134":58,"_38":191,"_13":136,"_33":34,"_35":152,"_24":25,"_137":-5,"_185":192,"_27":193},{"_43":139,"_32":140,"_30":141,"_133":-5,"_41":42,"_40":142,"_134":25,"_38":188,"_13":144,"_33":34,"_35":145,"_24":25,"_137":-5,"_185":189,"_27":190},{"_43":132,"_32":28,"_30":31,"_133":-5,"_41":42,"_40":14,"_134":25,"_38":184,"_13":136,"_33":34,"_35":37,"_24":25,"_137":-5,"_185":186,"_27":187},["D",1788829781086],"children",[],[28],["D",1788829780264],[],[140],["D",1788829780794],[],[148],["D",1788691013596],[],[155],["D",1788691013100],[],[162],["D",1788654659900],{"_96":95,"_104":100},{"_96":95,"_97":98,"_99":100,"_18":54,"_101":102,"_103":25},{"_13":85,"_32":86,"_43":42,"_87":44,"_88":-5,"_89":-5,"_90":-5,"_91":-5,"_92":-5,"_93":45,"_94":95},"ctx",{"_78":-5,"_124":237,"_238":239,"_240":241,"_242":25,"_243":25,"_244":25,"_245":58,"_246":-5,"_247":-7,"_248":-7,"_249":62,"_250":25,"_251":25,"_252":-5,"_253":25,"_254":25,"_255":25,"_256":-5},"ENV",{"_208":209,"_210":211,"_212":86,"_213":214,"_215":216,"_217":218,"_219":220,"_221":222,"_223":224,"_225":226,"_227":228,"_229":230,"_231":232,"_233":234,"_235":236},"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 · v12