chronicle

How the `dbcdata import` loader is structured and how to add a new game-data importer that uploads into a Chronicle dataset. Use when adding/modifying an Importer in scripts/dbcdata/cli, wiring a new DBC upload endpoint in api/gamedataapi, or migrating a game-data type (spells, items, talents, creatures) from compiled-in dbcmem to a database-backed dataset.

Chronicle's multi-tenant branding and CSS theming system. Covers the Branding struct, server-side CSS injection via Go templates, the ThemeEditor component, and how branding flows from database → API → HTML template → React components. Use when: modifying branding fields, adding theme knobs, changing how logos/colors/titles render, or debugging tenant vs site-level branding resolution.

AzerothCore ScriptAI hook system documentation. Covers the Observer pattern, creating new ScriptObject types, implementing hooks in ScriptMgr, naming conventions, and advanced patterns (filtering via references/bool returns, module-internal hooks). Use when: adding hooks to AzerothCore, creating modules, or working with ScriptMgr.

Multi-server build pipeline for Chronicle. Each WoW server (Turtle, Epoch, etc.) produces its own binary via Go build tags, its own Docker image, and its own Railway deployment. Covers the dbcmem driver-registration pattern, Dockerfile SERVER arg, CI matrix strategy, and how to add a new server.

Generate static Go code from WoW DBC files

Rankings and leaderboard system for Chronicle. Covers speedrun tracking (parser-side kill detection), leaderboard queries with version filtering, admin-configurable version requirements, and the semver encoding scheme for SQL-side comparison. Use when: adding ranking types, modifying speedrun rules, changing version requirements, or working with the leaderboard API/UI.

Guild Pages feature for Chronicle - customizable public pages for guilds with drag-drop panel editor

DPS simulation engine for Vanilla WoW (Turtle WoW) in TypeScript. Runs entirely in the browser. Covers combat formulas, spell/melee resolution, aura tracking, event-driven engine, the ApiDataProvider pattern, and EventsPanels integration. Use when: adding spells/rotations, modifying combat formulas, debugging sim output, building the sim UI page, or working with the panel bridge.

Rotations panel for Chronicle EventsPanels. Displays spell cast timelines as icons on a horizontal time axis. Default view shows one row per player; focus view (single entity selected) shows one row per spell ability. Uses spell_go/spell_start/spell_fail streams. Supports zoom, shift+scroll panning, and panel filters. Use when: modifying rotations panel UX, adding features to the cast timeline, changing how spell casts are visualized, or debugging rotation display issues.

Timeline events panel for Chronicle. A Nivo line chart that visualizes combat data over time with configurable multi-series support, per-series filtering, render-time aggregation, and drag-to-select time range. Uses custom card-back editor, base64 panelOption persistence, and several framework extension points (hydrateContext, renderCardBack, processAllEvents, _-prefix convention).

Pattern for adding generated JSON assets served by the Assets service. Use when: adding new DBC-derived data files, serving static JSON to the frontend, or working with the assets/generated/ directory and /api/v1/assets/ endpoint.

EventsPanels system for Chronicle combat log analysis. Processes WoW combat log event streams (damage, heal, resource_change, slain, cast, aura, extra_attack) into displayable metrics. Key architecture: processors are worker-safe pure TypeScript (NO React), panels are React wrappers. Processing runs in a Web Worker pool to keep UI responsive. Includes Focus feature: right-click player rows to drill into per-ability breakdown (URL-persisted).

Custom filter system for Chronicle EventsPanels. Covers filter types (ability_name, ability_id, ability_school, ability_hittype, source_type, target_type, players, enemies), compilation to predicates, UI editors, AND/OR combinator logic, and adding new filters. Use when: modifying filter behavior, adding filter types, debugging filter matching, or understanding how filters flow from UI → worker → event processing.

Iteratively refine development plans using TDD methodology. Ensures plans are clear, actionable, and include red-green-refactor cycles with proper test coverage.

Guides working with Chronicle's combat log parser for Classic World of Warcraft (Turtle WoW). Use when: adding new event types, debugging parsing failures, understanding GUID formats, or working with the vanilla combatlog package. Covers the matcher pattern, message types, regex-based parsing, and the 64-bit GUID structure with entity type bits.

Database patterns for Chronicle using PostgreSQL and sqlc. Covers query writing conventions, migration workflow, custom type overrides, batch operations, and testing with dbtestutil. Essential for any database schema or query changes.

Chronicle frontend data flow uses React Query for REST API calls and protobuf for high-volume event streams. Types are auto-generated from Go SDK via guts. Event streams are fetched as gzip-compressed binary, decoded in workers, and cached per-instance. The InstanceEventsContext provides stream caching and deduplication.

Chronicle HTTP API conventions using go-chi router. Covers request/response handling with httpapi helpers, JWT authentication via chronauth, SDK type definitions that auto-generate TypeScript, and database-to-SDK conversion patterns. Essential for adding or modifying API endpoints.

River is a PostgreSQL-based job queue used in Chronicle for background processing. Jobs are defined as Go types implementing rivertype.JobArgs. The queue handles log parsing, reparsing, and other async tasks. Workers process jobs from named queues with configurable priorities, retry policies, and deduplication.

Documents Chronicle's WoW encounter/instance detection system for Turtle WoW and Vanilla WoW. Covers registering raid instances, defining bosses and trash mobs via Identity maps, creating boss-specific Character handlers with custom mechanics (multi-phase, add tracking), and zone parsing from combat logs. Key patterns: CommonFactory for simple instances, characterFactory for boss behaviors, Identity struct for hostile classification.