[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_189":190,"_191":192},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":-7,"_18":19,"_17":-7,"_144":-5,"_20":145,"_22":146,"_147":148,"_149":150,"_26":151,"_24":152,"_153":-5,"_154":-5,"_155":52,"_156":157,"_158":43,"_159":-5,"_160":-5,"_161":162},"routes/_app.x.$handle.$name.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":25,"_26":27,"_28":-5,"_29":-5,"_30":-5,"_31":-5,"_32":-5},"handle","nbbaier","name","request-capture","branchName","main","version","path","lib.ts","project",{"_33":90,"_13":14,"_44":91,"_92":-5,"_93":52,"_94":95,"_96":95,"_97":98,"_99":-5,"_100":101,"_102":71,"_103":43,"_104":-5,"_105":-5,"_106":86,"_107":108,"_109":-5,"_110":-5,"_111":-5,"_112":-5,"_113":114,"_115":114,"_116":117,"_118":117,"_119":117,"_120":114,"_121":114,"_122":123,"_124":125,"_126":127,"_128":52},"tree",[55,56,57,58],"file",{"_33":34,"_13":19,"_35":36,"_37":-5,"_38":39,"_40":41,"_42":43,"_44":45,"_17":46,"_47":48,"_49":50,"_51":52,"_53":-5,"_18":54},"contents",[],"upstream","pull","ahead","behind","envVars","id","3167caee-add3-4b20-9e16-e7e9b94ac7c2","fileId","b0a8fe84-9acc-11f1-9ce8-1607ee4eb77e","parentId","branchId","3183b296-5847-427a-9a53-e0c005bb1bde","branchVersion",3,"latest",true,"createdAt",["D",1787033937487],1,"fileType","script","content","/**\n * request-capture — HTTP request logging middleware for Val Town.\n *\n * Wrap any HTTP handler and every request it receives is snapshotted\n * into val-scoped blob storage as a serializable object:\n *\n * import { withRequestLogging } from \"https://esm.town/v/nbbaier/request-capture/lib.ts\";\n *\n * export default withRequestLogging(async (req: Request) => {\n * return Response.json({ ok: true, path: new URL(req.url).pathname });\n * });\n *\n * The captured record includes method, url, timestamp, an id, and headers\n * (sensitive ones redacted). The request body is NOT consumed by default so\n * the wrapped handler still gets to read it. Retrieval helpers below.\n */\n\nimport { blob } from \"https://esm.town/v/std/blob/main.ts\";\n\n/** The serializable record persisted per captured request. */\nexport interface CapturedRequest {\n /** Unique id for this capture, in `captures:` blob key form later. */\n id: string;\n method: string;\n url: string;\n /** Unix timestamp in milliseconds. */\n timestamp: number;\n /** ISO datetime string. */\n time: string;\n headers: Record;\n /**\n * The request body, captured iff `options.captureBody` is true.\n * Returns undefined when body wasn't captured (the default).\n */\n body?: string;\n}\n\n/** Headers that commonly hold secrets and are redacted by default. */\nconst SENSITIVE_HEADERS = new Set([\n \"authorization\",\n \"proxy-authorization\",\n \"cookie\",\n \"set-cookie\",\n \"x-api-key\",\n \"api-key\",\n \"x-val-town-user\",\n]);\n\nexport interface RequestLoggingOptions {\n /** Capture the request body? Requires cloning the request; default false. */\n captureBody?: boolean;\n /**\n * Callback invoked with the capture after it's persisted. Use for\n * additional fan-out (log lines, other stores). Errors here don't\n * break the wrapped handler.\n */\n onCaptured?: (capture: CapturedRequest) => Promise | void;\n /** Max body bytes to capture when captureBody is true (default 64 KB). */\n maxBodyBytes?: number;\n /** Key prefix for stored captures (default \"captures\"). */\n keyPrefix?: string;\n}\n\n/** Builds the blob key for a capture id. */\nfunction captureKey(prefix: string, id: string): string {\n return `${prefix}:${id}`;\n}\n\n/** Hash a raw header name to a stable, mostly-readable pseudo-name. */\nfunction redactHeader(name: string): string {\n return `${name}:redacted`;\n}\n\nexport function withRequestLogging(\n handler: (req: Request) => Response | Promise,\n options: RequestLoggingOptions = {},\n): (req: Request) => Promise {\n const {\n captureBody = false,\n maxBodyBytes = 64 * 1024,\n keyPrefix = \"captures\",\n } = options;\n\n return async (req: Request): Promise => {\n const id = crypto.randomUUID();\n const timestamp = Date.now();\n const now = new Date(timestamp);\n\n // Build the serializable snapshot.\n const headers: Record = {};\n req.headers.forEach((value, key) => {\n headers[SENSITIVE_HEADERS.has(key) ? redactHeader(key) : key] = value;\n });\n\n const capture: CapturedRequest = {\n id,\n method: req.method,\n url: req.url,\n timestamp,\n time: now.toISOString(),\n headers,\n };\n\n // Optionally consume the body from a clone, leaving the original intact\n // for the wrapped handler.\n if (captureBody) {\n try {\n const cloned = req.clone();\n const text = await cloned.text();\n capture.body = text.length > maxBodyBytes\n ? text.slice(0, maxBodyBytes)\n : text;\n } catch {\n // Body unreadable (e.g. a streaming body) — skip it, not fatal.\n }\n }\n\n // Serialize once and persist. Punting on the id for anything else to attach.\n await blob.setJSON(captureKey(keyPrefix, id), capture);\n\n if (options.onCaptured) {\n // Fan out without letting a failure affect the handler.\n Promise.resolve(options.onCaptured(capture)).catch((err) => {\n console.error(\"request-capture: onCaptured hook failed\", err);\n });\n }\n\n return handler(req);\n };\n}\n\n/** Read back a single captured request. */\nexport async function readRequest(id: string, prefix = \"captures\"): Promise {\n return await blob.getJSON(captureKey(prefix, id));\n}\n\n/** List all captured request blobs (optionally filtered), newest first. */\nexport async function listCaptures(prefix = \"captures\", limit = 100): Promise {\n const entries = (await blob.list(prefix + \":\")).sort((a, b) =>\n b.key.localeCompare(a.key)\n );\n const out: CapturedRequest[] = [];\n for (const { key } of entries.slice(0, limit)) {\n const cap = await blob.getJSON(key);\n if (cap) out.push(cap);\n }\n return out;\n}\n\n/** Remove captures older than the given age in milliseconds. Returns count removed. */\nexport async function pruneCaptures(olderThanMs: number, prefix = \"captures\"): Promise {\n const nowMs = Date.now();\n const cutoff = nowMs - olderThanMs;\n const entries = await blob.list(prefix + \":\");\n let removed = 0;\n for (const { key, lastModified } of entries) {\n if (new Date(lastModified).getTime() < cutoff) {\n await blob.delete(key);\n removed++;\n }\n }\n return removed;\n}\n","deleted",false,"label",[19],{"_33":81,"_13":82,"_35":83,"_37":-5,"_38":39,"_40":84,"_42":43,"_44":85,"_17":86,"_47":24,"_49":87,"_51":52,"_53":-5,"_66":88,"_18":89},{"_33":34,"_13":19,"_35":36,"_37":-5,"_38":39,"_40":41,"_42":43,"_44":78,"_17":46,"_47":48,"_49":50,"_51":52,"_53":-5,"_66":79,"_18":80},{"_33":69,"_13":70,"_35":71,"_37":-5,"_38":39,"_40":72,"_42":43,"_44":73,"_17":64,"_47":74,"_49":75,"_51":52,"_53":14,"_66":76,"_18":77},{"_33":59,"_13":60,"_35":61,"_37":-5,"_38":39,"_40":62,"_42":43,"_44":63,"_17":64,"_47":24,"_49":65,"_51":52,"_53":-5,"_66":67,"_18":68},"e91f8654-0306-486f-8f8e-f41cc2bde141","vcr-plan.md","73b1e19a-a11f-11f1-9183-1607ee4eb77e",9,["D",1787730639836],2,"# Turning request-capture into a VCR-style record/replay tool\n\n## The one thing that has to change\n\n`request-capture` today is **inbound** middleware. `withRequestLogging(handler)`\nsits at the server edge and snapshots requests *coming into* the val. There is no\nresponse in the blob because, at capture time, the handler hasn't run yet — so\nthere is nothing to \"replay\" in the VCR sense.\n\nVCR is **outbound**. A cassette records the requests *your code sends to an\nupstream service* **paired with the responses that service sends back**, then\nshort-circuits future outbound calls to return the stored response without\ntouching the network.\n\nSo this is not a feature to bolt on — it's a mirror-image tool. Different capture\nsite (outbound `fetch`, not the inbound handler), different payload (request +\nresponse, not request only), different injection point (the `fetch` your val\ncalls out with, not the handler it exports).\n\nRecommendation: build it as a **separate module** (`vcr.ts`) alongside the\nexisting inbound capture. Keep `request-capture` as-is — it's still the right tool\nfor reproducing production traffic against a dev deploy. Don't conflate the two.\n\n## 0. How a cassette is used in a test\n\nCassettes are a **test-only** tool. Production code calls the real `fetch`; tests\ninject the cassette `fetch`. The code under test is byte-identical in both worlds —\nthat's the point, and it's what makes the test trustworthy.\n\n**The seam.** Production code takes a `fetch`, defaulting to the real one. That\ndefault parameter is the only concession production makes:\n\n```ts\n// user-service.ts — production code, knows nothing about cassettes\nexport function makeGetUser(fetchImpl = fetch) {\n return async (id: number) => {\n const res = await fetchImpl(`https://api.example.com/users/${id}`);\n if (!res.ok) throw new Error(`upstream ${res.status}`);\n return res.json() as Promise<{ id: number; name: string }>;\n };\n}\n```\n\nIn production nobody passes anything, so it's the real `fetch`. The test injects\nthe cassette version instead:\n\n```ts\n// user-service.test.ts\nimport { makeGetUser } from \"./user-service.ts\";\nimport { makeCassetteFetch } from \"./vcr.ts\";\n\nDeno.test(\"getUser loads a user\", async () => {\n const fetch = makeCassetteFetch(\"users/get-one\"); // ← the only VCR-specific line\n const getUser = makeGetUser(fetch);\n\n const user = await getUser(1);\n\n assertEquals(user.id, 1);\n assertEquals(user.name, \"Leanne Graham\");\n});\n```\n\n**The two-phase lifecycle.** The same test, unchanged, runs two ways depending on\nwhether the cassette exists:\n\n- *First run (record).* No `cassettes:users/get-one` blob → the wrapped `fetch`\n calls the real API, records the request/response pair, and the assertions run\n against the live response. You review the cassette diff (nothing sensitive\n leaked) and commit it next to the test.\n- *Every run after (replay).* The blob exists → the wrapped `fetch` matches the\n outgoing request to a recorded interaction and returns the stored response with\n no network call. Fast, offline, deterministic, no rate limits, no flake. The\n assertions and the code under test never changed — the test can't tell.\n\nTwo things this depends on, both detailed later: CI must **fail** on a missing\ncassette rather than silently record (§3c), and refreshing means **delete the\ncassette and re-record** so the change shows up as a reviewable diff (§6).\n\n## 1. Move the capture point: wrap `fetch`, not the handler\n\nInstead of wrapping the exported handler, produce a `fetch`-compatible function\nthat the val injects wherever it calls out:\n\n```ts\nconst fetch = makeCassetteFetch(\"anthropic/messages\");\n// pass `fetch` into your SDK/client, or use it directly\nconst res = await fetch(\"https://api.anthropic.com/v1/messages\", { ... });\n```\n\nThe whole record/replay decision lives inside that wrapped `fetch`.\n\n## 2. Storage model: a cassette is a named collection of interactions\n\nToday: one blob per request, key `captures:`, shape\n`{ id, method, url, timestamp, headers, body? }`.\n\nVCR: one blob per **cassette**, key `cassettes:`, holding an ordered array\nof **interactions**, where an interaction is a matched request/response pair:\n\n```ts\ntype Interaction = {\n request: { method: string; url: string; headers: Record; body?: string };\n response: { status: number; headers: Record; body?: string };\n};\ntype Cassette = { name: string; version: 1; interactions: Interaction[] };\n```\n\nThat \"response paired to request\" is the piece the current capture is missing and\nthe reason replay isn't possible yet.\n\n## 3. The three pieces to build\n\n**a. Recording fetch (cassette absent).** Do the real `fetch`, read the response\nvia `res.clone()` so the caller still gets a live body, append the interaction to\nthe cassette, write the blob, return the real response.\n\n**b. Matcher (cassette present).** Given an outgoing request, find the first\n*unclaimed* interaction whose recorded request matches it. Define request identity\nexplicitly — start with `method + url`; add a canonicalized (key-sorted) JSON body\ncompare when the body is JSON. Mark each interaction claimed once consumed, so\nrepeated identical requests replay their responses **in recorded order** — that's\nwhat makes retries and polling deterministic. Make the matcher pluggable\n(`match?: (incoming, recorded) => boolean`) for volatile fields like timestamps or\nidempotency keys.\n\n**c. Replay / reconstruct (the actual \"replay\" you're missing).** On a match,\nbuild a real `Response` from the stored interaction and return it *without hitting\nthe network*:\n\n```ts\nreturn new Response(interaction.response.body, {\n status: interaction.response.status,\n headers: interaction.response.headers,\n});\n```\n\nThe calling code can't tell it wasn't live. That's the whole trick.\n\nMode is implied by cassette presence: no cassette → record; cassette → replay.\nAdd a CI guard: when `Deno.env.get(\"CI\")`, a missing cassette should **throw**\nrather than silently record (prevents CI making live calls).\n\n## 4. Redaction has to move to both sides — and not break matching\n\nCurrent redaction covers request headers only. Now:\n\n- Redact **response** bodies/headers too — upstream responses routinely contain\n tokens, signed URLs, PII.\n- Redaction runs on **record**. If you redact a field that's also used for\n matching, the matcher has to compare the *redacted* form on both sides, or\n exclude that field from identity. Easiest rule: never match on a redacted field.\n- Keep the existing \"scan before write, fail on unsafe cassette\" instinct — a\n committed cassette with a live key is worse than a broken test.\n\n## 5. What to keep unchanged\n\n- Blob storage as the backing store — fine. Cassettes are just bigger, fewer blobs.\n- `req.clone()` / `res.clone()` body discipline — same principle, now on both ends.\n- The redaction option surface — extend it, don't replace it.\n- `listCaptures` / `pruneCaptures` style helpers — mirror as\n `listCassettes` / `removeCassette`.\n\n## 6. Decisions you need to make\n\n- **Cassette granularity.** One cassette per test (VCR default, most reviewable\n diffs) vs one per upstream. Per-test is the better default.\n- **Refresh semantics.** effect-http-recorder deliberately has *no overwrite mode*\n — you delete the cassette and re-record, so the refresh is visible in the diff.\n Worth copying; it's a good constraint.\n- **Where `fetch` gets injected.** If your outbound calls go through an SDK that\n doesn't accept a custom `fetch`, you may need to monkeypatch `globalThis.fetch`\n for the duration of the test scope instead. Uglier, but sometimes the only hook.\n\n- **Where cassettes live (open question).** Three options, and this is a\n correctness/artifact-model choice, not a performance one — at cassette scale\n (a few interactions, a few KB) replay is \"one round trip, then match in memory\"\n for all of them, and matching *can't* be pushed into a query anyway.\n - *Blob storage (current backing store).* Simplest record path (`blob.set`).\n But recording is read-modify-write of the whole cassette per interaction, so\n concurrent requests into one cassette are a lost-update race — a real problem\n given this plan allows concurrent recording. Mitigate by serializing writes,\n or keep one-blob-per-interaction and assemble the cassette at teardown.\n - *SQLite (one row per interaction).* Kills the concurrency race — a single\n `INSERT` in a transaction has no read-modify-write. Cheaper appends too. But\n the query engine goes unused (matching stays in memory), and you lose the\n diffable artifact: a val-scoped DB isn't reviewable in a PR.\n - *Files in the val (most VCR-faithful).* Preserves the property that makes\n cassettes worth it — a committed, diffable artifact, \"delete to refresh, diff\n shows what changed.\" The catch on Val Town: runtime-writing a val file goes\n through the API, not the blob SDK, so the record path is clunkier.\n\n Rough guidance: decide by whether the **diffable artifact** matters (it's most\n of why cassettes beat hand-written mocks — lean files) or whether **concurrent\n recording** is real for your tests (lean SQLite, or serialize blob writes).\n Don't switch off blob for performance alone; you won't observe it.\n\n## 7. Limitations to accept up front\n\n- Bodies are **buffered** on record and replay, so this won't test streaming\n timing, cancellation, or backpressure. (Same limitation effect-http-recorder\n documents. Fine for provider integration tests.)\n- Binary response bodies need base64 encoding in the cassette; text stays readable.\n- This is a test-time tool. Nothing here belongs in a production request path.\n\n## Reference\n\nPrior art with the same model, worth reading before building: Ruby `vcr`,\nJS `nock` / `polly-js` / `msw`, and `anomalyco/effect-http-recorder` (Effect 4,\ngood cassette-format and matcher design — note it explicitly does **not** run on\nWorkers/Deno, so it's reference only, not a dependency).\n","children",[],[60],"bd4a3c67-220f-4c4a-8734-c7e09e81e5d2","main.ts","aa3d4398-9acc-11f1-9e1b-1607ee4eb77e",5,["D",1787033943812],"http","/**\n * Demo HTTP endpoint wired up with withRequestLogging from ./lib.ts.\n *\n * Every request to this endpoint is snapshotted into val blob storage.\n * Visit /log (below) to read back what was captured.\n */\nimport {\n listCaptures,\n pruneCaptures,\n withRequestLogging,\n} from \"./lib.ts\";\n\nexport default withRequestLogging(async (req: Request) => {\n const url = new URL(req.url);\n\n if (url.pathname === \"/log\") {\n const cap = await listCaptures();\n return Response.json(cap);\n }\n\n if (url.pathname === \"/_prune\") {\n const removed = await pruneCaptures(30 * 24 * 60 * 60 * 1000); // >30 days old\n return Response.json({ removed });\n }\n\n return Response.json({\n ok: true,\n path: url.pathname,\n note: \"Request captured to blob storage. See /log to inspect.\",\n });\n}, {\n captureBody: true, // also snapshot request bodies (via clone) in this demo\n});\n",[],[70],["D",1787033937487],[],[19],"309161e6-4445-4ef4-8756-5b5733d43d57","README.md","bd30efb8-9acc-11f1-9134-1607ee4eb77e",6,["D",1787033956323],0,"# request-capture\n\nA drop-in HTTP middleware for Val Town that snapshots every incoming request into\nval-scoped **blob storage** as a serializable object, without disturbing the handler\nyou wrap.\n\n## Usage in your own HTTP val\n\nImport and wrap your handler:\n\n```ts\nimport { withRequestLogging } from \"https://esm.town/v/nbbaier/request-capture/lib.ts\";\n\nexport default withRequestLogging(async (req: Request) => {\n return Response.json({ ok: true });\n});\n```\n\nBy default each request is stored as a blob under `captures:` containing:\n\n```ts\n{\n id: string; // uuid\n method: string;\n url: string;\n timestamp: number; // ms\n time: string; // ISO\n headers: Record;\n body?: string; // only when captureBody is enabled\n}\n```\n\nSensitive headers (`authorization`, `cookie`, `set-cookie`, `x-api-key`, …) are\nredacted to `name:redacted` so secrets never land in storage.\n\n### Options\n\n```ts\nwithRequestLogging(handler, {\n captureBody: true, // snapshot the body via req.clone()\n maxBodyBytes: 64 * 1024, // cap body capture size\n keyPrefix: \"captures\", // blob key prefix\n onCaptured: (cap) => console.log(cap.url), // fan out (fire-and-forget)\n});\n```\n\nThe body is **not consumed** unless `captureBody` is set, so the wrapped handler can\nstill read it. Even with body capture, it reads a clone — the original stays intact.\n\n## Reading captures\n\n```ts\nimport { listCaptures, readRequest, pruneCaptures } from \"https://esm.town/v/nbbaier/request-capture/lib.ts\";\n\nconst all = await listCaptures(); // newest first, capped at `limit`\nconst one = await readRequest(id);\nconst removed = await pruneCaptures(7 * 24 * 60 * 60 * 1000); // delete old ones\n```\n\n## Demo\n\nThe live endpoint wraps its own handler and exposes two inspection routes:\n\n- `GET /log` — list every captured request\n- `GET /_prune` — delete captures older than 30 days\n",[],[82],"e41edbfa-0909-43a5-bb51-c38cadbbeed2",["D",1787033924484],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","HTTP middleware that snapshots requests to blob storage","imageUrl","userId","5d1042a9-7b0b-499d-8a72-3a8ac7a4e185","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","orgId","5f80108f-7ca4-4327-b77b-089dbe4b5a82","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_143":139},"org",{"_11":12,"_137":-5,"_138":139,"_100":101,"_140":141,"_142":52},"branch",{"_17":62,"_13":16,"_33":39,"_129":90,"_130":-5,"_131":-5,"_132":-5,"_133":-5,"_134":-5,"_135":14,"_136":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","avatar","https://secure.gravatar.com/avatar/0129a541b7b3574e92c4afd06c5e32da&d=identicon","tier","pro","canRestrictVals","profileImageUrl","adoptOrgId",{"_33":90,"_13":14,"_44":185,"_92":-5,"_93":52,"_94":95,"_96":95,"_97":98,"_99":-5,"_100":101,"_102":71,"_103":43,"_104":-5,"_105":-5,"_106":86,"_107":108,"_109":-5,"_110":-5,"_111":-5,"_112":-5,"_113":114,"_115":114,"_116":117,"_118":117,"_119":117,"_120":114,"_121":114,"_122":186,"_124":187,"_126":188,"_128":52},[173,174,175,176],"files",[173,174,175,176],"counts",{"_164":86,"_165":46,"_166":86,"_32":167,"_168":169},[],{"_33":34,"_13":19,"_35":36,"_37":-5,"_38":39,"_40":41,"_42":43,"_44":45,"_17":46,"_47":48,"_49":50,"_51":52,"_53":-5,"_18":163},"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},[19],"pulls","branches","forks",{"_170":86,"_172":86},"connections",{"_170":86,"_171":86},"count","unfilledCount","emptyCount",{"_33":81,"_13":82,"_35":83,"_37":-5,"_38":39,"_40":84,"_42":43,"_44":85,"_17":86,"_47":24,"_49":87,"_51":52,"_53":-5,"_66":183,"_18":184},{"_33":34,"_13":19,"_35":36,"_37":-5,"_38":39,"_40":41,"_42":43,"_44":78,"_17":46,"_47":48,"_49":50,"_51":52,"_53":-5,"_66":181,"_18":182},{"_33":69,"_13":70,"_35":71,"_37":-5,"_38":39,"_40":72,"_42":43,"_44":73,"_17":64,"_47":74,"_49":75,"_51":52,"_53":14,"_66":179,"_18":180},{"_33":59,"_13":60,"_35":61,"_37":-5,"_38":39,"_40":62,"_42":43,"_44":63,"_17":64,"_47":24,"_49":65,"_51":52,"_53":-5,"_66":177,"_18":178},[],[60],[],[70],[],[19],[],[82],["D",1787033924484],{"_11":12,"_143":139},{"_11":12,"_137":-5,"_138":139,"_100":101,"_140":141,"_142":52},{"_17":62,"_13":16,"_33":39,"_129":90,"_130":-5,"_131":-5,"_132":-5,"_133":-5,"_134":-5,"_135":14,"_136":12},"ctx",{"_122":-5,"_160":222,"_223":224,"_225":226,"_227":52,"_228":52,"_229":52,"_230":43,"_231":-5,"_232":-7,"_233":-7,"_234":86,"_235":52,"_236":52,"_237":-5,"_238":52,"_239":52,"_240":52,"_241":-5},"ENV",{"_193":194,"_195":196,"_197":16,"_198":199,"_200":201,"_202":203,"_204":205,"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221},"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"]