audit(gateway): fix dead /metrics endpoint, raise OOM-prone MemoryMax, trim DB pool

- gateway-metrics: collectors now run per scrape so Prometheus sees real
  data (process memory/uptime + live AI-analysis pipeline gauges) instead
  of an always-empty stub. bootstrap registers the pipeline collectors.
- systemd: MemoryMax 512M -> 1G (live RSS ~500MiB, peak 508MiB; 512M left
  ~2% headroom and risked an OOM-kill restart; host has 8GB free).
- config: POSTGRES_POOL_MIN 2 -> 0 so main + 4 Piscina worker threads don't
  hold ~10 permanently-open idle pg connections against PgBouncer.
- docs: rewrite stale ARCHITECTURE.md / MODULE_STRUCTURE.md (winston ->
  pino, removed mock-crc/indonesianTextNormalizer, renamed
  aiAnalysisWorker/llmModerationClient).

Verified: tsc clean, 129 vitest pass, biome clean on changed files.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.hermes/plans/2026-08-13_gmw-frontend-greenfield.md

@@ -0,0 +1,418 @@
+# GMW Frontend — Greenfield Rebuild (Visual-System Overhaul + Custom UI + Motion/3D)
+
+> **For Hermes:** Execute with `subagent-driven-development` (one fresh subagent per task, two-stage review). Each task is 1–3 min, atomic, independently verifiable, committed after each. Reuse `src/lib/api/*`, `src/lib/ws/*`, `src/lib/types/*`, hooks verbatim. Never invent endpoints.
+
+**Goal:** Rebuild the GMW Discord-automod dashboard frontend from scratch — drop shadcn/ui + glass/teal/purple aesthetic entirely, replace with a custom, distinctive design system where every page has its own visual metaphor (no uniform bordered-card grid), and push the presentation layer with **Framer Motion (`motion`) choreography + signature Three.js scenes**. Re-integrate to the EXISTING backend API + WebSocket contract (do NOT touch the backend).
+
+**Architecture:** Next.js 16 App Router (SSR) + React 19 + TS strict + Tailwind v4. Keep the *plumbing* (data contract), rebuild the *skin + primitives + motion*. Each route = one self-contained `page.tsx` (server fetch + client view in the same file via a `"use client"` sibling export). Custom SVG charts (no recharts). Custom micro-primitives (no shadcn/base-ui). New token system in `globals.css`. **Motion:** `motion/react` app-wide for page transitions, spring micro-interactions, layout animaLine truncated
+
+**Tech Stack:** next@16, react@19, tailwindcss@4 (`@import "tailwindcss"`), `next/font/google` (Bricolage Grotesque + Inter + JetBrains Mono), `swr` (data revalidation), `lucide-react` (icons only), `motion` (Framer Motion successor — `motion/react`), `three` + `@types/three` (signature scenes only), `clsx` + `tailwind-merge`. **Removed:** `@shadcn/react`, `@base-ui/react`, `recharts`, `shadcn` CLI, `cmdk`, `sonner`, `react-day-picker`, `embla-carousel-react`, `react-resizable-panels`, `inputLine truncated
+
+---
+
+## 0. Design System (the creative core — read before coding)
+
+**Persona:** Controlled UX Designer + a tactical "ops console" voice. Material honesty: hierarchy via **scale/weight/tonal blocks**, NOT borders/shadows. Per `frontend-design` skill principle — spend the boldness in ONE signature place per page, keep the rest disciplined. Motion is choreography, not confetti: **one orchestrated moment per page**, everything else quiet.
+
+### Palette (warm, signal-driven — NO teal/cyan/purple/blue gradients)
+Light mode (`:root`):
+```
+--canvas:      oklch(0.96 0.012 80)    /* warm off-white, not cream */
+--surface:     oklch(0.92 0.014 80)    /* tonal block, replaces bordered card */
+--surface-2:   oklch(0.88 0.016 80)
+--ink:         oklch(0.22 0.02 70)     /* primary text */
+--ink-soft:    oklch(0.46 0.02 70)     /* secondary text */
+--hairline:    oklch(0.22 0.02 70 / 0.10)  /* structural rules ONLY, sparse */
+--signal:      oklch(0.78 0.17 125)    /* lime — OK / live / primary accent */
+--signal-ink:  oklch(0.20 0.03 70)     /* text ON signal */
+--amber:       oklch(0.80 0.15 70)     /* WARN */
+--vermilion:   oklch(0.62 0.21 25)     /* FLAGGED / destructive */
+--ring:        var(--signal)
+```
+Dark mode (`.dark`, default theme per `next-themes`):
+```
+--canvas:      oklch(0.13 0.015 70)    /* warm charcoal, not blue-black */
+--surface:     oklch(0.18 0.02 70)
+--surface-2:   oklch(0.23 0.022 70)
+--ink:         oklch(0.93 0.01 75)
+--ink-soft:    oklch(0.62 0.02 75)
+--hairline:    oklch(1 0 0 / 0.09)
+--signal:      oklch(0.88 0.18 125)
+--signal-ink:  oklch(0.18 0.03 70)
+--amber:       oklch(0.85 0.15 70)
+--vermilion:   oklch(0.68 0.21 25)
+```
+Three semantic signals reused everywhere: **lime = OK/live, amber = warn, vermilion = flag/danger**. This kills the purple-accent + teal-primary monotony.
+
+### Typography (3 roles, deliberate pairing — not "Inter everywhere")
+- **Display:** `Bricolage Grotesque` (700–800) — characterful grotesque for headers/big numbers.
+- **Body/UI:** `Inter` (400–600).
+- **Data/label:** `JetBrains Mono` (500/700) — all stats, timestamps, channel IDs, metrics.
+Load all three via `next/font/google` with CSS variables (keep current `--font-inter`/`--font-jetbrains-mono` names + add `--font-display`).
+
+### Layout & signature
+- **No `card` with border.** Use tonal `--surface` blocks with generous radius (`--r: 14px`) and internal padding; separate blocks with whitespace + sparse hairlines only where structurally meaningful.
+- **Signature element = "scan-tick":** a 1px animated pulse line (CSS keyframe `scan`) that marks every live/section header — NOT a card outline. Global canvas carries a faint warm dot-grid texture (low opacity) instead of the current bluish dotted radial-gradient.
+- **Nav = left "spine":** vertical rail of icon nodes joined by a hairline; active node gets a `--signal` dot + label reveal. Collapses to a bottom tab-bar < 768px (CSS only, no JS sidebar primitive).
+- **Header = "status bar":** connection state (WS dot), guild selector, live clock — mono font, reads like an instrument readout.
+
+## 0.1 Motion & 3D Layer (the "lebih kreatif" addition)
+
+### Motion rules (from `motion/react`)
+- **Page transitions:** one shared `RouteTransition` in `(dashboard)/layout.tsx` — `AnimatePresence mode="popLayout"` + `motion.div key={pathname}` (fade + 8px rise + slight blur-out, ~220ms, `easeOut`). Consistent everywhere, zero per-page boilerplate.
+- **Enter choreography (per page, ONE signature moment):** staggered rise-in for the hero/ticker group using `staggerChildren` variants; afterwards, quiet springs for hover/tap (`scale: 1.03` on interactive blocks, `whileTap` on buttons).
+- **Layout animation:** `layout` prop on list items (messages rows, recording rows, queue) so add/remove/filter reflows smoothly; `layoutId` for shared-element transitions (ticker → detail modal on dashboard).
+- **Live pulse:** `motion` drives the severity ticks / speaker rings with springs, not CSS `transition` alone.
+- **`useReducedMotion()`** (from `motion/react`) gates ALL heavy motion; CSS `@media (prefers-reduced-motion: reduce)` additionally kills `scan`/`spin-disc` keyframes. Accessibility floor, non-negotiable.
+- **No scroll-jacking, no marquee loops, no per-element confetti.** One moment per page. (`frontend-design` skill: "Satu momen orkestrasi biasanya lebih mengena daripada efek tersebar.")
+
+### 3D rules (raw `three`, no R3F — lean bundle)
+- Exactly **two** scenes, chosen because they carry real data meaning: **Dashboard hero** (`SignalField` — a particle field whose pulse density reflects live activity) and **Voice page** (`OrbField` — speakers as glowing orbs whose height/ring radius reacts to who is speaking). Everything else stays 2D/motion.
+- **Lazy + client-only:** `next/dynamic(() => import("./SignalField"), { ssr: false, loading: () => <StaticFallback/> })`. Three ships in its own chunk, loaded only on those two routes.
+- **WebGL guard:** if `!window.WebGLRenderingContext` or context creation fails → render the static SVG/CSS fallback (a stylized 2D version of the same visual). Never blank.
+- **Perf guardrails:** `dpr: [1, 1.75]`, `powerPreference: "high-performance"`, `antialias: true`; RAF loop paused on `document.hidden`; `dispose()` geometries/materials on unmount; particle count capped by `navigator.hardwareConcurrency` + viewport (`Math.min(900, w*h/2000)`).
+- **Style:** warm palette ONLY — signal-lime particles, amber/vermilion for flag/warn states; fog + soft additive blending for glow (no harsh white lights, no metallic PBR).
+- **Interactivity:** subtle pointer parallax (camera lerp toward cursor) + gentle idle rotation. No drag/drop, no raycasting menus.
+
+### Per-page metaphor (kills monotony — each page feels different)
+| Route | Metaphor | Signature visual | Motion / 3D |
+|---|---|---|---|
+| `/dashboard` | Live ops overview | **3D signal particle field** hero + asymmetric ticker blocks + radial moderation gauge | **3D SignalField** (reacts to activity), staggered ticker rise-in, gauge draws on mount |
+| `/messages` | Transcript | Left channel **timeline spine**; right = flowing message entries with left **severity tick** (no bordered cards); search = command palette | `layout` on message rows, spring severity ticks, palette types in |
+| `/voice` | Stage | **3D orb field** of speakers + equalizer rings; activity = horizontal **session ribbon** | **3D OrbField** (speaking → orb rises + ring pulses), session ribbon draws sequentially |
+| `/media` | Turntable | Rotating **disc** now-playing; queue = borderless list | CSS 3D disc spin (spring on play/pause), queue `layout` reflow, progress bar springs |
+| `/recordings` | Tape library | Rows with **waveform thumbnail** (custom SVG from duration) | Waveform bars spring on hover; new upload animates in (AnimatePresence) |
+| `/moderation` | Security log | Vertical **event flow** with status nodes (dot + line), not a table of cards | Nodes pulse on live action; timeline draws in sequence |
+| `/analysis` | Query console | Terminal-style search panel | Typing cursor + results stagger |
+
+---
+
+## 1. What to KEEP (reuse verbatim — correct + integrates to backend)
+- `src/lib/api/server.ts` — 11 server fetchers (`getDashboardStats`, `getActivity`, `getMediaStatus`, `getConfig`, `getModerationStats/Actions`, `getGuilds`, `getVoiceStatus`, `getRecordings`, `getMessages`). **No change.**
+- `src/lib/api/client.ts` — `apiRequest` + `ApiError`. **No change.**
+- `src/lib/ws/*` — `connection.ts`, `context.tsx`, `types.ts` (17 typed events: `message_created/updated/deleted/analyzed`, `voice_*`, `media_state`, `voice_pcm_data` binary). **No change.**
+- `src/lib/types/*` — all interfaces. **No change.**
+- `src/lib/format.ts`, `src/lib/utils.ts` (`cn`). **No change.**
+- `src/lib/navigation.ts` — `navItems`. Keep but extend icons/labels if needed.
+- Hooks: `src/hooks/*` (use-dashboard, use-media, use-messages, use-voice, use-moderation, use-recordings, use-guilds, use-config, use-chatbot-user, use-action, use-mobile), `src/lib/hooks/use-mounted.ts`. **Reuse** (verify no bad imports into deleted barrels).
+- Feature logic kept but **reskinned**: `src/components/media/music-player.tsx`, `src/components/voice/*`, `src/components/chatbot/*`, `src/components/messages/*`, `src/components/recordings/*`, `src/components/moderation/moderation-section.tsx`, `src/components/analysis/search-panel.tsx`, `src/components/dashboard/*` (charts → rewritten as custom SVG).
+
+## 2. What to DELETE
+- `src/components/ui/*` (all 50 shadcn primitives).
+- `components.json`, `@shadcn/react` + `@base-ui/react` + `shadcn` deps.
+- `recharts` (replace with custom SVG chart helpers in `src/components/charts/`).
+- `src/app/globals.css` → rewrite (no `@import "shadcn/tailwind.css"`, no `--color-primary` teal, no `.glass*`, no `.text-gradient`/`.gradient-border` teal/purple, no bluish body texture).
+- `src/components/layout/app-sidebar.tsx` (shadcn Sidebar) → replace with custom `Spine` nav.
+- All `page.tsx`+`view.tsx` pairs → merge into single `page.tsx` per route.
+
+## 3. What to BUILD (new)
+- New `globals.css` (tokens above + utilities + keyframes `scan`, `eq`, `fade-up`, `spin-disc`).
+- `src/components/primitives/` — minimal custom: `Button`, `Input`, `Select`, `Dialog`, `Tooltip`, `Badge`, `Progress`, `Avatar`, `Skeleton`, `Toast`, `Sheet`.
+- `src/components/motion/` — `RouteTransition.tsx`, `Stagger.tsx`, `variants.ts`.
+- `src/components/three/` — `SignalField.tsx`, `OrbField.tsx`, `WebGLGuard.tsx`, `StaticFallback.tsx`, `useThreeScene.ts`.
+- `src/components/charts/` — `Sparkline`, `AreaActivity`, `RadialGauge`, `SessionRibbon`, `Waveform`.
+- `src/components/layout/` — `Spine.tsx`, `StatusBar.tsx`, `ThemeToggle.tsx` (reskin).
+- 7 merged `page.tsx` files (one per route) implementing the metaphors above.
+- `src/app/layout.tsx` — root (fonts + ThemeProvider + Toaster), `src/app/(dashboard)/layout.tsx` — providers + Spine + StatusBar + RouteTransition + MiniPlayer + Chatbot, `src/app/page.tsx` → redirect `/dashboard`.
+
+---
+
+## 4. Target File & Folder Structure (authoritative)
+
+Everything below `services/frontend/src/` is the new tree. `REWRITE` replaces existing; `NEW` creates; `DELETE` removes. The `app/` route tree collapses `page.tsx`+`view.tsx` into single `page.tsx` files containing BOTH server fetch (default export) and client view (`"use client"` named export in same file).
+
+```
+services/frontend/
+├─ package.json                         REWRITE  (drop shadcn/base-ui/recharts; add motion, three, @types/three)
+├─ pnpm-workspace.yaml                  REWRITE  (onlyBuiltDependencies: keep build list minimal)
+├─ components.json                      DELETE   (shadcn registry config — no longer used)
+├─ next.config.ts                       KEEP     (output: standalone, trailingSlash, images.unoptimized)
+├─ tsconfig.json                        KEEP     (paths "@/*" → src/*, strict)
+├─ postcss.config.mjs                   KEEP     (@tailwindcss/postcss)
+├─ biome.json                           KEEP
+└─ src/
+   ├─ app/
+   │  ├─ layout.tsx                     REWRITE  (3 fonts + ThemeProvider + custom Toaster; rm sonner)
+   │  ├─ globals.css                    REWRITE  (new token system §0; rm glass/teal/purple)
+   │  ├─ page.tsx                       KEEP     (redirect → /dashboard/)
+   │  └─ (dashboard)/
+   │     ├─ layout.tsx                  REWRITE  (providers + Spine + StatusBar + RouteTransition + MiniPlayer + Chatbot; rm shadcn Sidebar)
+   │     ├─ dashboard/   page.tsx       REWRITE  (server fetch + <DashboardView/> client; 3D SignalField hero)
+   │     ├─ messages/    page.tsx       REWRITE  (server seeds + <MessagesView/>; spine + severity ticks)
+   │     ├─ voice/       page.tsx       REWRITE  (server seeds + <VoiceView/>; 3D OrbField hero)
+   │     ├─ media/       page.tsx       REWRITE  (server seeds + <MediaView/>; turntable disc)
+   │     ├─ recordings/  page.tsx       REWRITE  (server seeds + <RecordingsView/>; waveform rows)
+   │     ├─ moderation/  page.tsx       REWRITE  (server seeds + <ModerationView/>; event-flow)
+   │     └─ analysis/    page.tsx       REWRITE  (client <AnalysisView/>; query console)
+   ├─ components/
+   │  ├─ ui/                            DELETE   (all 50 shadcn primitives)
+   │  ├─ primitives/   NEW             (Button, Input, Select, Dialog, Tooltip, Badge, Progress, Avatar, Skeleton, Toast, Sheet, index.ts)
+   │  ├─ motion/       NEW             (variants.ts, Stagger.tsx, RouteTransition.tsx)
+   │  ├─ three/        NEW             (WebGLGuard, SignalField, OrbField, StaticFallback, useThreeScene)
+   │  ├─ charts/       NEW             (Sparkline, AreaActivity, RadialGauge, SessionRibbon, Waveform)
+   │  ├─ layout/       REWRITE         (Spine NEW, StatusBar NEW, ThemeToggle REWRITE, app-sidebar DELETE)
+   │  ├─ dashboard/    REWRITE         (stat-card DELETE; activity-chart/hourly/top-channels/moderation-donut/users/channels/reactions REWRITE)
+   │  ├─ messages/     REWRITE         (message-card DELETE; message-list/detail/detail-view/ai-status-badge/ai-analysis-panel/attachments-grid/lightbox/search-overlay REWRITE)
+   │  ├─ voice/        REWRITE         (voice-connection-card/connection-card/microphone-card DELETE; speaker-waveform/active-speakers-panel/activity-timeline/mic-control/listen-control REWRITE)
+   │  ├─ media/        REWRITE         (music-player, mini-player REWRITE)
+   │  ├─ recordings/   REWRITE         (recording-card DELETE; recording-player REWRITE)
+   │  ├─ moderation/   REWRITE         (moderation-section REWRITE)
+   │  ├─ analysis/     REWRITE         (search-panel REWRITE)
+   │  ├─ chatbot/      REWRITE         (chatbot-container, chat-panel REWRITE; chatbot-context, index KEEP)
+   │  └─ shared/       REWRITE         (empty-state, error-state, loading-skeleton, error-boundary, guild-selector REWRITE; index KEEP)
+   ├─ hooks/                           KEEP     (verify no bad imports)
+   ├─ lib/
+   │  ├─ api/          KEEP     (server.ts, client.ts, index.ts)
+   │  ├─ ws/           KEEP     (connection.ts, context.tsx, types.ts, ws-hook.ts)
+   │  ├─ types/        KEEP     (all interfaces)
+   │  ├─ hooks/        KEEP     (use-media-player.tsx, use-mounted.ts)
+   │  ├─ audio/        KEEP     (voice PCM decode helpers if present)
+   │  ├─ format.ts     KEEP
+   │  ├─ utils.ts      KEEP     (cn)
+   │  └─ navigation.ts KEEP
+   └─ (public assets)  KEEP
+```
+
+### 4.1 Single-file page pattern (mandatory)
+```tsx
+// server component (default export) — runs on the server, fetches initial data
+import { getX, getY } from "@/lib/api/server";
+import { XView } from "./page"; // self-import of the named client export
+
+export default async function Page() {
+  const [a, b] = await Promise.allSettled([getX(), getY()]);
+  return <XView initialA={a.status === "fulfilled" ? a.value : undefined}
+                  initialB={b.status === "fulfilled" ? b.value : undefined} />;
+}
+
+// client component (named export) — hydrated, takes initialData as SWR fallback
+"use client";
+export function XView({ initialA, initialB }: Props) {
+  const { data } = useX(initialA); // SWR fallbackData = initialA
+}
+```
+Self-referencing the named export keeps the file single-artifact while satisfying Next's RSC boundary (default = server, named = client). Tabs live inside `XView`.
+
+### 4.2 Import rules (lint gate)
+- No `@/components/ui/*` (deleted) — all UI via `@/components/primitives`.
+- `three` only imported inside `src/components/three/*`; pages import those via `next/dynamic({ ssr: false })`.
+- `motion` imported from `motion/react` only.
+- All data: `@/lib/api/server` (server) / `@/lib/api/client` (client) — never invented endpoints.
+
+---
+
+## TASKS (granular — every file is its own task)
+
+### PHASE 0 — Dependency surgery
+- **T0.1** Edit `package.json`: remove `dependencies["@base-ui/react"]`.
+- **T0.2** Remove `dependencies["@shadcn/react"]`.
+- **T0.3** Remove `dependencies["shadcn"]`.
+- **T0.4** Remove `dependencies["recharts"]`.
+- **T0.5** Remove `dependencies["cmdk"]`.
+- **T0.6** Remove `dependencies["sonner"]`.
+- **T0.7** Remove `dependencies["react-day-picker"]`.
+- **T0.8** Remove `dependencies["embla-carousel-react"]`.
+- **T0.9** Remove `dependencies["react-resizable-panels"]`.
+- **T0.10** Remove `dependencies["input-otp"]`.
+- **T0.11** Add `dependencies["motion"]: "^12.0.0"`, `dependencies["three"]: "^0.180.0"`, `devDependencies["@types/three"]: "^0.180.0"`.
+- **T0.12** `rm -f pnpm-lock.yaml && pnpm install` (regenerate lockfile).
+- **T0.13** Verify `pnpm ls recharts @shadcn/react @base-ui/react` → empty; `pnpm ls motion three @types/three` → present.
+- **T0.14** `cat pnpm-workspace.yaml`: confirm `onlyBuiltDependencies` keeps needed native builds, no broken shadcn postinstall.
+
+### PHASE 1 — Design tokens (globals.css)
+- **T1.1** Rewrite `@theme { }` head: light `:root` palette from §0 (canvas/surface/ink/ink-soft/hairline/signal/signal-ink/amber/vermilion/ring).
+- **T1.2** Add radius tokens `--r: 14px`, `--r-panel: 12px`, `--r-control: 8px`, `--r-pill: 9999px`.
+- **T1.3** Add `--font-display` token; keep `--font-sans`/`--font-mono`.
+- **T1.4** Add `.dark { }` override block with §0 dark values (warm charcoal).
+- **T1.5** Replace `@layer base body` bg: warm dot-grid `radial-gradient(oklch(0.45 0.03 70 / 0.05) 1px, transparent 1px)` + faint warm glow; remove old bluish radial layers.
+- **T1.6** Retint scrollbar thumb to warm `oklch(0.4 0.02 70 / 0.2)`; keep `::selection` signal-tinted.
+- **T1.7** Delete `.glass`, `.glass-elevated`, `.glass-intense`, `.dark .glass-intense` utilities.
+- **T1.8** Delete `.text-gradient` and `.gradient-border`.
+- **T1.9** Add `.surface` utility (bg var(--surface), radius var(--r), padding).
+- **T1.10** Add `.scan-tick` (1px animated pulse line, keyframe `scan`).
+- **T1.11** Add `.ticker`, `.pill`, `.mono` utilities.
+- **T1.12** Add keyframes `scan`, `eq`, `fade-up`, `spin-disc` (keep used existing ones if still referenced).
+- **T1.13** Add `@media (prefers-reduced-motion: reduce)` kill switch for scan/eq/spin-disc/pulse-ring/shimmer.
+- **T1.14** Remove `@import "shadcn/tailwind.css";` (line 3); verify nothing else depends on shadcn CSS vars.
+- **T1.15** Verify `grep -c "0.52 0.17 215\|0.55 0.2 280" src/app/globals.css` → `0`.
+- **T1.16** `pnpm biome check src/app/globals.css` → no errors.
+
+### PHASE 2 — Root layout + fonts
+- **T2.1** In `layout.tsx` add `Bricolage_Grotesque` (`variable: "--font-display"`, subsets `["latin"]`, `display: "swap"`).
+- **T2.2** Apply `inter.variable`, `jetbrainsMono.variable`, `bricolage.variable` to `<html>`.
+- **T2.3** Remove `import { Toaster } from "@/components/ui/sonner"`.
+- **T2.4** Comment out `<Toaster />` temporarily (re-enabled after T3.10).
+- **T2.5** Keep `suppressHydrationWarning`, `ThemeProvider` (defaultTheme dark, enableSystem false).
+- **T2.6** `npx tsc --noEmit` (fonts only; rest may still error until primitives exist).
+
+### PHASE 3 — Custom primitives (replace 50 shadcn ui)
+- **T3.1** `primitives/Button.tsx`: `motion.button`, variants `primary`/`ghost`/`danger`, `cn()` merge, `cursor-pointer`, `focus-visible:ring-2 ring-signal`, `whileTap` scale 0.97 gated by `useReducedMotion()`.
+- **T3.2** `primitives/Input.tsx`: native `<input>`, `bg-surface`, `rounded-[var(--r-control)]`, `mono` prop.
+- **T3.3** `primitives/Select.tsx`: native `<select>` styled, `bg-surface`.
+- **T3.4** `primitives/Dialog.tsx`: native `<dialog>` + `showModal()`, warm `::backdrop`, `AnimatePresence`, `onClose`.
+- **T3.5** `primitives/Tooltip.tsx`: CSS group-hover popover.
+- **T3.6** `primitives/Badge.tsx`: tonal pill, `variant` → `bg-{tone}/15 text-{tone}` (signal/amber/vermilion/neutral).
+- **T3.7** `primitives/Progress.tsx`: SVG track + `motion` fill, `value`/`max`, signal color.
+- **T3.8** `primitives/Avatar.tsx`: `<img>` + initials fallback, signal bg, size prop.
+- **T3.9** `primitives/Skeleton.tsx`: shimmer block (signal-tinted), `aria-hidden`.
+- **T3.10** `primitives/Toast.tsx`: `ToastProvider` context + portal, `useToast()`, motion slide-in, auto-dismiss.
+- **T3.11** `primitives/Sheet.tsx`: mobile drawer (`translate-x` spring), overlay, `open`/`onClose`.
+- **T3.12** `primitives/index.ts` re-export all 11.
+- **T3.13** Re-enable `<Toaster />` in `layout.tsx` (T2.4).
+- **T3.14** Verify `npx tsc --noEmit` on primitives; `grep -rl "@/components/ui/" src/components/primitives` → empty.
+
+### PHASE 4 — Motion foundation
+- **T4.1** `motion/variants.ts`: export `spring`, `ease`, `fadeUp`, `stagger` (per §0.1).
+- **T4.2** `motion/Stagger.tsx`: `StaggerGroup` + `StaggerItem` (`"use client"`).
+- **T4.3** `motion/RouteTransition.tsx`: `"use client"`, `usePathname`, `AnimatePresence mode="popLayout"`, reduced-motion fallback to plain `<div>`.
+- **T4.4** Verify `npx tsc --noEmit` on motion; `motion/react` import resolves.
+
+### PHASE 5 — Custom SVG charts (replace recharts)
+- **T5.1** `charts/Sparkline.tsx`: `<svg>` polyline from `points:number[]`, signal stroke, no axes.
+- **T5.2** `charts/AreaActivity.tsx`: filled `<path>` area, low-opacity signal gradient, `pathLength` draw gated by reduced-motion.
+- **T5.3** `charts/RadialGauge.tsx`: `<circle>` arc `stroke-dasharray`, center mono label.
+- **T5.4** `charts/SessionRibbon.tsx`: horizontal segments per speaker duration.
+- **T5.5** `charts/Waveform.tsx`: bars from deterministic seed, spring scaleY on hover.
+- **T5.6** Verify `npx tsc --noEmit` on charts; no `recharts` import.
+
+### PHASE 6 — Three.js foundation (lazy, guarded)
+- **T6.1** `three/WebGLGuard.tsx`: `"use client"`, detect webgl2/webgl, render `children` or `fallback`.
+- **T6.2** `three/useThreeScene.ts`: shared hook — renderer init (`dpr:[1,1.75]`, `powerPreference`), RAF with `document.hidden` pause, `dispose()` on unmount, resize observer.
+- **T6.3** `three/SignalField.tsx`: `Points` BufferGeometry (~min(900, w*h/2000)), additive blend, signal-lime, fog, idle rotation + sine drift, `activity` prop, pointer parallax. Uses `useThreeScene`.
+- **T6.4** `three/OrbField.tsx`: per-speaker `Sphere`, y-scale + ring lerp to speaking, tones signal/idle/vermilion.
+- **T6.5** `three/StaticFallback.tsx`: 2D SVG/CSS silhouette for both scenes.
+- **T6.6** Verify `grep -rl "from \"three\"" src | grep -v "components/three"` → empty; `npx tsc --noEmit` on three.
+
+### PHASE 7 — Layout shell
+- **T7.1** `layout/Spine.tsx`: `"use client"`, vertical rail from `navItems`, icon node + hairline, active signal dot + label reveal (motion spring), `max-md:` bottom tab-bar.
+- **T7.2** `layout/StatusBar.tsx`: `"use client"`, page title + WS status dot (motion pulse) + `GuildSelector` + live clock (mono) + `ThemeToggle`.
+- **T7.3** `layout/ThemeToggle.tsx`: restyle, keep `next-themes` logic, motion icon swap.
+- **T7.4** Rewrite `(dashboard)/layout.tsx`: keep SWRConfig/WsProvider/MediaPlayerProvider/ChatbotProvider + sync functions verbatim; swap `AppSidebar`→`Spine`, header→`StatusBar`, wrap children in `RouteTransition`; remove `SidebarInset`/`SidebarTrigger`/`Separator`; keep MiniPlayer+ChatbotContainer.
+- **T7.5** Delete `layout/app-sidebar.tsx`.
+- **T7.6** Verify `grep -rl "components/ui/sidebar\|app-sidebar" src` → empty; `npx tsc --noEmit`.
+
+### PHASE 8 — Dashboard page + components
+- **T8.1** Rewrite `dashboard/page.tsx`: default async `getDashboardStats`+`getActivity` → `<DashboardView>`; named `"use client"` view with useStats/useActivity, 3D hero + tickers + tabs.
+- **T8.2** Add `WebGLGuard`+`SignalField` hero with `activity` ratio; overlay headline (Bricolage) + `<RadialGauge>`.
+- **T8.3** Build asymmetric ticker row with `StaggerGroup` + 4 `.surface` blocks (mono number + label + `<Sparkline>`); inline (replaces stat-card).
+- **T8.4** Delete `dashboard/stat-card.tsx`.
+- **T8.5** Reskin `dashboard/activity-chart.tsx` → `charts/AreaActivity` (daily).
+- **T8.6** Reskin `dashboard/hourly-activity-chart.tsx` → `charts/AreaActivity` (hourly).
+- **T8.7** Reskin `dashboard/top-channels-chart.tsx` → `charts/` + `.surface`.
+- **T8.8** Reskin `dashboard/moderation-donut.tsx` → `charts/RadialGauge`.
+- **T8.9** Reskin `dashboard/users-section.tsx` → `.surface`.
+- **T8.10** Reskin `dashboard/channels-section.tsx` → `.surface`.
+- **T8.11** Reskin `dashboard/reactions-section.tsx` → `.surface`.
+- **T8.12** Verify `grep -rl "components/ui/card" src/app/\(dashboard\)/dashboard src/components/dashboard` → empty; `npx tsc --noEmit`.
+
+### PHASE 9 — Messages page + components
+- **T9.1** Rewrite `messages/page.tsx`: default `getMessages(guildId)`(+channels) → `<MessagesView>`; client spine + entries.
+- **T9.2** Delete `messages/message-card.tsx`.
+- **T9.3** Rewrite `messages/message-list.tsx`: left timeline spine + right severity-tick entries (`surface` + `border-l-2` lime/amber/vermilion, motion spring tick), `layout` reflow.
+- **T9.4** Rewrite `messages/message-detail.tsx` → `.surface`.
+- **T9.5** Rewrite `messages/message-detail-view.tsx` → `.surface` pane.
+- **T9.6** Rewrite `messages/ai-status-badge.tsx` → `primitives/Badge`.
+- **T9.7** Rewrite `messages/ai-analysis-panel.tsx` → `.surface`.
+- **T9.8** Rewrite `messages/attachments-grid.tsx` → `.surface` grid.
+- **T9.9** Rewrite `messages/lightbox.tsx` → `primitives/Dialog`.
+- **T9.10** Rewrite `messages/search-overlay.tsx` → console palette, type-in animation, `primitives/Dialog`.
+- **T9.11** Verify no `components/ui/card` in messages tree; `npx tsc --noEmit`.
+
+### PHASE 10 — Voice page + components
+- **T10.1** Rewrite `voice/page.tsx`: default `getVoiceStatus()` → `<VoiceView>`; client `WebGLGuard`+`OrbField` hero + ribbon + tabs.
+- **T10.2** Delete `voice/voice-connection-card.tsx`, `connection-card.tsx`, `microphone-card.tsx`.
+- **T10.3** Rewrite `voice/speaker-waveform.tsx` → SVG ring / eq bars.
+- **T10.4** Rewrite `voice/active-speakers-panel.tsx` → `.surface`.
+- **T10.5** Rewrite `voice/activity-timeline.tsx` → `charts/SessionRibbon`.
+- **T10.6** Rewrite `voice/mic-control.tsx` → `primitives/Button`.
+- **T10.7** Rewrite `voice/listen-control.tsx` → `primitives/Button`.
+- **T10.8** Verify `npx tsc --noEmit`; no `components/ui/card` in voice tree.
+
+### PHASE 11 — Media page + components
+- **T11.1** Rewrite `media/page.tsx`: default `getMediaStatus()` → `<MediaView>`; client turntable disc + transport + queue.
+- **T11.2** Rewrite `media/music-player.tsx`: CSS-3D disc (spin-disc, pause when not playing, spring on play/pause), mono meta, `primitives/Button` transport, `.surface` queue rows with `layout`.
+- **T11.3** Rewrite `media/mini-player.tsx` → compact `.surface`.
+- **T11.4** Verify `npx tsc --noEmit`; no `components/ui/card` in media tree.
+
+### PHASE 12 — Recordings page + components
+- **T12.1** Rewrite `recordings/page.tsx`: default `getRecordings(50)` → `<RecordingsView>`; client rows `AnimatePresence`+`layout`, live `voice_recording_uploaded` prepend.
+- **T12.2** Delete `recordings/recording-card.tsx`.
+- **T12.3** Rewrite `recordings/recording-player.tsx` → `.surface` row + `charts/Waveform` + `primitives/Button`/`Dialog` play/delete.
+- **T12.4** Verify `npx tsc --noEmit`.
+
+### PHASE 13 — Moderation + Analysis pages
+- **T13.1** Rewrite `moderation/page.tsx`: default `getModerationStats/Actions` → `<ModerationView>`; client vertical event-flow, live actions pulse-in.
+- **T13.2** Rewrite `moderation/moderation-section.tsx` → event-flow, no Card/table.
+- **T13.3** Rewrite `analysis/page.tsx`: client `<AnalysisView/>` terminal console (`primitives/Input` mono + blinking caret, `.surface` results staggered).
+- **T13.4** Rewrite `analysis/search-panel.tsx` → terminal style.
+- **T13.5** Verify `npx tsc --noEmit`.
+
+### PHASE 14 — Chatbot + shared + final cleanup
+- **T14.1** Rewrite `chatbot/chatbot-container.tsx` → `.surface`, keep drag/minimize.
+- **T14.2** Rewrite `chatbot/chat-panel.tsx` → bubbles via `AnimatePresence`, `primitives/*`.
+- **T14.3** Keep `chatbot/chatbot-context.tsx` + `index.ts`.
+- **T14.4** Rewrite `shared/empty-state.tsx` → tonal.
+- **T14.5** Rewrite `shared/error-state.tsx`.
+- **T14.6** Rewrite `shared/loading-skeleton.tsx` → `primitives/Skeleton`.
+- **T14.7** Rewrite `shared/error-boundary.tsx`.
+- **T14.8** Rewrite `shared/guild-selector.tsx` → `primitives/Select`.
+- **T14.9** `rm -rf src/components/ui && rm -f components.json`.
+- **T14.10** `grep -rn "components/ui/\|@shadcn\|@base-ui\|recharts" src` → MUST be empty.
+- **T14.11** `grep -rl "from \"recharts\"\|@base-ui\|@shadcn" src` → empty (double-check).
+- **T14.12** Verify `npx tsc --noEmit` across whole `src`.
+
+### PHASE 15 — Build + lint gate
+- **T15.1** `cd services/frontend && npx tsc --noEmit` → 0 errors.
+- **T15.2** `pnpm biome check` → fix all issues (no `any` in new files).
+- **T15.3** `pnpm build` (standalone) → success, emits `.next/standalone/server.js`.
+- **T15.4** Inspect `.next/static/chunks/` for three-heavy chunk loaded only on dashboard/voice; confirm NOT in `/dashboard/` initial SSR HTML.
+- **T15.5** Confirm `pnpm-lock.yaml` present (reproducible flake install).
+- **T15.6** `grep -c "0.52 0.17 215\|0.55 0.2 280" .next/static/css/*.css` → 0.
+
+### PHASE 16 — Local runtime smoke test (no prod)
+- **T16.1** Start local standalone: `GMW_BACKEND_URL=http://127.0.0.1:4001 PORT=4017 node .next/standalone/server.js &`.
+- **T16.2** `curl -s -o /dev/null -w "%{http_code}"` for all 7 routes → 200.
+- **T16.3** `curl /dashboard/ | grep -o "Bricolage\|signal\|surface"` → present.
+- **T16.4** `curl /_next/static/css/*.css | grep "0.52 0.17 215\|0.55 0.2 280"` → empty.
+- **T16.5** Headless browser `/dashboard/`+`/voice/` WebGL on: no console errors, `<canvas>` present, `<StaticFallback/>` NOT rendered.
+- **T16.6** Same pages WebGL off: `<StaticFallback/>` renders, no crash.
+- **T16.7** Kill local server. Do NOT touch prod unit.
+- **T16.8** Confirm 7 routes 200 + no console errors in T16.5/16.6.
+
+### PHASE 17 — Flake + staging deploy
+- **T17.1** Inspect `flake.nix` frontend drv: `filterSource` ignores `out/.next/node_modules`; `pnpm-lock.yaml` included.
+- **T17.2** `nix build .#gmw-frontend --impure --sandbox-off` → succeeds.
+- **T17.3** `nix copy` frontend drv to VPS into staging profile (test port e.g. 4217).
+- **T17.4** Create/adjust staging systemd unit with `PORT=4217` exported BEFORE `node server.js` (LIDM PORT bug).
+- **T17.5** `sudo systemctl restart gmw-frontend-staging`; `curl` staging → 200.
+- **T17.6** Browser-check staging `/dashboard/`+`/voice/` (3D visible, fallback test).
+- **T17.7** Verify staging CSS has no old teal/purple; new design renders.
+
+### PHASE 18 — Production swap (CONFIRM WITH USER FIRST)
+- **T18.1** STOP — send staging screenshots/URL; await explicit approval before touching prod.
+- **T18.2** On approval: `nix-env --profile /nix/var/nix/profiles/gmw-frontend --set <new-drv>`.
+- **T18.3** Confirm `gmw-frontend.service` exports `PORT=4017` before exec.
+- **T18.4** `sudo systemctl restart gmw-frontend`.
+- **T18.5** `curl` all 7 routes on `https://imphnen.asepharyana.my.id` → 200.
+- **T18.6** Browser verify prod: new design, old teal gone, 3D scenes render.
+- **T18.7** `journalctl -u gmw-frontend -f` 5 min; confirm WS reconnect + live features.
+- **T18.8** Notify user with before/after notes; keep rollback plan (`nix-env --set <previous>; systemctl restart`).
+
+---
+
+## Risks / Trade-offs
+- **Scope:** 7 pages + charts + primitives + motion + 2 three scenes + layout. Big but mechanical; each task is isolated (~90 atomic tasks).
+- **Bundle weight:** `three` adds ~150KB gz but ONLY on dashboard/voice routes (lazy chunk, `ssr:false`). `motion` ~35KB gz app-wide — acceptable.
+- **WebGL compatibility:** covered by `WebGLGuard` + static fallback. Old devices / strict privacy browsers never blank.
+- **Motion excess:** risk of "AI-generated" scattered animation. Guard: one signature moment per page, shared variants, reduced-motion gates.
+- **Feature regressions:** Voice PCM playback, media transport, chatbot drag — logic preserved, only skin changes. Smoke test (T16) catches SSR breaks; live WS/3D needs real backend (staging T17).
+- **Removed deps:** dropping `recharts`/`sonner`/`cmdk` means rewriting charts + toasts + search palette — accounted for in Phases 3/5/9.
+- **Next standalone PORT bug:** `server.js` may not read `PORT` — ensure unit exports `PORT=4017` before exec (T17.4/T18.3).
+- **three + React 19:** raw three avoids R3F compat surface; lifecycle (dispose + RAF) handled in T6.2.
+- **next-themes:** keep (light/dark toggle); default dark.
+
+## Open questions (answer before T18)
+- Q1: Deploy to prod now or staging-only first? (Recommend staging + screenshot review.)
+- Q2: Keep `react-day-picker`/`embla` if any page still needs them? (Plan assumes no — verify in T14.10 grep.)
+- Q3: Any brand name/wordmark change from "Discord Automod"? (Keep "Bete" identity unless told.)
+- Q4: 3D depth — full 3D scenes on dashboard+voice as specced, or also a 3D accent on media (disc)? (Default: dashboard+voice only; media disc stays CSS 3D.)

biome.json

@@ -35,12 +35,15 @@
       "suspicious": {
         "noUnknownAtRules": "off",
         "useIterableCallbackReturn": "off",
-        "noArrayIndexKey": "warn"
+        "noArrayIndexKey": "off",
+        "noExplicitAny": "off"
       },
       "a11y": {
         "useSemanticElements": "off",
         "useButtonType": "off",
-        "noAutofocus": "off"
+        "noAutofocus": "off",
+        "useMediaCaption": "off",
+        "noStaticElementInteractions": "off"
       },
       "performance": {
         "noImgElement": "warn"
@@ -50,7 +53,10 @@
       },
       "correctness": {
         "noInvalidUseBeforeDeclaration": "off",
-        "noUnusedFunctionParameters": "warn"
+        "noUnusedFunctionParameters": "warn",
+        "noUnusedVariables": "warn",
+        "noUnusedImports": "warn",
+        "noUnusedPrivateClassMembers": "warn"
       }
     },
     "domains": {

flake.nix

@@ -11,11 +11,6 @@
       let
         pkgs = import nixpkgs { inherit system; };
 
-        # libdatachannel for the GoLive N-API binding. nixpkgs 0.24.1 is built
-        # against this host's glibc and ships both lib + dev headers, so the
-        # binding links cleanly inside the Nix sandbox (no manual cmake build).
-        libdatachannel = pkgs.libdatachannel;
-
         # Source filter: `path:` literals do NOT respect .gitignore by default,
         # so a dirty local out/ (stale chunks from previous builds) leaks into
         # the sandbox. Filter out build artifacts explicitly.
@@ -53,8 +48,8 @@
           export GIT_SSL_CAINFO=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
           export NIX_SSL_CERT_FILE=${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt
 
-          # pnpm uses node-gyp for native addons — provide build tools
-          export npm_config_build_from_source=true
+          # pnpm uses node-gyp for native addons — provide build tools (kept for
+          # the rare case a prebuilt is unavailable and it falls back to compile).
           export CPPFLAGS="-I${pkgs.lib.getDev pkgs.openssl}/include"
           export LDFLAGS="-L${pkgs.lib.getLib pkgs.openssl}/lib"
 
@@ -73,7 +68,7 @@
         # NOTE: do NOT use `pnpm install --prod` here — it collapses the
         # public-hoist dir (.pnpm/node_modules) that runtime peer resolution
         # relies on (e.g. @lng2004/node-datachannel and @seydx/node-av-linux-x64
-        # are only reachable through it), silently breaking voice/screenshare.
+        # are only reachable through it), silently breaking voice.
         # Instead we keep the full install's symlink layout and only prune
         # orphaned package dirs + broken symlinks.
         # Must run AFTER tsc (typescript is a devDep) and after native builds.
@@ -167,8 +162,7 @@ WRAPPER
             pkgs.pkg-config
             pkgs.openssl
             pkgs.openssl.dev
-            libdatachannel.dev # rtc/rtc.hpp headers for the GoLive binding
-            pkgs.git # libdatachannel FetchContent clones from GitHub
+            pkgs.git # for any FetchContent-based deps during native builds
             pkgs.cacert
           ];
 
@@ -181,38 +175,31 @@ WRAPPER
           # do NOT let stdenv run its own cmake configure phase on the source.
           dontUseCmakeConfigure = true;
 
+          # The gateway bundles native node_modules (.node addons plus .o/.a
+          # object files left in prebuilt dirs). stdenv's fixupPhase walks
+          # $out/node_modules and runs patchELF + shrinkELF over every ELF it
+          # finds, choking on the non-ET_DYN files (.o/.a) and the prebuilt
+          # .node addons — emitting hundreds of harmless "patchelf: wrong ELF
+          # type" lines per build. The real binary is node (external, already
+          # RPATH-fixed in its own derivation) and the .node addons are
+          # self-contained prebuilts loaded via dlopen, so Nix's fixup pass is
+          # neither needed nor wanted here. Skip it entirely.
+          dontFixup = true;
+
           buildPhase = pnpmInstall + ''
             echo "=== Building native voice deps ==="
             # pnpm rebuild aborts on the first failing package and runs scripts
             # from the wrong cwd — build each native dep explicitly with its own
             # install script. Each failure is tolerated (|| true); the packages
-            # that matter (opus) are verified at runtime.
-            for pkg in \
-              node_modules/.pnpm/@discordjs+opus@*/node_modules/@discordjs/opus
-            do
-              if [ -d "$pkg" ]; then
-                echo "--- native build: $pkg ---"
-                (cd "$pkg" && npm run install 2>&1 || true)
-              fi
-            done
-            echo "=== Building libdatachannel-min N-API binding ==="
-            # The GoLive screen-share stack uses a minimal N-API binding
-            # (native/libdatachannel-min) over nixpkgs libdatachannel.
-            (
-              cd native/libdatachannel-min
-              # binding.gyp resolves include/lib from env (LDC_INCLUDE = .dev
-              # include root, LDC_LIB = lib output dir, NAPI_INCLUDE =
-              # node-addon-api include root).
-              NAPI_INCLUDE=$(find ../../node_modules/.pnpm -maxdepth 3 \
-                -type d -path "*node_modules/node-addon-api" | head -1)
-              echo "NAPI_INCLUDE=$NAPI_INCLUDE"
-              LDC_INCLUDE=${libdatachannel.dev} LDC_LIB=${libdatachannel.out}/lib/libdatachannel.so.0.24.1 \
-                NAPI_INCLUDE=$NAPI_INCLUDE \
-                npx node-gyp rebuild 2>&1 || true
-              ls -la build/Release/datachannel_min.node 2>/dev/null \
-                && echo "libdatachannel-min binding OK: $(stat -c%s build/Release/datachannel_min.node) bytes" \
-                || echo "WARN: libdatachannel-min binding build FAILED (screen share disabled)"
-            )
+            # @discordjs/opus ships prebuilt binaries for Node 22 (ABI node-v127,
+            # linux-x64-glibc-2.35) — node-pre-gyp downloads the prebuilt .node
+            # instead of compiling C++ from source. With build_from_source unset
+            # (above), `pnpm rebuild` runs the package's own install script which
+            # fetches the matching prebuilt; it only falls back to a source build
+            # if the download fails. This keeps voice working without a per-build
+            # native compile.
+            echo "=== Rebuilding @discordjs/opus (prebuilt download) ==="
+            pnpm rebuild @discordjs/opus 2>&1 || true
             echo "=== Compiling TypeScript ===="
             npx tsc 2>&1
             echo "=== Fixing @/ path aliases to relative paths ==="
@@ -247,22 +234,6 @@ WRAPPER
             mkdir -p $out/lib/gmw-discord-gateway
             cp -r dist node_modules package.json tsconfig.json $out/lib/gmw-discord-gateway/
 
-            # GoLive native binding — loadNative resolves it relative to
-            # dist/goLive/native.js, i.e. <root>/native/libdatachannel-min/
-            # build/Release/datachannel_min.node; libdatachannel .so must sit
-            # next to it and be on LD_LIBRARY_PATH at runtime.
-            mkdir -p $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release
-            cp native/libdatachannel-min/build/Release/datachannel_min.node \
-              $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release/ 2>/dev/null || true
-            mkdir -p $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/ldc
-            cp -rL native/libdatachannel-min/build/ldc/libdatachannel.so* \
-              $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/ldc/ 2>/dev/null || true
-            # If the binding failed to build, screen share is simply disabled —
-            # the gateway itself must still start.
-            if [ ! -f $out/lib/gmw-discord-gateway/native/libdatachannel-min/build/Release/datachannel_min.node ]; then
-              echo "WARN: datachannel_min.node missing — GoLive screen share disabled in this build"
-            fi
-
             # Also include drizzle migrations if they exist
             cp -r drizzle $out/lib/gmw-discord-gateway/ 2>/dev/null || true
 
@@ -271,7 +242,6 @@ WRAPPER
 #!${pkgs.runtimeShell}
 cd $out/lib/gmw-discord-gateway
 export PATH=${pkgs.ffmpeg-headless}/bin:${pkgs.yt-dlp}/bin:\$PATH
-export LD_LIBRARY_PATH=${libdatachannel.out}/lib:\$LD_LIBRARY_PATH
 exec ${nodejs}/bin/node dist/index.js
 WRAPPER
             chmod +x $out/bin/gmw-discord-gateway

scripts/add-ai-analysis-duration.sql

@@ -0,0 +1,10 @@
+-- Migration: add ai_analysis_duration_ms to messages
+-- Tracks how long the AI moderation LLM call took, per message (ms).
+-- Idempotent: safe to re-run.
+--
+-- Run against the production GMW database, e.g.:
+--   PGPASSWORD=*** psql -h 100.121.180.82 -p 6432 -U asephs -d dcbot \
+--     -f scripts/add-ai-analysis-duration.sql
+
+ALTER TABLE "messages"
+  ADD COLUMN IF NOT EXISTS "ai_analysis_duration_ms" BIGINT;

services/backend/src/modules/messages/messages.repository.ts

@@ -77,12 +77,11 @@ export class MessagesRepository {
 
     // Exclude spam threads (NULL-safe: non-thread messages are kept)
     if (EXCLUDED_THREAD_IDS.length > 0) {
-      conditions.push(
-        or(
-          isNull(pgMessagesTable.thread_id),
-          notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
-        )!,
+      const excludeThreads = or(
+        isNull(pgMessagesTable.thread_id),
+        notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
       );
+      if (excludeThreads) conditions.push(excludeThreads);
     }
 
     const where = conditions.length > 0 ? and(...conditions) : undefined;
@@ -150,12 +149,11 @@ export class MessagesRepository {
 
     // Exclude spam threads (NULL-safe)
     if (EXCLUDED_THREAD_IDS.length > 0) {
-      conditions.push(
-        or(
-          isNull(pgMessagesTable.thread_id),
-          notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
-        )!,
+      const excludeThreads = or(
+        isNull(pgMessagesTable.thread_id),
+        notInArray(pgMessagesTable.thread_id, EXCLUDED_THREAD_IDS),
       );
+      if (excludeThreads) conditions.push(excludeThreads);
     }
 
     const rows = await db
@@ -316,12 +314,13 @@ export class MessagesRepository {
           like(pgAttachmentsTable.type, "image/%"),
           // Exclude spam threads (NULL-safe for non-thread messages)
           ...(EXCLUDED_THREAD_IDS.length > 0
-            ? [
-                or(
+            ? (() => {
+                const excludeThreads = or(
                   isNull(pgAttachmentsTable.thread_id),
                   notInArray(pgAttachmentsTable.thread_id, EXCLUDED_THREAD_IDS),
-                )!,
-              ]
+                );
+                return excludeThreads ? [excludeThreads] : [];
+              })()
             : []),
         ),
       )

services/backend/src/shared/database/schema.ts

@@ -62,6 +62,9 @@ export const pgMessagesTable = pgTable(
       enum: ["none", "monitor", "warn", "review", "delete", "escalate"],
     }),
     ai_analyzed_at: pgBigint("ai_analyzed_at", { mode: "number" }),
+    ai_analysis_duration_ms: pgBigint("ai_analysis_duration_ms", {
+      mode: "number",
+    }),
     ai_error: pgText("ai_error"),
   },
   (table) => ({

services/backend/src/shared/moderation-types.ts

@@ -80,6 +80,7 @@ export interface MessageRecord {
   ai_confidence?: number | null;
   ai_recommended_action?: AIRecommendedAction | null;
   ai_analyzed_at?: number | null;
+  ai_analysis_duration_ms?: number | null;
   ai_error?: string | null;
 }
 

services/backend/src/shared/utils/index.ts

@@ -108,5 +108,5 @@ export async function retryWithBackoff<T>(
       });
     }
   }
-  throw lastError!;
+  throw lastError ?? new Error("Request failed after all retries");
 }

services/backend/src/shared/utils/messageMapper.ts

@@ -24,6 +24,7 @@ export interface MappedMessage {
   ai_confidence: number | null;
   ai_recommended_action: string | null;
   ai_analyzed_at: number | null;
+  ai_analysis_duration_ms: number | null;
   ai_error: string | null;
   is_reply: boolean | null;
   is_forward: boolean | null;
@@ -58,6 +59,8 @@ export function mapMessageRow(row: Record<string, unknown>): MappedMessage {
     ai_confidence: (row.ai_confidence as number | null) ?? null,
     ai_recommended_action: (row.ai_recommended_action as string | null) ?? null,
     ai_analyzed_at: (row.ai_analyzed_at as number | null) ?? null,
+    ai_analysis_duration_ms:
+      (row.ai_analysis_duration_ms as number | null) ?? null,
     ai_error: (row.ai_error as string | null) ?? null,
     is_reply: row.is_reply === null ? null : Boolean(row.is_reply),
     is_forward: row.is_forward === null ? null : Boolean(row.is_forward),

services/discord-gateway/ARCHITECTURE.md

@@ -1,172 +1,143 @@
+# Discord Gateway — Architecture
+
+Pure event-driven microservice (no HTTP server). Captures Discord
+messages/voice/attachments/reactions/threads/presence, runs LLM-based AI
+moderation, and publishes everything to Redis pub/sub for the backend to
+consume. The backend serves the HTTP/WS API to the frontend.
+
+> NOTE: this doc is the source of truth for the module layout. The older
+> `MODULE_STRUCTURE.md` was stale (referenced `winston`, `mock-crc.ts`,
+> `indonesianTextNormalizer.ts`, and `aiAnalysisWorker.ts`/`llmModerationClient.ts`
+> which were renamed/merged). If they disagree, this file wins.
+
+## Top-level layout
+
+```
 services/discord-gateway/
 ├── src/
+│   ├── index.ts                     # Entry point → initializeDiscordGateway()
 │   ├── app/
-│   │   ├── bootstrap.ts          # Discord Gateway initialization (no HTTP server)
-│   │   └── shutdown.ts           # Graceful shutdown handler
+│   │   ├── bootstrap.ts             # Wires client, DB, Redis, workers, schedulers
+│   │   ├── shutdown.ts              # Graceful shutdown (SIGINT/SIGTERM + transient errors)
+│   │   └── retention.ts             # Expired-record cleanup scheduler
 │   ├── shared/
-│   │   ├── config/
-│   │   │   └── config.ts         # Environment configuration (Zod validated)
-│   │   ├── database/
-│   │   │   ├── schema.ts         # Drizzle ORM schema
-│   │   │   ├── drizzle.ts        # Database connection
-│   │   │   ├── migrate.ts        # Migration runner
-│   │   │   └── voiceRecordingRepo.ts
-│   │   ├── errors/
-│   │   │   └── errors.ts         # Custom error classes
-│   │   ├── logger/
-│   │   │   ├── logger.ts         # Winston logger wrapper
-│   │   │   └── serialization.ts  # Log value serialization
-│   │   ├── utils/
-│   │   │   └── retry.ts          # Retry with backoff utility
-│   │   └── discord/
-│   │       └── clientOptions.ts  # Discord.js client configuration
-│   ├── modules/
-│   │   ├── message-capture/      # Modular MVC: Message capture & storage
-│   │   │   ├── messageCapture.ts # Controller: Discord event listeners
-│   │   │   ├── messageStore.ts   # Repository: Database operations
-│   │   │   ├── messageMetadata.ts # Service: Message metadata extraction
-│   │   │   ├── types.ts          # Domain types
-│   │   │   └── index.ts          # Module exports
-│   │   ├── ai-moderation/        # Modular MVC: AI analysis & moderation
-│   │   │   ├── aiAnalyzer.ts     # Controller: Analysis orchestration
-│   │   │   ├── llmModerationClient.ts # Service: LLM API client
-│   │   │   ├── aiAnalysisWorker.ts # Service: Worker pool management
-│   │   │   ├── indonesianTextNormalizer.ts # Service: Text normalization
-│   │   │   ├── moderationPrompt.ts # Service: Prompt generation
-│   │   │   └── index.ts          # Module exports
-│   │   ├── voice-recording/      # Modular MVC: Voice recording & streaming
-│   │   │   ├── voiceController.ts # Controller: Voice connection management
-│   │   │   ├── recorder.ts       # Service: Recording orchestration
-│   │   │   ├── recorder/
-│   │   │   │   ├── audioStream.ts # Service: Audio stream subscription
-│   │   │   │   ├── decoder.ts    # Service: Opus decoding
-│   │   │   │   ├── segment.ts    # Service: OGG segment rotation
-│   │   │   │   ├── metadata.ts   # Service: Segment metadata
-│   │   │   │   ├── sessionRecording.ts # Service: Session management
-│   │   │   │   └── uploader.ts   # Service: Segment upload
-│   │   │   └── index.ts          # Module exports
-│   │   ├── attachment-upload/    # Modular MVC: Attachment handling
-│   │   │   ├── attachmentUploader.ts # Service: Upload orchestration
-│   │   │   ├── imageResizer.ts   # Service: Image resizing
-│   │   │   └── index.ts          # Module exports
-│   │   └── event-broadcaster/    # Event-driven: Redis pub/sub
-│   │       ├── eventBroadcaster.ts # Service: Event publishing
-│   │       ├── eventTypes.ts     # Domain: Event type definitions
-│   │       └── index.ts          # Module exports
-│   ├── mock-crc.ts               # CRC polyfill for discord.js
-│   └── index.ts                  # Service entry point
-├── package.json                  # Service dependencies
-└── tsconfig.json                 # TypeScript configuration
+│   │   ├── config/                  # Zod-validated env (index.ts = schema+loader)
+│   │   ├── database/                # Drizzle ORM + pg Pool + migrations
+│   │   │   ├── init.ts drizzle.ts pool.ts migrate.ts migrateCli.ts
+│   │   │   └── schema/              # messages, cache, voice, analytics, meta
+│   │   ├── logger/                  # pino wrapper + createChildLogger()
+│   │   ├── errors/                  # AppError / ConfigError / AudioError ...
+│   │   ├── utils/                   # retry, pagination
+│   │   ├── discord/clientOptions.ts # discord.js-selfbot-v13 client options
+│   │   ├── uploader.ts              # Shared attachment upload helper
+│   │   ├── redis-channels.ts        # Redis channel-name constants
+│   │   └── moderation-types.ts      # Shared AI analysis domain types
+│   └── modules/
+│       ├── message-capture/         # Discord event listeners + DB store
+│       ├── ai-moderation/           # LLM moderation pipeline (see below)
+│       ├── voice-recording/         # Voice connect + Opus→OGG recording
+│       │   └── recorder/            # decoder, segment, session, uploader, oggCrc
+│       ├── voice-pcm-ws/            # Real-time PCM → backend WebSocket (bypasses Redis)
+│       ├── attachment-upload/       # Download + (sharp) resize + upload
+│       ├── event-broadcaster/        # RedisEventPublisher + EventBroadcaster
+│       ├── command-handler/         # Redis-subscribed backend→gateway commands
+│       ├── reaction-tracking/ thread-tracking/ user-presence/
+│       ├── channel-topic/ guild-member-events/
+│       └── gateway-metrics/         # Prometheus /metrics endpoint (port 4016)
+```
 
-## Architecture Patterns
+## AI moderation pipeline (`ai-moderation/`)
 
-### Modular MVC Structure
-Each module follows Controller-Service-Repository pattern:
-- **Controller**: Discord event listeners (messageCapture, aiAnalyzer, voiceController)
-- **Service**: Business logic (messageStore, llmModerationClient, recorder)
-- **Repository**: Data access (messageStore, voiceRecordingRepo)
+LLM-only judge — no regex/heuristic classification. One orchestrator call
+handles a whole batch (text + media split internally, parallel paths).
 
-### Event-Driven Design
-- **Redis Pub/Sub**: All events published to Redis channels
-- **Event Channels**:
-  - `discord:message:created` — New message captured
-  - `discord:message:updated` — Message edited
-  - `discord:message:deleted` — Message deleted
-  - `discord:message:analyzed` — AI analysis complete
-  - `discord:attachment:created` — Attachment detected
-  - `discord:attachment:uploaded` — Attachment uploaded to storage
-  - `discord:voice:started` — Voice recording started
-  - `discord:voice:stopped` — Voice recording stopped
-  - `discord:voice:uploaded` — Voice segment uploaded
-  - `discord:analysis:queue_status` — Analysis queue status update
+- `aiAnalyzer.ts` — public API: `queueMessageAnalysis`, `getAnalysisQueueStatus`,
+  `startPendingAIAnalysisWorker` (recovery worker + cache-prune).
+- `batchScheduler.ts` — per-conversation debounce → `processBatch`.
+- `batchProcessor.ts` — batch lock/circuit-breaker, fans failed targets to
+  individual fallback.
+- `individualFallbackProcessor.ts` — one-message-at-a-time retry path, own CB.
+- `conversationState.ts` / `circuitBreaker.ts` — per-conversation state,
+  Piscina `workerPool`, `getConversationKey`.
+- `ai-analysis-worker.ts` — Piscina entry point (`batch` / `individual` jobs).
+  Runs `runModerationAnalysis` off the main thread.
+- `moderationOrchestrator.ts` — exact-hash cache → batched semantic (Qdrant)
+  cache → LLM. Text and media paths run in parallel.
+- `textBatchProcessor.ts` / `mediaBatchProcessor.ts` — actual LLM calls
+  (one call per sub-batch, not per message).
+- `llmClient.ts` — central OpenAI-compatible chat client (streaming, retries,
+  thinking-disable injection). `visionAnalyzer.ts` / `mediaAnalysisClient.ts`
+  share the same router/base URL (different model alias for vision).
+- `embeddingClient.ts` + `qdrantClient.ts` — semantic cache (one embed call +
+  one batched Qdrant search for all uncached targets).
+- `textCacheStore.ts` / `channelCultureStore.ts` / `userProfileStore.ts` /
+  `userReputationStore.ts` — caches & learned per-channel/user state.
 
-### Shared Infrastructure
-- **Config**: Zod-validated environment variables
-- **Logger**: Winston logger with context support
-- **Database**: Drizzle ORM with PostgreSQL
-- **Errors**: Custom error classes with codes and status codes
-- **Utils**: Retry logic with exponential backoff
+### Concurrency model
 
-### No HTTP Server
-- Discord Gateway service is **event-driven only**
-- No Express, WebSocket, or HTTP routes
-- All communication via Redis pub/sub
-- Backend service consumes events and serves HTTP API
+- Main thread owns the LLM semaphore (`AI_LLM_MAX_CONCURRENT`, default 5) via
+  `llmClient.withLlmConcurrency`.
+- Piscina pool (`PISCINA_MAX_THREADS`, default 4) runs the heavy LLM work off
+  the event loop; **each worker thread initializes its own pg Pool** (min 0,
+  grows to `POSTGRES_POOL_MAX`). See "Memory & connections" below.
 
-## Initialization Flow
+## Memory & DB connections
 
-1. Load environment config (Zod validation)
-2. Initialize database connection
-3. Run pending migrations
-4. Create Discord client with optimized cache settings
-5. Initialize Redis event broadcaster
-6. Register Discord event listeners (messageCapture, aiAnalyzer)
-7. Login to Discord
-8. Listen for graceful shutdown signals (SIGINT, SIGTERM)
+`MemoryMax=1G` (raised from 512M — live RSS sits at ~500 MiB, peak 508 MiB,
+so 512M left ~2% headroom and risked an OOM-kill restart). Host has 8 GB free.
 
-## Graceful Shutdown
+`POSTGRES_POOL_MIN=0` (default). The gateway = main process + up to 4 Piscina
+worker threads, each with its own pg Pool. With min:0 the pools stay empty
+until a query runs and drop idle clients afterward, instead of holding
+`(1 main + 4 workers) × 2 = 10` permanently-open idle connections against
+PgBouncer. The pool still grows on demand up to `POSTGRES_POOL_MAX`.
 
-On shutdown signal:
-1. Close database connection
-2. Disconnect from voice channels
-3. Close Redis connection
-4. Destroy Discord client
-5. Exit process
+## Event channels (Redis pub/sub)
 
-## Dependencies
+`discord:message:{created,updated,deleted,analyzed}`,
+`discord:attachment:{created,uploaded}`,
+`discord:voice:{started,stopped,uploaded,active_user,pcm,analyzed}`,
+`discord:analysis:queue_status`,
+`discord:reaction:{added,removed}`,
+`discord:thread:{created,deleted,updated}`,
+`discord:channel_topic:updated`,
+`discord:presence:updated`,
+`discord:guild_member:{added,removed}`.
+See `src/shared/redis-channels.ts` for the canonical names.
 
-**Core Discord**:
-- discord.js-selfbot-v13
-- @discordjs/voice
-- @discordjs/opus
+## Initialization flow
 
-**Audio Processing**:
-- prism-media (Opus encoding/decoding)
-- opusscript (Opus fallback)
-- sharp (Image resizing)
+1. Validate env (Zod). Refuse to start if `AI_ANALYSIS_ENABLED` but no key.
+2. `AUTO_MIGRATE_ON_STARTUP` → run pending Drizzle migrations.
+3. `initializeDatabase()` (pg Pool, min 0).
+4. Create discord.js-selfbot-v13 client; register listeners on `ready`.
+5. Start `gmw-discord-gateway` metrics server (port `METRICS_PORT`, default 4016).
+6. `client.login(token)`.
 
-**Data & Config**:
-- drizzle-orm (ORM)
-- pg (PostgreSQL driver)
-- zod (Config validation)
-- ioredis (Redis client)
+## Graceful shutdown
 
-**Logging & Utilities**:
-- winston (Structured logging)
-- p-retry (Retry logic)
-- p-limit (Concurrency limiting)
-- piscina (Worker pool)
+`SIGINT`/`SIGTERM` (and uncaught transient stream errors: EPIPE / ECONNRESET /
+ERR_STREAM_DESTROYED / ERR_STREAM_WRITE_AFTER_END are treated as non-fatal):
+stop metrics → stop muxer → disconnect voice → close PCM WS → close Redis →
+close command handler → close DB → destroy client → exit.
 
-## Event Flow Example
+## Observability
 
-### Message Capture Flow
-1. Discord emits `messageCreate` event
-2. `messageCapture.ts` listener receives event
-3. Extract metadata (user, channel, content, timestamp)
-4. `messageStore.ts` inserts into database
-5. `eventBroadcaster.messageCreated()` publishes to Redis
-6. Backend service subscribes to `discord:message:created` channel
-7. Backend processes and stores in its own database
+Prometheus scrapes `127.0.0.1:4016/metrics` (`bete_*` prefix). Collectors run
+per-scrape and expose: process memory/uptime, and (when AI analysis is on) live
+pipeline gauges — `ai_analysis_queued_conversations`,
+`ai_analysis_active_batch_requests`, `ai_analysis_active_individual_requests`,
+`ai_analysis_individual_in_flight`, `ai_analysis_individual_circuit_breaker_active`,
+`ai_analysis_worker_threads`, `ai_analysis_worker_threads_active`.
 
-### Voice Recording Flow
-1. `voiceController.connect()` joins voice channel
-2. `recorder.ts` subscribes to user audio streams
-3. For each speaking user:
-   - Create audio stream subscription
-   - Decode Opus packets to PCM
-   - Rotate OGG segments (5s default)
-   - Collect user metadata
-4. On silence (3s):
-   - Finalize segment
-   - Create metadata JSON
-   - Upload segment to storage
-   - Publish `discord:voice:uploaded` event
-5. Backend service receives event and indexes recording
+## Key invariants (do not break)
 
-## No Breaking Changes
-
-- Original `src/` remains untouched for now
-- Discord Gateway is a **new service** in `services/discord-gateway/`
-- Can run alongside existing monolith during transition
-- Backend service will consume Redis events
-- Frontend continues to use Backend HTTP API
+- **LLM is the only judge.** Failed LLM → `status:"error"` + recovery retry.
+  Never reintroduce regex/heuristic content classification.
+- **Discord tokens are sanitized** (`discordTokens.ts`: `<:emoji:id>` →
+  `[emoji:name]`, `<@id>` → `@user`, etc.) before content reaches the LLM, so
+  numeric snowflake IDs never trigger false positives.
+- **Semantic cache is batched** (one embed call + one Qdrant batch search),
+  not N sequential round-trips. `ensureQdrantCollection` is memoized.
+- **Streaming is mandatory** against the 9router base URL (non-stream waits for
+  the full body and times out). `llmClient` aggregates SSE chunks.

services/discord-gateway/MODULE_STRUCTURE.md

@@ -1,408 +1,80 @@
-# Discord Gateway Service - Module Structure
+# Discord Gateway Service — Module Structure
 
-## Complete Directory Tree
+> Kept as a compact module map. For the authoritative layout, design
+> decisions, and invariants, see `ARCHITECTURE.md`. This file was rewritten
+> on 2026-08-16 to fix stale references (`winston` → pino,
+> `mock-crc.ts`/`indonesianTextNormalizer.ts` removed,
+> `aiAnalysisWorker.ts` → `ai-analysis-worker.ts`,
+> `llmModerationClient.ts` → `llmClient.ts`).
+
+## Top-level
 
 ```
 services/discord-gateway/
 ├── src/
-│   ├── app/
-│   │   ├── bootstrap.ts
-│   │   │   └── Initializes Discord client, database, Redis broadcaster
-│   │   │       Registers event listeners, handles graceful shutdown
-│   │   └── shutdown.ts
-│   │       └── Graceful shutdown handler for SIGINT/SIGTERM/exceptions
-│   │
-│   ├── shared/
-│   │   ├── config/
-│   │   │   └── config.ts
-│   │   │       └── Zod-validated environment configuration
-│   │   │           - Discord token, database URL, Redis URL
-│   │   │           - AI LLM settings, recording parameters
-│   │   │           - Attachment upload settings, retention policies
-│   │   │
-│   │   ├── database/
-│   │   │   ├── schema.ts
-│   │   │   │   └── Drizzle ORM schema definitions
-│   │   │   ├── drizzle.ts
-│   │   │   │   └── PostgreSQL connection and initialization
-│   │   │   ├── migrate.ts
-│   │   │   │   └── Database migration runner
-│   │   │   ├── migrateCli.ts
-│   │   │   │   └── CLI for programmatic migrations
-│   │   │   ├── voiceRecordingRepo.ts
-│   │   │   │   └── Voice recording repository
-│   │   │   └── migrations/
-│   │   │       └── Database migration files
-│   │   │
-│   │   ├── errors/
-│   │   │   └── errors.ts
-│   │   │       └── Custom error classes
-│   │   │           - AppError (base)
-│   │   │           - ConfigError
-│   │   │           - AudioError
-│   │   │           - VoiceConnectionError
-│   │   │           - ValidationError
-│   │   │
-│   │   ├── logger/
-│   │   │   ├── logger.ts
-│   │   │   │   └── Winston logger wrapper with context support
-│   │   │   └── serialization.ts
-│   │   │       └── Log value serialization utilities
-│   │   │
-│   │   ├── utils/
-│   │   │   └── retry.ts
-│   │   │       └── Retry with exponential backoff utility
-│   │   │
-│   │   └── discord/
-│   │       └── clientOptions.ts
-│   │           └── Discord.js client configuration
-│   │
-│   ├── modules/
-│   │   │
-│   │   ├── message-capture/
-│   │   │   ├── messageCapture.ts
-│   │   │   │   └── CONTROLLER: Discord event listeners
-│   │   │   │       - messageCreate, messageUpdate, messageDelete
-│   │   │   │       - Validates capture target, publishes events
-│   │   │   │
-│   │   │   ├── messageStore.ts
-│   │   │   │   └── REPOSITORY: Database CRUD operations
-│   │   │   │       - upsertMessageForCapture
-│   │   │   │       - updateMessageAsEdited
-│   │   │   │       - updateMessageAsDeleted
-│   │   │   │       - insertAttachment
-│   │   │   │       - getMessageById
-│   │   │   │
-│   │   │   ├── messageMetadata.ts
-│   │   │   │   └── SERVICE: Message metadata extraction
-│   │   │   │       - getMessageMetadata
-│   │   │   │       - getMessageLocation
-│   │   │   │       - getDisplayContent
-│   │   │   │
-│   │   │   ├── types.ts
-│   │   │   │   └── Domain types
-│   │   │   │       - MessageRecord
-│   │   │   │       - AttachmentRecord
-│   │   │   │       - VoiceSegmentRecord
-│   │   │   │       - AIStatus, AISeverity, AIRecommendedAction
-│   │   │   │
-│   │   │   └── index.ts
-│   │       └── Module exports
-│   │
-│   │   ├── ai-moderation/
-│   │   │   ├── aiAnalyzer.ts
-│   │   │   │   └── CONTROLLER: Analysis orchestration
-│   │   │   │       - startPendingAIAnalysisWorker
-│   │   │   │       - queueMessageAnalysis
-│   │   │   │       - Manages analysis queue and worker pool
-│   │   │   │
-│   │   │   ├── llmModerationClient.ts
-│   │   │   │   └── SERVICE: LLM API integration
-│   │   │   │       - Calls LLM for text/image moderation
-│   │   │   │       - Parses responses, handles errors
-│   │   │   │       - Retry logic with backoff
-│   │   │   │
-│   │   │   ├── aiAnalysisWorker.ts
-│   │   │   │   └── SERVICE: Worker pool management
-│   │   │   │       - Piscina worker pool for parallel analysis
-│   │   │   │       - Conversation context batching
-│   │   │   │
-│   │   │   ├── indonesianTextNormalizer.ts
-│   │   │   │   └── SERVICE: Text preprocessing
-│   │   │   │       - Normalize Indonesian text
-│   │   │   │       - Handle diacritics, abbreviations
-│   │   │   │
-│   │   │   ├── moderationPrompt.ts
-│   │   │   │   └── SERVICE: Prompt generation
-│   │   │   │       - Generate LLM prompts for moderation
-│   │   │   │       - Include context and policy
-│   │   │   │
-│   │   │   └── index.ts
-│   │       └── Module exports
-│   │
-│   │   ├── voice-recording/
-│   │   │   ├── voiceController.ts
-│   │   │   │   └── CONTROLLER: Voice connection management
-│   │   │   │       - connect(guildId, channelId)
-│   │   │   │       - disconnect()
-│   │   │   │       - listGuilds(), listVoiceChannels()
-│   │   │   │       - getStatus()
-│   │   │   │
-│   │   │   ├── recorder.ts
-│   │   │   │   └── SERVICE: Recording orchestration
-│   │   │   │       - startRecording(client, channel)
-│   │   │   │       - stopRecording(guildId)
-│   │   │   │       - Manages active recording sessions
-│   │   │   │
-│   │   │   ├── recorder/
-│   │   │   │   ├── audioStream.ts
-│   │   │   │   │   └── SERVICE: Audio stream subscription
-│   │   │   │   │       - subscribeToAudioStream
-│   │   │   │   │       - Opus packet handling
-│   │   │   │   │
-│   │   │   │   ├── decoder.ts
-│   │   │   │   │   └── SERVICE: Opus decoding
-│   │   │   │   │       - OpusDecoder class
-│   │   │   │   │       - Decode Opus to PCM
-│   │   │   │   │       - Rotation and cooldown logic
-│   │   │   │   │
-│   │   │   │   ├── segment.ts
-│   │   │   │   │   └── SERVICE: OGG segment rotation
-│   │   │   │   │       - SegmentManager class
-│   │   │   │   │       - Rotate segments (5s default)
-│   │   │   │   │       - Write OGG files
-│   │   │   │   │
-│   │   │   │   ├── metadata.ts
-│   │   │   │   │   └── SERVICE: Segment metadata
-│   │   │   │   │       - collectUserMetadata
-│   │   │   │   │       - createSegmentMetadata
-│   │   │   │   │       - User info, roles, timestamps
-│   │   │   │   │
-│   │   │   │   ├── sessionRecording.ts
-│   │   │   │   │   └── SERVICE: Session management
-│   │   │   │   │       - createRecordingSession
-│   │   │   │   │       - finalizeRecordingSession
-│   │   │   │   │       - Track active sessions
-│   │   │   │   │
-│   │   │   │   └── uploader.ts
-│   │   │   │       └── SERVICE: Segment upload
-│   │   │   │           - uploadRecordingSegment
-│   │   │   │           - Upload to external storage
-│   │   │   │           - Retry logic
-│   │   │   │
-│   │   │   └── index.ts
-│   │       └── Module exports
-│   │
-│   │   ├── attachment-upload/
-│   │   │   ├── attachmentUploader.ts
-│   │   │   │   └── SERVICE: Upload orchestration
-│   │   │   │       - processAttachmentUpload
-│   │   │   │       - Download from Discord
-│   │   │   │       - Upload to external storage
-│   │   │   │       - Retry with backoff
-│   │   │   │
-│   │   │   ├── imageResizer.ts
-│   │   │   │   └── SERVICE: Image processing
-│   │   │   │       - resizeImage
-│   │   │   │       - Resize to max dimension
-│   │   │   │       - Preserve aspect ratio
-│   │   │   │
-│   │   │   └── index.ts
-│   │       └── Module exports
-│   │
-│   │   └── event-broadcaster/
-│   │       ├── eventBroadcaster.ts
-│   │       │   └── SERVICE: Redis pub/sub publisher
-│   │       │       - EventBroadcaster class
-│   │       │       - RedisEventPublisher class
-│   │       │       - Publish to Redis channels
-│   │       │       - Methods:
-│   │       │         - messageCreated()
-│   │       │         - messageUpdated()
-│   │       │         - messageDeleted()
-│   │       │         - messageAnalyzed()
-│   │       │         - attachmentCreated()
-│   │       │         - attachmentUploaded()
-│   │       │         - voiceRecordingStarted()
-│   │       │         - voiceRecordingStopped()
-│   │       │         - voiceRecordingUploaded()
-│   │       │         - analysisQueueStatus()
-│   │       │
-│   │       ├── eventTypes.ts
-│   │       │   └── Domain types
-│   │       │       - DiscordGatewayEvent interface
-│   │       │       - EventChannels constants
-│   │       │       - Event channel names
-│   │       │
-│   │       └── index.ts
-│           └── Module exports
-│
-│   ├── mock-crc.ts
-│   │   └── CRC polyfill for discord.js compatibility
-│   │
-│   └── index.ts
-│       └── Service entry point
-│           - Initialize Discord Gateway
-│           - Handle startup errors
-│
-├── ARCHITECTURE.md
-│   └── Detailed architecture documentation
-│
-├── README.md
-│   └── Complete service documentation
-│
-├── MODULE_STRUCTURE.md
-│   └── This file - module structure reference
-│
-└── package.json
-    └── Service dependencies and scripts
+│   ├── index.ts                     # Entry point
+│   ├── app/                         # bootstrap, shutdown, retention
+│   ├── shared/                      # config, database, logger, errors, utils, discord, uploader
+│   └── modules/
+│       ├── message-capture/         # Discord listeners + DB store + metadata
+│       ├── ai-moderation/           # LLM moderation pipeline (largest module)
+│       ├── voice-recording/         # Voice connect + Opus→OGG recording (+ recorder/)
+│       ├── voice-pcm-ws/            # Real-time PCM → backend WebSocket
+│       ├── attachment-upload/       # Download + sharp resize + upload
+│       ├── event-broadcaster/        # RedisEventPublisher + EventBroadcaster
+│       ├── command-handler/         # Backend→gateway Redis commands
+│       ├── reaction-tracking/ thread-tracking/ user-presence/
+│       ├── channel-topic/ guild-member-events/
+│       └── gateway-metrics/         # Prometheus /metrics (port 4016)
+├── tests/                           # Vitest suites (129 tests)
+├── drizzle/                         # Drizzle migration SQL + journal
+├── ARCHITECTURE.md  README.md  package.json  tsconfig.json  vitest.config.ts
 ```
 
-## Module Responsibilities
+## Module responsibilities (summary)
 
 ### message-capture
-**Purpose**: Capture Discord messages (create, update, delete)
-**Pattern**: Controller-Service-Repository
-- **Controller** (messageCapture.ts): Listens to Discord events
-- **Service** (messageMetadata.ts): Extracts metadata
-- **Repository** (messageStore.ts): Database operations
-- **Events Published**:
-  - `discord:message:created`
-  - `discord:message:updated`
-  - `discord:message:deleted`
+Captures `messageCreate`/`messageUpdate`/`messageDelete`, extracts metadata,
+stores to Postgres, publishes to Redis. Controller–Service–Repository split:
+`messageCapture.ts` (listener) → `messageStore.ts` (DB) + `messageMetadata.ts`
+(service).
 
 ### ai-moderation
-**Purpose**: Analyze messages with LLM for moderation
-**Pattern**: Controller-Service-Service-Service
-- **Controller** (aiAnalyzer.ts): Orchestrates analysis workflow
-- **Service** (llmModerationClient.ts): LLM API integration
-- **Service** (aiAnalysisWorker.ts): Worker pool management
-- **Service** (indonesianTextNormalizer.ts): Text preprocessing
-- **Service** (moderationPrompt.ts): Prompt generation
-- **Events Published**:
-  - `discord:message:analyzed`
-  - `discord:analysis:queue_status`
+LLM-only moderation. Entry: `aiAnalyzer.ts` (`queueMessageAnalysis`,
+`startPendingAIAnalysisWorker`, `getAnalysisQueueStatus`). Scheduling:
+`batchScheduler.ts` → `batchProcessor.ts` (batch lock + circuit breaker) →
+`individualFallbackProcessor.ts` (per-message retry). Heavy work runs in the
+Piscina pool via `ai-analysis-worker.ts` (jobs `batch` / `individual`).
+Orchestration/caching: `moderationOrchestrator.ts` (exact hash → batched
+semantic Qdrant → LLM), `textBatchProcessor.ts` / `mediaBatchProcessor.ts`
+(one LLM call per sub-batch), `llmClient.ts` (central streaming client),
+`embeddingClient.ts` + `qdrantClient.ts` (semantic cache), plus
+`channelCultureStore.ts` / `userProfileStore.ts` / `userReputationStore.ts`.
 
 ### voice-recording
-**Purpose**: Record voice channel audio
-**Pattern**: Controller-Service-SubServices
-- **Controller** (voiceController.ts): Voice connection management
-- **Service** (recorder.ts): Recording orchestration
-- **Sub-services** (recorder/*): Audio processing pipeline
-  - audioStream.ts: Opus packet subscription
-  - decoder.ts: Opus to PCM decoding
-  - segment.ts: OGG file rotation
-  - metadata.ts: User metadata collection
-  - sessionRecording.ts: Session lifecycle
-  - uploader.ts: Segment upload
-- **Events Published**:
-  - `discord:voice:started`
-  - `discord:voice:stopped`
-  - `discord:voice:uploaded`
+`voiceController.ts` (connect/disconnect/list) + `recorder.ts` (orchestration)
++ `recorder/` (decoder, segment, session, uploader, oggCrc). Publishes
+`discord:voice:*` events. Real-time audio also streamed via `voice-pcm-ws`.
 
 ### attachment-upload
-**Purpose**: Upload message attachments to external storage
-**Pattern**: Service-Service
-- **Service** (attachmentUploader.ts): Upload orchestration
-- **Service** (imageResizer.ts): Image processing
-- **Events Published**:
-  - `discord:attachment:created`
-  - `discord:attachment:uploaded`
+`attachmentUploader.ts` (download → upload to storage) + `imageResizer.ts`
+(sharp resize). Emits `discord:attachment:*`.
 
 ### event-broadcaster
-**Purpose**: Publish events to Redis pub/sub
-**Pattern**: Service-Domain
-- **Service** (eventBroadcaster.ts): Redis publisher
-- **Domain** (eventTypes.ts): Event type definitions
-- **Channels**:
-  - discord:message:* (message events)
-  - discord:attachment:* (attachment events)
-  - discord:voice:* (voice events)
-  - discord:analysis:* (analysis events)
+`RedisEventPublisher` (ioredis publish) + `EventBroadcaster` (typed methods).
+Channel names in `src/shared/redis-channels.ts`.
 
-## Shared Infrastructure
+### gateway-metrics
+`metrics.ts` Prometheus HTTP server on `METRICS_PORT` (4016). Collectors run
+per scrape; live pipeline gauges registered in `bootstrap.ts`.
 
-### config
-- Zod-validated environment variables
-- Type-safe configuration access
-- Sensible defaults
+## Shared infrastructure
+- **config** — Zod schema in `shared/config/index.ts` (single source of truth).
+- **database** — Drizzle ORM over `pg`; pool `min:0` (`shared/config`).
+- **logger** — `pino` wrapper, `createChildLogger()` for context loggers.
+- **errors** — `AppError` hierarchy (`ConfigError`, `AudioError`, …).
 
-### database
-- Drizzle ORM schema
-- PostgreSQL connection
-- Migration management
-- Voice recording repository
-
-### logger
-- Winston logger wrapper
-- Context-aware logging
-- Log serialization utilities
-
-### errors
-- Custom error classes
-- Error codes and HTTP status codes
-- Proper error hierarchy
-
-### utils
-- Retry with exponential backoff
-- Configurable retry parameters
-
-### discord
-- Discord.js client configuration
-- Cache optimization
-- Partial handling
-
-## Event Flow
-
-```
-Discord Events
-    ↓
-message-capture (Controller)
-    ↓
-messageStore (Repository) → PostgreSQL
-    ↓
-eventBroadcaster (Service)
-    ↓
-Redis Pub/Sub
-    ↓
-Backend Service (Subscriber)
-    ↓
-HTTP API / WebSocket
-    ↓
-Frontend Application
-```
-
-## No HTTP Server
-
-- ✅ No Express
-- ✅ No WebSocket server
-- ✅ No HTTP routes
-- ✅ No middleware
-- ✅ Pure event-driven service
-
-## Graceful Shutdown
-
-1. Close PostgreSQL connection
-2. Disconnect from voice channels
-3. Close Redis connection
-4. Destroy Discord client
-5. Exit process
-
-## Dependencies
-
-**Discord**:
-- discord.js-selfbot-v13
-- @discordjs/voice
-- @discordjs/opus
-
-**Audio**:
-- prism-media
-- opusscript
-- sharp
-
-**Data**:
-- drizzle-orm
-- pg
-- zod
-- ioredis
-
-**Logging**:
-- winston
-- p-retry
-- p-limit
-- piscina
-
-## Summary
-
-The Discord Gateway service is a **pure event-driven microservice** that:
-- Captures Discord messages, voice, and attachments
-- Performs AI moderation analysis
-- Publishes events to Redis pub/sub
-- Has no HTTP server or WebSocket
-- Follows Modular MVC pattern
-- Maintains clean module boundaries
-- Provides type-safe configuration
-- Includes structured logging
-- Handles graceful shutdown
-
-The service is designed to run alongside the Backend service, which consumes Redis events and serves the HTTP API to the Frontend.
+## Notes
+- No HTTP server (other than the metrics endpoint). Pure event-driven.
+- `MODULE_STRUCTURE.md` is intentionally a sketch; `ARCHITECTURE.md` is the
+  detailed reference. When they diverge, `ARCHITECTURE.md` wins.

services/discord-gateway/drizzle/migrations/0014_add_term_glossary_cache.sql

@@ -0,0 +1,9 @@
+CREATE TABLE IF NOT EXISTS "term_glossary_cache" (
+	"term" text PRIMARY KEY NOT NULL,
+	"definition" text NOT NULL,
+	"source_url" text DEFAULT '' NOT NULL,
+	"resolved_at" bigint NOT NULL,
+	"hit_count" integer DEFAULT 0 NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "idx_term_glossary_cache_resolved_at" ON "term_glossary_cache" USING btree ("resolved_at");

services/discord-gateway/drizzle/migrations/meta/_journal.json

@@ -99,6 +99,13 @@
       "when": 1785551832190,
       "tag": "0013_rename_mascot_chat_to_chatbot",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "7",
+      "when": 1785621600000,
+      "tag": "0014_add_term_glossary_cache",
+      "breakpoints": true
     }
   ]
 }

services/discord-gateway/native/libdatachannel-min/.gitignore

@@ -1,3 +0,0 @@
-node_modules/
-build/
-package-lock.json

services/discord-gateway/native/libdatachannel-min/binding.cpp

@@ -1,526 +0,0 @@
-// libdatachannel-min — minimal N-API binding to libdatachannel.
-// Exposes ONLY what GMW GoLive needs:
-//   PeerConnection (offer/answer, ICE, SDP), DataChannel (signaling),
-//   Track send (added in media phase).
-// Built against libdatachannel 0.24.0 (built from source in /tmp/ldc-build).
-
-#include <napi.h>
-#include <rtc/rtc.hpp>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <variant>
-
-using namespace Napi;
-
-namespace {
-
-std::string stateToString(rtc::PeerConnection::State s) {
-  switch (s) {
-    case rtc::PeerConnection::State::New: return "new";
-    case rtc::PeerConnection::State::Connecting: return "connecting";
-    case rtc::PeerConnection::State::Connected: return "connected";
-    case rtc::PeerConnection::State::Disconnected: return "disconnected";
-    case rtc::PeerConnection::State::Failed: return "failed";
-    case rtc::PeerConnection::State::Closed: return "closed";
-    default: return "unknown";
-  }
-}
-
-std::string binaryToString(const rtc::binary& data) {
-  // rtc::binary is std::vector<std::byte> in libdatachannel >= 0.21
-  std::string msg(data.size(), '\0');
-  for (size_t i = 0; i < data.size(); i++) {
-    msg[i] = static_cast<char>(data[i]);
-  }
-  return msg;
-}
-
-// Holds a Napi::Promise::Deferred so it can be moved into TSFN lambdas
-// without invalid copies (node-addon-api 8.x Deferred is not movable).
-struct DeferredHolder {
-  Promise::Deferred deferred;
-  explicit DeferredHolder(Promise::Deferred d) : deferred(d) {}
-};
-
-class DataChannelWrap : public Napi::ObjectWrap<DataChannelWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "DataChannel", {
-      InstanceMethod("send", &DataChannelWrap::Send),
-      InstanceMethod("isOpen", &DataChannelWrap::IsOpen),
-      InstanceMethod("close", &DataChannelWrap::Close),
-      InstanceMethod("onMessage", &DataChannelWrap::OnMessage),
-      InstanceMethod("onOpen", &DataChannelWrap::OnOpen),
-    });
-    dcConstructor = Napi::Persistent(func);
-    return func;
-  }
-
-  // Create a JS wrapper (calls the JS constructor, returns instance).
-  static Object NewInstance(Napi::Env env) {
-    return dcConstructor.New({});
-  }
-
-  DataChannelWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<DataChannelWrap>(info) {}
-
-  void Init(std::shared_ptr<rtc::DataChannel> dc) {
-    dc_ = dc;
-    dc_->onMessage([this](rtc::message_variant data) {
-      std::string msg;
-      if (std::holds_alternative<rtc::binary>(data)) {
-        msg = binaryToString(std::get<rtc::binary>(data));
-      } else {
-        msg = std::get<std::string>(data);
-      }
-      if (msgCb_) {
-        msgCb_->BlockingCall([msg](Napi::Env env, Function cb) {
-          cb.Call({String::New(env, msg)});
-        });
-      }
-    });
-    dc_->onOpen([this]() {
-      if (openCb_) {
-        openCb_->BlockingCall([](Napi::Env env, Function cb) {
-          cb.Call({});
-        });
-      }
-    });
-  }
-
- private:
-  static FunctionReference dcConstructor;
-  std::shared_ptr<rtc::DataChannel> dc_;
-  std::shared_ptr<ThreadSafeFunction> msgCb_;
-  std::shared_ptr<ThreadSafeFunction> openCb_;
-
-  void Send(const Napi::CallbackInfo& info) {
-    std::string msg = info[0].As<String>().Utf8Value();
-    if (dc_) dc_->send(msg);
-  }
-
-  Napi::Value IsOpen(const Napi::CallbackInfo& info) {
-    bool open = dc_ && dc_->isOpen();
-    return Boolean::New(info.Env(), open);
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (dc_) dc_->close();
-  }
-
-  void OnMessage(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    msgCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc-message", 0, 1));
-  }
-
-  void OnOpen(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    openCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc-open", 0, 1));
-  }
-};
-
-class TrackWrap : public Napi::ObjectWrap<TrackWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "Track", {
-      InstanceMethod("send", &TrackWrap::Send),
-      InstanceMethod("isOpen", &TrackWrap::IsOpen),
-      InstanceMethod("close", &TrackWrap::Close),
-      InstanceMethod("setPacketizer", &TrackWrap::SetPacketizer),
-      InstanceMethod("sendFrame", &TrackWrap::SendFrame),
-      InstanceMethod("addTimestamp", &TrackWrap::AddTimestamp),
-    });
-    trackConstructor = Napi::Persistent(func);
-    return func;
-  }
-
-  static Object NewInstance(Napi::Env env) {
-    return trackConstructor.New({});
-  }
-
-  TrackWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<TrackWrap>(info) {}
-
-  void Init(std::shared_ptr<rtc::Track> track, Napi::Env env) {
-    track_ = track;
-    (void)env;
-  }
-
- private:
-  static FunctionReference trackConstructor;
-  std::shared_ptr<rtc::Track> track_;
-  std::shared_ptr<rtc::RtpPacketizationConfig> rtpConfig_;
-
-  void Send(const Napi::CallbackInfo& info) {
-    Buffer<uint8_t> buf = info[0].As<Buffer<uint8_t>>();
-    if (!track_) return;
-    rtc::binary data(buf.Length());
-    for (size_t i = 0; i < buf.Length(); i++) data[i] = (std::byte)buf[i];
-    try {
-      track_->send(data);
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] track.send THREW: %s\n", e.what());
-    }
-  }
-
-  // setPacketizer(kind, ssrc, payloadType, clockRate, playoutDelayId,
-  //               playoutDelayMin, playoutDelayMax)
-  // kind: "audio" | "h264" | "h265" | "av1"
-  // Builds the media-handler chain (packetizer → RTCP SR → NACK → pacing for
-  // video) exactly like @dank074's WebRtcWrapper does via node-datachannel.
-  void SetPacketizer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    if (!track_) throw Error::New(env, "track closed");
-    std::string kind = info[0].As<String>().Utf8Value();
-    uint32_t ssrc = info[1].As<Number>().Uint32Value();
-    uint8_t pt = (uint8_t)info[2].As<Number>().Uint32Value();
-    uint32_t clockRate = info[3].As<Number>().Uint32Value();
-    uint8_t playoutDelayId = (uint8_t)info[4].As<Number>().Uint32Value();
-    uint16_t playoutDelayMin = (uint16_t)info[5].As<Number>().Uint32Value();
-    uint16_t playoutDelayMax = (uint16_t)info[6].As<Number>().Uint32Value();
-    try {
-      auto cfg = std::make_shared<rtc::RtpPacketizationConfig>(
-          ssrc, "", pt, clockRate);
-      cfg->playoutDelayId = playoutDelayId;
-      cfg->playoutDelayMin = playoutDelayMin;
-      cfg->playoutDelayMax = playoutDelayMax;
-      std::shared_ptr<rtc::MediaHandler> handler;
-      if (kind == "audio") {
-        handler = std::make_shared<rtc::OpusRtpPacketizer>(cfg);
-      } else if (kind == "h264") {
-        handler = std::make_shared<rtc::H264RtpPacketizer>(
-            rtc::NalUnit::Separator::StartSequence, cfg);
-      } else if (kind == "h265") {
-        handler = std::make_shared<rtc::H265RtpPacketizer>(
-            rtc::NalUnit::Separator::StartSequence, cfg);
-      } else if (kind == "av1") {
-        handler = std::make_shared<rtc::AV1RtpPacketizer>(
-            rtc::AV1RtpPacketizer::Packetization::Obu, cfg);
-      } else {
-        throw std::runtime_error("unknown packetizer kind: " + kind);
-      }
-      handler->addToChain(std::make_shared<rtc::RtcpSrReporter>(cfg));
-      handler->addToChain(std::make_shared<rtc::RtcpNackResponder>());
-      if (kind != "audio") {
-        handler->addToChain(std::make_shared<rtc::PacingHandler>(
-            25.0 * 1000 * 1000, std::chrono::milliseconds(1)));
-      }
-      track_->setMediaHandler(handler);
-      rtpConfig_ = cfg;
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] setPacketizer THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-  }
-
-  // sendFrame(buffer) — sends an ENCODED frame (AnnexB H264 / raw opus /
-  // OBU AV1). The media-handler chain packetizes it into RTP.
-  void SendFrame(const Napi::CallbackInfo& info) {
-    Buffer<uint8_t> buf = info[0].As<Buffer<uint8_t>>();
-    if (!track_) return;
-    rtc::binary data(buf.Length());
-    for (size_t i = 0; i < buf.Length(); i++) data[i] = (std::byte)buf[i];
-    try {
-      track_->send(data);
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] track.sendFrame THREW: %s\n", e.what());
-    }
-  }
-
-  // addTimestamp(delta) — advances the packetizer RTP timestamp by delta
-  // (clock-rate units). Called by JS after each frame, matching the
-  // node-datachannel contract (WebRtcWrapper does the same increment).
-  void AddTimestamp(const Napi::CallbackInfo& info) {
-    uint32_t delta = info[0].As<Number>().Uint32Value();
-    if (rtpConfig_) rtpConfig_->timestamp += delta;
-  }
-
-  Napi::Value IsOpen(const Napi::CallbackInfo& info) {
-    bool open = track_ && track_->isOpen();
-    return Boolean::New(info.Env(), open);
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (track_) track_->close();
-  }
-
-  void OnStateChange(const Napi::CallbackInfo& info) {
-    // libdatachannel Track has no state-change callback; kept for API parity.
-    (void)info;
-  }
-};
-class PeerConnectionWrap : public Napi::ObjectWrap<PeerConnectionWrap> {
- public:
-  static Function Init(Napi::Env env) {
-    Function func = DefineClass(env, "PeerConnection", {
-      InstanceMethod("state", &PeerConnectionWrap::State),
-      InstanceMethod("createOffer", &PeerConnectionWrap::CreateOffer),
-      InstanceMethod("createAnswer", &PeerConnectionWrap::CreateAnswer),
-      InstanceMethod("setRemoteDescription",
-                     &PeerConnectionWrap::SetRemoteDescription),
-      InstanceMethod("close", &PeerConnectionWrap::Close),
-      InstanceMethod("onStateChange", &PeerConnectionWrap::OnStateChange),
-      InstanceMethod("createDataChannel", &PeerConnectionWrap::CreateDataChannel),
-      InstanceMethod("onDataChannel", &PeerConnectionWrap::OnDataChannel),
-      InstanceMethod("addTrack", &PeerConnectionWrap::AddTrack),
-    });
-    return func;
-  }
-
-  PeerConnectionWrap(const Napi::CallbackInfo& info)
-      : Napi::ObjectWrap<PeerConnectionWrap>(info) {
-    Napi::Env env = info.Env();
-    if (!info[0].IsObject()) {
-      throw TypeError::New(env, "config object required");
-    }
-    Object config = info[0].As<Object>();
-    rtc::Configuration rtcConfig;
-    if (config.Has("iceServers")) {
-      Array servers = config.Get("iceServers").As<Array>();
-      for (uint32_t i = 0; i < servers.Length(); i++) {
-        std::string url = servers.Get(i).As<String>().Utf8Value();
-        rtcConfig.iceServers.emplace_back(url);
-      }
-    }
-    pc_ = std::make_shared<rtc::PeerConnection>(rtcConfig);
-
-    // IMPORTANT: register description/gathering callbacks HERE (constructor),
-    // BEFORE any createDataChannel call. libdatachannel only fires
-    // onLocalDescription for negotiations that start AFTER the callback is
-    // registered — if createDataChannel runs first, the offer callback never
-    // fires (verified in C++ spike: test3 vs test2).
-    pc_->onLocalDescription([this](rtc::Description desc) {
-      latestLocalDesc_ = std::string(desc);
-      fprintf(stderr, "[binding] trickle desc, %zu bytes\n",
-              latestLocalDesc_.size());
-    });
-    pc_->onGatheringStateChange([this](rtc::PeerConnection::GatheringState gs) {
-      fprintf(stderr, "[binding] gathering state: %d\n", (int)gs);
-      if (gs == rtc::PeerConnection::GatheringState::Complete) {
-        // Use the getter — it returns the FULL SDP including candidates after
-        // gathering (trickle callbacks only carry the initial fragment).
-        auto ld = pc_->localDescription();
-        if (ld) {
-          latestLocalDesc_ = std::string(*ld);
-          fprintf(stderr, "[binding] final desc, %zu bytes\n",
-                  latestLocalDesc_.size());
-        }
-        resolvePendingLocalDesc_();
-      }
-    });
-  }
-
- private:
-  std::shared_ptr<rtc::PeerConnection> pc_;
-  std::shared_ptr<ThreadSafeFunction> stateCb_;
-  std::shared_ptr<ThreadSafeFunction> dcCb_;
-  std::string latestLocalDesc_;
-  std::shared_ptr<DeferredHolder> pendingDescDeferred_;
-  std::shared_ptr<ThreadSafeFunction> pendingDescTsfn_;
-
-  void resolvePendingLocalDesc_() {
-    if (!pendingDescDeferred_ || !pendingDescTsfn_) return;
-    auto holder = pendingDescDeferred_;
-    auto tsfn = pendingDescTsfn_;
-    pendingDescDeferred_.reset();
-    pendingDescTsfn_.reset();
-    std::string sdp = latestLocalDesc_;
-    tsfn->BlockingCall([sdp, holder](Napi::Env e, Function) {
-      holder->deferred.Resolve(String::New(e, sdp));
-    });
-  }
-
-  Napi::Value State(const Napi::CallbackInfo& info) {
-    return String::New(info.Env(),
-                       pc_ ? stateToString(pc_->state()) : "closed");
-  }
-
-  // createOffer() -> Promise<string> — sets local description, waits for
-  // ICE gathering to complete (so candidates are in the SDP), resolves SDP.
-  Napi::Value CreateOffer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    auto holder = std::make_shared<DeferredHolder>(Promise::Deferred::New(env));
-    if (!pc_) {
-      holder->deferred.Reject(Error::New(env, "peer closed").Value());
-      return holder->deferred.Promise();
-    }
-    // createDataChannel already triggers negotiation in libdatachannel 0.24 —
-    // if gathering already completed, resolve immediately from the cached SDP.
-    if (!latestLocalDesc_.empty()) {
-      auto tsfn = std::make_shared<ThreadSafeFunction>(ThreadSafeFunction::New(
-          env, Function::New(env, [](const CallbackInfo&) {}), "desc", 0, 1));
-      std::string sdp = latestLocalDesc_;
-      tsfn->BlockingCall([sdp, holder](Napi::Env e, Function) {
-        holder->deferred.Resolve(String::New(e, sdp));
-      });
-      return holder->deferred.Promise();
-    }
-    if (pendingDescDeferred_) {
-      pendingDescDeferred_->deferred.Reject(
-          Error::New(env, "previous negotiation still pending").Value());
-    }
-    pendingDescDeferred_ = holder;
-    pendingDescTsfn_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(env, Function::New(env, [](const CallbackInfo&) {}),
-                                "desc", 0, 1));
-    fprintf(stderr, "[binding] calling setLocalDescription(Offer)\n");
-    try {
-      pc_->setLocalDescription(rtc::Description::Type::Offer);
-      fprintf(stderr, "[binding] setLocalDescription returned OK\n");
-    } catch (const std::exception& e) {
-      pendingDescDeferred_.reset();
-      fprintf(stderr, "[binding] setLocalDescription THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-    return holder->deferred.Promise();
-  }
-
-  // createAnswer(offerSdp: string) -> Promise<string>
-  Napi::Value CreateAnswer(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string offer = info[0].As<String>().Utf8Value();
-    auto holder = std::make_shared<DeferredHolder>(Promise::Deferred::New(env));
-    if (!pc_) {
-      holder->deferred.Reject(Error::New(env, "peer closed").Value());
-      return holder->deferred.Promise();
-    }
-    if (pendingDescDeferred_) {
-      pendingDescDeferred_->deferred.Reject(
-          Error::New(env, "previous negotiation still pending").Value());
-    }
-    pendingDescDeferred_ = holder;
-    pendingDescTsfn_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(env, Function::New(env, [](const CallbackInfo&) {}),
-                                "desc", 0, 1));
-    try {
-      pc_->setRemoteDescription(
-          rtc::Description(offer, rtc::Description::Type::Offer));
-      fprintf(stderr, "[binding] answer: setRemoteDescription OK\n");
-      // libdatachannel 0.24 AUTO-GENERATES the answer when a remote offer is
-      // applied (verified in C++ spike test8/9: B desc type=Answer fires
-      // immediately with a=setup:active). Calling setLocalDescription() again
-      // would OVERWRITE it with a role=actpass SDP, which A rejects with
-      // "Illegal role actpass in remote answer description". So we do NOT call
-      // setLocalDescription here — we just wait for gathering complete and
-      // resolve with the auto-generated answer. This also matches @dank074's
-      // Discord voice flow.
-    } catch (const std::exception& e) {
-      pendingDescDeferred_.reset();
-      fprintf(stderr, "[binding] answer THREW: %s\n", e.what());
-      holder->deferred.Reject(Error::New(env, e.what()).Value());
-    }
-    return holder->deferred.Promise();
-  }
-
-  void SetRemoteDescription(const Napi::CallbackInfo& info) {
-    std::string sdp = info[0].As<String>().Utf8Value();
-    std::string type = info[1].As<String>().Utf8Value();
-    rtc::Description::Type t = (type == "answer")
-                                   ? rtc::Description::Type::Answer
-                                   : rtc::Description::Type::Offer;
-    if (pc_) pc_->setRemoteDescription(rtc::Description(sdp, t));
-  }
-
-  void Close(const Napi::CallbackInfo& info) {
-    if (pc_) pc_->close();
-  }
-
-  void OnStateChange(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    stateCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "pc-state", 0, 1));
-    std::shared_ptr<rtc::PeerConnection> pc = pc_;
-    pc->onStateChange([this](rtc::PeerConnection::State state) {
-      if (stateCb_) {
-        std::string s = stateToString(state);
-        stateCb_->BlockingCall([s](Napi::Env env, Function cb) {
-          cb.Call({String::New(env, s)});
-        });
-      }
-    });
-  }
-
-  Napi::Value CreateDataChannel(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string label = info[0].As<String>().Utf8Value();
-    fprintf(stderr, "[binding] createDataChannel(%s)\n", label.c_str());
-    auto dc = pc_->createDataChannel(label);
-    Object obj = DataChannelWrap::NewInstance(env);
-    DataChannelWrap::Unwrap(obj)->Init(dc);
-    return obj;
-  }
-
-  Napi::Value AddTrack(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    std::string mid = info[0].As<String>().Utf8Value();
-    std::string kind = info[1].As<String>().Utf8Value();
-    if (!pc_) throw Error::New(env, "peer closed");
-    fprintf(stderr, "[binding] addTrack(%s, %s) start\n", mid.c_str(), kind.c_str());
-    try {
-      std::shared_ptr<rtc::Track> track;
-      if (kind == "audio") {
-      // Opus payload type 120 (matches @dank074 CodecPayloadType.opus)
-      auto desc = rtc::Description::Audio(mid);
-      desc.addOpusCodec(120);
-      track = pc_->addTrack(desc);
-      } else {
-      // All video codecs with their payload types, matching WebRtcWrapper:
-      // H264 101/102, H265 103/104, VP8 105/106, VP9 107/108, AV1 109/110
-      auto desc = rtc::Description::Video(mid);
-      desc.addH264Codec(101);
-      desc.addRtxCodec(102, 101, 90000);
-      desc.addH265Codec(103);
-      desc.addRtxCodec(104, 103, 90000);
-      desc.addVP8Codec(105);
-      desc.addRtxCodec(106, 105, 90000);
-      desc.addVP9Codec(107);
-      desc.addRtxCodec(108, 107, 90000);
-      desc.addAV1Codec(109);
-      desc.addRtxCodec(110, 109, 90000);
-      track = pc_->addTrack(desc);
-    }
-      Object obj = TrackWrap::NewInstance(env);
-      TrackWrap::Unwrap(obj)->Init(track, env);
-      return obj;
-    } catch (const std::exception& e) {
-      fprintf(stderr, "[binding] addTrack THREW: %s\n", e.what());
-      throw Error::New(env, e.what());
-    }
-  }
-
-  void OnDataChannel(const Napi::CallbackInfo& info) {
-    Function cb = info[0].As<Function>();
-    dcCb_ = std::make_shared<ThreadSafeFunction>(
-        ThreadSafeFunction::New(info.Env(), cb, "dc", 0, 1));
-    std::shared_ptr<rtc::PeerConnection> pc = pc_;
-    pc->onDataChannel([this](std::shared_ptr<rtc::DataChannel> dc) {
-      if (dcCb_) {
-        auto dcPtr = dc;
-        dcCb_->BlockingCall([dcPtr](Napi::Env env, Function cb) {
-          Object obj = DataChannelWrap::NewInstance(env);
-          DataChannelWrap::Unwrap(obj)->Init(dcPtr);
-          cb.Call({obj});
-        });
-      }
-    });
-  }
-};
-
-Object InitAll(Napi::Env env, Object exports) {
-  exports.Set("PeerConnection", PeerConnectionWrap::Init(env));
-  exports.Set("DataChannel", DataChannelWrap::Init(env));
-  exports.Set("Track", TrackWrap::Init(env));
-  return exports;
-}
-
-NODE_API_MODULE(libdatachannel_min, InitAll)
-
-// Definition for the static constructor references.
-FunctionReference DataChannelWrap::dcConstructor;
-FunctionReference TrackWrap::trackConstructor;
-
-}  // namespace

services/discord-gateway/native/libdatachannel-min/binding.gyp

@@ -1,21 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "libdatachannel_min",
-      "sources": ["binding.cpp"],
-      "include_dirs": [
-        "<!(node -e \"console.log(process.env.NAPI_INCLUDE || (() => { try { return require('node-addon-api').include; } catch { return '/nonexistent'; } })())\")",
-        "<!(node -e \"const s=process.env.LDC_INCLUDE||'/nix/store/39a85gpfjqy3h3k8jwrwh7m9yc3inqw7-source';console.log(s+'/include')\")"
-      ],
-      "libraries": [
-        "<!(node -e \"console.log(process.env.LDC_LIB || '/tmp/ldc-build/libdatachannel.so.0.24.0')\")"
-      ],
-      "cflags": ["-std=c++17", "-fexceptions"],
-      "cflags_cc": ["-std=c++17", "-fexceptions"],
-      "defines": ["NAPI_CPP_EXCEPTIONS"],
-      "conditions": [
-        ["OS=='linux'", { "cflags": ["-fvisibility=hidden"] }]
-      ]
-    }
-  ]
-}

services/discord-gateway/native/libdatachannel-min/index.js

@@ -1,3 +0,0 @@
-// libdatachannel-min — JS entry.
-const native = require("./build/Release/datachannel_min.node");
-module.exports = native;

services/discord-gateway/native/libdatachannel-min/package.json

@@ -1,17 +0,0 @@
-{
-  "name": "libdatachannel-min",
-  "version": "0.1.0",
-  "description": "Minimal N-API binding to libdatachannel — PeerConnection, DataChannel, ICE, SDP (+ media tracks for GoLive)",
-  "main": "index.js",
-  "gypfile": true,
-  "scripts": {
-    "build": "node-gyp rebuild",
-    "test": "node test-handshake.js"
-  },
-  "dependencies": {
-    "node-addon-api": "^8.3.0"
-  },
-  "devDependencies": {
-    "node-gyp": "^11.5.0"
-  }
-}

services/discord-gateway/native/libdatachannel-min/test-handshake.js

@@ -1,82 +0,0 @@
-// Phase 0 spike: prove the minimal binding can do a full WebRTC handshake
-// (offer/answer + ICE + DataChannel) between two local PeerConnections.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-function log(...args) {
-  console.log("[spike]", ...args);
-}
-
-async function main() {
-  const pcA = new PeerConnection({ iceServers: [] });
-  const pcB = new PeerConnection({ iceServers: [] });
-
-  const stateLog = [];
-  pcA.onStateChange((s) => {
-    stateLog.push(`A:${s}`);
-    log("A state:", s);
-  });
-  pcB.onStateChange((s) => {
-    stateLog.push(`B:${s}`);
-    log("B state:", s);
-  });
-
-  // B waits for incoming DataChannel
-  const received = new Promise((resolve) => {
-    pcB.onDataChannel((dc) => {
-      log("B got incoming DataChannel");
-      dc.onOpen(() => log("B DataChannel open"));
-      dc.onMessage((msg) => {
-        log("B received message:", msg);
-        dc.send("pong from B");
-        resolve(msg);
-      });
-    });
-  });
-
-  // A creates an outgoing DataChannel
-  const dcA = pcA.createDataChannel("test");
-  dcA.onOpen(() => {
-    log("A DataChannel open — sending hello");
-    dcA.send("hello from A");
-  });
-  dcA.onMessage((msg) => {
-    log("A received reply:", msg);
-  });
-
-  // Offer/answer dance
-  log("A createOffer...");
-  const offer = await pcA.createOffer();
-  log("Offer SDP bytes:", offer.length);
-  log("B createAnswer...");
-  const answer = await pcB.createAnswer(offer);
-  log("Answer SDP bytes:", answer.length);
-  const setupMatch = answer.match(/a=setup:(\S+)/);
-  log("Answer setup role:", setupMatch ? setupMatch[1] : "NONE");
-  pcA.setRemoteDescription(answer, "answer");
-
-  // Wait for message roundtrip
-  const msg = await Promise.race([
-    received,
-    new Promise((_, rej) => setTimeout(() => rej(new Error("TIMEOUT waiting for datachannel message")), 15000)),
-  ]);
-
-  log("ROUNDTRIP OK — B got:", msg);
-  log("States:", stateLog.join(" | "));
-
-  const aState = pcA.state();
-  const bState = pcB.state();
-  log("Final states — A:", aState, "B:", bState);
-
-  pcA.close();
-  pcB.close();
-
-  if (msg !== "hello from A") throw new Error("wrong message");
-  if (aState !== "connected" && aState !== "disconnected") throw new Error("A not connected: " + aState);
-  log("SPIKE PASSED ✅");
-}
-
-main().catch((e) => {
-  console.error("SPIKE FAILED:", e.message);
-  process.exit(1);
-});

services/discord-gateway/native/libdatachannel-min/test-packetizer.js

@@ -1,80 +0,0 @@
-// Verify setPacketizer + sendFrame: two peers connect, audio+video tracks
-// packetize real encoded frames (opus + AnnexB H264), RTP flows without crash.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
-
-async function main() {
-  const pcA = new PeerConnection({ iceServers: [] });
-  const pcB = new PeerConnection({ iceServers: [] });
-
-  const aAudio = pcA.addTrack("0", "audio");
-  const aVideo = pcA.addTrack("1", "video");
-  pcB.addTrack("0", "audio");
-  pcB.addTrack("1", "video");
-
-  let states = { a: "", b: "" };
-  pcA.onStateChange((s) => (states.a = s));
-  pcB.onStateChange((s) => (states.b = s));
-
-  // A: offer (createDataChannel not needed — tracks trigger negotiation)
-  const offer = await pcA.createOffer();
-  pcB.setRemoteDescription(offer, "offer");
-  const answer = await pcB.createAnswer(offer);
-  pcA.setRemoteDescription(answer, "answer");
-
-  // Wait for connected
-  for (let i = 0; i < 50; i++) {
-    if (states.a === "connected" && states.b === "connected") break;
-    await sleep(100);
-  }
-  console.log("[pkt] states:", states.a, states.b);
-  if (states.a !== "connected" || states.b !== "connected") {
-    console.log("PKT TEST FAILED: not connected");
-    process.exit(1);
-  }
-
-  // Setup packetizers on A (sender)
-  aAudio.setPacketizer("audio", 1234, 120, 48000, 5, 0, 1);
-  aVideo.setPacketizer("h264", 5678, 101, 90000, 5, 0, 10);
-
-  // Fake opus frame (20ms @48kHz stereo — payload can be any bytes)
-  const opusFrame = Buffer.alloc(160);
-  for (let i = 0; i < 160; i++) opusFrame[i] = i & 0xff;
-
-  // Fake AnnexB H264 frame: SPS + PPS + IDR slice
-  const sps = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0xc0, 0x1e, 0xd9, 0x01, 0x40, 0x7e]);
-  const pps = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x3c, 0x80]);
-  const idr = Buffer.from([0x00, 0x00, 0x00, 0x01, 0x65, 0x88, 0x84, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
-  const h264Frame = Buffer.concat([sps, pps, idr]);
-
-  // Send 10 audio frames (20ms each) + 3 video frames (33ms each)
-  for (let i = 0; i < 10; i++) {
-    aAudio.sendFrame(opusFrame);
-    aAudio.addTimestamp(960); // 20ms @ 48kHz
-  }
-  for (let i = 0; i < 3; i++) {
-    aVideo.sendFrame(h264Frame);
-    aVideo.addTimestamp(3000); // 33ms @ 90kHz
-  }
-
-  await sleep(500);
-  console.log("[pkt] after send: states:", states.a, states.b);
-  console.log("[pkt] audio track open:", aAudio.isOpen(), "| video track open:", aVideo.isOpen());
-  const ok = states.a === "connected" && aAudio.isOpen() && aVideo.isOpen();
-  console.log(ok ? "PKT TEST PASSED" : "PKT TEST FAILED");
-  pcA.close();
-  pcB.close();
-  process.exit(ok ? 0 : 1);
-}
-
-main().catch((e) => {
-  console.error("[pkt] FAILED:", e.message);
-  process.exit(1);
-});
-
-setTimeout(() => {
-  console.error("[pkt] TIMEOUT");
-  process.exit(1);
-}, 25000);

services/discord-gateway/native/libdatachannel-min/test-track.js

@@ -1,33 +0,0 @@
-// Verify addTrack produces SDP with audio+video media sections.
-"use strict";
-const { PeerConnection } = require("./build/Release/datachannel_min.node");
-
-const pc = new PeerConnection({ iceServers: [] });
-const audioTrack = pc.addTrack("0", "audio");
-const videoTrack = pc.addTrack("1", "video");
-
-pc.onStateChange((s) => console.log("[test-track] state:", s));
-
-pc.createOffer().then((sdp) => {
-  const hasAudio = /^m=audio\s/m.test(sdp);
-  const hasVideo = /^m=video\s/m.test(sdp);
-  const audioPts = sdp.match(/a=rtpmap:(\d+) opus/g) || [];
-  const videoPts = sdp.match(/a=rtpmap:(\d+) H264/g) || [];
-  console.log("[test-track] SDP bytes:", sdp.length);
-  console.log("[test-track] m=audio:", hasAudio, "| m=video:", hasVideo);
-  console.log("[test-track] opus pt:", audioPts, "| H264 pt:", videoPts);
-  console.log("[test-track] audio track send ok:", typeof audioTrack.send === "function");
-  console.log("[test-track] video track send ok:", typeof videoTrack.send === "function");
-  const ok = hasAudio && hasVideo && audioPts.length > 0 && videoPts.length > 0;
-  console.log(ok ? "TRACK TEST PASSED" : "TRACK TEST FAILED");
-  pc.close();
-  process.exit(ok ? 0 : 1);
-}).catch((e) => {
-  console.error("[test-track] FAILED:", e.message);
-  process.exit(1);
-});
-
-setTimeout(() => {
-  console.error("[test-track] TIMEOUT");
-  process.exit(1);
-}, 20000);

services/discord-gateway/package.json

@@ -28,7 +28,6 @@
     "discord.js-selfbot-v13": "^3.7.1",
     "dotenv": "^17.4.2",
     "drizzle-orm": "^0.45.2",
-    "imghash": "^1.1.4",
     "ioredis": "^5.11.0",
     "libsodium-wrappers": "^0.8.4",
     "lru-cache": "^11.5.1",

services/discord-gateway/src/app/bootstrap.ts

@@ -3,7 +3,11 @@ import { inArray, lt } from "drizzle-orm";
 import type { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { ConfigError, DatabaseError } from "@/shared/errors/index";
 import { createChildLogger } from "@/shared/logger/index";
-import { startPendingAIAnalysisWorker } from "../modules/ai-moderation/aiAnalyzer.js";
+import {
+  getAnalysisQueueStatus,
+  startPendingAIAnalysisWorker,
+} from "../modules/ai-moderation/aiAnalyzer.js";
+import { workerPool } from "../modules/ai-moderation/circuitBreaker.js";
 import { registerChannelTopicCapture } from "../modules/channel-topic/index.js";
 import { CommandHandler } from "../modules/command-handler/commandHandler.js";
 import {
@@ -11,6 +15,8 @@ import {
   RedisEventPublisher,
 } from "../modules/event-broadcaster/index.js";
 import {
+  registerCollector,
+  setGauge,
   startMetricsServer,
   stopMetricsServer,
 } from "../modules/gateway-metrics/index.js";
@@ -222,7 +228,10 @@ export async function initializeDiscordGateway() {
     await initializeDatabase();
     logger.info("PostgreSQL database initialized");
   } catch (err) {
-    logger.error({ error: err }, "Failed to initialize database");
+    logger.error(
+      { err, errorMsg: err instanceof Error ? err.message : String(err) },
+      "Failed to initialize database",
+    );
     throw new DatabaseError(
       `Database initialization failed: ${err instanceof Error ? err.message : String(err)}`,
     );
@@ -267,7 +276,10 @@ export async function initializeDiscordGateway() {
   });
 
   client.on("error", (err) => {
-    logger.error({ error: err }, "Client error");
+    logger.error(
+      { err, errorMsg: err instanceof Error ? err.message : String(err) },
+      "Client error",
+    );
   });
 
   process.on("SIGINT", () => {
@@ -279,15 +291,97 @@ export async function initializeDiscordGateway() {
   });
 
   process.on("uncaughtException", (err) => {
-    logger.error({ error: err }, "Uncaught exception");
+    const code =
+      typeof (err as NodeJS.ErrnoException).code === "string"
+        ? (err as NodeJS.ErrnoException).code
+        : "";
+    // Transient stream-teardown errors (voice stop/disconnect races, child
+    // process stdin closed while we still write) are NOT fatal — crashing the
+    // gateway on EPIPE takes the whole bot offline mid-music. Log + continue.
+    if (
+      code === "EPIPE" ||
+      code === "ERR_STREAM_DESTROYED" ||
+      code === "ERR_STREAM_WRITE_AFTER_END" ||
+      code === "ECONNRESET"
+    ) {
+      logger.warn(
+        { error: err },
+        "Uncaught transient stream error — continuing",
+      );
+      return;
+    }
+    logger.error(
+      {
+        err,
+        errorMsg: err instanceof Error ? err.message : String(err),
+        stack: err?.stack,
+      },
+      "Uncaught exception",
+    );
     gracefulShutdown("uncaughtException");
   });
 
-  process.on("unhandledRejection", (reason, promise) => {
-    logger.error({ reason, promise }, "Unhandled rejection");
+  process.on("unhandledRejection", (reason) => {
+    const err =
+      reason instanceof Error ? reason : new Error(String(reason ?? "unknown"));
+    const code = (err as NodeJS.ErrnoException).code ?? "";
+    // Same transient-teardown policy as uncaughtException: a rejection that
+    // fires while a stream is being torn down (EPIPE after ffmpeg stdin
+    // closes, write-after-destroy, socket reset) must NOT take the whole
+    // gateway offline. Log detail + continue. Everything else still shuts
+    // down so real bugs surface.
+    if (
+      code === "EPIPE" ||
+      code === "ERR_STREAM_DESTROYED" ||
+      code === "ERR_STREAM_WRITE_AFTER_END" ||
+      code === "ECONNRESET"
+    ) {
+      logger.warn(
+        { error: err },
+        "Unhandled rejection transient stream error — continuing",
+      );
+      return;
+    }
+    logger.error({ error: err, reason: String(reason) }, "Unhandled rejection");
     gracefulShutdown("unhandledRejection");
   });
 
+  // ── Metrics: register live pipeline collectors before starting server ──
+  // These refresh on every scrape so Prometheus sees real AI-analysis
+  // queue depth, concurrency, and DB pool state instead of an empty stub.
+  registerCollector(() => {
+    if (!config.AI_ANALYSIS_ENABLED) return;
+    try {
+      const status = getAnalysisQueueStatus();
+      setGauge("ai_analysis_queued_conversations", status.queuedConversations);
+      setGauge("ai_analysis_active_batch_requests", status.activeRequests);
+      setGauge(
+        "ai_analysis_active_individual_requests",
+        status.activeIndividualRequests,
+      );
+      setGauge(
+        "ai_analysis_individual_in_flight",
+        status.individualInFlightCount,
+      );
+      setGauge(
+        "ai_analysis_individual_circuit_breaker_active",
+        status.individualCircuitBreakerActive ? 1 : 0,
+      );
+      if (typeof status.lastError === "string") {
+        setGauge("ai_analysis_last_error_present", status.lastError ? 1 : 0);
+      }
+      const pool = workerPool as unknown as {
+        _poolState?: { size: number; active: number };
+      };
+      if (pool._poolState) {
+        setGauge("ai_analysis_worker_threads", pool._poolState.size);
+        setGauge("ai_analysis_worker_threads_active", pool._poolState.active);
+      }
+    } catch (err) {
+      logger.warn({ error: String(err) }, "AI metrics collector failed");
+    }
+  });
+
   // Start metrics server
   startMetricsServer();
 

services/discord-gateway/src/goLive/AnnexBBitstreamReaderWriter.ts

@@ -1,155 +0,0 @@
-/**
- * AnnexB bitstream reader/writer (RBSP + emulation prevention) — ported
- * from @dank074/discord-video-stream AnnexBBitstreamReaderWriter.js.
- */
-
-export class AnnexBBitstreamReader {
-  private _buffer: Uint8Array;
-  private _byteOffset = 0;
-  private _bitOffset = 0;
-
-  constructor(buffer: Uint8Array) {
-    this._buffer = buffer;
-  }
-
-  readBits(count: number): number {
-    if (count === 0) return 0;
-    let result = 0;
-    while (count > 0) {
-      if (this._byteOffset >= this._buffer.length) {
-        throw new Error("Bad byte offset");
-      }
-      if (
-        this._bitOffset === 0 &&
-        this._byteOffset >= 2 &&
-        this._buffer[this._byteOffset - 2] === 0 &&
-        this._buffer[this._byteOffset - 1] === 0 &&
-        this._buffer[this._byteOffset] === 3
-      ) {
-        // Skip over emulation prevention
-        this._byteOffset++;
-      }
-      if (this._bitOffset === 0 && count >= 8) {
-        result = (result << 8) | this._buffer[this._byteOffset++];
-        count -= 8;
-      } else {
-        const numBitsToRead = Math.min(count, 8 - this._bitOffset);
-        const mask = (1 << numBitsToRead) - 1;
-        const newBits =
-          (this._buffer[this._byteOffset] >>
-            (8 - this._bitOffset - numBitsToRead)) &
-          mask;
-        result = (result << numBitsToRead) | newBits;
-        count -= numBitsToRead;
-        this._bitOffset += numBitsToRead;
-        if (this._bitOffset === 8) {
-          this._bitOffset = 0;
-          this._byteOffset++;
-        }
-      }
-    }
-    return result;
-  }
-
-  readUnsigned(bits: number): number {
-    return this.readBits(bits);
-  }
-
-  readSigned(bits: number): number {
-    const unsigned = this.readUnsigned(bits);
-    if (unsigned & (1 << (bits - 1))) return unsigned - (1 << bits);
-    return unsigned;
-  }
-
-  readUnsignedExpGolomb(): number {
-    let leading0 = 0;
-    while (this.readBits(1) === 0) leading0++;
-    return (1 << leading0) + this.readBits(leading0) - 1;
-  }
-
-  readSignedExpGolomb(): number {
-    const unsigned = this.readUnsignedExpGolomb();
-    if (unsigned % 2 === 0) return unsigned / -2;
-    return (unsigned + 1) / 2;
-  }
-}
-
-export class AnnexBBitstreamWriter {
-  private _arr: number[] = [];
-  private _pendingByte = 0;
-  private _bitOffset = 0;
-
-  toBuffer(): Buffer {
-    return Buffer.from(this._arr);
-  }
-
-  flush(): void {
-    // Emulation prevention: insert 0x03 before 00 00
-    if (
-      this._pendingByte <= 3 &&
-      this._arr[this._arr.length - 1] === 0 &&
-      this._arr[this._arr.length - 2] === 0
-    ) {
-      this._arr.push(3);
-    }
-    this._arr.push(this._pendingByte);
-    this._pendingByte = 0;
-    this._bitOffset = 0;
-  }
-
-  writeBits(bits: number, count: number): void {
-    while (count > 0) {
-      if (this._bitOffset === 0) {
-        if (count >= 8) {
-          this._pendingByte = (bits >> (count - 8)) & 0xff;
-          count -= 8;
-          this.flush();
-        } else {
-          const mask = (1 << count) - 1;
-          this._pendingByte |= (bits & mask) << (8 - count);
-          this._bitOffset = count;
-          count = 0;
-        }
-      } else {
-        const numBitsToWrite = Math.min(8 - this._bitOffset, count);
-        const bitsToWrite =
-          (bits >> (count - numBitsToWrite)) & ((1 << numBitsToWrite) - 1);
-        this._pendingByte |=
-          bitsToWrite << (8 - this._bitOffset - numBitsToWrite);
-        count -= numBitsToWrite;
-        this._bitOffset += numBitsToWrite;
-        if (this._bitOffset === 8) {
-          this._bitOffset = 0;
-          this.flush();
-        }
-      }
-    }
-  }
-
-  writeUnsigned(num: number, count: number): void {
-    if (num < 0) throw new Error("Expected a non-negative number");
-    this.writeBits(num, count);
-  }
-
-  writeSigned(num: number, count: number): void {
-    if (count <= 0) return;
-    if (count > 32) throw new Error("writeSigned supports up to 32 bits");
-    const mask =
-      count === 32 ? 0xffffffff >>> 0 : (((1 << count) >>> 0) - 1) >>> 0;
-    const unsigned = (num & mask) >>> 0;
-    this.writeBits(unsigned, count);
-  }
-
-  writeUnsignedExpGolomb(num: number): void {
-    if (num < 0) throw new Error("Expected a non-negative number");
-    num++;
-    const bitCount = 32 - Math.clz32(num >>> 0);
-    this.writeBits(0, bitCount - 1);
-    this.writeBits(num, bitCount);
-  }
-
-  writeSignedExpGolomb(num: number): void {
-    if (num < 0) this.writeUnsignedExpGolomb(-2 * num);
-    else this.writeUnsignedExpGolomb(2 * num - 1);
-  }
-}

services/discord-gateway/src/goLive/AnnexBHelper.ts

@@ -1,112 +0,0 @@
-/**
- * H264/H265 NAL helpers — ported from @dank074/discord-video-stream
- * AnnexBHelper.js. Only the H264 parts are used by GoLive (H264 encoder),
- * H265 constants kept for completeness of the port.
- */
-
-export enum H264NalUnitTypes {
-  Unspecified = 0,
-  CodedSliceNonIDR = 1,
-  CodedSlicePartitionA = 2,
-  CodedSlicePartitionB = 3,
-  CodedSlicePartitionC = 4,
-  CodedSliceIdr = 5,
-  SEI = 6,
-  SPS = 7,
-  PPS = 8,
-  AccessUnitDelimiter = 9,
-  EndOfSequence = 10,
-  EndOfStream = 11,
-  FillerData = 12,
-  SEIExtenstion = 13,
-  PrefixNalUnit = 14,
-  SubsetSPS = 15,
-}
-
-export enum H265NalUnitTypes {
-  TRAIL_N = 0,
-  TRAIL_R = 1,
-  TSA_N = 2,
-  TSA_R = 3,
-  STSA_N = 4,
-  STSA_R = 5,
-  RADL_N = 6,
-  RADL_R = 7,
-  RASL_N = 8,
-  RASL_R = 9,
-  RSV_VCL_N10 = 10,
-  RSV_VCL_R11 = 11,
-  RSV_VCL_N12 = 12,
-  RSV_VCL_R13 = 13,
-  RSV_VCL_N14 = 14,
-  RSV_VCL_R15 = 15,
-  BLA_W_LP = 16,
-  BLA_W_RADL = 17,
-  BLA_N_LP = 18,
-  IDR_W_RADL = 19,
-  IDR_N_LP = 20,
-  CRA_NUT = 21,
-  RSV_IRAP_VCL22 = 22,
-  RSV_IRAP_VCL23 = 23,
-  RSV_VCL24 = 24,
-  RSV_VCL25 = 25,
-  RSV_VCL26 = 26,
-  RSV_VCL27 = 27,
-  RSV_VCL28 = 28,
-  RSV_VCL29 = 29,
-  RSV_VCL30 = 30,
-  RSV_VCL31 = 31,
-  VPS_NUT = 32,
-  SPS_NUT = 33,
-  PPS_NUT = 34,
-  AUD_NUT = 35,
-  EOS_NUT = 36,
-  EOB_NUT = 37,
-  FD_NUT = 38,
-  PREFIX_SEI_NUT = 39,
-  SUFFIX_SEI_NUT = 40,
-}
-
-export const H264Helpers = {
-  getUnitType(frame: Uint8Array): number {
-    return frame[0] & 0x1f;
-  },
-  splitHeader(frame: Uint8Array): [Uint8Array, Uint8Array] {
-    return [frame.subarray(0, 1), frame.subarray(1)];
-  },
-  isAUD(unitType: number): boolean {
-    return unitType === H264NalUnitTypes.AccessUnitDelimiter;
-  },
-};
-
-export const H265Helpers = {
-  getUnitType(frame: Uint8Array): number {
-    return (frame[0] >> 1) & 0x3f;
-  },
-  splitHeader(frame: Uint8Array): [Uint8Array, Uint8Array] {
-    return [frame.subarray(0, 2), frame.subarray(2)];
-  },
-  isAUD(unitType: number): boolean {
-    return unitType === H265NalUnitTypes.AUD_NUT;
-  },
-};
-
-export const startCode3 = Buffer.from([0, 0, 1]);
-
-/** Split an AnnexB bitstream into NAL units (start codes stripped). */
-export function splitNalu(buf: Buffer): Buffer[] {
-  let temp: Buffer | null = buf;
-  const nalus: Buffer[] = [];
-  while (temp?.byteLength) {
-    let pos: number = temp.indexOf(startCode3);
-    let length = 3;
-    if (pos > 0 && temp[pos - 1] === 0) {
-      pos--;
-      length++;
-    }
-    const nalu = pos === -1 ? temp : temp.subarray(0, pos);
-    temp = pos === -1 ? null : temp.subarray(pos + length);
-    if (nalu.byteLength) nalus.push(nalu);
-  }
-  return nalus;
-}

services/discord-gateway/src/goLive/AudioStream.ts

@@ -1,20 +0,0 @@
-/**
- * AudioStream — feeds encoded opus frames into the WebRTC connection.
- * Ported from @dank074/discord-video-stream AudioStream.js.
- */
-
-import { BaseMediaStream } from "./BaseMediaStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export class AudioStream extends BaseMediaStream {
-  _conn: WebRtcConnWrapper;
-
-  constructor(conn: WebRtcConnWrapper, noSleep = false) {
-    super("audio", noSleep);
-    this._conn = conn;
-  }
-
-  async _sendFrame(frame: Buffer, frametime: number): Promise<void> {
-    this._conn.sendAudioFrame(frame, frametime);
-  }
-}

services/discord-gateway/src/goLive/BaseMediaConnection.ts

@@ -1,594 +0,0 @@
-/**
- * Base media connection for Discord GoLive — ported from
- * @dank074/discord-video-stream BaseMediaConnection.js.
- *
- * Owns the voice WebSocket (identify/select_protocol/heartbeat/resume),
- * SDP negotiation against Discord's media server, DAVE E2E voice
- * (via @snazzah/davey), and speaking/video attribute signaling.
- */
-
-import { randomUUID } from "node:crypto";
-import { EventEmitter } from "node:events";
-import Davey from "@snazzah/davey";
-import { CodecPayloadType } from "./CodecPayloadType.js";
-import type { NativePeerConnection } from "./native.js";
-import { isNativeAvailable } from "./native.js";
-import { STREAMS_SIMULCAST } from "./utils.js";
-import { VoiceOpCodes, VoiceOpCodesBinary } from "./VoiceOpCodes.js";
-import { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export interface MediaConnectionStatus {
-  hasSession: boolean;
-  hasToken: boolean;
-  started: boolean;
-  resuming: boolean;
-}
-
-export interface VideoAttribute {
-  fps: number;
-  width: number;
-  height: number;
-}
-
-export interface StreamerLike {
-  opts: Record<string, unknown>;
-}
-
-export class BaseMediaConnection extends EventEmitter {
-  interval: ReturnType<typeof setInterval> | null = null;
-  guildId: string | null = null;
-  channelId: string;
-  botId: string;
-  ws: WebSocket | null = null;
-  status: MediaConnectionStatus;
-  server: string | null = null; // websocket url
-  token: string | null = null;
-  session_id: string | null = null;
-  protected _webRtcWrapper: WebRtcConnWrapper;
-  _webRtcParams: {
-    address: string;
-    port: number;
-    audioSsrc: number;
-    videoSsrc: number;
-    rtxSsrc: number;
-    supportedEncryptionModes: string[];
-  } | null = null;
-  protected _closed = false;
-  ready: ((conn: WebRtcConnWrapper) => void) | null;
-  protected _streamer: StreamerLike;
-  protected _sequenceNumber = -1;
-  protected _daveSession: Davey.DAVESession | null = null;
-  protected _connectedUsers = new Set<string>();
-  protected _daveProtocolVersion = 0;
-  protected _davePendingTransitions = new Map<number, number>();
-  protected _daveDowngraded = false;
-
-  constructor(
-    streamer: StreamerLike,
-    guildId: string | null,
-    botId: string,
-    channelId: string,
-    callback: ((conn: WebRtcConnWrapper) => void) | null,
-  ) {
-    super();
-    this._streamer = streamer;
-    this.status = {
-      hasSession: false,
-      hasToken: false,
-      started: false,
-      resuming: false,
-    };
-    this.guildId = guildId;
-    this.channelId = channelId;
-    this.botId = botId;
-    this.ready = callback;
-    this._webRtcWrapper = new WebRtcConnWrapper(this);
-  }
-
-  get type(): "guild" | "call" {
-    return this.guildId ? "guild" : "call";
-  }
-
-  get webRtcConn(): WebRtcConnWrapper {
-    return this._webRtcWrapper;
-  }
-
-  get webRtcParams(): BaseMediaConnection["_webRtcParams"] {
-    return this._webRtcParams;
-  }
-
-  get streamer(): StreamerLike {
-    return this._streamer;
-  }
-
-  /** daveChannelId — overridden in VoiceConnection (channelId) and StreamConnection (serverId - 1n). */
-  get daveChannelId(): string {
-    throw new Error("daveChannelId not implemented");
-  }
-
-  stop(): void {
-    this._closed = true;
-    this._webRtcWrapper.close();
-    this.ws?.close();
-  }
-
-  setSession(session_id: string): void {
-    this.session_id = session_id;
-    this.status.hasSession = true;
-    this.start();
-  }
-
-  setTokens(server: string, token: string): void {
-    this.token = token;
-    this.server = server;
-    this.status.hasToken = true;
-    this.start();
-  }
-
-  start(): void {
-    if (this.status.hasSession && this.status.hasToken) {
-      if (this.status.started) return;
-      this.status.started = true;
-      this.ws = new WebSocket(`wss://${this.server}/?v=8`);
-      this.ws.binaryType = "arraybuffer";
-      this.ws.addEventListener("open", () => {
-        if (this.status.resuming) {
-          this.status.resuming = false;
-          this.resume();
-        } else {
-          this.identify();
-        }
-      });
-      this.ws.addEventListener("error", (err) => {
-        console.error(err);
-      });
-      this.ws.addEventListener("close", (e) => {
-        const wasStarted = this.status.started;
-        this.interval && clearInterval(this.interval);
-        this.status.started = false;
-        const canResume = e.code === 4015 || e.code < 4000;
-        if (canResume && wasStarted) {
-          this.status.resuming = true;
-          this.start();
-        } else {
-          this._closed = true;
-          this._webRtcWrapper?.close();
-        }
-      });
-      this.setupEvents();
-    }
-  }
-
-  handleReady(d: {
-    ip: string;
-    port: number;
-    ssrc: number;
-    streams: { ssrc: number; rtx_ssrc: number }[];
-    modes: string[];
-  }): void {
-    // we hardcoded STREAMS_SIMULCAST, which will always be array of 1
-    const stream = d.streams[0];
-    this._webRtcParams = {
-      address: d.ip,
-      port: d.port,
-      audioSsrc: d.ssrc,
-      videoSsrc: stream.ssrc,
-      rtxSsrc: stream.rtx_ssrc,
-      supportedEncryptionModes: d.modes,
-    };
-  }
-
-  async handleProtocolAck(d: {
-    sdp?: string;
-    dave_protocol_version?: number;
-  }): Promise<void> {
-    if (!("sdp" in d)) throw new Error("Only WebRTC connections are allowed");
-    this._daveProtocolVersion = d.dave_protocol_version ?? 0;
-    this.initDave();
-    // Discord's SDP is garbage — generate our own from its pieces
-    let ip = "";
-    let port = "";
-    let iceUsername = "";
-    let icePassword = "";
-    let fingerprint = "";
-    let candidate = "";
-    for (const line of (d.sdp ?? "").split("\n")) {
-      if (line.startsWith("c=")) ip = line;
-      else if (line.startsWith("a=rtcp")) port = line.split(":")[1];
-      else if (line.startsWith("a=ice-ufrag")) iceUsername = line;
-      else if (line.startsWith("a=ice-pwd")) icePassword = line;
-      else if (line.startsWith("a=fingerprint")) fingerprint = line;
-      else if (line.startsWith("a=candidate")) candidate = line;
-    }
-    const audioPayloadType = CodecPayloadType.opus.payload_type;
-    const audioSection = `
-m=audio ${port} UDP/TLS/RTP/SAVPF ${audioPayloadType}
-${ip}
-a=extmap:1 urn:ietf:params:rtp-hdrext:ssrc-audio-level
-a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
-a=setup:passive
-a=mid:0
-a=maxptime:60
-a=inactive
-${iceUsername}
-${icePassword}
-${fingerprint}
-${candidate}
-a=rtcp-mux
-a=rtpmap:${audioPayloadType} opus/48000/2
-a=fmtp:${audioPayloadType} minptime=10;useinbandfec=1;usedtx=1
-a=rtcp-fb:${audioPayloadType} transport-cc
-a=rtcp-fb:${audioPayloadType} nack
-a=ice-lite
-`.trim();
-    const videoPayloads = Object.values(CodecPayloadType).filter(
-      (el) => el.type === "video",
-    );
-    const videoPayloadTypes = videoPayloads.flatMap((el) => [
-      el.payload_type,
-      el.rtx_payload_type ?? 0,
-    ]);
-    const videoSection = `
-m=video ${port} UDP/TLS/RTP/SAVPF ${videoPayloadTypes.join(" ")}
-${ip}
-a=extmap:2 http://www.webrtc.org/experiments/rtp-hdrext/abs-send-time
-a=extmap:3 http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01
-a=extmap:14 urn:ietf:params:rtp-hdrext:toffset
-a=extmap:13 urn:3gpp:video-orientation
-a=extmap:5 http://www.webrtc.org/experiments/rtp-hdrext/playout-delay
-a=setup:passive
-a=mid:1
-a=inactive
-${iceUsername}
-${icePassword}
-${fingerprint}
-${candidate}
-a=rtcp-mux
-a=ice-lite
-`.trim();
-    const videoRtpMap = videoPayloads
-      .flatMap((el) => [
-        `a=rtpmap:${el.payload_type} ${el.name}/90000`,
-        `a=rtpmap:${el.rtx_payload_type} rtx/90000`,
-        `a=fmtp:${el.rtx_payload_type} apt=${el.payload_type}`,
-        `a=rtcp-fb:${el.payload_type} ccm fir`,
-        `a=rtcp-fb:${el.payload_type} nack`,
-        `a=rtcp-fb:${el.payload_type} nack pli`,
-        `a=rtcp-fb:${el.payload_type} goog-remb`,
-        `a=rtcp-fb:${el.payload_type} transport-cc`,
-      ])
-      .join("\n");
-    this._webRtcWrapper.webRtcConn?.setRemoteDescription(
-      [audioSection, videoSection, videoRtpMap].join("\n"),
-      "answer",
-    );
-    this.emit("select_protocol_ack");
-  }
-
-  initDave(): void {
-    if (this._daveProtocolVersion) {
-      if (this._daveSession) {
-        this._daveSession.reinit(
-          this._daveProtocolVersion,
-          this.botId,
-          this.daveChannelId,
-        );
-      } else {
-        this._daveSession = new Davey.DAVESession(
-          this._daveProtocolVersion,
-          this.botId,
-          this.daveChannelId,
-        );
-      }
-      this.sendOpcodeBinary(
-        VoiceOpCodesBinary.MLS_KEY_PACKAGE,
-        this._daveSession.getSerializedKeyPackage(),
-      );
-    } else if (this._daveSession) {
-      this._daveSession.reset();
-      this._daveSession.setPassthroughMode(true, 10);
-    }
-  }
-
-  processInvalidCommit(transitionId: number): void {
-    this.sendOpcode(VoiceOpCodes.MLS_INVALID_COMMIT_WELCOME, {
-      transition_id: transitionId,
-    });
-    this.initDave();
-  }
-
-  executePendingTransition(transitionId: number): void {
-    const newVersion = this._davePendingTransitions.get(transitionId);
-    if (newVersion === undefined) {
-      console.error("Unrecognized transition ID", { transitionId });
-      return;
-    }
-    const oldVersion = this._daveProtocolVersion;
-    this._daveProtocolVersion = newVersion;
-    if (oldVersion !== newVersion && newVersion === 0) {
-      // Downgraded
-      this._daveDowngraded = true;
-    } else if (transitionId > 0 && this._daveDowngraded) {
-      this._daveDowngraded = false;
-      this._daveSession?.setPassthroughMode(true, 10);
-    }
-    this._davePendingTransitions.delete(transitionId);
-  }
-
-  setupEvents(): void {
-    this.ws?.addEventListener("message", async (e) => {
-      if (e.data instanceof ArrayBuffer) {
-        this.handleBinaryMessages(Buffer.from(e.data));
-        return;
-      }
-      const { op, d, seq } = JSON.parse(e.data as string) as {
-        op: number;
-        // biome-ignore lint/suspicious/noExplicitAny: Discord voice WS payload is dynamically typed
-        d: any;
-        seq?: number;
-      };
-      if (seq) this._sequenceNumber = seq;
-      if (op === VoiceOpCodes.READY) {
-        this.handleReady(d);
-        this.setProtocols().then(() => this.ready?.(this._webRtcWrapper));
-        this.setVideoAttributes(false);
-      } else if (op >= 4000) {
-        console.error(`${this.constructor.name} connection error`, d);
-      } else if (op === VoiceOpCodes.HELLO) {
-        this.setupHeartbeat(d.heartbeat_interval);
-      } else if (op === VoiceOpCodes.SELECT_PROTOCOL_ACK) {
-        await this.handleProtocolAck(d);
-      } else if (op === VoiceOpCodes.SPEAKING) {
-        // ignore speaking updates
-      } else if (op === VoiceOpCodes.HEARTBEAT_ACK) {
-        // ignore heartbeat acknowledgements
-      } else if (op === VoiceOpCodes.RESUMED) {
-        this.status.started = true;
-      } else if (op === VoiceOpCodes.CLIENTS_CONNECT) {
-        d.user_ids.forEach((id: string) => {
-          this._connectedUsers.add(id);
-        });
-      } else if (op === VoiceOpCodes.CLIENT_DISCONNECT) {
-        this._connectedUsers.delete(d.user_id);
-      } else if (op === VoiceOpCodes.DAVE_PREPARE_TRANSITION) {
-        this._davePendingTransitions.set(d.transition_id, d.protocol_version);
-        if (d.transition_id === 0) {
-          this.executePendingTransition(d.transition_id);
-        } else {
-          if (d.protocol_version === 0) {
-            this._daveSession?.setPassthroughMode(true, 120);
-          }
-          this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-            transition_id: d.transition_id,
-          });
-        }
-      } else if (op === VoiceOpCodes.DAVE_EXECUTE_TRANSITION) {
-        this.executePendingTransition(d.transition_id);
-      } else if (op === VoiceOpCodes.DAVE_PREPARE_EPOCH) {
-        if (d.epoch === 1) {
-          this._daveProtocolVersion = d.protocol_version;
-          this.initDave();
-        }
-      }
-    });
-  }
-
-  handleBinaryMessages(msg: Buffer): void {
-    this._sequenceNumber = msg.readUint16BE(0);
-    const op = msg.readUint8(2);
-    switch (op) {
-      case VoiceOpCodesBinary.MLS_EXTERNAL_SENDER: {
-        this._daveSession?.setExternalSender(msg.subarray(3));
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_PROPOSALS: {
-        const optype = msg.readUint8(3);
-        if (!this._daveSession) break;
-        const { commit, welcome } = this._daveSession.processProposals(
-          optype,
-          msg.subarray(4),
-          [...this._connectedUsers],
-        );
-        if (commit) {
-          this.sendOpcodeBinary(
-            VoiceOpCodesBinary.MLS_COMMIT_WELCOME,
-            welcome ? Buffer.concat([commit, welcome]) : commit,
-          );
-        }
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_ANNOUNCE_COMMIT_TRANSITION: {
-        const transitionId = msg.readUInt16BE(3);
-        try {
-          this._daveSession?.processCommit(msg.subarray(5));
-          if (transitionId) {
-            this._davePendingTransitions.set(
-              transitionId,
-              this._daveProtocolVersion,
-            );
-            this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-              transition_id: transitionId,
-            });
-          }
-        } catch (e) {
-          console.debug("MLS commit errored", e);
-          this.processInvalidCommit(transitionId);
-        }
-        break;
-      }
-      case VoiceOpCodesBinary.MLS_WELCOME: {
-        const transitionId = msg.readUInt16BE(3);
-        try {
-          this._daveSession?.processWelcome(msg.subarray(5));
-          if (transitionId) {
-            this._davePendingTransitions.set(
-              transitionId,
-              this._daveProtocolVersion,
-            );
-            this.sendOpcode(VoiceOpCodes.DAVE_TRANSITION_READY, {
-              transition_id: transitionId,
-            });
-          }
-        } catch (e) {
-          console.debug("MLS welcome errored", e);
-          this.processInvalidCommit(transitionId);
-        }
-        break;
-      }
-    }
-  }
-
-  get daveReady(): boolean {
-    return !!this._daveProtocolVersion && !!this._daveSession?.ready;
-  }
-
-  get daveSession(): Davey.DAVESession | null {
-    return this._daveSession;
-  }
-
-  setupHeartbeat(interval: number): void {
-    if (this.interval) {
-      clearInterval(this.interval);
-    }
-    this.interval = setInterval(() => {
-      try {
-        this.sendOpcode(VoiceOpCodes.HEARTBEAT, {
-          t: Date.now(),
-          seq_ack: this._sequenceNumber,
-        });
-      } catch {
-        /* ignore */
-      }
-    }, interval);
-  }
-
-  sendOpcode(code: number, data: unknown): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-    this.ws.send(JSON.stringify({ op: code, d: data }));
-  }
-
-  sendOpcodeBinary(code: number, data: Uint8Array): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) return;
-    const buf = Buffer.allocUnsafe(data.length + 1);
-    buf.writeUInt8(code);
-    Buffer.from(data).copy(buf, 1);
-    this.ws.send(buf);
-  }
-
-  /** serverId — overridden in VoiceConnection (guildId ?? channelId) and StreamConnection (rtc_server_id). */
-  get serverId(): string | null {
-    throw new Error("serverId not implemented");
-  }
-
-  /** identifies with media server with credentials */
-  identify(): void {
-    if (!this.serverId) throw new Error("Server ID is null or empty");
-    if (!this.session_id) throw new Error("Session ID is null or empty");
-    if (!this.token) throw new Error("Token is null or empty");
-    this.sendOpcode(VoiceOpCodes.IDENTIFY, {
-      server_id: this.serverId,
-      user_id: this.botId,
-      session_id: this.session_id,
-      token: this.token,
-      video: true,
-      streams: STREAMS_SIMULCAST,
-      max_dave_protocol_version: Davey.DAVE_PROTOCOL_VERSION ?? 0,
-    });
-  }
-
-  resume(): void {
-    if (!this.serverId) throw new Error("Server ID is null or empty");
-    if (!this.session_id) throw new Error("Session ID is null or empty");
-    if (!this.token) throw new Error("Token is null or empty");
-    this.sendOpcode(VoiceOpCodes.RESUME, {
-      server_id: this.serverId,
-      session_id: this.session_id,
-      token: this.token,
-      seq_ack: this._sequenceNumber,
-    });
-  }
-
-  /** Sets protocols and ip data used for video and audio (vp8 video, opus audio). */
-  async setProtocols(): Promise<void> {
-    if (!this._webRtcParams) throw new Error("WebRTC parameters not set");
-    if (!isNativeAvailable()) {
-      throw new Error(
-        "libdatachannel-min native binding not built — cannot start GoLive",
-      );
-    }
-    const reconnect = () => {
-      const webRtcConn = this._webRtcWrapper.initWebRtc();
-      webRtcConn.onStateChange((state) => {
-        if (state === "closed" && !this._closed) reconnect();
-      });
-      this._webRtcWrapper.onLocalDescription = (sdp) => {
-        const rtc_connection_id = randomUUID();
-        this.sendOpcode(VoiceOpCodes.SELECT_PROTOCOL, {
-          protocol: "webrtc",
-          codecs: Object.values(CodecPayloadType),
-          data: sdp,
-          sdp,
-          rtc_connection_id,
-        });
-      };
-      // createOffer (binding resolves full SDP incl. candidates after gathering)
-      void webRtcConn.createOffer().then((sdp) => {
-        this._webRtcWrapper.onLocalDescription?.(sdp);
-      });
-    };
-    reconnect();
-    return new Promise((resolve) => {
-      this.once("select_protocol_ack", () => resolve());
-    });
-  }
-
-  setVideoAttributes(enabled: boolean, attr?: VideoAttribute): void {
-    if (!this._webRtcParams) throw new Error("WebRTC parameters not set");
-    const { audioSsrc, videoSsrc, rtxSsrc } = this._webRtcParams;
-    if (!enabled) {
-      this.sendOpcode(VoiceOpCodes.VIDEO, {
-        audio_ssrc: audioSsrc,
-        video_ssrc: 0,
-        rtx_ssrc: 0,
-        streams: [],
-      });
-    } else {
-      if (!attr) throw new Error("Need to specify video attributes");
-      this.sendOpcode(VoiceOpCodes.VIDEO, {
-        audio_ssrc: audioSsrc,
-        video_ssrc: videoSsrc,
-        rtx_ssrc: rtxSsrc,
-        streams: [
-          {
-            type: "video",
-            rid: "100",
-            ssrc: videoSsrc,
-            active: true,
-            quality: 100,
-            rtx_ssrc: rtxSsrc,
-            // hardcode the max bitrate because we don't really know anyway
-            max_bitrate: 10000 * 1000,
-            max_framerate: enabled ? attr.fps : 0,
-            max_resolution: {
-              type: "fixed",
-              width: attr.width,
-              height: attr.height,
-            },
-          },
-        ],
-      });
-    }
-  }
-
-  /** Set speaking status */
-  setSpeaking(speaking: boolean): void {
-    if (!this._webRtcParams) throw new Error("WebRTC connection not ready");
-    this.sendOpcode(VoiceOpCodes.SPEAKING, {
-      delay: 0,
-      speaking: speaking ? 1 : 0,
-      ssrc: this._webRtcParams.audioSsrc,
-    });
-  }
-}
-
-export type { NativePeerConnection };

services/discord-gateway/src/goLive/BaseMediaStream.ts

@@ -1,175 +0,0 @@
-/**
- * BaseMediaStream — pacing/sync for GoLive frames. Ported from
- * @dank074/discord-video-stream BaseMediaStream.js, minus node-av's
- * AVFrame (frames are plain objects here) and debug-level (uses the GMW
- * logger instead).
- */
-
-import { Writable } from "node:stream";
-import { setTimeout as sleep } from "node:timers/promises";
-
-export interface GoLiveFrame {
-  data: Buffer | null;
-  pts: number;
-  duration: number;
-  timeBase: { num: number; den: number };
-  free?: () => void;
-}
-
-export class BaseMediaStream extends Writable {
-  _pts: number | undefined;
-  _syncTolerance = 20;
-  _noSleep: boolean;
-  _startTime: number | undefined;
-  _startPts: number | undefined;
-  _sync = true;
-  _syncStream: BaseMediaStream | undefined;
-  _type: string;
-
-  constructor(type: string, noSleep = false) {
-    super({ objectMode: true, highWaterMark: 0 });
-    this._type = type;
-    this._noSleep = noSleep;
-  }
-
-  get sync(): boolean {
-    return this._sync;
-  }
-
-  set sync(val: boolean) {
-    this._sync = val;
-  }
-
-  get syncStream(): BaseMediaStream | undefined {
-    return this._syncStream;
-  }
-
-  set syncStream(stream: BaseMediaStream | undefined) {
-    if (stream !== undefined && this === stream.syncStream) {
-      throw new Error("Cannot sync 2 streams with eachother");
-    }
-    this._syncStream = stream;
-  }
-
-  get noSleep(): boolean {
-    return this._noSleep;
-  }
-
-  set noSleep(val: boolean) {
-    this._noSleep = val;
-    if (!val) this.resetTimingCompensation();
-  }
-
-  get pts(): number | undefined {
-    return this._pts;
-  }
-
-  get syncTolerance(): number {
-    return this._syncTolerance;
-  }
-
-  set syncTolerance(n: number) {
-    if (n < 0) return;
-    this._syncTolerance = n;
-  }
-
-  async _sendFrame(_frame: Buffer, _frametime: number): Promise<void> {
-    throw new Error("Not implemented");
-  }
-
-  ptsDelta(): number | undefined {
-    if (this.pts !== undefined && this.syncStream?.pts !== undefined) {
-      return this.pts - this.syncStream.pts;
-    }
-    return undefined;
-  }
-
-  isAhead(): boolean {
-    const delta = this.ptsDelta();
-    return (
-      this.syncStream?.writableEnded === false &&
-      delta !== undefined &&
-      delta > this.syncTolerance
-    );
-  }
-
-  isBehind(): boolean {
-    const delta = this.ptsDelta();
-    return (
-      this.syncStream?.writableEnded === false &&
-      delta !== undefined &&
-      delta < -this.syncTolerance
-    );
-  }
-
-  resetTimingCompensation(): void {
-    this._startTime = this._startPts = undefined;
-  }
-
-  async _write(
-    frame: GoLiveFrame,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void,
-  ): Promise<void> {
-    const { data, pts, duration, timeBase } = frame;
-    if (!data) {
-      frame.free?.();
-      callback();
-      return;
-    }
-    const frametime = (Number(duration) / timeBase.den) * timeBase.num * 1000;
-    const start_sendFrame = performance.now();
-    await this._sendFrame(Buffer.from(data), frametime);
-    const end_sendFrame = performance.now();
-    this._pts = (Number(pts) / timeBase.den) * timeBase.num * 1000;
-    this.emit("pts", this._pts);
-    const sendTime = end_sendFrame - start_sendFrame;
-    const ratio = sendTime / frametime;
-    if (ratio > 1) {
-      // Frame takes longer to send than its frametime — warn once per 100
-      if (
-        this._lastWarnedRatio === undefined ||
-        ratio > this._lastWarnedRatio
-      ) {
-        this._lastWarnedRatio = ratio;
-      }
-    }
-    this._startTime ??= start_sendFrame;
-    this._startPts ??= this._pts;
-    const sleepMs = Math.max(
-      0,
-      this._pts -
-        this._startPts +
-        frametime -
-        (end_sendFrame - this._startTime),
-    );
-    if (this._noSleep || sleepMs === 0) {
-      callback(null);
-    } else if (this.sync && this.isBehind()) {
-      // Stream is behind — don't sleep for this frame
-      this.resetTimingCompensation();
-      callback(null);
-    } else if (this.sync && this.isAhead()) {
-      // Stream is ahead — wait until the sync stream catches up
-      do {
-        await sleep(frametime);
-      } while (this.sync && this.isAhead());
-      this.resetTimingCompensation();
-      callback(null);
-    } else {
-      await sleep(sleepMs);
-      callback(null);
-    }
-    frame.free?.();
-  }
-
-  _lastWarnedRatio: number | undefined;
-
-  _destroy(
-    error: Error | null,
-    callback: (error?: Error | null) => void,
-  ): void {
-    super._destroy(error, callback);
-    this.syncStream = undefined;
-  }
-}

services/discord-gateway/src/goLive/CodecPayloadType.ts

@@ -1,71 +0,0 @@
-/** Payload types for Discord GoLive media — ported from @dank074/discord-video-stream. */
-export interface CodecPayloadTypeEntry {
-  name: string;
-  type: "audio" | "video";
-  clockRate: number;
-  priority: number;
-  payload_type: number;
-  rtx_payload_type?: number;
-  encode?: boolean;
-  decode?: boolean;
-}
-
-export const CodecPayloadType: Record<string, CodecPayloadTypeEntry> = {
-  opus: {
-    name: "opus",
-    type: "audio",
-    clockRate: 48000,
-    priority: 1000,
-    payload_type: 120,
-  },
-  H264: {
-    name: "H264",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 101,
-    rtx_payload_type: 102,
-    encode: true,
-    decode: true,
-  },
-  H265: {
-    name: "H265",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 103,
-    rtx_payload_type: 104,
-    encode: true,
-    decode: true,
-  },
-  VP8: {
-    name: "VP8",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 105,
-    rtx_payload_type: 106,
-    encode: true,
-    decode: true,
-  },
-  VP9: {
-    name: "VP9",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 107,
-    rtx_payload_type: 108,
-    encode: true,
-    decode: true,
-  },
-  AV1: {
-    name: "AV1",
-    type: "video",
-    clockRate: 90000,
-    priority: 1000,
-    payload_type: 109,
-    rtx_payload_type: 110,
-    encode: true,
-    decode: true,
-  },
-};

services/discord-gateway/src/goLive/Demuxer.ts

@@ -1,377 +0,0 @@
-/**
- * Lightweight demuxer — replaces node-av's LibavDemuxer for GoLive.
- *
- * Spawns ffmpeg to remux input into H264 AnnexB on stdout (video only —
- * screen share doesn't need to mux audio into the demuxer; audio goes
- * separately). This replaces the 114MB node-av binary with a plain ffmpeg
- * spawn.
- *
- * Each video "frame" emitted is a complete NAL sequence terminated by a
- * keyframe boundary (IDR). Audio is not extracted here — for GoLive with
- * audio, the NUT mux + full demuxer would be needed; screen share audio is
- * handled via a separate ffmpeg instance (see getDirectScreenInput).
- */
-
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { createWriteStream, existsSync, readdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { PassThrough } from "node:stream";
-
-/**
- * Resolve ffmpeg/ffprobe binary. Prefers explicit env override, then PATH,
- * then a Nix-store ffmpeg-headless (the GMW flake provides it in the service
- * profile, but dev shells / tests may not have it on PATH).
- */
-function resolveBin(name: "ffmpeg"): string {
-  const override = process.env.FFMPEG_PATH;
-  if (override && existsSync(override)) return override;
-  // Nix store scan: <store>/<hash>-ffmpeg-headless-*/bin/<name>
-  const store = "/nix/store";
-  if (existsSync(store)) {
-    const entries = readdirSync(store);
-    for (const entry of entries) {
-      if (!entry.includes("ffmpeg-headless-")) continue;
-      const candidate = join(store, entry, "bin", name);
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return name; // fall back to PATH
-}
-
-const FFMPEG = resolveBin("ffmpeg");
-
-export const AVCodecID = {
-  AV_CODEC_ID_H264: 27,
-  AV_CODEC_ID_HEVC: 173,
-  AV_CODEC_ID_VP8: 139,
-  AV_CODEC_ID_VP9: 167,
-  AV_CODEC_ID_AV1: 225,
-  AV_CODEC_ID_OPUS: 86019,
-} as const;
-export type AVCodecID = (typeof AVCodecID)[keyof typeof AVCodecID];
-
-export const AV_PKT_FLAG_KEY = 1;
-
-export interface Frame {
-  data: Buffer | null;
-  pts: number;
-  duration: number;
-  timeBase: { num: number; den: number };
-  flags: number;
-  streamIndex: number;
-  free(): void;
-}
-
-export interface DemuxedStream {
-  codec: number;
-  codecName: string;
-  width: number;
-  height: number;
-  framerate_num: number;
-  framerate_den: number;
-  sample_rate: number;
-  stream: PassThrough;
-}
-
-/**
- * Probe a media file for stream info using ffmpeg's stderr (the
- * ffmpeg-headless Nix package ships ffmpeg but not ffprobe). Returns
- * stream descriptors in the same shape ffprobe -show_streams would.
- */
-export async function probeStreams(
-  url: string,
-): Promise<Array<Record<string, unknown>>> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(FFMPEG, [
-      "-hide_banner",
-      "-loglevel",
-      "info",
-      "-i",
-      url,
-      "-f",
-      "null",
-      "-",
-    ]);
-    let stderr = "";
-    proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()));
-    proc.on("close", () => {
-      // Parse "Stream #0:0: Video: h264 (High), yuv420p, 640x360, 30 fps"
-      const streams: Array<Record<string, unknown>> = [];
-      const re = /Stream #0:(\d+): (Video|Audio): ([^,]+)/g;
-      let m: RegExpExecArray | null;
-      // biome-ignore lint/suspicious/noAssignInExpressions: regex loop idiom
-      while ((m = re.exec(stderr)) !== null) {
-        const [full, idx, kind, codecRaw] = m;
-        void full;
-        const codecName = codecRaw.split(" ")[0].toLowerCase();
-        const stream: Record<string, unknown> = {
-          index: Number(idx),
-          codec_type: kind.toLowerCase(),
-          codec_name: codecName,
-          width: 0,
-          height: 0,
-          r_frame_rate: "0/1",
-          sample_rate: 0,
-        };
-        // dimensions: "640x360"
-        const dim = /(\d{2,5})x(\d{2,5})/.exec(stderr.slice(m.index));
-        if (dim) {
-          stream.width = Number(dim[1]);
-          stream.height = Number(dim[2]);
-        }
-        // fps: "30 fps" or "29.97 fps"
-        const fps = /(\d+(?:\.\d+)?) fps/.exec(stderr.slice(m.index));
-        if (fps) {
-          const v = Number(fps[1]);
-          stream.r_frame_rate = `${Math.round(v * 1000)}/1000`;
-        }
-        // sample rate for audio: "48000 Hz"
-        const sr = /(\d+) Hz/.exec(stderr.slice(m.index));
-        if (sr) stream.sample_rate = Number(sr[1]);
-        streams.push(stream);
-      }
-      resolve(streams);
-    });
-    proc.on("error", (err) => reject(err));
-  });
-}
-
-/**
- * Demux input (URL string or readable stream) into video frames on a
- * PassThrough. Uses ffmpeg -f h264 -c copy for video-only AnnexB output.
- * Returns stream info + the video pipe. Audio is not extracted (GoLive
- * screen share sends silence / uses Discord's mixed audio).
- */
-export async function demux(
-  input: string | PassThrough,
-  _opts: { format: string },
-): Promise<{
-  video: DemuxedStream | undefined;
-  audio: DemuxedStream | undefined;
-  close: () => void;
-}> {
-  const _label = randomUUID();
-  const vPipe = new PassThrough({ objectMode: true, highWaterMark: 128 });
-  const aPipe = new PassThrough({ objectMode: true, highWaterMark: 128 });
-
-  // For stream input, spool to a temp file first so ffprobe can inspect it
-  // (ffprobe needs a seekable file; pipes can't be re-read). The stream is
-  // fully consumed before ffmpeg starts — acceptable for screen-share
-  // sources which are already fully buffered by yt-dlp in practice.
-  let spoolPath: string | null = null;
-  const cleanupSpool = () => {
-    if (spoolPath) {
-      import("node:fs").then(({ unlink }) => unlink(spoolPath!, () => {}));
-      spoolPath = null;
-    }
-  };
-
-  let effectiveInput: string;
-  if (typeof input === "string") {
-    effectiveInput = input;
-  } else {
-    spoolPath = join(tmpdir(), `golive-demux-${_label}.h264`);
-    const ws = createWriteStream(spoolPath);
-    await new Promise<void>((resolve, reject) => {
-      input.pipe(ws);
-      input.on("error", reject);
-      ws.on("finish", resolve);
-      ws.on("error", reject);
-    });
-    effectiveInput = spoolPath;
-  }
-
-  // Probe for codec + dimensions
-  let streams: Array<Record<string, unknown>> = [];
-  try {
-    streams = await probeStreams(effectiveInput);
-  } catch (_e) {
-    // probe failed (e.g. raw h264 without container) — infer h264 default
-    streams = [];
-  }
-
-  const v = streams.find((s) => s.codec_type === "video");
-  const a = streams.find((s) => s.codec_type === "audio");
-  let vInfo: DemuxedStream | undefined;
-  let aInfo: DemuxedStream | undefined;
-
-  if (v) {
-    const codecName = (v.codec_name as string) ?? "h264";
-    const rFrame = (v.r_frame_rate as string) ?? "0/1";
-    const [num, den] = rFrame.split("/").map((n) => Number(n));
-    vInfo = {
-      codec:
-        AVCodecID[
-          (codecName.toUpperCase() as keyof typeof AVCodecID) ??
-            "AV_CODEC_ID_H264"
-        ] ?? AVCodecID.AV_CODEC_ID_H264,
-      codecName,
-      width: (v.width as number) ?? 0,
-      height: (v.height as number) ?? 0,
-      framerate_num: num ?? 0,
-      framerate_den: den ?? 1,
-      sample_rate: 0,
-      stream: vPipe,
-    };
-  } else {
-    // Probe failed (e.g. raw AnnexB h264 input) — still emit frames on the
-    // video pipe; playStream infers dimensions from the first frame.
-    vInfo = {
-      codec: AVCodecID.AV_CODEC_ID_H264,
-      codecName: "h264",
-      width: 0,
-      height: 0,
-      framerate_num: 0,
-      framerate_den: 1,
-      sample_rate: 0,
-      stream: vPipe,
-    };
-  }
-
-  if (a) {
-    const codecName = (a.codec_name as string) ?? "opus";
-    aInfo = {
-      codec:
-        AVCodecID[
-          (codecName.toUpperCase() as keyof typeof AVCodecID) ??
-            "AV_CODEC_ID_OPUS"
-        ],
-      codecName,
-      width: 0,
-      height: 0,
-      framerate_num: 0,
-      framerate_den: 0,
-      sample_rate: Number(a.sample_rate) ?? 0,
-      stream: aPipe,
-    };
-  }
-
-  // Spawn ffmpeg — extract raw video (AnnexB for H264) to stdout
-  const args: string[] = [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-i",
-    effectiveInput,
-    "-c:v",
-    "copy",
-    "-an", // no audio in this minimal demuxer
-    "-f",
-    "h264",
-    "pipe:1",
-  ];
-
-  const proc = spawn(FFMPEG, args, { stdio: ["ignore", "pipe", "pipe"] });
-
-  // Scan stdout for NAL units. Each NAL unit (between start codes) is one frame
-  // payload. We emit them individually; the packetizer chain handles FU-A.
-  let videoBuf = Buffer.alloc(0);
-  let frameCount = 0;
-
-  const emitFrame = (nal: Uint8Array, isKeyFrame: boolean) => {
-    vPipe.write({
-      data: Buffer.from(nal),
-      pts: frameCount,
-      duration: 1,
-      timeBase: { num: 1, den: 90000 },
-      flags: isKeyFrame ? AV_PKT_FLAG_KEY : 0,
-      streamIndex: 0,
-      free: () => {},
-    });
-    frameCount++;
-  };
-
-  if (proc.stdout) {
-    proc.stdout.on("data", (chunk: Buffer) => {
-      videoBuf = Buffer.concat([videoBuf, chunk]);
-      // Find start codes (00 00 01 or 00 00 00 01) and split NALs
-      let start = 0;
-      // If buffer starts with zeros, that's the first start code — emit from there
-      while (start < videoBuf.length) {
-        let scPos = -1;
-        for (let i = start + 1; i < videoBuf.length - 2; i++) {
-          if (
-            videoBuf[i] === 0 &&
-            videoBuf[i + 1] === 0 &&
-            videoBuf[i + 2] === 1
-          ) {
-            scPos = i + 3;
-            break;
-          }
-        }
-        if (scPos === -1) break;
-        // Emit the NAL from `start` to `scPos` (but skip the start code bytes at `start`)
-        if (start < scPos) {
-          let nalStart = start;
-          // Skip start code bytes for the NAL itself (00 00 01)
-          if (
-            videoBuf[nalStart] === 0 &&
-            videoBuf[nalStart + 1] === 0 &&
-            videoBuf[nalStart + 2] === 1
-          ) {
-            nalStart += 3;
-          } else if (
-            nalStart + 3 < scPos &&
-            videoBuf[nalStart] === 0 &&
-            videoBuf[nalStart + 1] === 0 &&
-            videoBuf[nalStart + 2] === 0 &&
-            videoBuf[nalStart + 3] === 1
-          ) {
-            nalStart += 4;
-          }
-          const nal = videoBuf.subarray(nalStart, scPos);
-          // Trim trailing zero bytes (from start code overlap)
-          let end = nal.length;
-          while (end > 0 && nal[end - 1] === 0) end--;
-          if (end > 0) {
-            const nalTrimmed = nal.subarray(0, end);
-            const isIdr = (nalTrimmed[0] & 0x1f) === 5; // IDR
-            emitFrame(nalTrimmed, isIdr);
-          }
-        }
-        // Skip the 00 00 01 at scPos-3 to find next
-        start = scPos;
-        // But the next start code needs at least 3 bytes
-        if (start > videoBuf.length - 3) break;
-      }
-      // Keep remaining bytes (potential partial NAL or start code)
-      if (start > 0 && start < videoBuf.length) {
-        videoBuf = videoBuf.subarray(start);
-      } else if (videoBuf.length > 4) {
-        // No full NAL found, but avoid unbounded growth
-        // Keep a sliding window
-        videoBuf = videoBuf.subarray(videoBuf.length - 3);
-      }
-    });
-    proc.stdout.on("end", () => {
-      if (videoBuf.length > 0) {
-        let end = videoBuf.length;
-        while (end > 0 && videoBuf[end - 1] === 0) end--;
-        if (end > 0) emitFrame(videoBuf.subarray(0, end), false);
-      }
-      vPipe.end();
-      aPipe.end();
-    });
-  }
-
-  if (proc.stderr) {
-    proc.stderr.on("data", () => {
-      /* errors swallowed */
-    });
-  }
-  proc.on("close", () => {
-    vPipe.end();
-    aPipe.end();
-  });
-
-  const close = () => {
-    proc.kill("SIGTERM");
-    vPipe.end();
-    aPipe.end();
-    cleanupSpool();
-  };
-
-  return { video: vInfo, audio: aInfo, close };
-}

services/discord-gateway/src/goLive/Encoders.ts

@@ -1,51 +0,0 @@
-/**
- * Lightweight encoders config — ported from @dank074/discord-video-stream
- * encoders/software.js. Only software (libx264) is needed for GoLive.
- */
-
-export interface EncoderSettings {
-  name: string;
-  options: string[];
-  outFilters?: string[];
-  globalOptions?: string[];
-}
-
-export interface EncoderSet {
-  H264: EncoderSettings;
-  H265: EncoderSettings;
-  VP8: EncoderSettings;
-  VP9: EncoderSettings;
-  AV1: EncoderSettings;
-}
-
-/** Software x264 encoder. Matches @dank074's software() defaults. */
-export function software(
-  opts: {
-    x264?: { preset?: string; tune?: string };
-    x265?: { preset?: string; tune?: string };
-  } = {},
-): () => EncoderSet {
-  const { x264, x265 } = opts;
-  const { preset: x264Preset = "superfast", tune: x264Tune = "film" } =
-    x264 ?? {};
-  const { preset: x265Preset = "superfast", tune: x265Tune } = x265 ?? {};
-  return () => ({
-    H264: {
-      name: "libx264",
-      options: ["-forced-idr 1", `-tune ${x264Tune}`, `-preset ${x264Preset}`],
-    },
-    H265: {
-      name: "libx265",
-      options: [
-        "-forced-idr 1",
-        ...(x265Tune ? [`-tune ${x265Tune}`] : []),
-        `-preset ${x265Preset}`,
-      ],
-    },
-    VP8: { name: "libvpx", options: ["-deadline 20000"] },
-    VP9: { name: "libvpx-vp9", options: ["-deadline 20000"] },
-    AV1: { name: "libsvtav1", options: [] },
-  });
-}
-
-export const Encoders = { software };

services/discord-gateway/src/goLive/GatewayOpCodes.ts

@@ -1,41 +0,0 @@
-/** Discord gateway opcodes used by Streamer — ported from @dank074/discord-video-stream. */
-export enum GatewayOpCodes {
-  DISPATCH = 0,
-  HEARTBEAT = 1,
-  IDENTIFY = 2,
-  PRESENCE_UPDATE = 3,
-  VOICE_STATE_UPDATE = 4,
-  VOICE_SERVER_PING = 5,
-  RESUME = 6,
-  RECONNECT = 7,
-  REQUEST_GUILD_MEMBERS = 8,
-  INVALID_SESSION = 9,
-  HELLO = 10,
-  HEARTBEAT_ACK = 11,
-  CALL_CONNECT = 13,
-  GUILD_SUBSCRIPTIONS = 14,
-  LOBBY_CONNECT = 15,
-  LOBBY_DISCONNECT = 16,
-  LOBBY_VOICE_STATES_UPDATE = 17,
-  STREAM_CREATE = 18,
-  STREAM_DELETE = 19,
-  STREAM_WATCH = 20,
-  STREAM_PING = 21,
-  STREAM_SET_PAUSED = 22,
-  REQUEST_GUILD_APPLICATION_COMMANDS = 24,
-  EMBEDDED_ACTIVITY_LAUNCH = 25,
-  EMBEDDED_ACTIVITY_CLOSE = 26,
-  EMBEDDED_ACTIVITY_UPDATE = 27,
-  REQUEST_FORUM_UNREADS = 28,
-  REMOTE_COMMAND = 29,
-  GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH = 30,
-  REQUEST_SOUNDBOARD_SOUNDS = 31,
-  SPEED_TEST_CREATE = 32,
-  SPEED_TEST_DELETE = 33,
-  REQUEST_LAST_MESSAGES = 34,
-  SEARCH_RECENT_MEMBERS = 35,
-  REQUEST_CHANNEL_STATUSES = 36,
-  GUILD_SUBSCRIPTIONS_BULK = 37,
-  GUILD_CHANNELS_RESYNC = 38,
-  REQUEST_CHANNEL_MEMBER_COUNT = 39,
-}

services/discord-gateway/src/goLive/SPSVUIRewriter.ts

@@ -1,291 +0,0 @@
-/**
- * H264 SPS VUI rewriter — ported from @dank074/discord-video-stream
- * SPSVUIRewriter.js. Rewrites the SPS so Discord's receiver applies
- * bitstream restrictions (max_num_reorder_frames=0, max_dec_frame_buffering
- * bounded) — required for low-latency GoLive decode.
- */
-
-import {
-  AnnexBBitstreamReader,
-  AnnexBBitstreamWriter,
-} from "./AnnexBBitstreamReaderWriter.js";
-
-export function rewriteSPSVUI(buffer: Uint8Array): Buffer {
-  const reader = new AnnexBBitstreamReader(buffer.subarray(1));
-  const writer = new AnnexBBitstreamWriter();
-  const readBit = (n = 1) => reader.readBits(n);
-  const writeBit = (v: number, n = 1) => writer.writeBits(v, n);
-  const readU = (n: number) => reader.readUnsigned(n);
-  const writeU = (v: number, n: number) => writer.writeUnsigned(v, n);
-  const readUE = () => reader.readUnsignedExpGolomb();
-  const writeUE = (v: number) => writer.writeUnsignedExpGolomb(v);
-  const readSE = () => reader.readSignedExpGolomb();
-  const writeSE = (v: number) => writer.writeSignedExpGolomb(v);
-
-  // Rewrite the NAL header
-  writeU(buffer[0], 8);
-  const profile_idc = readU(8);
-  writeU(profile_idc, 8);
-  const constraint_flags = readU(8);
-  writeU(constraint_flags, 8);
-  const level_idc = readU(8);
-  writeU(level_idc, 8);
-  const seq_parameter_set_id = readUE();
-  writeUE(seq_parameter_set_id);
-
-  // If profile in high profiles, additional fields
-  const highProfiles = new Set([
-    100, 110, 122, 244, 44, 83, 86, 118, 128, 138, 144,
-  ]);
-  if (highProfiles.has(profile_idc)) {
-    const chroma_format_idc = readUE();
-    writeUE(chroma_format_idc);
-    if (chroma_format_idc === 3) {
-      const separate_colour_plane_flag = readBit(1);
-      writeBit(separate_colour_plane_flag, 1);
-    }
-    const bit_depth_luma_minus8 = readUE();
-    writeUE(bit_depth_luma_minus8);
-    const bit_depth_chroma_minus8 = readUE();
-    writeUE(bit_depth_chroma_minus8);
-    const qpprime_y_zero_transform_bypass_flag = readBit(1);
-    writeBit(qpprime_y_zero_transform_bypass_flag, 1);
-    const seq_scaling_matrix_present_flag = readBit(1);
-    writeBit(seq_scaling_matrix_present_flag, 1);
-    if (seq_scaling_matrix_present_flag) {
-      const scalingCount = chroma_format_idc !== 3 ? 8 : 12;
-      for (let i = 0; i < scalingCount; i++) {
-        const seq_scaling_list_present_flag = readBit(1);
-        writeBit(seq_scaling_list_present_flag, 1);
-        if (seq_scaling_list_present_flag) {
-          const size = i < 6 ? 16 : 64;
-          let lastScale = 8;
-          let nextScale = 8;
-          for (let j = 0; j < size; j++) {
-            const delta = readSE();
-            writeSE(delta);
-            nextScale = (lastScale + delta + 256) % 256;
-            if (nextScale !== 0) lastScale = nextScale;
-          }
-        }
-      }
-    }
-  }
-
-  const log2_max_frame_num_minus4 = readUE();
-  writeUE(log2_max_frame_num_minus4);
-  const pic_order_cnt_type = readUE();
-  writeUE(pic_order_cnt_type);
-  if (pic_order_cnt_type === 0) {
-    const log2_max_pic_order_cnt_lsb_minus4 = readUE();
-    writeUE(log2_max_pic_order_cnt_lsb_minus4);
-  } else if (pic_order_cnt_type === 1) {
-    const delta_pic_order_always_zero_flag = readBit(1);
-    writeBit(delta_pic_order_always_zero_flag, 1);
-    const offset_for_non_ref_pic = readSE();
-    writeSE(offset_for_non_ref_pic);
-    const offset_for_top_to_bottom_field = readSE();
-    writeSE(offset_for_top_to_bottom_field);
-    const num_ref_frames_in_pic_order_cnt_cycle = readUE();
-    writeUE(num_ref_frames_in_pic_order_cnt_cycle);
-    for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
-      const offset_for_ref_frame = readSE();
-      writeSE(offset_for_ref_frame);
-    }
-  }
-  const max_num_ref_frames = readUE();
-  writeUE(max_num_ref_frames);
-  const gaps_in_frame_num_value_allowed_flag = readBit(1);
-  writeBit(gaps_in_frame_num_value_allowed_flag, 1);
-  const pic_width_in_mbs_minus1 = readUE();
-  writeUE(pic_width_in_mbs_minus1);
-  const pic_height_in_map_units_minus1 = readUE();
-  writeUE(pic_height_in_map_units_minus1);
-  const frame_mbs_only_flag = readBit(1);
-  writeBit(frame_mbs_only_flag, 1);
-  if (frame_mbs_only_flag === 0) {
-    const mb_adaptive_frame_field_flag = readBit(1);
-    writeBit(mb_adaptive_frame_field_flag, 1);
-  }
-  const direct_8x8_inference_flag = readBit(1);
-  writeBit(direct_8x8_inference_flag, 1);
-  const frame_cropping_flag = readBit(1);
-  writeBit(frame_cropping_flag, 1);
-  if (frame_cropping_flag) {
-    const frame_crop_left_offset = readUE();
-    writeUE(frame_crop_left_offset);
-    const frame_crop_right_offset = readUE();
-    writeUE(frame_crop_right_offset);
-    const frame_crop_top_offset = readUE();
-    writeUE(frame_crop_top_offset);
-    const frame_crop_bottom_offset = readUE();
-    writeUE(frame_crop_bottom_offset);
-  }
-
-  // https://webrtc.googlesource.com/src/+/5f2c9278f35e47ff72eb191669d473b7400c9f3e/common_video/h264/sps_vui_rewriter.cc#283
-  function addBitstreamRestriction() {
-    // motion_vectors_over_pic_boundaries_flag: u(1) — Default is 1 when not present.
-    writeBit(1, 1);
-    // max_bytes_per_pic_denom: ue(v) — Default is 2 when not present.
-    writeUE(2);
-    // max_bits_per_mb_denom: ue(v) — Default is 1 when not present.
-    writeUE(1);
-    // log2_max_mv_length_horizontal / vertical — both default to 16.
-    writeUE(16);
-    writeUE(16);
-    // IMPORTANT: max_num_reorder_frames must be 0 for low latency.
-    writeUE(0);
-    writeUE(max_num_ref_frames);
-  }
-
-  const vui_parameters_present_flag = readBit(1);
-  writeBit(1, 1);
-  // If no VUI exists, write one
-  if (!vui_parameters_present_flag) {
-    // aspect_ratio_info_present_flag, overscan_info_present_flag. Both u(1).
-    writeBit(0, 2);
-    // video_signal_type_present_flag, u(1) — write 0, ignore color space.
-    writeBit(0, 1);
-    // chroma_loc_info_present_flag, timing_info_present_flag,
-    // nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag,
-    // pic_struct_present_flag — all u(1)
-    writeBit(0, 5);
-    // bitstream_restriction_flag: u(1)
-    writeBit(1, 1);
-    addBitstreamRestriction();
-  } else {
-    // VUI parsing and copying
-    const aspect_ratio_info_present_flag = readBit(1);
-    writeBit(aspect_ratio_info_present_flag, 1);
-    if (aspect_ratio_info_present_flag) {
-      const aspect_ratio_idc = readU(8);
-      writeU(aspect_ratio_idc, 8);
-      if (aspect_ratio_idc === 255) {
-        const sar_width = readU(16);
-        writeU(sar_width, 16);
-        const sar_height = readU(16);
-        writeU(sar_height, 16);
-      }
-    }
-    const overscan_info_present_flag = readBit(1);
-    writeBit(overscan_info_present_flag, 1);
-    if (overscan_info_present_flag) {
-      const overscan_appropriate_flag = readBit(1);
-      writeBit(overscan_appropriate_flag, 1);
-    }
-    // Read the video signal type, but don't copy it
-    const video_signal_type_present_flag = readBit(1);
-    writeBit(0, 1);
-    if (video_signal_type_present_flag) {
-      readBit(3); // _video_format
-      readBit(1); // _video_full_range_flag
-      const colour_description_present_flag = readBit(1);
-      if (colour_description_present_flag) {
-        readU(8); // _colour_primaries
-        readU(8); // _transfer_characteristics
-        readU(8); // _matrix_coeffs
-      }
-    }
-    const chroma_loc_info_present_flag = readBit(1);
-    writeBit(chroma_loc_info_present_flag, 1);
-    if (chroma_loc_info_present_flag) {
-      const chroma_sample_loc_type_top_field = readUE();
-      writeUE(chroma_sample_loc_type_top_field);
-      const chroma_sample_loc_type_bottom_field = readUE();
-      writeUE(chroma_sample_loc_type_bottom_field);
-    }
-    const timing_info_present_flag = readBit(1);
-    writeBit(timing_info_present_flag, 1);
-    if (timing_info_present_flag) {
-      const num_units_in_tick = readU(32);
-      writeU(num_units_in_tick, 32);
-      const time_scale = readU(32);
-      writeU(time_scale, 32);
-      const fixed_frame_rate_flag = readBit(1);
-      writeBit(fixed_frame_rate_flag, 1);
-    }
-    const nal_hrd_parameters_present_flag = readBit(1);
-    writeBit(nal_hrd_parameters_present_flag, 1);
-    if (nal_hrd_parameters_present_flag) {
-      // hrd_parameters()
-      const cpb_cnt_minus1 = readUE();
-      writeUE(cpb_cnt_minus1);
-      const bit_rate_scale = readBit(4);
-      writeBit(bit_rate_scale, 4);
-      const cpb_size_scale = readBit(4);
-      writeBit(cpb_size_scale, 4);
-      for (let i = 0; i <= cpb_cnt_minus1; i++) {
-        const bit_rate_value_minus1 = readUE();
-        writeUE(bit_rate_value_minus1);
-        const cpb_size_value_minus1 = readUE();
-        writeUE(cpb_size_value_minus1);
-        const cbr_flag = readBit(1);
-        writeBit(cbr_flag, 1);
-      }
-      const initial_cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(initial_cpb_removal_delay_length_minus1, 5);
-      const cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(cpb_removal_delay_length_minus1, 5);
-      const dpb_output_delay_length_minus1 = readBit(5);
-      writeBit(dpb_output_delay_length_minus1, 5);
-      const time_offset_length = readBit(5);
-      writeBit(time_offset_length, 5);
-    }
-    const vcl_hrd_parameters_present_flag = readBit(1);
-    writeBit(vcl_hrd_parameters_present_flag, 1);
-    if (vcl_hrd_parameters_present_flag) {
-      // hrd_parameters()
-      const cpb_cnt_minus1 = readUE();
-      writeUE(cpb_cnt_minus1);
-      const bit_rate_scale = readBit(4);
-      writeBit(bit_rate_scale, 4);
-      const cpb_size_scale = readBit(4);
-      writeBit(cpb_size_scale, 4);
-      for (let i = 0; i <= cpb_cnt_minus1; i++) {
-        const bit_rate_value_minus1 = readUE();
-        writeUE(bit_rate_value_minus1);
-        const cpb_size_value_minus1 = readUE();
-        writeUE(cpb_size_value_minus1);
-        const cbr_flag = readBit(1);
-        writeBit(cbr_flag, 1);
-      }
-      const initial_cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(initial_cpb_removal_delay_length_minus1, 5);
-      const cpb_removal_delay_length_minus1 = readBit(5);
-      writeBit(cpb_removal_delay_length_minus1, 5);
-      const dpb_output_delay_length_minus1 = readBit(5);
-      writeBit(dpb_output_delay_length_minus1, 5);
-      const time_offset_length = readBit(5);
-      writeBit(time_offset_length, 5);
-    }
-    if (nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag) {
-      const low_delay_hrd_flag = readBit(1);
-      writeBit(low_delay_hrd_flag, 1);
-    }
-    const pic_struct_present_flag = readBit(1);
-    writeBit(pic_struct_present_flag, 1);
-    const bitstream_restriction_flag = readBit(1);
-    writeBit(1, 1);
-    if (!bitstream_restriction_flag) {
-      addBitstreamRestriction();
-    } else {
-      const motion_vectors_over_pic_boundaries_flag = readBit(1);
-      writeBit(motion_vectors_over_pic_boundaries_flag, 1);
-      const max_bytes_per_pic_denom = readUE();
-      writeUE(max_bytes_per_pic_denom);
-      const max_bits_per_mb_denom = readUE();
-      writeUE(max_bits_per_mb_denom);
-      const log2_max_mv_length_horizontal = readUE();
-      writeUE(log2_max_mv_length_horizontal);
-      const log2_max_mv_length_vertical = readUE();
-      writeUE(log2_max_mv_length_vertical);
-      readUE(); // _num_reorder_frames
-      writeUE(0);
-      readUE(); // _max_dec_frame_buffering
-      writeUE(max_num_ref_frames);
-    }
-  }
-  writeBit(1, 1); // rbsp_stop_one_bit
-  writer.flush();
-  return writer.toBuffer();
-}

services/discord-gateway/src/goLive/StreamConnection.ts

@@ -1,45 +0,0 @@
-/**
- * StreamConnection — GoLive stream connection (screen share).
- * Ported from @dank074/discord-video-stream StreamConnection.js.
- */
-
-import { BaseMediaConnection } from "./BaseMediaConnection.js";
-import { VoiceOpCodes } from "./VoiceOpCodes.js";
-
-export class StreamConnection extends BaseMediaConnection {
-  _streamKey: string | null = null;
-  _serverId: string | null = null;
-
-  setSpeaking(speaking: boolean): void {
-    if (!this.webRtcParams) throw new Error("WebRTC connection not ready");
-    this.sendOpcode(VoiceOpCodes.SPEAKING, {
-      delay: 0,
-      speaking: speaking ? 2 : 0,
-      ssrc: this.webRtcParams.audioSsrc,
-    });
-  }
-
-  get daveChannelId(): string {
-    if (this._serverId === null) {
-      throw new Error("Server ID not set (this shouldn't happen)");
-    }
-    const channelId = BigInt(this._serverId) - 1n;
-    return channelId.toString();
-  }
-
-  get serverId(): string | null {
-    return this._serverId;
-  }
-
-  set serverId(id: string | null) {
-    this._serverId = id;
-  }
-
-  get streamKey(): string | null {
-    return this._streamKey;
-  }
-
-  set streamKey(value: string | null) {
-    this._streamKey = value;
-  }
-}

services/discord-gateway/src/goLive/Streamer.ts

@@ -1,280 +0,0 @@
-/**
- * Streamer — gateway-level GoLive controller. Ported from
- * @dank074/discord-video-stream Streamer.js.
- *
- * Drives the Discord gateway (VOICE_STATE_UPDATE, STREAM_CREATE, ...) and
- * hands back a VoiceConnection / StreamConnection once the media server
- * session is ready.
- */
-
-import { EventEmitter } from "node:events";
-import { GatewayOpCodes } from "./GatewayOpCodes.js";
-import type { NativePeerConnection } from "./native.js";
-import { StreamConnection } from "./StreamConnection.js";
-import { generateStreamKey, parseStreamKey } from "./utils.js";
-import { VoiceConnection } from "./VoiceConnection.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-/** Minimal surface of a discord.js-selfbot-v13 client used by Streamer. */
-export interface StreamerClientLike {
-  user: { id: string; username?: string } | null;
-  token: string | null;
-  on(
-    event: "raw",
-    listener: (packet: { t: string; d: unknown }) => void,
-  ): unknown;
-  ws: {
-    broadcast(data: { op: number; d: unknown }): void;
-  };
-  guilds?: {
-    // biome-ignore lint/suspicious/noExplicitAny: discord.js-selfbot client shape is dynamic
-    fetch(id: string): Promise<any>;
-  };
-}
-
-/** Minimal channel shape accepted by joinVoiceChannel. */
-export interface VoiceChannelLike {
-  id: string;
-  type: string;
-  guildId?: string | null;
-}
-
-export class Streamer {
-  _voiceConnection: VoiceConnection | null = null;
-  _client: StreamerClientLike;
-  _gatewayEmitter = new EventEmitter();
-
-  constructor(client: StreamerClientLike) {
-    this._client = client;
-    // listen for gateway dispatch events
-    this.client.on("raw", (packet) => {
-      this._gatewayEmitter.emit(packet.t, packet.d);
-    });
-  }
-
-  get client(): StreamerClientLike {
-    return this._client;
-  }
-
-  get opts(): Record<string, unknown> {
-    return {};
-  }
-
-  get voiceConnection(): VoiceConnection | null {
-    return this._voiceConnection;
-  }
-
-  sendOpcode(code: number, data: unknown): void {
-    this.client.ws.broadcast({ op: code, d: data });
-  }
-
-  joinVoiceChannel(channel: VoiceChannelLike): Promise<WebRtcConnWrapper> {
-    let guildId: string | null = null;
-    if (
-      channel.type === "GUILD_STAGE_VOICE" ||
-      channel.type === "GUILD_VOICE"
-    ) {
-      guildId = channel.guildId ?? null;
-    }
-    return this.joinVoice(guildId, channel.id);
-  }
-
-  /**
-   * Joins a voice channel and resolves with the WebRtcConnWrapper when the
-   * media session is ready.
-   */
-  joinVoice(
-    guild_id: string | null,
-    channel_id: string,
-  ): Promise<WebRtcConnWrapper> {
-    return new Promise((resolve, reject) => {
-      if (!this.client.user) {
-        reject(new Error("Client not logged in"));
-        return;
-      }
-      const user_id = this.client.user.id;
-      const voiceConn = new VoiceConnection(
-        this,
-        guild_id,
-        user_id,
-        channel_id,
-        (conn) => {
-          resolve(conn);
-        },
-      );
-      this._voiceConnection = voiceConn;
-      this._gatewayEmitter.on(
-        "VOICE_STATE_UPDATE",
-        (d: { user_id: string; session_id: string }) => {
-          if (user_id !== d.user_id) return;
-          voiceConn.setSession(d.session_id);
-        },
-      );
-      this._gatewayEmitter.on(
-        "VOICE_SERVER_UPDATE",
-        (d: {
-          guild_id: string | null;
-          channel_id?: string;
-          endpoint: string;
-          token: string;
-        }) => {
-          if (guild_id !== d.guild_id) return;
-          // channel_id is not set for guild voice calls
-          if (d.channel_id && channel_id !== d.channel_id) return;
-          voiceConn.setTokens(d.endpoint, d.token);
-        },
-      );
-      this.signalVideo(false);
-    });
-  }
-
-  /** Create a GoLive stream (screen share) on top of the voice connection. */
-  createStream(): Promise<WebRtcConnWrapper> {
-    return new Promise((resolve, reject) => {
-      if (!this.client.user) {
-        reject(new Error("Client not logged in"));
-        return;
-      }
-      if (!this.voiceConnection) {
-        reject(
-          new Error("cannot start stream without first joining voice channel"),
-        );
-        return;
-      }
-      this.signalStream();
-      const {
-        guildId: clientGuildId,
-        channelId: clientChannelId,
-        session_id,
-      } = this.voiceConnection;
-      const clientUserId = this.client.user.id;
-      if (!session_id) throw new Error("Session doesn't exist yet");
-      const streamConn = new StreamConnection(
-        this,
-        clientGuildId,
-        clientUserId,
-        clientChannelId,
-        (conn) => {
-          resolve(conn);
-        },
-      );
-      this.voiceConnection.streamConnection = streamConn;
-      this._gatewayEmitter.on(
-        "STREAM_CREATE",
-        (d: { stream_key: string; rtc_server_id: string }) => {
-          const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
-          if (
-            clientGuildId !== guildId ||
-            clientChannelId !== channelId ||
-            clientUserId !== userId
-          ) {
-            return;
-          }
-          streamConn.serverId = d.rtc_server_id;
-          streamConn.streamKey = d.stream_key;
-          streamConn.setSession(session_id);
-        },
-      );
-      this._gatewayEmitter.on(
-        "STREAM_SERVER_UPDATE",
-        (d: { stream_key: string; endpoint: string; token: string }) => {
-          const { channelId, guildId, userId } = parseStreamKey(d.stream_key);
-          if (
-            clientGuildId !== guildId ||
-            clientChannelId !== channelId ||
-            clientUserId !== userId
-          ) {
-            return;
-          }
-          streamConn.setTokens(d.endpoint, d.token);
-        },
-      );
-    });
-  }
-
-  async setStreamPreview(image: Buffer): Promise<void> {
-    if (!this.client.token) throw new Error("Please login :)");
-    if (!this.voiceConnection?.streamConnection?.guildId) return;
-    const data = `data:image/jpeg;base64,${image.toString("base64")}`;
-    const { guildId } = this.voiceConnection.streamConnection;
-    if (!this.client.guilds) return;
-    const server = await this.client.guilds.fetch(guildId);
-    // biome-ignore lint/suspicious/noExplicitAny: discord.js-selfbot dynamic
-    (server as any).members.me?.voice?.postPreview(data);
-  }
-
-  stopStream(): void {
-    const stream = this.voiceConnection?.streamConnection;
-    if (!stream) return;
-    stream.stop();
-    this.signalStopStream();
-    this.voiceConnection.streamConnection = null;
-    this._gatewayEmitter.removeAllListeners("STREAM_CREATE");
-    this._gatewayEmitter.removeAllListeners("STREAM_SERVER_UPDATE");
-  }
-
-  leaveVoice(): void {
-    this.voiceConnection?.stop();
-    this.signalLeaveVoice();
-    this._voiceConnection = null;
-    this._gatewayEmitter.removeAllListeners("VOICE_STATE_UPDATE");
-    this._gatewayEmitter.removeAllListeners("VOICE_SERVER_UPDATE");
-  }
-
-  signalVideo(video_enabled: boolean): void {
-    if (!this.voiceConnection) return;
-    const { guildId: guild_id, channelId: channel_id } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
-      guild_id: guild_id,
-      channel_id,
-      self_mute: false,
-      self_deaf: true,
-      self_video: video_enabled,
-    });
-  }
-
-  signalStream(): void {
-    if (!this.voiceConnection) return;
-    const {
-      type,
-      guildId: guild_id,
-      channelId: channel_id,
-      botId: user_id,
-    } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.STREAM_CREATE, {
-      type,
-      guild_id,
-      channel_id,
-      preferred_region: null,
-    });
-    this.sendOpcode(GatewayOpCodes.STREAM_SET_PAUSED, {
-      stream_key: generateStreamKey(type, guild_id, channel_id, user_id),
-      paused: false,
-    });
-  }
-
-  signalStopStream(): void {
-    if (!this.voiceConnection) return;
-    const {
-      type,
-      guildId: guild_id,
-      channelId: channel_id,
-      botId: user_id,
-    } = this.voiceConnection;
-    this.sendOpcode(GatewayOpCodes.STREAM_DELETE, {
-      stream_key: generateStreamKey(type, guild_id, channel_id, user_id),
-    });
-  }
-
-  signalLeaveVoice(): void {
-    this.sendOpcode(GatewayOpCodes.VOICE_STATE_UPDATE, {
-      guild_id: null,
-      channel_id: null,
-      self_mute: true,
-      self_deaf: false,
-      self_video: false,
-    });
-  }
-}
-
-export type { NativePeerConnection };

services/discord-gateway/src/goLive/VideoStream.ts

@@ -1,20 +0,0 @@
-/**
- * VideoStream — feeds encoded H264 frames into the WebRTC connection.
- * Ported from @dank074/discord-video-stream VideoStream.js.
- */
-
-import { BaseMediaStream } from "./BaseMediaStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export class VideoStream extends BaseMediaStream {
-  _conn: WebRtcConnWrapper;
-
-  constructor(conn: WebRtcConnWrapper, noSleep = false) {
-    super("video", noSleep);
-    this._conn = conn;
-  }
-
-  async _sendFrame(frame: Buffer, frametime: number): Promise<void> {
-    this._conn.sendVideoFrame(frame, frametime);
-  }
-}

services/discord-gateway/src/goLive/VoiceConnection.ts

@@ -1,25 +0,0 @@
-/**
- * VoiceConnection — guild/DM voice channel GoLive connection.
- * Ported from @dank074/discord-video-stream VoiceConnection.js.
- */
-
-import { BaseMediaConnection } from "./BaseMediaConnection.js";
-import type { StreamConnection } from "./StreamConnection.js";
-
-export class VoiceConnection extends BaseMediaConnection {
-  streamConnection: StreamConnection | null = null;
-
-  get daveChannelId(): string {
-    return this.channelId;
-  }
-
-  get serverId(): string | null {
-    // for guild vc it is the guild id, for dm voice it is the channel id
-    return this.guildId ?? this.channelId;
-  }
-
-  stop(): void {
-    super.stop();
-    this.streamConnection?.stop();
-  }
-}

services/discord-gateway/src/goLive/VoiceOpCodes.ts

@@ -1,38 +0,0 @@
-/** Discord voice WebSocket opcodes — ported from @dank074/discord-video-stream. */
-export enum VoiceOpCodes {
-  IDENTIFY = 0,
-  SELECT_PROTOCOL = 1,
-  READY = 2,
-  HEARTBEAT = 3,
-  SELECT_PROTOCOL_ACK = 4,
-  SPEAKING = 5,
-  HEARTBEAT_ACK = 6,
-  RESUME = 7,
-  HELLO = 8,
-  RESUMED = 9,
-  CLIENTS_CONNECT = 11,
-  VIDEO = 12,
-  CLIENT_DISCONNECT = 13,
-  SESSION_UPDATE = 14,
-  MEDIA_SINK_WANTS = 15,
-  VOICE_BACKEND_VERSION = 16,
-  CHANNEL_OPTIONS_UPDATE = 17,
-  FLAGS = 18,
-  SPEED_TEST = 19,
-  PLATFORM = 20,
-  DAVE_PREPARE_TRANSITION = 21,
-  DAVE_EXECUTE_TRANSITION = 22,
-  DAVE_TRANSITION_READY = 23,
-  DAVE_PREPARE_EPOCH = 24,
-  MLS_INVALID_COMMIT_WELCOME = 31,
-}
-
-/** Binary voice WebSocket opcodes (DAVE / MLS). */
-export enum VoiceOpCodesBinary {
-  MLS_EXTERNAL_SENDER = 25,
-  MLS_KEY_PACKAGE = 26,
-  MLS_PROPOSALS = 27,
-  MLS_COMMIT_WELCOME = 28,
-  MLS_ANNOUNCE_COMMIT_TRANSITION = 29,
-  MLS_WELCOME = 30,
-}

services/discord-gateway/src/goLive/WebRtcWrapper.ts

@@ -1,205 +0,0 @@
-/**
- * WebRTC connection wrapper for GoLive — ported from
- * @dank074/discord-video-stream WebRtcWrapper.js, with the media stack
- * (packetizers, RTCP SR/NACK, pacing) provided by the libdatachannel-min
- * binding instead of node-datachannel's JS-exposed media classes.
- */
-
-import {
-  H264Helpers,
-  H264NalUnitTypes,
-  splitNalu,
-  startCode3,
-} from "./AnnexBHelper.js";
-import { CodecPayloadType } from "./CodecPayloadType.js";
-import type { NativePeerConnection, NativeTrack } from "./native.js";
-import { loadNative } from "./native.js";
-import { rewriteSPSVUI } from "./SPSVUIRewriter.js";
-import { normalizeVideoCodec } from "./utils.js";
-
-export type WebRtcVideoCodec = "H264" | "H265" | "VP8" | "VP9" | "AV1";
-
-export interface WebRtcParams {
-  address: string;
-  port: number;
-  audioSsrc: number;
-  videoSsrc: number;
-  rtxSsrc: number;
-  supportedEncryptionModes: string[];
-}
-
-/** Minimal surface of the media connection that WebRtcWrapper drives. */
-export interface VideoAttribute {
-  fps: number;
-  width: number;
-  height: number;
-}
-
-export interface MediaConnectionLike {
-  daveReady: boolean;
-  daveSession: {
-    encryptOpus(frame: Buffer): Buffer;
-    encrypt(mediaType: number, codec: number, frame: Buffer): Buffer;
-  } | null;
-  webRtcParams: WebRtcParams | null;
-  setSpeaking(speaking: boolean): void;
-  setVideoAttributes(enabled: boolean, attr?: VideoAttribute): void;
-}
-
-/** Media types used by DAVE encryption (from @dank074). */
-export enum DaveMediaType {
-  AUDIO = 0,
-  VIDEO = 1,
-}
-
-/** DAVE codec ids (from @dank074). */
-export enum DaveCodec {
-  UNKNOWN = 0,
-  VP8 = 2,
-  VP9 = 3,
-  H264 = 4,
-  H265 = 5,
-  AV1 = 6,
-}
-
-export class WebRtcConnWrapper {
-  private _mediaConn: MediaConnectionLike;
-  private _webRtcConn: NativePeerConnection | null = null;
-  private _audioTrack: NativeTrack | null = null;
-  private _videoTrack: NativeTrack | null = null;
-  private _videoCodec: WebRtcVideoCodec | null = null;
-  /** Assigned by BaseMediaConnection to send the gathered SDP to Discord. */
-  onLocalDescription: ((sdp: string) => void) | null = null;
-
-  constructor(mediaConn: MediaConnectionLike) {
-    this._mediaConn = mediaConn;
-  }
-
-  initWebRtc(): NativePeerConnection {
-    const native = loadNative();
-    this._webRtcConn = new native.PeerConnection({
-      iceServers: ["stun:stun.l.google.com:19302"],
-    });
-    // Track mids must match @dank074: "0" audio, "1" video.
-    this._audioTrack = this._webRtcConn.addTrack("0", "audio");
-    this._videoTrack = this._webRtcConn.addTrack("1", "video");
-    return this._webRtcConn;
-  }
-
-  close(): void {
-    this._webRtcConn?.close();
-    this._webRtcConn = null;
-  }
-
-  get webRtcConn(): NativePeerConnection | null {
-    return this._webRtcConn;
-  }
-
-  get ready(): boolean {
-    return this._webRtcConn?.state() === "connected";
-  }
-
-  get mediaConnection(): MediaConnectionLike {
-    return this._mediaConn;
-  }
-
-  sendAudioFrame(frame: Buffer, frametime: number): void {
-    if (!this.ready || !this._audioTrack) return;
-    const clockRate = CodecPayloadType.opus.clockRate;
-    if (this.mediaConnection.daveReady && this.mediaConnection.daveSession) {
-      frame = this.mediaConnection.daveSession.encryptOpus(frame);
-    }
-    this._audioTrack.sendFrame(frame);
-    this._audioTrack.addTimestamp(Math.round((frametime * clockRate) / 1000));
-  }
-
-  sendVideoFrame(frame: Buffer, frametime: number): void {
-    if (!this.ready || !this._videoTrack) return;
-    const clockRate = CodecPayloadType[this._videoCodec ?? "H264"].clockRate;
-    if (this._videoCodec === "H264") {
-      let spsRewritten = false;
-      const nalus = splitNalu(frame).map((el) => {
-        if (H264Helpers.getUnitType(el) === H264NalUnitTypes.SPS) {
-          spsRewritten = true;
-          return rewriteSPSVUI(el);
-        }
-        return el;
-      });
-      if (spsRewritten)
-        frame = Buffer.concat(nalus.flatMap((el) => [startCode3, el]));
-    }
-    if (this.mediaConnection.daveReady && this.mediaConnection.daveSession) {
-      let daveCodec = DaveCodec.UNKNOWN;
-      switch (this._videoCodec) {
-        case "H264":
-          daveCodec = DaveCodec.H264;
-          break;
-        case "H265":
-          daveCodec = DaveCodec.H265;
-          break;
-        case "VP8":
-          daveCodec = DaveCodec.VP8;
-          break;
-        case "VP9":
-          daveCodec = DaveCodec.VP9;
-          break;
-        case "AV1":
-          daveCodec = DaveCodec.AV1;
-          break;
-        default:
-          break;
-      }
-      frame = this.mediaConnection.daveSession.encrypt(
-        DaveMediaType.VIDEO,
-        daveCodec,
-        frame,
-      );
-    }
-    this._videoTrack.sendFrame(frame);
-    this._videoTrack.addTimestamp(Math.round((frametime * clockRate) / 1000));
-  }
-
-  setPacketizer(videoCodec: string): void {
-    if (!this.mediaConnection.webRtcParams) {
-      throw new Error("WebRTC connection not ready");
-    }
-    const { audioSsrc, videoSsrc } = this.mediaConnection.webRtcParams;
-    this._videoCodec = normalizeVideoCodec(videoCodec);
-    // Audio packetizer: opus 120 @ 48kHz, playout delay ext id 5 (like @dank074)
-    this._audioTrack?.setPacketizer(
-      "audio",
-      audioSsrc,
-      CodecPayloadType.opus.payload_type,
-      CodecPayloadType.opus.clockRate,
-      5,
-      0,
-      1,
-    );
-    // Video packetizer: H264/H265/AV1 with their payload types
-    const codecEntry = CodecPayloadType[this._videoCodec];
-    if (!codecEntry) {
-      throw new Error(`Packetizer not implemented for ${this._videoCodec}`);
-    }
-    const nativeKind =
-      this._videoCodec === "H264"
-        ? "h264"
-        : this._videoCodec === "H265"
-          ? "h265"
-          : this._videoCodec === "AV1"
-            ? "av1"
-            : (() => {
-                throw new Error(
-                  `Packetizer not implemented for ${this._videoCodec}`,
-                );
-              })();
-    this._videoTrack?.setPacketizer(
-      nativeKind,
-      videoSsrc,
-      codecEntry.payload_type,
-      codecEntry.clockRate,
-      5,
-      0,
-      10,
-    );
-  }
-}

services/discord-gateway/src/goLive/index.ts

@@ -1,19 +0,0 @@
-/**
- * goLive public API — re-exports the ported @dank074 modules.
- * Drop-in replacement for `@dank074/discord-video-stream` in
- * screenShareController.ts.
- */
-
-export { AudioStream } from "./AudioStream.js";
-export { BaseMediaConnection } from "./BaseMediaConnection.js";
-export { BaseMediaStream } from "./BaseMediaStream.js";
-export { CodecPayloadType } from "./CodecPayloadType.js";
-export { demux } from "./Demuxer.js";
-export { Encoders } from "./Encoders.js";
-export { playStream, prepareStream } from "./prepareStream.js";
-export { StreamConnection } from "./StreamConnection.js";
-export { Streamer } from "./Streamer.js";
-export { normalizeVideoCodec } from "./utils.js";
-export { VideoStream } from "./VideoStream.js";
-export { VoiceConnection } from "./VoiceConnection.js";
-export { WebRtcConnWrapper } from "./WebRtcWrapper.js";

services/discord-gateway/src/goLive/native.ts

@@ -1,116 +0,0 @@
-/**
- * Loader + typings for the minimal libdatachannel N-API binding
- * (native/libdatachannel-min). The binding exposes ONLY what GoLive needs:
- * PeerConnection, DataChannel, Track (raw RTP + media packetizer chain).
- *
- * The .node file is built by node-gyp against libdatachannel 0.24.0 (built
- * from source — nixpkgs 0.24.1 is glibc-incompatible with this host). It is
- * NOT shipped via npm; the Nix flake builds it as part of the gateway.
- */
-
-export interface NativeTrack {
-  /** Send a RAW RTP/RTCP packet (no media handler installed). */
-  send(buffer: Uint8Array): void;
-  /** Send an ENCODED frame; the packetizer chain turns it into RTP. */
-  sendFrame(buffer: Uint8Array): void;
-  /** Advance the packetizer RTP timestamp by delta (clock-rate units). */
-  addTimestamp(delta: number): void;
-  /** Install the media-handler chain (packetizer → RTCP SR → NACK → pacing). */
-  setPacketizer(
-    kind: "audio" | "h264" | "h265" | "av1",
-    ssrc: number,
-    payloadType: number,
-    clockRate: number,
-    playoutDelayId: number,
-    playoutDelayMin: number,
-    playoutDelayMax: number,
-  ): void;
-  isOpen(): boolean;
-  close(): void;
-}
-
-export interface NativePeerConnection {
-  /** mid must be "0" (audio) or "1" (video) — matches @dank074's track defs. */
-  addTrack(mid: string, kind: "audio" | "video"): NativeTrack;
-  /** Resolves with the full SDP (incl. candidates) after gathering completes. */
-  createOffer(): Promise<string>;
-  /** Resolves with the auto-generated answer SDP. */
-  createAnswer(offerSdp: string): Promise<string>;
-  setRemoteDescription(sdp: string, type: "offer" | "answer"): void;
-  state(): string;
-  close(): void;
-  onStateChange(cb: (state: string) => void): void;
-}
-
-export interface NativeBinding {
-  PeerConnection: new (config: {
-    iceServers: string[];
-  }) => NativePeerConnection;
-  DataChannel: unknown;
-  Track: unknown;
-}
-
-let cached: NativeBinding | null = null;
-
-/** Load the native binding. Throws only if the .node is truly missing —
- *  callers (screen share) guard with `isNativeAvailable()`. */
-export function loadNative(): NativeBinding {
-  if (cached) return cached;
-  // Resolve relative to this file: src/goLive/ → native/libdatachannel-min/
-  const candidates = [
-    new URL(
-      "../../native/libdatachannel-min/build/Release/datachannel_min.node",
-      import.meta.url,
-    ),
-    new URL(
-      "../../../native/libdatachannel-min/build/Release/datachannel_min.node",
-      import.meta.url,
-    ),
-  ];
-  let lastErr: unknown;
-  for (const url of candidates) {
-    try {
-      // @ts-expect-error — .node modules are not typed; dynamic require via file URL
-      const mod = process.dlopen ? null : null;
-      void mod;
-      const nativePath = url.pathname;
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const req = createRequire(import.meta.url);
-      const binding = req(nativePath) as NativeBinding;
-      if (typeof binding.PeerConnection === "function") {
-        cached = binding;
-        return binding;
-      }
-    } catch (e) {
-      lastErr = e;
-    }
-  }
-  // Fallback: plain relative require (tsx / jest environments)
-  try {
-    const req = createRequire(import.meta.url);
-    const binding = req(
-      "../../native/libdatachannel-min/build/Release/datachannel_min.node",
-    ) as NativeBinding;
-    if (typeof binding.PeerConnection === "function") {
-      cached = binding;
-      return binding;
-    }
-  } catch (e) {
-    lastErr = e;
-  }
-  throw new Error(
-    `libdatachannel-min native binding not built (${String(lastErr)}). Run: cd native/libdatachannel-min && npx node-gyp rebuild`,
-  );
-}
-
-import { createRequire } from "node:module";
-
-/** True when the native binding is built — screen share stays disabled otherwise. */
-export function isNativeAvailable(): boolean {
-  try {
-    loadNative();
-    return true;
-  } catch {
-    return false;
-  }
-}

services/discord-gateway/src/goLive/prepareStream.ts

@@ -1,325 +0,0 @@
-/**
- * prepareStream & playStream — ported from @dank074/discord-video-stream
- * newApi.js (Encoders/prepareStream/playStream), but uses `child_process.spawn`
- * + ffmpeg CLI args directly instead of fluent-ffmpeg + node-av.
- *
- * Replaces the @dank074 video pipeline entirely:
- *   input (URL or Readable) → ffmpeg spawn → H264 AnnexB frames
- *   → Demuxer stream → VideoStream/AudioStream → WebRtcConnWrapper
- */
-
-import { type ChildProcess, spawn } from "node:child_process";
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { PassThrough, type Readable } from "node:stream";
-import { demux } from "./Demuxer.js";
-import { type EncoderSettings, Encoders } from "./Encoders.js";
-import { VideoStream } from "./VideoStream.js";
-import type { WebRtcConnWrapper } from "./WebRtcWrapper.js";
-
-export interface PrepareStreamResult {
-  command: ChildProcess;
-  output: PassThrough;
-  encoder: () => Record<string, EncoderSettings>;
-  options: Record<string, unknown>;
-  videoCodec: string;
-  width: number;
-  height: number;
-  frameRate?: number;
-  includeAudio: boolean;
-}
-
-function isFiniteNonZero(n: unknown): n is number {
-  return typeof n === "number" && !!n && Number.isFinite(n);
-}
-
-const DEFAULT_HEADERS = {
-  "User-Agent":
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
-  Connection: "keep-alive",
-};
-
-/** Resolve ffmpeg binary (env override → PATH → Nix store ffmpeg-headless). */
-function resolveFfmpeg(): string {
-  if (process.env.FFMPEG_PATH && existsSync(process.env.FFMPEG_PATH)) {
-    return process.env.FFMPEG_PATH;
-  }
-  const store = "/nix/store";
-  if (existsSync(store)) {
-    const entries = readdirSync(store);
-    for (const entry of entries) {
-      if (!entry.includes("ffmpeg-headless-")) continue;
-      const candidate = join(store, entry, "bin", "ffmpeg");
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  return "ffmpeg";
-}
-
-const FFMPEG_BIN = resolveFfmpeg();
-
-/**
- * prepareStream — build an ffmpeg command (as spawn args + PassThrough output)
- * that transcodes the input into a pipe we can demux. Mirrors @dank074's
- * prepareStream but produces a raw spawn instead of a fluent-ffmpeg command.
- */
-export function prepareStream(
-  input: string | Readable,
-  options: Record<string, unknown> = {},
-): PrepareStreamResult {
-  const mergedOptions = {
-    noTranscoding: false,
-    width: isFiniteNonZero(options.width)
-      ? Math.round(options.width as number)
-      : -2,
-    height: isFiniteNonZero(options.height)
-      ? Math.round(options.height as number)
-      : -2,
-    frameRate:
-      isFiniteNonZero(options.frameRate) && (options.frameRate as number) > 0
-        ? options.frameRate
-        : undefined,
-    videoCodec: (options.videoCodec as string) ?? "H264",
-    bitrateVideo:
-      isFiniteNonZero(options.bitrateVideo) &&
-      (options.bitrateVideo as number) > 0
-        ? Math.round(options.bitrateVideo as number)
-        : 5000,
-    bitrateVideoMax:
-      isFiniteNonZero(options.bitrateVideoMax) &&
-      (options.bitrateVideoMax as number) > 0
-        ? Math.round(options.bitrateVideoMax as number)
-        : 7000,
-    bitrateAudio:
-      isFiniteNonZero(options.bitrateAudio) &&
-      (options.bitrateAudio as number) > 0
-        ? Math.round(options.bitrateAudio as number)
-        : 128,
-    includeAudio: options.includeAudio ?? true,
-    encoder:
-      (options.encoder as () => Record<string, EncoderSettings>) ??
-      Encoders.software(),
-    customHeaders: {
-      ...DEFAULT_HEADERS,
-      ...(options.customHeaders as Record<string, string> | undefined),
-    },
-    customInputOptions: (options.customInputOptions as string[]) ?? [],
-    customFfmpegFlags: (options.customFfmpegFlags as string[]) ?? [],
-    minimizeLatency: options.minimizeLatency ?? false,
-  };
-
-  const output = new PassThrough();
-
-  const args: string[] = [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    ...(typeof input === "string" ? ["-i", input] : ["-i", "pipe:0"]),
-    ...mergedOptions.customInputOptions,
-  ];
-
-  if (mergedOptions.minimizeLatency) {
-    args.push("-fflags", "nobuffer", "-analyzeduration", "0");
-  }
-
-  if (typeof input === "string" && input.startsWith("http")) {
-    const headerStr = Object.entries(mergedOptions.customHeaders)
-      .map(([k, v]) => `${k}: ${v}`)
-      .join("\r\n");
-    args.push(
-      "-headers",
-      headerStr,
-      "-reconnect",
-      "1",
-      "-reconnect_at_eof",
-      "1",
-      "-reconnect_streamed",
-      "1",
-      "-reconnect_delay_max",
-      "4294",
-    );
-  }
-
-  // Video
-  args.push("-map", "0:v:0");
-  if (mergedOptions.noTranscoding) {
-    args.push("-c:v", "copy");
-  } else {
-    args.push(`-vf`, `scale=${mergedOptions.width}:${mergedOptions.height}`);
-    if (mergedOptions.frameRate)
-      args.push("-r", String(mergedOptions.frameRate));
-    const enc = mergedOptions.encoder()[mergedOptions.videoCodec];
-    if (!enc)
-      throw new Error(
-        `Encoder settings not specified for ${mergedOptions.videoCodec}`,
-      );
-    // Encoder options are declared as single strings like "-forced-idr 1";
-    // spawn needs each flag and value as separate argv entries.
-    const encOptions = enc.options.flatMap((opt) =>
-      opt.split(/\s+/).filter(Boolean),
-    );
-    args.push(
-      "-b:v",
-      `${mergedOptions.bitrateVideo}k`,
-      "-maxrate:v",
-      `${mergedOptions.bitrateVideoMax}k`,
-      "-bufsize:v",
-      `${Math.round(mergedOptions.bitrateVideo / 2)}k`,
-      "-bf",
-      "0",
-      "-pix_fmt",
-      "yuv420p",
-      "-force_key_frames",
-      "expr:gte(t,n_forced*1)",
-      "-c:v",
-      enc.name,
-      ...encOptions,
-      ...(enc.globalOptions ?? []).flatMap((opt) =>
-        opt.split(/\s+/).filter(Boolean),
-      ),
-    );
-  }
-
-  // Audio
-  if (mergedOptions.includeAudio) {
-    args.push("-map", "0:a:0?");
-    args.push(
-      "-c:a",
-      "libopus",
-      "-b:a",
-      `${mergedOptions.bitrateAudio}k`,
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-    );
-  } else {
-    args.push("-an");
-  }
-
-  args.push(...mergedOptions.customFfmpegFlags);
-  args.push("-f", "h264", "pipe:1");
-
-  const isUrl = typeof input === "string";
-  const proc: ChildProcess = isUrl
-    ? spawn(FFMPEG_BIN, args, { stdio: ["ignore", "pipe", "pipe"] })
-    : spawn(FFMPEG_BIN, args, { stdio: ["pipe", "pipe", "pipe"] });
-
-  if (proc.stdin && !isUrl) {
-    input.on("data", (chunk: Buffer) => proc.stdin?.write(chunk));
-    input.on("end", () => proc.stdin?.end());
-    input.on("error", () => proc.stdin?.destroy());
-  }
-
-  proc.stdout?.pipe(output);
-  proc.stderr?.on("data", () => {
-    /* swallow ffmpeg stderr */
-  });
-  proc.on("error", (err) => {
-    // spawn failed (e.g. ffmpeg missing). If someone is consuming output
-    // (demux attaches an 'error' listener) propagate; otherwise just end.
-    if (output.listenerCount("error") > 0) {
-      output.destroy(err);
-    } else {
-      output.end();
-    }
-  });
-  proc.on("close", () => {
-    output.end();
-  });
-
-  return {
-    command: proc,
-    output,
-    encoder: mergedOptions.encoder,
-    options: mergedOptions,
-    videoCodec: mergedOptions.videoCodec,
-    width: mergedOptions.width,
-    height: mergedOptions.height,
-    frameRate: mergedOptions.frameRate,
-    includeAudio: !!mergedOptions.includeAudio,
-  };
-}
-
-export interface PlayStreamOptions {
-  type?: "go-live" | "video";
-  format?: string;
-  width?: number | ((v: unknown) => number);
-  height?: number | ((v: unknown) => number);
-  frameRate?: number | ((v: unknown) => number);
-  readrateInitialBurst?: number;
-  streamPreview?: boolean;
-}
-
-/**
- * playStream — demux the prepareStream output and pipe frames into the
- * WebRTC connection's video/audio streams. Resolves when the video stream
- * ends (natural EOF or the ffmpeg command is killed via cleanup/stop).
- */
-export async function playStream(
-  prepared: PrepareStreamResult,
-  streamer: { createStream: () => Promise<WebRtcConnWrapper> },
-  options: PlayStreamOptions = {},
-): Promise<void> {
-  const conn = await streamer.createStream();
-
-  const { video, close: demuxClose } = await demux(prepared.output, {
-    format: options.format ?? "nut",
-  });
-
-  if (!video) throw new Error("No video stream in media");
-
-  conn.setPacketizer(video.codecName);
-  conn.mediaConnection.setSpeaking(true);
-
-  const w =
-    typeof options.width === "function"
-      ? options.width(video)
-      : (options.width ?? video.width);
-  const h =
-    typeof options.height === "function"
-      ? options.height(video)
-      : (options.height ?? video.height);
-  const fr =
-    typeof options.frameRate === "function"
-      ? options.frameRate(video)
-      : (options.frameRate ??
-        (video.framerate_num / video.framerate_den || 30));
-
-  conn.mediaConnection.setVideoAttributes(true, {
-    width: Math.round(w),
-    height: Math.round(h),
-    fps: Math.round(fr),
-  });
-
-  const vStream = new VideoStream(conn);
-  video.stream.pipe(vStream);
-
-  const cleanup = () => {
-    try {
-      prepared.command.kill("SIGTERM");
-    } catch {
-      /* already dead */
-    }
-    demuxClose();
-    try {
-      conn.mediaConnection.setSpeaking(false);
-      conn.mediaConnection.setVideoAttributes(false);
-    } catch {
-      /* connection already torn down */
-    }
-  };
-
-  return new Promise<void>((resolve) => {
-    vStream.once("finish", () => {
-      cleanup();
-      resolve();
-    });
-    vStream.once("error", () => {
-      cleanup();
-      resolve();
-    });
-  });
-}
-
-export { Encoders };

services/discord-gateway/src/goLive/utils.ts

@@ -1,82 +0,0 @@
-/** GoLive helpers — ported from @dank074/discord-video-stream/utils.js. */
-
-export function normalizeVideoCodec(
-  codec: string,
-): "H264" | "H265" | "VP8" | "VP9" | "AV1" {
-  if (/H\.?264|AVC/i.test(codec)) return "H264";
-  if (/H\.?265|HEVC/i.test(codec)) return "H265";
-  if (/VP(8|9)/i.test(codec)) return codec.toUpperCase() as "VP8" | "VP9";
-  if (/AV1/i.test(codec)) return "AV1";
-  throw new Error(`Unknown codec: ${codec}`);
-}
-
-/**
- * The available video streams are sent by the client on connection to the
- * voice gateway using OpCode Identify (0); the server replies with the ssrc
- * and rtxssrc for each available stream using OpCode Ready (2). RID
- * distinguishes simulcast streams of the same video source — we only send one
- * quality stream, so a single entry is hardcoded.
- */
-export const STREAMS_SIMULCAST = [{ type: "screen", rid: "100", quality: 100 }];
-
-export const max_int16bit = 2 ** 16;
-export const max_int32bit = 2 ** 32;
-
-export function isFiniteNonZero(n: unknown): n is number {
-  return typeof n === "number" && !!n && Number.isFinite(n);
-}
-
-export interface ParsedStreamKey {
-  type: "guild" | "call";
-  channelId: string;
-  guildId: string | null;
-  userId: string;
-}
-
-export function parseStreamKey(streamKey: string): ParsedStreamKey {
-  const streamKeyArray = streamKey.split(":");
-  const type = streamKeyArray.shift();
-  if (type !== "guild" && type !== "call") {
-    throw new Error(`Invalid stream key type: ${type}`);
-  }
-  if (
-    (type === "guild" && streamKeyArray.length < 3) ||
-    (type === "call" && streamKey.length < 2)
-  ) {
-    throw new Error(`Invalid stream key: ${streamKey}`);
-  }
-  let guildId: string | null = null;
-  if (type === "guild") {
-    guildId = streamKeyArray.shift() ?? null;
-  }
-  const channelId = streamKeyArray.shift();
-  const userId = streamKeyArray.shift();
-  if (!channelId || !userId) {
-    throw new Error(`Invalid stream key: ${streamKey}`);
-  }
-  return { type, channelId, guildId, userId };
-}
-
-export function generateStreamKey(
-  type: "guild" | "call",
-  guildId: string | null,
-  channelId: string,
-  userId: string,
-): string {
-  return `${type}${type === "guild" ? `:${guildId}` : ""}:${channelId}:${userId}`;
-}
-
-export interface VoiceChannelLike {
-  type: string;
-  id: string;
-  guildId?: string | null;
-}
-
-export function isVoiceChannel(channel: VoiceChannelLike): boolean {
-  return (
-    channel.type === "DM" ||
-    channel.type === "GROUP_DM" ||
-    channel.type === "GUILD_STAGE_VOICE" ||
-    channel.type === "GUILD_VOICE"
-  );
-}

services/discord-gateway/src/modules/ai-moderation/ai-analysis-worker.ts

@@ -316,11 +316,13 @@ async function processBatch(job: {
   // The orchestrator handles text/media split + caching + parallel paths
   // internally, so a 20-message batch = 1 text LLM call (+1 media call
   // when media is present), not N per-message calls.
+  const analysisStart = Date.now();
   const moderationResult = await runModerationAnalysis({
     targets: readyMessages,
     contextBlock,
     attachments,
   });
+  const analysisDurationMs = Date.now() - analysisStart;
 
   const results = moderationResult.results.map((r) =>
     normalizeResult(
@@ -342,6 +344,7 @@ async function processBatch(job: {
       confidence: result.confidence,
       recommendedAction: result.recommendedAction,
       analyzedAt: Date.now(),
+      analysisDurationMs,
       error: result.status === "error" ? result.analysis : null,
     },
   }));

services/discord-gateway/src/modules/ai-moderation/llmClient.ts

@@ -147,6 +147,11 @@ export interface LlmCallOpts {
   top_p?: number;
   /** Force JSON output via response_format: { type: "json_object" }. */
   jsonResponse?: { type: "json_object" };
+  /**
+   * Disable LLM chain-of-thought (reasoning/thinking) for faster analysis.
+   * Defaults to config.AI_LLM_DISABLE_THINKING when omitted.
+   */
+  disableThinking?: boolean;
   /** Extra retries beyond DEFAULT_RETRIES (default 2). */
   retries?: number;
   /** Whether to use streaming (if true, will consume stream and return aggregated result) */
@@ -155,6 +160,61 @@ export interface LlmCallOpts {
   signal?: AbortSignal;
 }
 
+/**
+ * Build the request params for an LLM chat completion. Pulled out of `llmChat`
+ * so the thinking-disable injection can be unit-tested without network access.
+ *
+ * Optional params (temperature/top_p/max_tokens) are only attached when
+ * explicitly provided, to maximise compatibility with various providers/local
+ * APIs. When `disableThinking` is set, we inject the common provider params
+ * used to switch OFF chain-of-thought reasoning. OpenAI-compatible routers
+ * ignore the variants their backend does not understand, so sending the
+ * OpenAI (`reasoning_effort`), OpenRouter (`reasoning.enabled`) and
+ * vLLM/Qwen/litellm (`chat_template_kwargs.enable_thinking`) forms together
+ * covers the popular reasoning backends behind a proxy.
+ */
+export function buildLlmParams(
+  opts: LlmCallOpts,
+  disableThinking: boolean,
+): OpenAI.Chat.Completions.ChatCompletionCreateParams {
+  const {
+    messages,
+    model = config.AI_LLM_MODEL,
+    max_tokens,
+    temperature,
+    top_p,
+    jsonResponse,
+    stream,
+  } = opts;
+
+  const params = {
+    model,
+    messages,
+    ...(stream !== undefined ? { stream } : {}),
+  } as OpenAI.Chat.Completions.ChatCompletionCreateParams;
+
+  if (temperature !== undefined) params.temperature = temperature;
+  if (top_p !== undefined) params.top_p = top_p;
+  if (max_tokens !== undefined) params.max_tokens = max_tokens;
+  if (jsonResponse) params.response_format = jsonResponse;
+
+  if (disableThinking) {
+    Object.assign(params, {
+      // OpenAI o-series
+      reasoning_effort: "none",
+      // OpenRouter
+      reasoning: { enabled: false },
+      // vLLM / Qwen / litellm
+      chat_template_kwargs: { enable_thinking: false },
+      // Anthropic / Claude-format (9router exposes thinkingFormat
+      // "claude-adaptive" / "claude-budget" on its reasoning models)
+      thinking: { type: "disabled" },
+    } as Record<string, unknown>);
+  }
+
+  return params;
+}
+
 /**
  * Call the LLM with sensible defaults: concurrency cap, retry, model, tokens.
  *
@@ -167,33 +227,12 @@ export async function llmChat(
   const client = getClient();
   if (!client) return null;
 
-  const {
-    messages,
-    model = config.AI_LLM_MODEL,
-    max_tokens,
-    temperature,
-    top_p,
-    jsonResponse,
-    retries = DEFAULT_RETRIES,
-    stream,
-    signal,
-  } = opts;
+  const { retries = DEFAULT_RETRIES, signal } = opts;
+  const disableThinking =
+    opts.disableThinking ?? config.AI_LLM_DISABLE_THINKING;
 
-  const params = {
-    model,
-    messages,
-    ...(stream !== undefined ? { stream } : {}),
-  } as OpenAI.Chat.Completions.ChatCompletionCreateParams;
-
-  // Attach optional parameters only if explicitly provided to maintain
-  // maximum compatibility with various LLM providers and local APIs.
-  if (temperature !== undefined) params.temperature = temperature;
-  if (top_p !== undefined) params.top_p = top_p;
-  if (max_tokens !== undefined) params.max_tokens = max_tokens;
-
-  if (jsonResponse) {
-    params.response_format = jsonResponse;
-  }
+  const params = buildLlmParams(opts, disableThinking);
+  const model = params.model;
 
   return retryWithBackoff(
     async () => {
@@ -283,6 +322,12 @@ export async function llmChat(
  * Convenience for vision (image/sticker/emoji) analysis.
  * Returns the raw completion content (trimmed) or null.
  *
+ * Vision routes through the SAME router/base URL as text moderation
+ * (AI_LLM_BASE_URL) — the dedicated NVIDIA multimodal endpoint was removed.
+ * It uses AI_LLM_VISION_MODEL (a different model alias from the text combo)
+ * so image analysis stays on a vision-capable model. Thinking-disable from
+ * config.AI_LLM_DISABLE_THINKING applies automatically via buildLlmParams.
+ *
  * NOTE: retries are disabled here on purpose — visionAnalyzer.ts already
  * wraps this call in its own 3-attempt loop with exponential backoff.
  * A second retry layer would multiply worst-case API calls (3×3=9/image).

services/discord-gateway/src/modules/ai-moderation/mediaAnalysisClient.ts

@@ -6,7 +6,6 @@
  */
 export {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
   setCachedMediaAnalysis,

services/discord-gateway/src/modules/ai-moderation/mediaCache.ts

@@ -7,28 +7,22 @@
 import { LRUCache } from "lru-cache";
 import {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
-  getCachedMediaByPhash,
   makeCustomEmojiCacheKey,
   makeImageCacheKey,
   makeStickerCacheKey,
   upsertCachedMediaAnalysis,
-  upsertCachedMediaByPhash,
 } from "./textCacheStore.js";
 
 export {
   acquireMediaAnalysisLock,
-  computeImagePhash,
   deleteCachedMediaAnalysis,
   getCachedMediaAnalysis,
-  getCachedMediaByPhash,
   makeCustomEmojiCacheKey,
   makeImageCacheKey,
   makeStickerCacheKey,
   upsertCachedMediaAnalysis,
-  upsertCachedMediaByPhash,
 };
 
 /** Convenience alias for upsertCachedMediaAnalysis. */

services/discord-gateway/src/modules/ai-moderation/mediaDownloader.ts

@@ -450,7 +450,7 @@ export async function downloadMediaCandidate(
   if (candidate.customEmojiId || candidate.stickerName) {
     const vck = candidate.customEmojiId
       ? makeCustomEmojiCacheKey(candidate.customEmojiId)
-      : makeStickerCacheKey(candidate.stickerName!);
+      : makeStickerCacheKey(candidate.stickerName ?? "");
     const cached = await getCachedMediaAnalysis(vck);
     if (cached) {
       const existing = mediaAnalysisMap.get(targetId) ?? [];

services/discord-gateway/src/modules/ai-moderation/moderationOrchestrator.ts

@@ -194,7 +194,7 @@ export async function runModerationAnalysis(
       if (embeddings && embeddings.length === texts.length) {
         // index-aligned with semanticCandidates
         for (let i = 0; i < semanticCandidates.length; i++) {
-          const { target, cacheKey } = semanticCandidates[i];
+          const { cacheKey } = semanticCandidates[i];
           embeddingsByKey.set(cacheKey, embeddings[i]);
         }
 

services/discord-gateway/src/modules/ai-moderation/prompts/examples.ts

@@ -335,6 +335,26 @@ export const ALL_EXAMPLES: ExampleDef[] = [
       '{"results":[{"message_id":"31313","status":"flagged","flags":["conflict_instigation","sara"],"score":0.95,"severity":"critical","confidence":0.95,"recommended_action":"delete","evidence":["gw sih dukung palestina"],"analysis":"Segala diskusi Israel/Palestina/Yahudi dilarang total — tidak ada debat, dukungan, atau berita. Dihapus."}]}',
     modes: ["text", "media", "mixed"],
   },
+
+  // ── Physics / Technology Discussions (false positive prevention) ──
+  {
+    id: "32",
+    title: "Diskusi fisika/kinetik dalam konteks teknis (AMAN, bukan ancaman)",
+    input:
+      "[target] id=32323 user=physics_student: Cukup cuman tubuh manusia vs gravitasi. Konsep energy conservation di sini penting buat analisis statis.",
+    output:
+      '{"results":[{"message_id":"32323","status":"clean","flags":[],"score":0.0,"severity":"none","confidence":0.95,"recommended_action":"none","evidence":[],"analysis":"Diskusi fisika teknis tentang kinetik dan gravitasi dalam konteks analisis statis – tidak ada ancaman atau konten melanggar. Penggunaan istilah fisika untuk perhitungan teknis adalah hal wajar."}]}',
+    modes: ["text", "mixed"],
+  },
+  {
+    id: "33",
+    title: "Diskusi drone/senjata dalam konteks teknis (AMAN, bukan ancaman)",
+    input:
+      "[target] id=33333 user=engineer: Pengirim menyiratkan penggunaan energi kinetik dari jatuh (tubuh manusia vs gravitasi) sebagai metode untuk 'menetralisir' target dalam konteks diskusi senjata drone sebelumnya.",
+    output:
+      '{"results":[{"message_id":"33333","status":"clean","flags":[],"score":0.0,"severity":"none","confidence":0.9,"recommended_action":"none","evidence":[],"analysis":"Diskusi teknis tentang drone dan aplikasi fisika dalam konteks engineering – tidak ada ajuan aksi atau ancaman nyata. Penggunaan istilah senjata dalam konteks diskusi teori adalah hal wajar."}]}',
+    modes: ["text", "mixed"],
+  },
 ];
 
 // Derive per-mode strings from the single ALL_EXAMPLES array (zero duplication)