Webpoke — Acme Orders

A content-free poke wakes each consumer; the consumer pulls from the log at its own pace. Heartbeat floor: 1 min · poke: on

\n\n

Ledger head

Events lost

\n\n

\n \n \n \n \n \n \n \n

\n\n\n`;\n",[],[216,217,236],"e42984c3-1b8c-48a3-a445-a3f2c445ffbc","consumer-inventory.ts","41ca9dee-6767-11f1-9a08-1607ee4eb77e",12,["D",1781382860818],"import { type Consumer, makeConsumer } from \"../lib/consumer-runtime.ts\";\nimport type { OrderEvent } from \"../lib/events.ts\";\nimport type { Env } from \"../lib/runtime-env.ts\";\n\n// CUSTOMER. Everything below `handle` is the shared template. The customer\n// writes ONLY `handle` — a pure reducer over the events it pulled. That purity\n// is the whole point: rewind the cursor and re-run it, and you get byte-for-byte\n// the same state (beat 6).\n\ninterface Inventory {\n units: Record;\n revenue: number;\n orders: number;\n}\n\n// ▶ the one function they write\nfunction handle(events: OrderEvent[], state: Inventory): Inventory {\n for (const e of events) {\n state.units[e.sku] = (state.units[e.sku] ?? 0) + e.qty;\n state.revenue += e.amount;\n state.orders += 1;\n }\n return state;\n}\n\nexport function createInventory(env?: Env): Consumer {\n return makeConsumer({\n name: \"inventory\",\n env,\n initialState: { units: {}, revenue: 0, orders: 0 },\n handle,\n });\n}\n",[],[216,217,245],"e7e2cf71-70db-463c-9224-386b79ed7ec7","consumer-inventory-v2.ts","47cb937e-6767-11f1-95bd-1607ee4eb77e",14,["D",1781382870883],"import { type Consumer, makeConsumer } from \"../lib/consumer-runtime.ts\";\nimport type { OrderEvent } from \"../lib/events.ts\";\nimport type { Env } from \"../lib/runtime-env.ts\";\n\n// CUSTOMER, v2 (beat 6 — blue/green). Same log, its OWN checkpoint, a `handle`\n// that derives MORE: it adds per-customer revenue the v1 reducer never computed.\n// Run side-by-side and diff /state against v1 to verify a new version before\n// promoting it — \"the cursor makes the rehearsal free.\" No vendor change.\n\ninterface InventoryV2 {\n units: Record;\n revenue: number;\n orders: number;\n revenueByCustomer: Record; // the new derived view\n}\n\nfunction handle(events: OrderEvent[], state: InventoryV2): InventoryV2 {\n for (const e of events) {\n state.units[e.sku] = (state.units[e.sku] ?? 0) + e.qty;\n state.revenue += e.amount;\n state.orders += 1;\n state.revenueByCustomer[e.customer] = (state.revenueByCustomer[e.customer] ?? 0) + e.amount;\n }\n return state;\n}\n\nexport function createInventoryV2(env?: Env): Consumer {\n return makeConsumer({\n name: \"inventory-v2\",\n env,\n initialState: { units: {}, revenue: 0, orders: 0, revenueByCustomer: {} },\n handle,\n });\n}\n",[],[216,217,253],"7ec06b25-cd55-4036-8414-bebcebc879bf","consumer-analytics.ts","44d9bb8c-6767-11f1-825e-1607ee4eb77e",13,["D",1781382865952],"import { type Consumer, makeConsumer } from \"../lib/consumer-runtime.ts\";\nimport type { OrderEvent } from \"../lib/events.ts\";\nimport type { Env } from \"../lib/runtime-env.ts\";\n\n// CUSTOMER #2 (beat 5). A different `handle` — same events, a different view.\n// Deployed dormant (START_ACTIVE=0) so the film can spin it up and watch it\n// bootstrap the full history from cursor zero through the same /changes door,\n// while consumer #1's cursor is untouched. Its SLEEP toggle makes it lag alone.\n\ninterface Analytics {\n ordersByCustomer: Record;\n totalOrders: number;\n totalRevenue: number;\n}\n\nfunction handle(events: OrderEvent[], state: Analytics): Analytics {\n for (const e of events) {\n state.ordersByCustomer[e.customer] = (state.ordersByCustomer[e.customer] ?? 0) + 1;\n state.totalOrders += 1;\n state.totalRevenue += e.amount;\n }\n return state;\n}\n\nexport function createAnalytics(env?: Env): Consumer {\n return makeConsumer({\n name: \"analytics\",\n env,\n initialState: { ordersByCustomer: {}, totalOrders: 0, totalRevenue: 0 },\n handle,\n });\n}\n",[],[216,217,261],"763d019d-c990-4dff-b889-c11dc66a9947","changes.ts","682242a8-6767-11f1-b6b8-1607ee4eb77e",16,["D",1781382925135],"import { BEATS } from \"../../config/beats.ts\";\nimport type { OrderEvent } from \"../lib/events.ts\";\nimport { Router, json } from \"../lib/http.ts\";\nimport { type Env, ambientEnv } from \"../lib/runtime-env.ts\";\nimport { openStream, s2ConfigFromEnv } from \"../lib/s2-client.ts\";\n\n// VENDOR · changes endpoint. A thin shim over a ranged S2 read — the ONE read\n// path, so \"history\" and \"live\" come through the same door. Ordered, bounded,\n// replayable. It advertises the retention floor in `meta` (the script's stated\n// open question: S2 retention IS the replay window).\n\nexport function createChanges(injected?: Env): { fetch: (req: Request) => Promise } {\n const env = injected ?? ambientEnv();\n const s2 = openStream(s2ConfigFromEnv(env));\n\n const handler = async (_req: Request, { url }: { url: URL }): Promise => {\n const since = Math.max(0, Number(url.searchParams.get(\"since\") ?? \"0\") || 0);\n const asked = Number(url.searchParams.get(\"limit\") ?? String(BEATS.changesLimit)) || BEATS.changesLimit;\n const limit = Math.min(BEATS.changesLimit, Math.max(1, asked)); // bounded\n const { records, nextSeq, tail } = await s2.read({ since, limit });\n const events = records.map((rec) => JSON.parse(rec.body) as OrderEvent);\n return json({\n events,\n next_cursor: nextSeq,\n meta: { tail, retention_floor_seq: BEATS.retentionFloorSeq, limit },\n });\n };\n\n const r = new Router();\n r.get(\"/\", handler);\n r.get(\"/changes\", handler);\n return { fetch: r.fetch };\n}\n",[],[216,217,269],"b4254817-2deb-4592-93b0-7bb9379b67fc","e2c8c30f-0c01-4bcd-b3f0-e7ba9512e569",["D",1781382860818],[191,192,193,194,195,196,197,198],[216,217],"0f435798-77bf-4138-971a-a08f77756d40","store.ts","07e0d792-6767-11f1-8090-1607ee4eb77e","d0fc993d-cf06-4f17-9a2f-d189260e76b1",8,["D",1781382763655],"import { isDeno } from \"./runtime-env.ts\";\n\n// Tiny async key/value store, the one piece of persistence a val needs (its\n// cursor, counters, and a bounded latency ring). Two backends behind one\n// interface:\n// - val.town → std/sqlite (survives the val going cold between requests)\n// - local → an in-process Map (the local runtime is one long-lived process)\n// Same interface either way, so the val code never branches on runtime.\n\nexport interface Store {\n getJSON(key: string): Promise;\n setJSON(key: string, value: unknown): Promise;\n /** Wipe this store's namespace — the reset path's \"zero the cursor\". */\n clear(): Promise;\n}\n\n// ── local: in-process Map, one bucket per namespace ──────────────────────────\nconst BUCKETS = new Map>();\n\nclass MemStore implements Store {\n private bucket: Map;\n constructor(ns: string) {\n this.bucket = BUCKETS.get(ns) ?? new Map();\n BUCKETS.set(ns, this.bucket);\n }\n getJSON(key: string): Promise {\n const raw = this.bucket.get(key);\n return Promise.resolve(raw === undefined ? undefined : (JSON.parse(raw) as T));\n }\n setJSON(key: string, value: unknown): Promise {\n this.bucket.set(key, JSON.stringify(value));\n return Promise.resolve();\n }\n clear(): Promise {\n this.bucket.clear();\n return Promise.resolve();\n }\n}\n\n// ── val.town: std/sqlite, keys prefixed by namespace ─────────────────────────\ninterface SqliteClient {\n execute(q: string | { sql: string; args?: unknown[] }): Promise<{ rows: unknown[][] }>;\n}\n\nclass SqliteStore implements Store {\n private ready: Promise;\n constructor(private ns: string) {\n this.ready = this.init();\n }\n private async init(): Promise {\n // Computed specifier so Node's bundler never tries to resolve this esm.town\n // URL — it is only ever evaluated on Deno (val.town).\n const url = \"https://esm.town/v/std/\" + \"sqlite\";\n const mod = (await import(url)) as { sqlite: SqliteClient };\n await mod.sqlite.execute(\"CREATE TABLE IF NOT EXISTS webpoke_kv (k TEXT PRIMARY KEY, v TEXT)\");\n return mod.sqlite;\n }\n private k(key: string): string {\n return `${this.ns}:${key}`;\n }\n async getJSON(key: string): Promise {\n const db = await this.ready;\n const res = await db.execute({ sql: \"SELECT v FROM webpoke_kv WHERE k = ?\", args: [this.k(key)] });\n const raw = res.rows[0]?.[0];\n return raw == null ? undefined : (JSON.parse(String(raw)) as T);\n }\n async setJSON(key: string, value: unknown): Promise {\n const db = await this.ready;\n await db.execute({\n sql: \"INSERT OR REPLACE INTO webpoke_kv (k, v) VALUES (?, ?)\",\n args: [this.k(key), JSON.stringify(value)],\n });\n }\n async clear(): Promise {\n const db = await this.ready;\n await db.execute({ sql: \"DELETE FROM webpoke_kv WHERE k LIKE ?\", args: [`${this.ns}:%`] });\n }\n}\n\nexport function getStore(namespace: string): Store {\n return isDeno ? new SqliteStore(namespace) : new MemStore(namespace);\n}\n",[],[216,290,282],"lib","0f8c1448-e3fb-4d75-bdf9-f3c8bc5e24ae","s2-client.ts","29c21e8e-6767-11f1-acfc-1607ee4eb77e",10,["D",1781382820494],"import type { Env } from \"./runtime-env.ts\";\n\n// One stream interface, one wire contract — real S2 v1 REST — verified live\n// against s2-lite (local) and the S2 cloud. (S2Config is inlined here rather than\n// imported from config/targets.ts, which pulls node:fs; the type is erased on\n// Deno anyway, but inlining removes any import-resolution risk on val.town.)\n\ninterface S2Config {\n endpoint: string;\n token: string;\n basin: string;\n stream: string;\n}\n\nexport interface LedgerRecord {\n seqNum: number;\n body: string;\n}\nexport interface AppendResult {\n start: number;\n end: number;\n tail: number;\n}\nexport interface ReadResult {\n records: LedgerRecord[];\n nextSeq: number;\n tail: number;\n}\n\nexport interface S2Stream {\n append(bodies: string[], opts?: { matchSeqNum?: number }): Promise;\n read(opts: { since: number; limit: number }): Promise;\n tail(): Promise;\n}\n\n/** Open the configured stream. One REST client, both substrates. */\nexport function openStream(cfg: S2Config): S2Stream {\n return new RestStream(cfg);\n}\n\n/** Build an S2Config from a val's injected Env (val.town Deno.env, or local). */\nexport function s2ConfigFromEnv(env: Env): S2Config {\n const endpoint = env.get(\"S2_ENDPOINT\");\n if (!endpoint) throw new Error(\"S2_ENDPOINT is required\");\n return {\n endpoint,\n token: env.get(\"S2_TOKEN\") ?? \"ignored\",\n basin: env.get(\"S2_BASIN\") ?? \"acme-shop\",\n stream: env.get(\"S2_STREAM\") ?? \"orders\",\n };\n}\n\n// S2 addresses a basin one of two ways, distinguished by a `{basin}` placeholder:\n// • cloud: https://{basin}.b.aws.s2.dev → basin in the subdomain, no header\n// • s2-lite: http://localhost:9090 → fixed origin, basin via s2-basin header\ntype StreamPosition = { seq_num: number; timestamp: number };\n\nclass RestStream implements S2Stream {\n private base: string;\n private basinHeader?: string;\n constructor(private cfg: S2Config) {\n let root = cfg.endpoint.replace(/\\/+$/, \"\");\n if (root.includes(\"{basin}\")) {\n root = root.replace(\"{basin}\", encodeURIComponent(cfg.basin));\n } else {\n this.basinHeader = cfg.basin;\n }\n this.base = `${root}/v1/streams/${encodeURIComponent(cfg.stream)}`;\n }\n private headers(): Record {\n const h: Record = {\n authorization: `Bearer ${this.cfg.token}`,\n \"s2-format\": \"raw\",\n \"content-type\": \"application/json\",\n };\n if (this.basinHeader) h[\"s2-basin\"] = this.basinHeader;\n return h;\n }\n async append(bodies: string[], opts: { matchSeqNum?: number } = {}): Promise {\n const payload: Record = { records: bodies.map((body) => ({ body })) };\n if (typeof opts.matchSeqNum === \"number\") payload.match_seq_num = opts.matchSeqNum;\n const res = await fetch(`${this.base}/records`, {\n method: \"POST\",\n headers: this.headers(),\n body: JSON.stringify(payload),\n });\n if (!res.ok) throw new Error(`s2 append ${res.status}: ${await res.text()}`);\n const ack = (await res.json()) as { start: StreamPosition; end: StreamPosition; tail: StreamPosition };\n return { start: ack.start.seq_num, end: ack.end.seq_num, tail: ack.tail.seq_num };\n }\n async read(opts: { since: number; limit: number }): Promise {\n const u = new URL(`${this.base}/records`);\n u.searchParams.set(\"seq_num\", String(opts.since));\n u.searchParams.set(\"count\", String(opts.limit));\n const res = await fetch(u, { headers: this.headers() });\n if (res.status === 416) {\n const body = (await res.json().catch(() => ({}))) as { tail?: StreamPosition };\n return { records: [], nextSeq: opts.since, tail: body.tail?.seq_num ?? opts.since };\n }\n if (!res.ok) throw new Error(`s2 read ${res.status}: ${await res.text()}`);\n const batch = (await res.json()) as { records: { seq_num: number; body: string }[]; tail?: StreamPosition };\n const records = batch.records.map((r) => ({ seqNum: r.seq_num, body: r.body }));\n const last = records[records.length - 1];\n const nextSeq = last ? last.seqNum + 1 : opts.since;\n return { records, nextSeq, tail: batch.tail?.seq_num ?? nextSeq };\n }\n async tail(): Promise {\n const res = await fetch(`${this.base}/records/tail`, { headers: this.headers() });\n if (!res.ok) throw new Error(`s2 tail ${res.status}: ${await res.text()}`);\n return ((await res.json()) as { tail: StreamPosition }).tail.seq_num;\n }\n}\n",[],[216,290,292],"7f2304b1-e0d6-4605-94b6-6230931064df","runtime-env.ts","db540b68-6766-11f1-9a66-1607ee4eb77e",2,["D",1781382688901],"// The one place that knows whether we're on Deno (val.town) or Node (local).\n//\n// On val.town each val is its own deployment with its own env vars (Deno.env).\n// Locally we run *all* the vals in one Node process, so they can't share\n// process.env for per-val config. Every val is therefore built by a factory\n// that takes an `Env`; on val.town the factory is fed the ambient Deno.env, and\n// locally the runtime feeds each val its own injected record.\n\nexport interface Env {\n get(key: string): string | undefined;\n}\n\n/** The platform's own environment — Deno.env on val.town, process.env on Node. */\nexport function ambientEnv(): Env {\n const deno = (globalThis as { Deno?: { env?: { get(k: string): string | undefined } } }).Deno;\n if (deno?.env && typeof deno.env.get === \"function\") {\n return { get: (k) => deno.env!.get(k) };\n }\n return { get: (k) => (typeof process !== \"undefined\" ? process.env[k] : undefined) };\n}\n\n/** A fixed lookup, for injecting one val's config in the local runtime. */\nexport function makeEnv(record: Record): Env {\n return { get: (k) => record[k] };\n}\n\nexport const isDeno = typeof (globalThis as { Deno?: unknown }).Deno !== \"undefined\";\n",[],[216,290,300],"51305476-90c3-417a-8a1f-194924413636","poke.ts","e492f91e-6766-11f1-babd-1607ee4eb77e",4,["D",1781382704417],"import { Buffer } from \"node:buffer\";\nimport { createHmac, timingSafeEqual } from \"node:crypto\";\n\n// The poke is content-free and best-effort, so the signature is NOT a\n// correctness mechanism — it just lets a consumer ignore a forged poke. A\n// bad or missing sig at worst drops one poke (the heartbeat covers it); it can\n// never lose or corrupt data, because the poke carries no data. This is\n// deliberately simple and flagged on-screen as an open question.\n\nexport function signPoke(body: string, secret: string): string {\n return createHmac(\"sha256\", secret).update(body).digest(\"hex\");\n}\n\nexport function verifyPoke(body: string, sig: string | null | undefined, secret: string): boolean {\n if (!sig) return false;\n const expected = signPoke(body, secret);\n if (sig.length !== expected.length) return false;\n try {\n return timingSafeEqual(Buffer.from(sig), Buffer.from(expected));\n } catch {\n return false;\n }\n}\n\nexport interface PokeBody {\n stream: string;\n hint: number; // the ledger tail the vendor saw — monotone, coalesced by max()\n}\n",[],[216,290,308],"abacbf28-a9f0-46d0-bdc0-8771176b0be6","metrics.ts","ee298fec-6766-11f1-81ab-1607ee4eb77e",["D",1781382720506],"import type { Store } from \"./store.ts\";\n\n// The only place that knows both ends of the latency: it records, per event,\n// (handled time − the event's append time) into a bounded ring, and keeps the\n// counters the dashboard reads. eventsLost is structurally 0 — a cursor only\n// advances past events that handle() actually saw — so it is reported as the\n// constant it is. That zero, through every failure beat, is the payload.\n\nconst RING = 200;\n\nexport interface Snapshot {\n processed: number;\n pokesReceived: number;\n pokesDropped: number; // pokes that caused no forward progress (forged, stale, coalesced)\n eventsLost: number; // always 0\n p50: number | null;\n p95: number | null;\n samples: number;\n}\n\nexport class Metrics {\n constructor(private store: Store) {}\n\n async recordLatency(ms: number): Promise {\n const ring = (await this.store.getJSON(\"lat\")) ?? [];\n ring.push(Math.max(0, Math.round(ms)));\n while (ring.length > RING) ring.shift();\n await this.store.setJSON(\"lat\", ring);\n }\n\n async bump(counter: \"processed\" | \"pokesReceived\" | \"pokesDropped\", by = 1): Promise {\n const v = (await this.store.getJSON(counter)) ?? 0;\n await this.store.setJSON(counter, v + by);\n }\n\n /** Beat 6 rewind: clear the derived metrics so a re-drain reproduces them. */\n async resetCounters(): Promise {\n await this.store.setJSON(\"processed\", 0);\n await this.store.setJSON(\"lat\", []);\n }\n\n async snapshot(): Promise {\n const ring = (await this.store.getJSON(\"lat\")) ?? [];\n return {\n processed: (await this.store.getJSON(\"processed\")) ?? 0,\n pokesReceived: (await this.store.getJSON(\"pokesReceived\")) ?? 0,\n pokesDropped: (await this.store.getJSON(\"pokesDropped\")) ?? 0,\n eventsLost: 0,\n p50: percentile(ring, 50),\n p95: percentile(ring, 95),\n samples: ring.length,\n };\n }\n}\n\nfunction percentile(arr: number[], p: number): number | null {\n if (arr.length === 0) return null;\n const sorted = [...arr].sort((a, b) => a - b);\n const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));\n return sorted[idx]!;\n}\n",[],[216,290,316],"997ac5a3-ed9f-4ba2-afef-d84b05750ca8","http.ts","e1b5c230-6766-11f1-9a66-1607ee4eb77e",["D",1781382699625],"// A tiny router over the Web fetch handler shape, so a val's code is the same\n// on val.town (where the default export IS a `(Request) => Response`) and in the\n// local runtime (which mounts these handlers behind a Node http server). No\n// framework — the routes a val needs fit on one screen.\n\nexport type Handler = (\n req: Request,\n ctx: { url: URL; params: Record },\n) => Response | Promise;\n\ninterface Route {\n method: string;\n parts: string[];\n handler: Handler;\n}\n\nexport class Router {\n private routes: Route[] = [];\n\n on(method: string, path: string, handler: Handler): this {\n this.routes.push({ method, parts: split(path), handler });\n return this;\n }\n get(path: string, handler: Handler): this {\n return this.on(\"GET\", path, handler);\n }\n post(path: string, handler: Handler): this {\n return this.on(\"POST\", path, handler);\n }\n\n async handle(req: Request): Promise {\n const url = new URL(req.url);\n const got = split(url.pathname);\n for (const route of this.routes) {\n if (route.method !== req.method) continue;\n const params = match(route.parts, got);\n if (params) return route.handler(req, { url, params });\n }\n // CORS preflight for the dashboard's cross-val fetches.\n if (req.method === \"OPTIONS\") return cors(new Response(null, { status: 204 }));\n return cors(json({ error: \"not found\", path: url.pathname }, 404));\n }\n\n /** Convenience: a `(Request) => Response` for val.town's default export. */\n get fetch(): (req: Request) => Promise {\n return (req) => this.handle(req);\n }\n}\n\nfunction split(path: string): string[] {\n return path.split(\"/\").filter(Boolean);\n}\n\nfunction match(pattern: string[], got: string[]): Record | null {\n if (pattern.length !== got.length) return null;\n const params: Record = {};\n for (let i = 0; i < pattern.length; i++) {\n const p = pattern[i]!;\n if (p.startsWith(\":\")) params[p.slice(1)] = decodeURIComponent(got[i]!);\n else if (p !== got[i]) return null;\n }\n return params;\n}\n\n// Every demo surface is read cross-origin by the dashboard and (in valtown mode)\n// across vals, so every response carries permissive CORS.\nexport function cors(res: Response): Response {\n res.headers.set(\"access-control-allow-origin\", \"*\");\n res.headers.set(\"access-control-allow-headers\", \"*\");\n res.headers.set(\"access-control-allow-methods\", \"GET,POST,DELETE,OPTIONS\");\n return res;\n}\n\nexport function json(data: unknown, status = 200): Response {\n return cors(\n new Response(JSON.stringify(data), {\n status,\n headers: { \"content-type\": \"application/json\" },\n }),\n );\n}\n\nexport function html(body: string, status = 200): Response {\n return cors(new Response(body, { status, headers: { \"content-type\": \"text/html; charset=utf-8\" } }));\n}\n\nexport function text(body: string, status = 200): Response {\n return cors(new Response(body, { status, headers: { \"content-type\": \"text/plain; charset=utf-8\" } }));\n}\n\nexport async function readJson(req: Request): Promise {\n try {\n const text = await req.text();\n return text ? (JSON.parse(text) as T) : null;\n } catch {\n return null;\n }\n}\n",[],[216,290,323],"8ca04789-2b35-4ed9-b41c-eb2b800d3b48","events.ts","e9467d1e-6766-11f1-8990-1607ee4eb77e",5,["D",1781382712302],"import { CATALOG, CUSTOMERS } from \"../../config/beats.ts\";\n\n// The order events that flow through the ledger. Small and legible — on camera\n// the subject is the cursor / lag / latency, not the order contents. Every\n// event carries `ts`, the moment it was appended, so a consumer can measure\n// end-to-end latency (append → handled) — which is what visibly rises during\n// the cut-poke beat and falls back after the heartbeat drains the backlog.\n\nexport interface OrderEvent {\n type: \"order.created\";\n id: string; // stable order id, derived from n\n n: number; // 1-based demo sequence (deterministic content key)\n sku: string;\n product: string;\n qty: number;\n amount: number; // qty * unit price\n customer: string;\n ts: number; // append timestamp (ms since epoch), stamped by emit\n}\n\n// A tiny seeded PRNG (mulberry32) so the same n always yields the same order.\nfunction rngFor(n: number): () => number {\n let a = (0x9e3779b9 ^ (n * 0x85ebca6b)) >>> 0;\n return () => {\n a |= 0;\n a = (a + 0x6d2b79f5) | 0;\n let t = Math.imul(a ^ (a >>> 15), 1 | a);\n t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n };\n}\n\n/** Deterministic order content for demo entry `n` (1-based). `ts` is stamped later. */\nexport function makeOrder(n: number): OrderEvent {\n const r = rngFor(n);\n const item = CATALOG[Math.floor(r() * CATALOG.length)]!;\n const customer = CUSTOMERS[Math.floor(r() * CUSTOMERS.length)]!;\n const qty = 1 + Math.floor(r() * 3);\n return {\n type: \"order.created\",\n id: `ord-${String(n).padStart(4, \"0\")}`,\n n,\n sku: item.sku,\n product: item.name,\n qty,\n amount: qty * item.price,\n customer,\n ts: 0,\n };\n}\n",[],[216,290,330],"134de356-7058-4d4c-b07e-0227cccdc8c8","cursor.ts","0bbba996-6767-11f1-8e04-1607ee4eb77e",9,["D",1781382770123],"import type { Store } from \"./store.ts\";\n\n// The consumer-owned checkpoint: one number, \"the next seq I want.\" This is the\n// whole of the customer's bookkeeping — remember your place.\n//\n// Sequence numbers are absolute S2 seqs. A consumer onboards at a BASELINE — the\n// stream head at the moment it joined — because an append-only log it doesn't own\n// may already hold history from before its time (and you can't truncate someone\n// else's log). A fresh or rewound cursor therefore starts at the baseline, not at\n// absolute 0; the dashboard shows positions relative to it. Locally the baseline\n// is 0 (the stack recreates its own stream fresh), so all of this is a no-op and\n// the cursor is just \"0, then up.\" lag = head − cursor is computed by the\n// dashboard from the absolute cursor and the absolute tail, so it is unaffected.\n\nexport class Cursor {\n constructor(\n private store: Store,\n private globalStore: Store,\n ) {}\n\n /** The deployment-wide origin; absent (local) means 0. Read live so a cloud\n * re-baseline on reset takes effect without redeploying. */\n baseline(): Promise {\n return this.globalStore.getJSON(\"baseline\").then((v) => v ?? 0);\n }\n async get(): Promise {\n const v = await this.store.getJSON(\"cursor\");\n return v ?? (await this.baseline());\n }\n set(seq: number): Promise {\n return this.store.setJSON(\"cursor\", seq);\n }\n /** Beat 6: rewind to the baseline so the consumer re-derives its state from the log. */\n async rewind(): Promise {\n await this.store.setJSON(\"cursor\", await this.baseline());\n }\n}\n",[],[216,290,338],"59844699-8182-440f-abb9-4f7b6d3c40f7","consumer-runtime.ts","3fd1a8de-6767-11f1-b7ab-1607ee4eb77e",11,["D",1781382857490],"import { BEATS } from \"../../config/beats.ts\";\nimport { Cursor } from \"./cursor.ts\";\nimport type { OrderEvent } from \"./events.ts\";\nimport { Router, json, text } from \"./http.ts\";\nimport { Metrics } from \"./metrics.ts\";\nimport { type PokeBody, verifyPoke } from \"./poke.ts\";\nimport { type Env, ambientEnv } from \"./runtime-env.ts\";\nimport { getStore } from \"./store.ts\";\n\n// THE TEMPLATE ENGINE. Everything a consumer needs is here; the customer writes\n// exactly one function — a pure reducer `handle(events, state) => state`. That\n// purity is what makes the replay beat true: rewind the cursor, clear the\n// derived state, re-drain, and you land on byte-identical state.\n//\n// tick() drain pull -> handle -> commit cursor, until the log is empty\n// POST /poke verify HMAC, coalesce the hint by max(), single-flight a tick\n// interval the heartbeat floor (cron) — the safety net when pokes are lost\n// POST /tick manual \"poll now\"\n// POST /rewind beat 6: zero the cursor + state, re-derive\n// GET /stats the dashboard's data source\n// GET /state the derived state, for the beat-6 blue/green diff\n\nexport interface ConsumerOptions {\n name: string;\n initialState: S;\n handle: (events: OrderEvent[], state: S) => S | Promise;\n /** Local runtime injects per-val config here; on val.town it's the ambient Deno.env. */\n env?: Env;\n}\n\nexport interface Consumer {\n name: string;\n fetch: (req: Request) => Promise;\n interval: () => Promise;\n}\n\nexport function makeConsumer(opts: ConsumerOptions): Consumer {\n const env = opts.env ?? ambientEnv();\n const name = opts.name;\n const changesUrlRaw = env.get(\"CHANGES_URL\");\n if (!changesUrlRaw) throw new Error(`consumer ${name}: CHANGES_URL is required`);\n const changesUrl: string = changesUrlRaw;\n const secret = env.get(\"POKE_SECRET\") ?? \"demo-poke-secret\";\n const sleepMs = Number(env.get(\"SLEEP_MS\") ?? BEATS.analyticsSleepMs) || BEATS.analyticsSleepMs;\n\n const store = getStore(`consumer:${name}`);\n // Deployment-wide origin (baseline), shared across vals; 0 locally. See Cursor.\n const cursor = new Cursor(store, getStore(\"webpoke:global\"));\n const metrics = new Metrics(store);\n\n // `opts.initialState` is the canonical prototype — never hand it to `handle`\n // or persist it directly. Reducers are free to mutate the state they receive\n // (the simple, natural style), so every working copy must be private. This is\n // what makes rewind/replay byte-identical: a fresh zero every time, never a\n // prototype some earlier drain already mutated.\n const freshInitial = (): S => structuredClone(opts.initialState);\n\n // Single-flight: at most one drain in flight. Five simultaneous pokes cause at\n // most one extra tick — the rest see `running` and coalesce (the beat-4 defense).\n let running = false;\n let coalescedHint = -1;\n\n async function pull(since: number): Promise<{ events: OrderEvent[]; next: number }> {\n const u = `${changesUrl}${changesUrl.includes(\"?\") ? \"&\" : \"?\"}since=${since}&limit=${BEATS.changesLimit}`;\n const res = await fetch(u);\n if (!res.ok) throw new Error(`pull ${res.status}`);\n const data = (await res.json()) as { events?: OrderEvent[]; next_cursor?: number };\n return { events: data.events ?? [], next: data.next_cursor ?? since };\n }\n\n async function drain(): Promise {\n let did = 0;\n for (;;) {\n const since = await cursor.get();\n const { events, next } = await pull(since);\n if (events.length === 0) break;\n if (await sleeping()) await sleep(sleepMs);\n let state = (await store.getJSON(\"state\")) ?? freshInitial();\n state = await opts.handle(events, state);\n const done = Date.now();\n await store.setJSON(\"state\", state);\n await cursor.set(next); // consumer-owned checkpoint — commit AFTER handle\n await metrics.bump(\"processed\", events.length);\n for (const e of events) await metrics.recordLatency(done - (e.ts ?? done));\n did += events.length;\n }\n return did;\n }\n\n async function singleFlight(): Promise {\n if (running) return 0; // coalesced into the in-flight drain\n running = true;\n try {\n return await drain();\n } finally {\n running = false;\n }\n }\n\n async function sleeping(): Promise {\n return (await store.getJSON(\"sleeping\")) ?? false;\n }\n\n // A consumer can be deployed dormant — poked, but not yet listening — so beat 5\n // can spin it up and watch it bootstrap the whole history from cursor zero.\n async function active(): Promise {\n const v = await store.getJSON(\"active\");\n return v === undefined ? (env.get(\"START_ACTIVE\") ?? \"1\") !== \"0\" : v;\n }\n\n const r = new Router();\n\n // The poke receiver. The poke is content-free: its only job is to wake a tick.\n r.post(\"/poke\", async (req) => {\n const raw = await req.text();\n const sig = req.headers.get(\"x-poke-sig\");\n if (!(await active())) return json({ ok: true, skipped: \"dormant\" }); // not subscribed yet\n await metrics.bump(\"pokesReceived\");\n if (!verifyPoke(raw, sig, secret)) {\n await metrics.bump(\"pokesDropped\"); // forged/unsigned — safely ignored\n return json({ ok: false, reason: \"bad signature\" });\n }\n try {\n const body = JSON.parse(raw) as PokeBody;\n coalescedHint = Math.max(coalescedHint, body.hint ?? -1);\n } catch {\n /* the hint is advisory; a malformed body still can't lose data */\n }\n const before = await cursor.get();\n const did = await singleFlight();\n const after = await cursor.get();\n if (after === before) await metrics.bump(\"pokesDropped\"); // stale/duplicate/coalesced — no progress\n return json({ ok: true, processed: did });\n });\n\n // Manual \"poll now\".\n r.post(\"/tick\", async () => json({ ok: true, processed: await singleFlight() }));\n\n // The heartbeat, also exposed as a button for recording (the real cron floor\n // is disclosed on camera).\n r.post(\"/heartbeat\", async () => {\n if (!(await active())) return json({ ok: true, skipped: \"dormant\" });\n return json({ ok: true, processed: await singleFlight() });\n });\n\n // Beat 5: spin up a dormant consumer — it bootstraps the full history from zero.\n r.post(\"/control/activate\", async () => {\n await store.setJSON(\"active\", true);\n return json({ ok: true, processed: await singleFlight() });\n });\n\n // Beat 6: rewind to zero and re-derive identical state.\n r.post(\"/rewind\", async () => {\n await cursor.rewind();\n await store.setJSON(\"state\", freshInitial());\n await metrics.resetCounters();\n const did = await singleFlight();\n return json({ ok: true, processed: did, state: await store.getJSON(\"state\") });\n });\n\n // Beat 5: analytics' sleep toggle (?on=1|0).\n r.post(\"/control/sleep\", async (_req, { url }) => {\n await store.setJSON(\"sleeping\", url.searchParams.get(\"on\") !== \"0\");\n return json({ ok: true, sleeping: await sleeping() });\n });\n\n // Full reset to defaults (reset.ts).\n r.post(\"/reset\", async () => {\n await store.clear();\n return json({ ok: true });\n });\n\n r.get(\"/stats\", async () => {\n const snap = await metrics.snapshot();\n return json({\n name,\n cursor: await cursor.get(),\n sleeping: await sleeping(),\n active: await active(),\n coalescedHint,\n ...snap,\n });\n });\n\n r.get(\"/state\", async () => {\n return json({ name, cursor: await cursor.get(), state: (await store.getJSON(\"state\")) ?? freshInitial() });\n });\n\n r.get(\"/\", async () => text(`webpoke consumer \"${name}\" — POST /poke /tick /rewind, GET /stats /state`));\n\n return {\n name,\n fetch: r.fetch,\n interval: async () => {\n if (await active()) await singleFlight();\n },\n };\n}\n\nfunction sleep(ms: number): Promise {\n return new Promise((resolve) => setTimeout(resolve, ms));\n}\n",[],[216,290,346],"75464b4d-fc86-46a6-a530-f0834c28c1bb",["D",1781382688901],[181,182,183,184,185,186,187,188,189],[216,290],"e7198b4a-a53e-4c00-90f8-4786a20f105e",["D",1781382688901],[180,190],[216],["D",1781408741910],[],[18,65],["D",1781382751420],[178],[18],["D",1781382627825],{"_11":12,"_131":71},{"_11":12,"_127":-5,"_70":71,"_31":69,"_128":129,"_130":30},{"_40":118,"_13":16,"_34":37,"_119":83,"_120":-5,"_121":-5,"_122":-5,"_123":-5,"_124":-5,"_125":14,"_126":12},"ctx",{"_53":-5,"_150":404,"_405":406,"_407":408,"_409":30,"_410":30,"_411":30,"_412":24,"_413":-5,"_414":-7,"_415":-7,"_416":26,"_417":30,"_418":30,"_419":-5,"_420":30,"_421":30,"_422":30,"_423":-5},"ENV",{"_375":376,"_377":378,"_379":16,"_380":381,"_382":383,"_384":385,"_386":387,"_388":389,"_390":391,"_392":393,"_394":395,"_396":397,"_398":399,"_400":401,"_402":403},"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"]

History · config