Gallery

Every page here is a plain .html file: one runtime script tag and one OpenUI Lang program. The thumbnails are screenshots taken at build time. Open one to see the live page. Token counts are estimates of the program text (characters ÷ 3.8).

Buttons and forms do nothing on this site. Under austere-axi <file> they send your choices to the agent.

Screenshot of the Session storage migration pageOpen live page

Session storage migration

Plan for moving session storage from Redis to Postgres: KPIs, diagram, rollout options, diff and a decision form.

  • ~947 tokens
  • 34 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([intro, kpis, flow, options, openQuestion, change, files, decide], "column", "l")
intro = Card([CardHeader("Session storage migration", "Move sessions from Redis to Postgres"), introText])
introText = MarkDownRenderer("Sessions live only in Redis and are lost on failover — last month that logged out **~38k users** twice.

**Goal:** durable sessions with no forced logout, and no extra p99 latency on the auth path.

- Keep the `SessionStore` interface unchanged
- Cut over behind the `sessions_pg` flag")
kpis = OverviewCardBlock([kpiUsers, kpiP99, kpiCost])
kpiUsers = OverviewCardItem("users", Text("text", "Forced logouts / mo"), MetricIndicatorInline("38,214", "last 30 days", {direction: "up", value: 12}))
kpiP99 = OverviewCardItem("p99", Text("text", "Auth p99"), MetricIndicatorInline("41 ms", "target ≤ 45 ms"))
kpiCost = OverviewCardItem("cost", Text("text", "Extra storage"), MetricIndicatorInline("$140/mo", "Postgres, 3 replicas"))
flow = Card([CardHeader("Request path after the change"), flowDiagram])
flowDiagram = Architecture([client, edge, api, pg, redis], [toEdge, toApi, toPg, toRedis], [platform])
client = Node("Client", "external", "browser / mobile")
edge = Node("Edge worker", "cloud", "Cloudflare")
api = Node("API", "backend", "Node :8080")
pg = Node("Postgres", "database", "sessions table", "new")
redis = Node("Redis", "database", "read-through cache")
toEdge = Edge(client, edge, "HTTPS", "emphasis")
toApi = Edge(edge, api)
toPg = Edge(api, pg, "SQL")
toRedis = Edge(api, redis, "during rollout", "dashed")
platform = Group("Platform VPC", [api, pg, redis])
options = Card([CardHeader("Rollout options"), optionTable, latencyChart])
optionTable = Table([Col("Option", ["Big bang", "Dual-write"]), Col("Effort", ["2 days", "5 days"]), Col("Downtime", ["~10 min", "none"]), Col("Risk", [riskHigh, riskLow])])
riskHigh = Tag("high", null, "sm", "danger")
riskLow = Tag("low", null, "sm", "success")
latencyChart = BarChart(["p50", "p90", "p99"], [Series("Redis", [4, 11, 38]), Series("Postgres", [6, 15, 44])], "grouped", "Percentile", "ms")
openQuestion = Callout("warning", "Open question", "Keep Redis as a read-through cache after cutover, or drop it entirely?")
change = Card([CardHeader("Core change", "src/session/store.ts"), storePatch])
storePatch = Diff("diff --git a/src/session/store.ts b/src/session/store.ts
--- a/src/session/store.ts
+++ b/src/session/store.ts
@@ -12,7 +12,11 @@ export class SessionStore {
   async get(id: string) {
-    return this.redis.get(key(id));
+    const cached = await this.redis.get(key(id));
+    if (cached) return cached;
+    const row = await this.pg.sessions.find(id);
+    if (row) await this.redis.set(key(id), row, { ex: TTL });
+    return row;
   }")
files = Card([CardHeader("Files touched"), changedFiles])
changedFiles = FileTree(["M src/session/store.ts # read-through to Postgres", "A src/session/pg-store.ts", "A migrations/0042_sessions.sql # table + expiry index", "M src/config.ts # SESSIONS_PG flag", "M test/session.test.ts"])
decide = Card([CardHeader("Your call"), decideForm])
decideForm = Form("rollout", decideButtons, [strategyField, notesField])
strategyField = FormControl("Rollout", RadioGroup("strategy", [RadioItem("Big bang", "One deploy, short maintenance window", "bigbang"), RadioItem("Dual-write", "Two weeks writing to both stores", "dualwrite")]))
notesField = FormControl("Notes", TextArea("notes", "Anything to change?", 3))
decideButtons = Buttons([Button("Send decision", @ToAssistant("Decision: rollout strategy"), "primary"), Button("Explain the risk column")])
Screenshot of the Postmortem: checkout outage, 14 Oct pageOpen live page

Postmortem: checkout outage, 14 Oct

Postmortem of a 47-minute checkout outage: impact, timeline, failure path and action items.

  • ~1,018 tokens
  • 38 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([summary, impact, timeline, cause, actions, decide], "column", "l")
summary = Card([CardHeader("Checkout outage, 14 Oct", "SEV-1 · 47 minutes · resolved"), summaryText, resolvedNote])
summaryText = MarkDownRenderer("A config push changed the payments client timeout from **8 s** to **800 ms**: one zero dropped. Every card payment that needed a 3-D Secure round trip timed out, and the retry loop turned each failure into three requests.

**Root cause:** nothing rejected a timeout shorter than the processor's normal 3-D Secure latency.")
resolvedNote = Callout("success", "Resolved", "Rolled back at 15:09 UTC. Error rate back under 0.5% by 15:14.")
impact = Card([CardHeader("Impact"), impactKpis, errorChart])
impactKpis = OverviewCardBlock([kpiOrders, kpiRevenue, kpiTickets])
kpiOrders = OverviewCardItem("orders", Text("text", "Failed orders"), MetricIndicatorInline("2,340", "of 6,100 attempts"))
kpiRevenue = OverviewCardItem("revenue", Text("text", "Revenue deferred"), MetricIndicatorInline("$118k", "~71% recovered by retry email"))
kpiTickets = OverviewCardItem("tickets", Text("text", "Support tickets"), MetricIndicatorInline("412", "peak 9/min", {direction: "up", value: 340}))
errorChart = LineChart(["14:15", "14:25", "14:35", "14:45", "14:55", "15:05", "15:15"], [Series("Checkout error rate %", [0.4, 61, 74, 72, 70, 66, 0.5])], "linear", "UTC", "%")
timeline = Card([CardHeader("Timeline", "all times UTC"), timelineList])
timelineList = Timeline([tPush, tAlert, tPage, tWrong, tRollback, tRecover])
tPush = TimelineItem("Config push", "14:22", "payments-client timeout: 8000 → 800 ms (dropped zero).")
tAlert = TimelineItem("First alert", "14:25", "Checkout error rate above 5% for 3 minutes.")
tPage = TimelineItem("Incident declared", "14:31", "On-call pages payments; SEV-1 opened.")
tWrong = TimelineItem("Wrong hypothesis", "14:38", "Blamed the card processor; status page showed green. 24 minutes lost.")
tRollback = TimelineItem("Rollback", "15:09", "Config reverted by hand.", "current")
tRecover = TimelineItem("Recovered", "15:14", "Error rate under 0.5%.")
cause = Card([CardHeader("What failed"), causeDiagram])
causeDiagram = Architecture([shopper, checkout, payments, processor, config], [toCheckout, toPayments, toProcessor, fromConfig], [platform])
shopper = Node("Shopper", "external", "browser / app")
checkout = Node("Checkout API", "backend", "retries x3")
payments = Node("payments-client", "backend", "timeout 800 ms", null, "danger")
processor = Node("Card processor", "external", "3-D Secure ~2 s")
config = Node("Config service", "cloud", "push at 14:22", "changed")
toCheckout = Edge(shopper, checkout, "HTTPS", "emphasis")
toPayments = Edge(checkout, payments, "x3 on error", "dashed", "danger")
toProcessor = Edge(payments, processor, "times out", "solid", "danger")
fromConfig = Edge(config, payments, "bad value", "security", "danger")
platform = Group("Platform", [checkout, payments, config])
actions = Card([CardHeader("Action items"), actionTable])
actionTable = Table([Col("Action", ["Reject sub-second timeouts for the processor client", "Canary config pushes to 5% of pods for 10 minutes", "Alert on timeout-rate, not only on error rate", "Runbook: check config changes before blaming a vendor"]), Col("Owner", ["Priya", "Platform", "Sam", "Incident lead"]), Col("Due", ["21 Oct", "4 Nov", "28 Oct", "21 Oct"]), Col("Priority", [pHigh, pHigh, pMed, pMed])])
pHigh = Tag("P1", null, "sm", "danger")
pMed = Tag("P2", null, "sm", "warning")
decide = Card([CardHeader("Review"), decideForm])
decideForm = Form("signoff", decideButtons, [followField])
followField = FormControl("Missing from the action items?", TextArea("missing", "Anything we should add or change", 3))
decideButtons = Buttons([Button("Approve postmortem", @ToAssistant("Postmortem approved"), "primary"), Button("Request changes")])
Screenshot of the API design review: bulk invoice export pageOpen live page

API design review: bulk invoice export

Design review for a bulk invoice export API: endpoints, request shapes, alternatives and a format decision.

  • ~951 tokens
  • 24 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([overview, endpoints, shapes, pagination, risks, decide], "column", "l")
overview = Card([CardHeader("Bulk invoice export", "Proposal for /v2/invoices/exports"), overviewText, breakingNote])
overviewText = MarkDownRenderer("Finance needs every invoice for a quarter as CSV. Today they page through `GET /v1/invoices` for about 40 minutes and hit the rate limit twice.

**Proposal:** an asynchronous export job. Create it, poll it, download one file.

- Same auth scopes as `/v1/invoices`
- Results are a snapshot taken when the job starts
- Files expire after 24 hours")
breakingNote = Callout("info", "Not a breaking change", "`/v1/invoices` is untouched. The export lives under `/v2` only because the job model is new.")
endpoints = Card([CardHeader("Endpoints"), endpointTable])
endpointTable = Table([Col("Method", ["POST", "GET", "GET", "DELETE"]), Col("Path", ["/v2/invoices/exports", "/v2/invoices/exports/{id}", "/v2/invoices/exports/{id}/file", "/v2/invoices/exports/{id}"]), Col("Purpose", ["Start a job", "Status and progress", "Download when ready (302 to a signed URL)", "Cancel or delete early"]), Col("Success", ["202", "200", "302", "204"])])
shapes = Card([CardHeader("Request and response"), shapeTabs])
shapeTabs = Tabs([TabItem("create", "Create", [createReq, createRes]), TabItem("status", "Poll", [statusRes]), TabItem("error", "Errors", [errorRes])])
createReq = CodeBlock("http", "POST /v2/invoices/exports
Idempotency-Key: 7c1e0f3a-2b0d-4a51-9a40-6f1d1e9c2b11

{
  \"from\": \"2026-07-01\",
  \"to\": \"2026-09-30\",
  \"format\": \"csv\",
  \"status\": [\"paid\", \"open\"]
}")
createRes = CodeBlock("json", "{
  \"id\": \"exp_01J9ZK3Q\",
  \"status\": \"queued\",
  \"links\": { \"self\": \"/v2/invoices/exports/exp_01J9ZK3Q\" }
}")
statusRes = CodeBlock("json", "{
  \"id\": \"exp_01J9ZK3Q\",
  \"status\": \"running\",
  \"rows_written\": 182400,
  \"rows_total\": 311250,
  \"retry_after\": 5
}")
errorRes = CodeBlock("json", "{
  \"error\": {
    \"code\": \"range_too_large\",
    \"message\": \"A range may cover at most 366 days.\",
    \"param\": \"to\"
  }
}")
pagination = Card([CardHeader("Why a job, not a bigger page"), alternatives])
alternatives = Table([Col("Option", ["Raise page size to 10,000", "Streaming NDJSON response", "Async export job"]), Col("Client effort", ["Low", "Medium", "Medium"]), Col("Timeouts", ["Likely above 30 s", "Connection can drop mid-file", "None, polled"]), Col("Verdict", [vNo, vNo, vYes])])
vNo = Tag("rejected", null, "sm", "danger")
vYes = Tag("proposed", null, "sm", "success")
risks = Card([CardHeader("Open questions"), riskList])
riskList = Accordion([AccordionItem("limits", "Limits", [limitsText]), AccordionItem("privacy", "Customer data in files", [privacyText])])
limitsText = MarkDownRenderer("One running job per account, at most 20 per day. A tenth of accounts have more than 1M invoices; do we split by month for them?")
privacyText = MarkDownRenderer("Signed URLs last 10 minutes and are bound to the caller's IP. Files are encrypted at rest with the account's key. **Needs a security review before launch.**")
decide = Card([CardHeader("Your call"), decideForm])
decideForm = Form("format", decideButtons, [formatField])
formatField = FormControl("Output formats at launch", CheckBoxGroup("formats", [CheckBoxItem("CSV", "Required by finance", "csv"), CheckBoxItem("NDJSON", "For the data team", "ndjson"), CheckBoxItem("Parquet", "Not yet requested", "parquet")]))
decideButtons = Buttons([Button("Send decision", @ToAssistant("Decision: export formats"), "primary"), Button("Split large accounts by month")])
Screenshot of the PR #482: rate limiter for the public API pageOpen live page

PR #482: rate limiter for the public API

Summary of a rate-limiter pull request: where it sits, the core diff, test results and files touched.

  • ~847 tokens
  • 24 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([summary, flow, change, tests, files, followUps], "column", "l")
summary = Card([CardHeader("PR #482: token-bucket rate limiter", "5 files, +96 -12"), facts, why])
facts = EntityList([{left: "Author", right: "dana"}, {left: "Tests", right: "212 passed, 6 new"}, {left: "Risk", right: "Medium: sits on every request"}, {left: "Flag", right: "RATE_LIMIT_V2, off by default"}])
why = MarkDownRenderer("The fixed-window limiter let a client burst **2x** the limit across a window boundary. This swaps it for a token bucket per API key, kept in Redis, and returns `Retry-After` on 429.")
flow = Card([CardHeader("Where it sits"), flowDiagram])
flowDiagram = Architecture([client, gateway, limiter, redis, api], [toGateway, toLimiter, toRedis, toApi])
client = Node("Client", "external")
gateway = Node("Gateway", "cloud", "auth + routing")
limiter = Node("Rate limiter", "security", "middleware", "new")
redis = Node("Redis", "database", "bucket per key")
api = Node("API", "backend")
toGateway = Edge(client, gateway, "HTTPS", "emphasis")
toLimiter = Edge(gateway, limiter)
toRedis = Edge(limiter, redis, "EVALSHA", "dashed")
toApi = Edge(limiter, api, "allowed", "solid", "success")
change = Card([CardHeader("Core change", "src/middleware/rate-limit.ts"), limiterPatch])
limiterPatch = Diff("diff --git a/src/middleware/rate-limit.ts b/src/middleware/rate-limit.ts
--- a/src/middleware/rate-limit.ts
+++ b/src/middleware/rate-limit.ts
@@ -1,18 +1,31 @@
-export async function rateLimit(req, res, next) {
-  const key = `rl:${req.apiKey}:${Math.floor(Date.now() / 60000)}`;
-  const n = await redis.incr(key);
-  if (n === 1) await redis.expire(key, 60);
-  if (n > LIMIT) return res.status(429).end();
-  next();
-}
+const BUCKET = { capacity: 100, refillPerSec: 10 };
+
+export async function rateLimit(req, res, next) {
+  const key = `rl:${req.apiKey}`;
+  const [allowed, retryMs] = await redis.evalsha(TAKE_TOKEN, 1, key, BUCKET.capacity, BUCKET.refillPerSec, Date.now());
+  if (!allowed) {
+    res.set('Retry-After', String(Math.ceil(retryMs / 1000)));
+    return res.status(429).json({ error: 'rate_limited' });
+  }
+  next();
+}
@@ -40,3 +53,4 @@ export const config = {
   limit: 100,
+  failOpen: true,
 };", "rate-limit.ts")
tests = Card([CardHeader("Tests"), testTable])
testTable = Table([Col("Case", ["Burst across a window boundary", "Refill after idle", "Redis unavailable", "Concurrent requests, one key"]), Col("Result", [ok, ok, ok, warn]), Col("Note", ["Now capped at capacity", "Matches refillPerSec", "Fails open, logs once a minute", "Passes, but 3 of 50 runs flaked locally"])])
ok = Tag("pass", null, "sm", "success")
warn = Tag("flaky", null, "sm", "warning")
files = Card([CardHeader("Files touched"), changedFiles])
changedFiles = FileTree(["M src/middleware/rate-limit.ts # token bucket", "A src/middleware/take-token.lua", "M src/config.ts # failOpen", "A test/rate-limit.test.ts", "M docs/api/errors.md # Retry-After"])
followUps = Buttons([Button("Approve", @ToAssistant("Approve PR #482"), "primary"), Button("Fix the flaky test first", @ToAssistant("Fix the flaky concurrent-request test before merging"), "secondary"), Button("Should it fail open?", null, "tertiary")])
Screenshot of the Sprint 24 plan pageOpen live page

Sprint 24 plan

Sprint plan with the work

  • ~1,055 tokens
  • 39 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([goal, schedule, capacity, scope, risks, decide], "column", "l")
goal = Card([CardHeader("Sprint 24", "2 Nov – 13 Nov · 4 engineers"), goalText, goalKpis])
goalText = MarkDownRenderer("**Goal:** ship team workspaces to 10% of accounts behind a flag, with billing seats correct on day one.

Anything that does not serve that goal waits for sprint 25.")
goalKpis = OverviewCardBlock([kpiPoints, kpiCarry, kpiBuffer])
kpiPoints = OverviewCardItem("points", Text("text", "Planned"), MetricIndicatorInline("34 pts", "velocity avg 36"))
kpiCarry = OverviewCardItem("carry", Text("text", "Carry-over"), MetricIndicatorInline("5 pts", "2 stories"))
kpiBuffer = OverviewCardItem("buffer", Text("text", "Unplanned buffer"), MetricIndicatorInline("15%", "one day for bugs"))
schedule = Card([CardHeader("Schedule", "Billing is the long pole: it cannot start before the membership API lands."), scheduleMap])
scheduleMap = Architecture([schemaWork, apiWork, billingWork, switcherWork, inviteWork, rolloutWork, bufferWork], [schemaToApi, apiToBilling, switcherToInvite, billingToRollout, inviteToRollout], [backendLane, frontendLane, releaseLane], "lanes")
schemaWork = Node("Workspace schema + migration", "database", "2–3 Nov · Ben", "done", "success", 1)
apiWork = Node("Membership API", "backend", "4–7 Nov · Ben", "in progress", "info", 2)
billingWork = Node("Seat counting in billing", "backend", "8–10 Nov · Chi", "long pole", "warning", 3)
switcherWork = Node("Workspace switcher", "frontend", "4–7 Nov · Ana", "in progress", "info", 2)
inviteWork = Node("Invite flow", "frontend", "8–10 Nov · Ana", null, null, 3)
rolloutWork = Node("Flag + staged rollout", "cloud", "12 Nov", "milestone", "strong", 4)
bufferWork = Node("Bug buffer", "backend", "12–13 Nov", null, null, 5)
schemaToApi = Edge(schemaWork, apiWork)
apiToBilling = Edge(apiWork, billingWork, "API contract", "emphasis")
switcherToInvite = Edge(switcherWork, inviteWork)
billingToRollout = Edge(billingWork, rolloutWork, "seats on day one", "emphasis")
inviteToRollout = Edge(inviteWork, rolloutWork)
backendLane = Group("Backend", [schemaWork, apiWork, billingWork], "plain")
frontendLane = Group("Frontend", [switcherWork, inviteWork], "plain")
releaseLane = Group("Release", [rolloutWork, bufferWork], "plain")
capacity = Card([CardHeader("Capacity by person"), capacityChart])
capacityChart = BarChart(["Ana", "Ben", "Chi", "Dev"], [Series("Planned pts", [10, 9, 8, 7]), Series("Available pts", [11, 10, 8, 9])], "grouped", "Engineer", "pts")
scope = Card([CardHeader("Committed stories"), storyTable])
storyTable = Table([Col("Story", ["Workspace schema + migration", "Membership API", "Seat counting in billing", "Workspace switcher", "Invite flow", "Audit log for member changes"]), Col("Owner", ["Ben", "Ben", "Chi", "Ana", "Ana", "Dev"]), Col("Pts", ["5", "8", "8", "5", "5", "3"], "number"), Col("Status", [sDone, sProg, sNext, sProg, sNext, sCut])])
sDone = Tag("done", null, "sm", "success")
sProg = Tag("in progress", null, "sm", "info")
sNext = Tag("not started", null, "sm", "neutral")
sCut = Tag("at risk", null, "sm", "warning")
risks = Card([CardHeader("Risks"), riskCallout, riskList])
riskCallout = Callout("warning", "Billing depends on the membership API", "If the API slips past Friday 6 Nov, seat counting moves to sprint 25 and the rollout is flag-only.")
riskList = Steps([StepsItem("Wed 4 Nov", "Checkpoint: membership API contract frozen."), StepsItem("Fri 6 Nov", "Checkpoint: billing starts or scope is cut."), StepsItem("Thu 12 Nov", "Flag on for the 10% cohort.")])
decide = Card([CardHeader("Your call"), decideForm])
decideForm = Form("scope", decideButtons, [auditField])
auditField = FormControl("Audit log", RadioGroup("audit", [RadioItem("Keep in sprint", "3 pts, leaves 12% buffer", "keep"), RadioItem("Move to sprint 25", "Buffer back to 21%", "move")], "move"))
decideButtons = Buttons([Button("Commit the sprint", @ToAssistant("Sprint 24 committed"), "primary"), Button("Rebalance Ana's load")])
Screenshot of the Retry fix review pageOpen live page

Retry fix review

Review of a small retry fix: the patch, a backoff chart and one-click follow-ups.

  • ~441 tokens
  • 11 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([summary, change, design, followUps], "column", "l")
summary = Card([CardHeader("Retry fix", "1 file, +4 -1"), facts, why])
facts = EntityList([{left: "Tests", right: "48 passed"}, {left: "Risk", right: "Low"}, {left: "Touches", right: "src/retry.ts"}])
why = MarkDownRenderer("Retries fired back-to-back, so a flapping dependency got hammered 3× in ~20 ms. This adds **exponential backoff with jitter** and makes the attempt count configurable.")
change = Card([CardHeader("Patch"), retryPatch])
retryPatch = Diff("diff --git a/src/retry.ts b/src/retry.ts
--- a/src/retry.ts
+++ b/src/retry.ts
@@ -10,5 +10,8 @@ export async function retry(fn) {
-  for (let i = 0; i < 3; i++) {
+  for (let i = 0; i < MAX_ATTEMPTS; i++) {
+    if (i > 0) await sleep(backoff(i));
     try {
       return await fn();
     } catch {}
+  }
+  throw new RetryExhausted(MAX_ATTEMPTS);")
design = Card([CardHeader("Backoff curve"), designTabs])
designTabs = Tabs([TabItem("chart", "Delay per attempt", [backoffChart]), TabItem("code", "backoff()", [backoffCode])])
backoffChart = LineChart(["1", "2", "3", "4", "5"], [Series("p50 delay (ms)", [100, 200, 400, 800, 1600]), Series("max with jitter", [150, 300, 600, 1200, 2400])], "linear", "Attempt", "ms")
backoffCode = CodeBlock("ts", "export function backoff(attempt: number, base = 100): number {
  const exp = base * 2 ** (attempt - 1);
  return exp + Math.random() * exp * 0.5; // up to +50% jitter
}")
followUps = Buttons([Button("Ship it", @ToAssistant("Ship it"), "primary"), Button("Add a jitter test", @ToAssistant("Add a test for the jitter bounds"), "secondary"), Button("Make base delay configurable", null, "tertiary")])
Screenshot of the shadcn pack sample pageOpen live page

shadcn pack sample

Sample of the bundled shadcn pack: progress, avatars, tooltips, calendar and a timeline.

  • ~275 tokens
  • 21 statements
  • passes austere-axi check

OpenUI Lang source

root = Stack([trail, card])
trail = Breadcrumb([crumbRepo, crumbPack, crumbPage])
crumbRepo = BreadcrumbItem("austere-axi")
crumbPack = BreadcrumbItem("packs")
crumbPage = BreadcrumbItem("shadcn")
card = Card([intro, bar, team, term, svc, keys, loading, cal, history])
intro = TextContent("Sample page for the shadcn pack.")
bar = Progress(64, "Rows migrated")
team = AvatarGroup([ada, grace, linus], 2)
ada = Avatar("Ada Lovelace")
grace = Avatar("Grace Hopper")
linus = Avatar("Linus Torvalds")
term = Tooltip("idempotent", "Safe to run twice with the same result.")
svc = HoverCard("billing-api", "billing-api", "Owns invoices and refunds.")
keys = Kbd("Ctrl+Shift+P")
loading = Skeleton(3, "avatar")
cal = Calendar("2026-11", ["2026-11-04 Code freeze", "2026-11-12 Release"])
history = Timeline([found, fixed, rollout])
found = TimelineItem("Bug found", "Oct 28", "Retries double-charge on timeout.")
fixed = TimelineItem("Fix merged", "Oct 29", "Idempotency key added.", "current")
rollout = TimelineItem("Rollout", "Nov 3", "", "upcoming")