How t3-content/quipslop works
What this project is (from the tree + README)
Quipslop appears to be a Bun + TypeScript web app used live on Twitch. The file layout strongly suggests a single-server “full-stack” app that:
• Serves multiple browser UIs/pages (separate entrypoints for different roles):
• frontend.tsx (main viewer/user-facing UI)
• admin.tsx / admin.html (control panel for the operator/mod)
• broadcast.ts / broadcast.html (broadcast/overlay view for OBS “browser source”)
• history.tsx / history.html (past rounds/history view)
• Runs a backend in server.ts with domain logic in game.ts
• Persists state via db.ts (+ check-db.ts)
• Has deployment/build artifacts: Dockerfile, bun.lock, tsconfig.json, public/assets/...
Viewer / Main Web UI
• index.html
• frontend.tsx, frontend.css
Admin UI (Operator)
• admin.html
• admin.tsx, admin.css
Broadcast/Overlay UI (OBS Browser Source)
• broadcast.html
• broadcast.ts, broadcast.css
History UI
• history.html
• history.tsx, history.css
Backend container (single service)
• Bun Server / API + Realtime Hub
• server.ts (request handling, routing, probably websocket/SSE)
• Serves static assets from /public and compiled bundles for the pages
• Game/Domain Engine
• game.ts (state machine, scoring, round progression, etc.)
• Persistence Layer
• db.ts (DB connection + queries)
• check-db.ts (schema validation / migrations / sanity checks)
• Prompt/Content Generation
• prompts.ts (very likely content templates or generation logic used by the game)
• Utilities / Tests
• bulk-test.ts (load/test harness hitting APIs or simulating sessions)
Data store(s)
• Database (persistent state)
• connected via db.ts
Ops / deployment / build
• Bun toolchain
• package.json, bun.lock, tsconfig.json
• Containerization
• Dockerfile, .dockerignore
• Static assets
• public/assets/logos/...
• Scripts
• scripts/stream-browser.ts (likely launches/controls a browser for streaming workflows)
Single-service backend with modular domain separation
• server.ts (transport) separated from game.ts (domain) and db.ts (persistence)
Multiple frontends / multiple entrypoints
• Distinct pages for distinct roles (viewer/admin/broadcast/history)
Realtime system
• Presence of a dedicated broadcast UI strongly implies push-based updates
Stream-operator workflow integration
• Dedicated script under scripts/ implies tooling around running the show live
Call these out using labels like “Transport Layer”, “Domain Layer”, “Persistence”, “Realtime”.
Level 1 — System Context (who uses it)
• Viewer(s)
• Stream Operator (Admin)
• OBS / Broadcast overlay (Browser Source)
• “Plays/Views”
• “Controls game”
• “Renders overlay”
• “Reads/Writes state”
• Bun Server Container (Docker)
• Database
• Viewer Web App
• Admin Web App
• Broadcast Web App
• History Web App
• HTTP for page load
• Realtime channel for updates
• DB connections
• server.ts (HTTP routes + realtime hub)
• game.ts (game engine)
• prompts.ts (content)
• db.ts (persistence adapter)
• check-db.ts (ops/migrations check)
Optionally show:
• bulk-test.ts (test client)
• scripts/stream-browser.ts (operator tool)
Labels
• Use actual filenames for component names when possible (e.g., “Game Engine (game.ts)”).
• “HTTP GET (static/bundle)”
• “HTTP API (admin commands)”
• “WebSocket/SSE (state updates)”
• “SQL queries (state persistence)”
Detail bias (important for this repo)
Because the README doesn’t explain architecture, your best accuracy comes from maximizing explicit components derived from the tree:
• Keep Admin vs Broadcast vs Viewer vs History separate.
• Keep server transport vs game domain vs DB separate.
• scripts and test harnesses as “supporting components” (a separate lane).