| record AccentRowElement |
Wraps a row Child with a per-row accent backdrop drawn BEHIND it: a faint Stripe-tinted bar whose width is Share (0..1) of the row, plus a 3-px Stripe-coloured left edge. The CombatMeter History/Skill table rows use this for the role-coloured stripe + share-fraction wash the IMGUI build drew (DrawRowAccent). Both Funcs are poll-diffed. |
| record BackdropElement |
Full-size black backdrop behind all content — an ignoreLayout Image that stretches to cover its parent GO. Place as the FIRST child of a ColumnElement so all siblings render on top. Opacity (0..1) is poll-diffed each Apply tick so a settings slider updates it in real time. |
| record BarElement |
Graphical fill bar (0..1). Chrome framework-themed; Fill is the plugin’s semantic colour (from its colour slot). Optional right-aligned numeric Label and optional fixed-width left Prefix caption (e.g. “HP” / “Stamina”) so stacked bars align in a column. |
| enum BarStyle |
Render style for a BarElement. |
| record BarWidget |
Horizontal fill bar child widget for a PanelSpec. |
| record BrandLogoElement |
Animated brand logo (the launcher’s Stellar sparkle): an accent-tinted Sparkle inside an accent button cell, over a soft Glow halo whose alpha + scale PULSE. The renderer drives the pulse each frame (the builder is sandbox-pure → renders static in the sandbox). Size is the sparkle size (default 22). |
| record BubbleElement |
A content-hugging rounded “chat bubble” / card: a FillColor-tinted rounded sliced background (the same rounded chip sprite SelectableElement draws) hosting a single Child with inner padding. Unlike SelectableElement — which is forced to stretch the full column width — a bubble’s width HUGS its child’s preferred width, so a short label makes a narrow bubble and a long sentence makes a wide one, capped at MaxWidth (or the available width) past which a wrapping TextElement child flows to multiple lines and the bubble grows in height. Built for a game-style chat UI (translucent fills + right-aligned self rows). It is a PURELY VISUAL container: it does not intercept clicks (its background is not a raycast target), so to make a bubble clickable, wrap it in a SelectableElement (or place a ButtonElement beside it) — the bubble renders on top of the selectable’s own tint. |
| record ButtonElement |
Clickable button. Enabled null = always enabled. Style null = the chrome’s active IChromeStyle default. Active (poll-diffed) renders the accent/filled look when true — used for active tab / toggle-button highlighting. Width > 0 fixes the button width (it can’t grow/shrink) and WRAPS its label — use for right-aligned cells (e.g. a hotkey binding) that must never overflow the row regardless of font metrics. Icon (optional PNG) renders a leading icon INSIDE the button, co-centred with the label by the button’s own layout (so icon↔label alignment can’t drift with font metrics — used by the Settings hub’s iconed tabs). |
| record CellElement |
Width-controlled column cell — fixes or weights a cell’s width for aligning a Row’s children into a table. Wraps any Child subtree. Width > 0 fixes the cell width (cannot grow/shrink — use for numeric columns like Current / Proj / Δ so they align across the header + every body row regardless of font metrics). Weight > 0 makes the cell GROW to share leftover row width in that proportion (the elastic label column, or master-detail panes — Weight 1 : 2 = ⅓ : ⅔). Width and Weight are mutually exclusive (Width wins if both set); both 0 = natural content size. Per-cell colour stays on the Child (e.g. Color) — the cell owns geometry only. Header and body align by using the SAME cell specs on every Row. Weighted cells require the enclosing Row to be a direct child of a Column / Scroll content / window body (all force-expand width — true for every layout that needs alignment). |
| struct ChartSeries |
One labelled series in a LineChartElement. |
| record ColorPickerElement |
HSV colour picker (SV square + hue bar + hex field). Get reflects the slot’s colour; a pick calls Set. The one hand-drawn custom widget. |
| record ColorSlotInfo |
Editor enumeration record for one registered slot. |
| record ColumnElement |
Vertical layout container: children stacked top-to-bottom with optional spacing. |
| record ConditionalElement |
React-style conditional. Both subtrees are built once; the renderer SetActive-toggles them each refresh from When (no reconciliation). Else may be null. Fill = the active branch expands to fill leftover height in a fixed-size (Resizable) window (so e.g. a meter’s list scroll grows with the window). Default false — no effect in content-sized windows. |
| record CooldownTileElement |
One cooldown/debuff tile for the CooldownBar: a fixed icon square (game-asset art via Icon/Uv) with an Accent-tinted outline, a foot fill-bar (width = Fill01, 0..1), an optional ★ corner badge when IsImagine, an optional ×N charge count when ChargeCount > 1, and a centred Seconds caption below — all poll-diffed each refresh. The framework binds the boxed texture on the window’s refresh pass (renders without the runtime ticker, unlike GameTextureElement), so it appears immediately. Compose pooled tiles inside a RowElement wrapped in ConditionalElements for active-only collapse. |
| record DragSlotElement |
Wraps a grid cell so it can be dragged onto another cell. Key identifies the cell (the CombatMeter uses the flat group*5+slot index). OnDrop fires on the grabbed cell when it is released over a different registered cell, as OnDrop(fromKey, toKey). CanDrag gates the whole interaction (e.g. leader-only); when it returns false the cell neither drags nor accepts drops. While dragging, a dimmed ghost of Child follows the cursor and the hovered target highlights. Renderer-neutral — no IMGUI tokens. |
| record DropdownElement |
Compact dropdown for a small, fixed set of mutually-exclusive choices (e.g. a mode selector) — a reusable replacement for a click-to-cycle button. The trigger shows the current option (caption + ▾); a click opens a themed floating option list that floats above the window’s scroll clip. Picking an option calls OnSelect with its index; the list dismisses on pick, outside-click, or Esc. |
| enum DropdownStyle |
Render style for a DropdownElement. |
| struct EntityMenuItem |
A registered context-menu item, scoped to the entity it was resolved for. |
| struct EquippedItem |
One equipped item resolved for display: which item id occupies which slot. |
| record GameTextureElement |
Displays a game-asset texture handle (boxed UnityEngine.Texture) at a fixed pixel size, optionally cropped to a UV sub-rect (for atlas icons such as profession crests). The framework re-pulls Texture (and Uv when set) each frame, so an icon whose async load finishes after the window builds still appears. Renderer-neutral — the handle crosses the boundary as Object. Null texture = an invisible box that keeps its layout slot. The simpler sibling of RenderTextureHostElement (no drag/zoom/pan, no backdrop) and of SpriteElement (which takes PNG bytes, not a live texture handle). |
| struct GearSlotRef |
One equipped item from social data: which item-config id occupies which slot (no instance rolls — social data carries slot+id only). |
| abstract record HudElement |
A node in a HUD’s declarative element tree. Plugins compose these; the framework renders them as native uGUI with one enforced chrome. Dynamic leaves carry Funcs the framework re-pulls on its capped refresh (state→view without touching the UI engine). |
| interface IBossVitals |
Native boss-HP tap: reads the SAME merged per-entity store the game’s own boss bar reads (Panda.ZUi.BossBloodUtil.ConversionBloodLogicDataToViewData(ZEntity)) instead of the combat wire’s AttrCollection mirror (GetVitals). Immune by construction to the wire mirror’s AOI-eviction starvation (a raid boss that leaves your AOI mid-fight on a raid’s one big multi-stage map) — see docs/superpowers/specs/2026-08-26-raid-bosshp-capture-design.md § decision 2. Backed by the game’s entity manager; reads MUST happen on the main thread (the framework Update tick), same contract as IEntityTransforms. Returns false when the entity isn’t resolvable this frame (despawned / not loaded / no game) or has never reported a blood/boss observation — callers should treat that as “unknown”, not “zero”, and fall back to GetVitals. |
| interface ICameraControl |
A held camera override. Dispose to hand the camera back (the game blends back to its own camera). |
| interface ICameraOverride |
Exclusive takeover of the game camera for a free camera. Main thread only. One holder at a time; a second TryAcquire returns false. The framework ends the override on a zone change, a cutscene, the game’s own camera mode opening, a disconnect, the holder’s unload, or an exception in the holder’s Frame handler, and raises Released with the reason. The camera is never placed more than 60 m from the local player, whatever the holder asks for. |
| interface IChat |
Plugin-facing chat service. MessageReceived fires on the main (Unity) thread; Send is fire-and-forget — failures are logged, never thrown. |
| interface IChromeStyle |
User-selected global chrome control styles — the button + scrollbar look applied to every GlassMenu panel. Persisted with the theme; changing either fires the theme’s ActiveChanged so the renderer rebuilds its skin. A plugin may pin its own per-window button and scrollbar style via ButtonElement, which the user cannot override here. |
| interface IClientState |
Player session state plus the client-phase and UI-state signals. Session state (IsLoggedIn/Login/Logout) and client phase (Phase) are distinct concepts that coexist — they correlate today but answer different questions. |
| interface IColorRegistry |
Plugins register the colours they OWN. Key is namespaced “Owner.Concept.Property” (e.g. “PlayerHUD.StaminaBar.Fill”), unique. A Register overload supplies the owner’s colour for each built-in preset. Register only colours a plugin owns; to match a theme colour, read Theme.Colors.X directly instead. |
| interface IColorSlot |
Handle returned by IColorRegistry’s Register methods. Read Value when drawing — it resolves to the colour for the active theme, honouring user overrides. Cache the handle, not the value. |
| interface ICombatBuffEffectLookup |
Per-buff-instance “effect ids” decoded off the combat wire — the extra payload a buff instance carries that ActiveBuff does not: the BuffEffectLogicPlayEffect.effect_id of its PlayEffect logic entries, or the values of a BuffEventCustomize event (slot / lock codes). Raid mechanics encode per-player meaning there (e.g. a slash order, a colour pattern). A base of ICombatLookup, so it is reached as services.CombatLookup.TryGetBuffEffectIds(...); it is a separate interface only because ICombatLookup is at the 8-member cap. Needs framework ≥ 2.30.0. |
| interface ICombatEvents |
Combat event stream. Mirrors the event half of the original mixed combat surface; polled state lives on ICombatSnapshot and per-entity lookups on ICombatLookup. Events always fire on the Unity main thread (drained once per Game.Update postfix). |
| interface ICombatLookup |
Per-entity combat lookups. Covers any entity observed in AOI on the combat wire — not limited to party members or the local player. Mirrors the lookup half of the original mixed combat surface; the polled local snapshot lives on ICombatSnapshot and the event stream lives on ICombatEvents. Per-buff effect ids come from the ICombatBuffEffectLookup base (added on a base because this interface is at the STELLAR0005 member cap — existing members never move). |
| interface ICombatSnapshot |
Polled snapshot of the local player’s combat state plus a ring buffer of recently observed events. Mirrors the polled half of the original mixed combat surface; the event stream lives on ICombatEvents and per-entity lookups live on ICombatLookup. All reads are safe from the Unity main thread. |
| interface ICombatSpec |
Per-entity active sub-profession (spec). |
| interface ICombatState |
Whether the local player is in combat, from the game’s own combat-state changes (never polled). |
| interface IConfigSection |
A named subset of a plugin’s configuration. Read access via Get is lock-free against the in-memory cache; writes via Set are cached and persisted to disk on Save. Supported T: primitives (Int32, Int64, Boolean, String, Single, Double), arrays of primitives, and string-keyed dictionaries of primitives. Records and complex objects are out of scope for v1 — use multiple keys instead. |
| interface IDeepSlumber |
Read-only access to the local player’s Deep-Slumber Psychoscope (season cultivate) state — season level plus every cultivate line’s areas, socketed cards, and node levels. The state is refreshed from the game’s live containers via the framework’s on-demand Lua bridge (on login, and again on build-state changes — including Deep-Slumber edits), then cached until the next refresh; it is cleared on logout so a relog never serves the previous character’s data. Because the refresh is on-demand rather than synchronous with the edit, GetState called immediately after an edit may briefly return the state from before that edit. |
| interface IDungeonState |
Read-only view of the current dungeon run, decoded from the game’s WorldNtf.SyncDungeonData notification. Surfaces the per-run unique id (CurrentRunId) that an upload/logging plugin needs to key a run (the StellarLogs level_uuid), plus the clear-time / score once the run settles (LastSettlement). |
| interface IEmotes |
The local player’s unlocked emotes (the same set as the game’s emote wheel) and playing one through the game’s own emote action — the game’s checks and refusal messages apply; no packet is ever built. Main thread only. |
| interface IEntityContextMenu |
Extension point for entity-scoped row context menus (CombatMeter renders these on a right-click). Any plugin registers items; the renderer need not know the registrant. Items can gate per-entity. |
| interface IEntityDetail |
Per-entity detail captured from the combat wire’s SyncNearEntities attribute stream — the full broadcast attribute map and equipment for any in-AOI entity. Identity/skills come from ICombatLookup; derived self-only stats from IPlayerStats. |
| interface IEntityPicker |
Finds the character drawn under a screen point: players (including the local player) and, since 2.15.0, NPCs. Main thread only. |
| interface IEntityPortrait |
Live, posed 3D portrait of a player entity — full body, real outfit, idle-animated — rendered by the game’s own UI-model pipeline into a render texture that a RenderTextureHostElement displays. Works for the local player and any other player (the subject is created from the player’s social data, the same way the game’s own character preview windows do it). The plugin calls Show when its portrait slot opens on an entity and reads Texture (the boxed UnityEngine.Texture) to display it. |
| interface IEntityPortraitView |
Camera-interaction controls for the entity portrait (drag/scroll/resize). |
| interface IEntityTransforms |
Toolkit service that reads the live world transform (position + facing) of an arbitrary game entity by id. Backed by the game’s entity manager; reads MUST happen on the main thread (the framework Update tick). Intended for replay/position capture; returns false when the entity is not resolvable (despawned, not loaded, or off-game), leaving the out-parameters at their defaults. |
| interface IExchange |
Query the in-game player exchange/marketplace and buy items through the game’s own trade system. Buying drives the game’s native buy (server-validated); it never builds packets or bypasses game-side checks. All reads are point-in-time async requests. |
| interface IFramework |
Per-frame callbacks driven by the game’s main update loop. Timing / main-thread-marshalling members (Post, Every, TimeNow) are inherited from IFrameworkTiming; the read-only developer mode flag (DeveloperMode + DeveloperModeChanged) from IFrameworkDeveloperMode. |
| interface IFrameworkDeveloperMode |
The user’s framework developer mode, read-only for plugins (2.30.0). Split out of IFramework, which is at the framework’s interface-size budget; consumers reach it through services.Framework exactly as if it were declared there. |
| interface IFrameworkTiming |
Timing / main-thread-marshalling surface of IFramework. Split out from the frame/screen metrics so each interface stays within the framework’s shape budget; consumers reach these through services.Framework exactly as if they were declared on IFramework. |
| interface IFriends |
The local player’s friend list and private-chat (whisper) conversations, read from the game’s own data and refreshed every few seconds while in the world and in use (a Changed subscriber, a queued action, or a list read in the last ~30 s — the FIRST read starts the refresh, so its data can lag that read by a tick); plus the game’s own private-chat actions. Pair with IChat: whispers arrive there with PeerId = the conversation’s CharId, and are sent with ChatTarget.Whisper(charId). |
| interface IGameAssets |
Toolkit service for loading game assets (textures, sprites) via the game’s own Addressables loader (ZResLoader). Provides an opaque texture handle so plugins can render icons without a direct Unity dependency on Texture2D. |
| interface IGameData |
Read-only lookup over the game’s static Panda.Table data. Resolves Bokura.*TableBase row IDs to typed POCO records with display strings pre-resolved through the game’s LocalizationMgr. Eager batch (Skill, Buff, Profession, Attribute, Item) is loaded inline at HybridCLR-ready; IsAvailable becomes true once that completes. 17 deferred tables drain one per Game.Update tick — lookups return null until their table is loaded (typically a few seconds after IsAvailable=true). Strings are resolved at cache-build time. Mid-run language switch will not refresh names until next game restart (deferred to Phase 6+). |
| interface IGameDataCombat |
Static-data lookups for combat-related rows. |
| interface IGameDataEquip |
Static-data lookups for the gear-slot tables (equip rows, attr-lib ranges, slot names). Deferred-loaded: lookups return null/empty for a few seconds after boot. |
| interface IGameDataInventory |
Static-data lookups for inventory-related rows. |
| interface IGameDataProgress |
Static-data lookups for progression-related rows. |
| interface IGameDataResonance |
Static game-data lookups for Battle Imagines (Resonance Skills). |
| interface IGameDataWorld |
Static-data lookups for world-related rows. |
| interface IGameEnvironment |
Identity of the running game install: which regional release it is and the installed game version. Detected once at boot from install markers (executable name / install layout); the framework config key environment.region ("sea" | "jp") overrides detection. Values are latched at boot and never change during a session. |
| interface IGameEvents |
Subscribe to typed game events by their fully-qualified Panda type name. Backed by MessagePipe’s ISubscriber<T> when the host can reach the game’s container; otherwise backed by hook fallbacks. Plugins see the same API either way. |
| interface IGameStickerCatalog |
Chat-sticker CATALOG concern of IGameAssets (which inherits this). Split out so IGameAssets stays within the framework’s interface-width budget while keeping the whole surface reachable through a single _services.GameAssets handle — the sticker THUMBNAIL loader (LoadStickerIcon) stays on IGameAssets; the catalog ENUMERATION lives here. |
| interface IHarmonyHost |
Per-plugin owner of Harmony instances. Plugins still author their own patch classes, but obtain the Harmony from here so the framework guarantees id uniqueness (namespaced to the plugin) and unpatches every instance automatically when the plugin is disposed — a plugin can no longer leak an un-unpatched instance across a soft enable/disable cycle. Pairs with FindMethod for resolving patch targets. |
| interface IHotkeys |
Plugin-facing hotkey service. Declare bindable keyboard actions and receive callbacks when pressed. |
| interface IInputShield |
While any handle is held (reference-counted across plugins): blocks the game’s movement, camera, combat and interaction actions (mouse included), and blocks every keyboard key from the game — the same gate a focused Stellar text field uses, so Esc, Enter, M, Tab and the rest open nothing in the game. The holder reads the keyboard and mouse itself through the handle; framework hotkeys keep working. Main thread only. Handles a plugin still holds are released when it unloads. |
| interface IInputShieldHandle |
A held input shield plus raw input reads. Reads return defaults once disposed. |
| interface IInventory |
Read-only access to the player’s module-package inventory and currently equipped set. Sampled at 1Hz from the Game.Update tick; not subscription driven (inventory changes are infrequent enough that 1Hz polling beats the bookkeeping cost of subscriptions). Pair with GetAttributeProfile to resolve ModulePart.AttrId labels (Phase 6 reuse). Threading: GetModules and GetEquipped are thread-safe lock-free reads (Volatile under the hood). The InventoryChanged event raises on the framework Update thread; subscribers can call IMGUI from the handler. SelfGearChanged is different — it raises on the network/sync thread (see its remarks). |
| interface ILauncher |
Registry of launcher entries. Plugins call Register to add a tile to the Stellar launcher menu and hold the returned IDisposable to remove it on unload. Entries preserves registration order. |
| interface ILights |
Photo lights: lamps placed in the world, the level at which characters take lamp light, and a key light and rim per person. Everything is local and visual only, and belongs to the scene: the framework removes every lamp and puts every game value back — exactly as it was — on the reasons the scene freeze ends on (a zone change or scene leave, a cutscene, the game’s own camera mode, a disconnect, the framework unloading), raising Released; a plugin’s lights also go when it unloads, and on its own ResetAll. Leaving a free camera keeps them. |
| interface ILoadout |
Read + apply the player’s saved in-game loadouts (class + gear + spec + modules). Applying drives the game’s own switch and surfaces the game’s result; it never bypasses game-side validation (combat lock, profession/weapon match). |
| interface ILoadoutSave |
Save the setup the player is WEARING into one of their saved in-game loadouts — the game’s own “Save” (its Role Plan AsyncSaveRolePlan), aimed at a loadout other than the worn one. Split from ILoadout (read + switch) so that interface stays within its member budget; reach it through LoadoutSave. |
| interface ILocalization |
Localizes this plugin’s own UI text. Resolves a stable structured key to the active UI language, falling back to English and then to the key literal. Scoped to the calling plugin’s own catalog (like IPluginLog) — keys never collide across plugins. Ship six Lang/<code>.json catalogs (en, ja, th, id, fil, ko) as EmbeddedResource in your plugin; the framework auto-discovers them at load. |
| interface ILocalizationControl |
Framework-facing control over the active UI language, injected into Settings only. Deliberately NOT part of IPluginServices — plugins read the language via Language but cannot change the global setting. |
| interface ILookHandle |
An active look. Dispose to restore the game’s own look. |
| interface ILua |
Bridge to the game’s live tolua# Lua state (LuaInterface.LuaState.mainState) where all Z.* game globals are registered. Lets a plugin run a Lua chunk and read simple global values back, without hand-rolling the reflection resolution in every plugin. |
| record ImageElement |
Escape hatch: plugin supplies its own PNG; framework displays it. Consistency is the plugin’s responsibility here (the one unenforced spot). |
| interface IModuleEquip |
Game-state mutation primitive: equip / uninstall modules via the game’s own RPC dispatcher. Implementations invoke the game’s Lua functions ModVM.AsyncEquipMod / ModVM.AsyncUninstallMod through the ZLuaFramework bridge — the plugin supplies inputs, the game’s Lua code builds the protobuf and applies its own validation. User-initiated only. Plugins MUST trigger calls from a user action (button press, slash command, hotkey) — not from a timer, scheduled event, or background loop. See the project’s out-of-scope policy (README). Async: every call polls the game’s Mod.ModSlots map until it reflects the requested change, or times out at 6 seconds (matching the Lua proxy timeout). Callers must await and check the returned EquipResult. |
| interface INamedTheme |
User-facing theme controls — preset selector + global font scale. The concrete implementation persists selections to config and tints every plugin’s rendered chrome / text on the next OnGUI pass. |
| interface INativeUiElementHandle |
Handle to a registered element. Auto-removed on plugin/framework dispose. |
| interface INativeUiHost |
Plugin-facing service for injecting declarative mod uGUI into curated game-UI anchors. The framework builds, styles, and lifecycle-manages the real uGUI; plugins only describe intent via NativeUiElementSpec. |
| record IndicatorSpec |
A read-only text indicator; OnUpdate is re-pulled each refresh. |
| interface INoticeTipBuilder |
Fluent builder for a single noticetip display request. |
| interface INoticeTips |
Framework service for triggering the game’s noticetip system (dungeon bars, win/fail banners, pop-up stacking tips) from any plugin, with full control over content, duration, and audio. |
| interface INotificationBuilder |
Fluent builder for a single toast. Accumulates message / kind / duration / icon, then Show enqueues the toast. Mirrors INoticeTipBuilder’s shape for surface consistency. Obtain one via Create. |
| interface INotifications |
Framework toast surface — show short, transient on-screen messages from any plugin. Messages auto-disappear after their lifetime; this is fire-and-forget and read-only (no dismissal handle, no input). Use for plugin-side feedback the game does not show itself (guard / edge messages). |
| record InputElement |
Single-line text field (wraps the proven UGuiTextInput: Enter submits without opening chat, Esc/cursor escape). Get seeds the text; Enter/blur calls Submit. OnChange (optional) fires per-keystroke — use it for live filters that should reflow as-you-type rather than on Enter. |
| interface IPartyControl |
Plugin-facing control over the local player’s party. Actions are routed through the game’s own dispatcher (never hand-built packets); the game applies its own validation, so a request may be silently rejected (e.g. a non-leader, or the 20-player mode being locked for the account). |
| interface IPartyEvents |
Party membership lifecycle events. All events fire on the Unity main thread. |
| interface IPartyRoster |
Read-only access to the current party roster. Observed on the Unity main thread. |
| interface IPartySnapshot |
Read-only scalar state of the local player’s party. All properties are observed on the Unity main thread. |
| interface IPhotoModeState |
The game’s own photo / selfie mode state. |
| interface IPlayerIdentity |
Identity and availability facet of the local player’s state. |
| interface IPlayerLocation |
Location facet of the local player’s state. |
| interface IPlayerProfile |
Resolves a player’s cosmetic profile data by character/role id through the game’s own Social.GetSocialData RPC. v1 exposes a single lookup, RequestAvatarUrl, which hands back the player’s profile avatar image URL — for chat / nameplate avatars. |
| interface IPlayerState |
Read-only view of the local player’s basic state. All properties are safe to read at any time; when IsAvailable is false (e.g. on title / character select / loading screens) the vitals and position return defaults (zero, Zero). Identity — name, level, profession — is served from the character record and can be populated independently of IsAvailable. |
| interface IPlayerStats |
Read-only access to live player attribute values. Each tracked attribute is identified by its Zproto.EAttrType integer code (e.g. 11011 for AttrStrengthTotal). Pair with GetAttribute to resolve the localized label and GetAttributeProfile to discover the UI group. Attributes must be Subscribed before they are sampled. The probe polls only subscribed IDs each Game.Update tick — sampling all 1289 EAttrType members per frame would be wasteful. Unsubscribed IDs return null. |
| interface IPlayerVitals |
Vitals (HP / Stamina) facet of the local player’s state. |
| interface IPluginConfig |
Per-plugin persistent configuration. Each plugin gets one JSON file on disk (<plugin-dir>/<pluginGuid>.config.json) organized into named sections. Plugins read settings on construct, write whenever the user changes them, and subscribe to SectionChanged to react to external edits or settings-window writes from sibling code. |
| interface IPluginDataStore |
Per-plugin binary file storage for data too large or too opaque for IConfigSection (which holds only primitives, arrays, and dictionaries). Each plugin gets its own directory (<plugins-dir>/<pluginGuid>.data/); names are relative to it. A name may contain at most one / separating a single subdirectory from the file (e.g. replay/123-456.gz); .., rooted paths, and backslashes are rejected. Every method is best-effort and NEVER throws — IO faults are logged and swallowed. |
| interface IPluginDownloads |
Downloads and verifies one plugin-requested file or zip into the plugin’s own data folder, one at a time. |
| interface IPluginExchange |
The sanctioned inter-plugin communication channel. One plugin Provides an implementation of a contract interface; another Consumes it — without the two plugins referencing each other (the framework is their only shared reference). The framework brokers purely by Type and never references any contract type, so this surface stays plugin-agnostic — it is the ONE generic extension point; specific contracts live in a shared contracts assembly (e.g. Stellar.PluginContracts), never here. Late-bind: Consume at use-time (not construction) so plugin load order does not matter. |
| interface IPluginInventory |
Read-side surface for the Settings → Plugins panel. Lists every discovered plugin with its current enabled / errored state, fires on state changes, and lets the user request a recovery retry after an exception. |
| interface IPluginLog |
Plugin-scoped logger. Output is routed through the host’s log sink. |
| interface IPluginServices |
The single object passed to every plugin’s constructor. Plugins obtain all framework capabilities by reading sub-services from here. |
| interface IPoseTarget |
One person being posed. Calls on a Released target do nothing. |
| interface IPosing |
Pose people in the world, like the game’s own photo panel — with or without a free camera (ICameraOverride): the local player live, other players as a local photo copy (the real player hidden), NPCs as a locally generated model (the real NPC hidden and never changed). Everything is local: copies and generated models send nothing. The copy or model is made on the first control that changes something, never on Select. Poses belong to the scene, not the camera: leaving the free camera keeps every pose. The scene ends — and the framework resets every touched person (action, expression, look, facing; copies and models removed, real people shown again) — on the reasons the scene freeze ends on: a zone change or scene leave, a cutscene, the game’s own camera mode, a disconnect and the framework unloading; also on ResetAll. A person who leaves is released alone; a plugin’s people are released when it unloads. At most the game’s own photo-member limit of copies (you plus limit − 1 players) and of NPC models exist at once; beyond it a target reports Full. While the scene freeze (ISceneFreeze) is on, posed copies and models freeze too. Main thread only. |
| interface IProfileCardActions |
Plugin-facing service for contributing buttons to the game’s native profile card action bar. Each registered ProfileCardActionSpec becomes a styled button the framework injects into the card on open; the returned handle removes the action when disposed. |
| interface IRenderLook |
Applies a look through the game’s own renderer effects. One active look framework-wide. |
| interface IRenderQuality |
Raises the game’s render quality (supersampling + TAA, high shadows) while a token is held. Shared by every plugin, so two plugins never fight over the same game settings. Main thread only. |
| interface IReShade |
Bridge to ReShade (via the Stellar add-on) — effects on/off, technique toggles, preset switching and shader/texture search paths. |
| interface IReShadeUniforms |
Holds ReShade uniform variables (effect settings) at fixed values, in the game’s ReShade runtime and in the separate runtime photos may be drawn in — whatever preset is loaded, and again after every effect reload or preset switch (ReShade resets uniforms to their shader defaults on each reload). Use it for a setting an effect must never have in this game, for example AcerolaFX’s _MaskUI, whose default hides the effect’s output here. |
| interface IResonanceState |
Read-only view of the local player’s equipped Battle Imagines, read from the skill hotbar’s aoyi slots (the game’s Slot container, slots 7/8 — the only representation the game re-serializes on an in-session swap). The equipped set drives the CombatMeter’s setup-identity Imagine pair. Populated on the game main thread and published as an immutable snapshot so reads are lock-free. |
| interface IRunTimer |
Run-timer identity anchor for the current dungeon run — the split-off companion of IDungeonState, which sits exactly at the 8-member interface cap (see its NOTE). |
| interface ISceneFreeze |
Pauses the whole game world while any token is held: the game’s clock stops, so every character — yours included — NPCs, pets, mounts, monsters, skills mid-cast, effects and particles hold still where they are. Players and monsters the server moves while paused stay where they were drawn (unless turned off — HoldsPositions). The framework, its windows and hotkeys, plugin updates, the free camera and screen capture keep running, and so do the network and the server’s world: a fight goes on server-side, and damage or a death taken meanwhile shows when the world runs again. A monster killed while paused stays visible until the pause ends. Local only. Reference-counted; the framework releases every token on a zone change, a cutscene, the game’s own camera mode, a logout (a disconnect is seen only as the game’s logout, Logout) and the holder’s unload — never on a free-camera release — and releases every token on its own if a pause is ever lost (outside the world, a stalled framework tick). Main thread only. |
| interface ISceneVisibility |
Reference-counted hiding of scene layers. Main thread only. |
| interface IScreenCapture |
Captures the rendered screen to an image file. Call from the main thread. |
| interface ITheme |
Plugin-facing theme façade. The single entry point plugins receive via IPluginServices.Theme; bundles the palette, draw helpers, semantic text, and layout primitives under one type. Facade-inheritance keeps the surface cohesive while letting each facet sit under the analyzer’s member-count cap. |
| interface IThemeAccess |
Composition + access facet — accessors for the semantic text helpers and plugin colour registry. |
| interface IThemeBaseColors |
Original Phase 8 colour vocabulary — preserved verbatim. Extracted into its own facet by Phase 9b so IThemeColors can remain at the STELLAR0005 8-member cap while gaining HUD + menu colour sub-facets. |
| interface IThemeColors |
Theme colour facade — zero declared members. Plugins access the full colour vocabulary (base, HUD, menu, status) through this single type; the split into IThemeBaseColors + IThemeHudColors + IThemeMenuColors + IThemeStatusColors exists so each facet stays inside the STELLAR0005 8-member cap (the analyzer counts declared members per interface; inherited members are unbounded). |
| interface IThemeHudColors |
Phase 9b HUD-overlay palette — colours used by WindowPanelStyle.HudOverlay chrome and the PillStatus chip. Renders on top of the live game world, so all colours assume no enclosing panel. |
| interface IThemeMenuColors |
Phase 9b menu / tool-panel palette — colours used by WindowPanelStyle.GlassMenu chrome. Renders as a light gradient panel with subtle border and shadow, matching the game’s Profile / Modules visual language. |
| interface IThemePalette |
Palette + font identity facet of the active theme. |
| interface IThemeStatusColors |
Semantic status colours of the active theme: the green / red / amber the house style uses for “on”, destructive and cautionary states. They follow the theme (the Light preset darkens them so they stay readable on its light panels) and a custom theme can override each one. |
| interface IThemeText |
Semantic text drawing API for plugins, modelled after HTML’s heading + paragraph levels. Each method renders text at the corresponding base size and weight, scaled by FontScale so a single Phase 9 user setting can globally enlarge or shrink every plugin’s text in one place. Plugin usage: _services.Theme.Text.DrawH2(“Combat Meter”); _services.Theme.Text.DrawBody($“DPS: {dps:F1}”); _services.Theme.Text.DrawCaption(“(last update 2s ago)”); Base sizes match the mockup hierarchy (theme-palette-v3 / panel-styles): H1 = 20px (top-level section), H2 = 17px (subheading), H3 = 15px (group label), H4 = 14px (list item header), Body = 13px (paragraph default), Caption = 11px (muted footnote). All headings render in bold; Body and Caption render in normal weight. Captions use the muted text colour. |
| interface ITimeOfDay |
Pins the in-world clock (time of day) to a chosen hour, then hands it back to the server. Shared by every plugin. Main thread only. |
| interface ITimePin |
A held time-of-day pin. Dispose to release it. |
| interface IUpdateRateScope |
Holds a dynamic update-rate request made via RequestUpdateRate. Dispose to release the request. Idempotent — safe to dispose more than once. |
| interface IVoiceClip |
An immutable decoded sound, reusable across sources. Holds source PCM; thread-safe to share. |
| interface IVoiceInjection |
Injects audio into the game’s OUTGOING team-voice stream (mixed with the live microphone). Backed by a process-wide native DirectSound capture hook installed by the framework at boot. Multiple sources — across all plugins — mix together into the one shared uplink. |
| interface IVoiceSource |
One independent voice in the uplink mixer. Not thread-safe for concurrent mutation by the caller. |
| interface IWardrobe |
Save and re-apply the local player’s worn cosmetic outfit (fashion). An outfit is a map of FashionRegion code → cosmetic fashionId (0 = empty slot); it is applied through the game’s own WorldProxy.FashionWear dispatcher, which runs every server-side validation (combat lock, ownership) — plugins never bypass it. Dyes travel with the pieces server-side (one dye per fashionId). The weapon skin is a SEPARATE per-class game system (the Wardrobe’s Weapon Skin tab, class dropdown) and is exposed alongside the outfit through GetWornWeaponSkin / ApplyWeaponSkinAsync. |
| interface IWardrobePreview |
A live 3D preview of the local player wearing an ARBITRARY saved outfit (region→fashionId), rendered by the game’s own UI-model pipeline into a render texture a RenderTextureHostElement displays. Unlike IEntityPortrait (which shows an entity’s CURRENT worn outfit), this dresses a fresh self model with the outfit you pass — for a wardrobe hover/click preview. The model is created asynchronously; Texture stays null for a few frames until the game delivers it. |
| interface IWardrobePreviewOptions |
Wardrobe-preview options added in framework 2.31.0: the weapon on/off switch and the outfit’s own show/hide state. Split out of IWardrobePreview, which is at the framework’s interface-size budget; consumers reach both through services.WardrobePreview exactly as if they were declared there. A plugin that uses either needs framework ≥ 2.31.0. |
| interface IWindowControl |
Handle to a registered interactive uGUI window. Auto-removed on plugin/framework dispose. |
| interface IWindowHost |
Plugin/framework-facing toolkit: describe an interactive window as composed elements; the framework builds native uGUI and owns chrome, rendering, refresh, lifecycle, input gating, persistence. |
| interface IWindowTopmost |
Runtime “always on top” for a registered window — the switch behind Topmost. Every IWindowControl the framework returns also implements this interface (it is separate only because IWindowControl is at the 8-member interface cap). Call it through the WindowTopmostExtensions helpers: control.SetTopmost(true) / control.IsTopmost(). |
| record LabelWidget |
Static text label child widget for a PanelSpec. |
| record LauncherEntry |
A plugin (or the framework) entry shown in the Stellar launcher menu. Title doubles as the stable identity used to persist the entry’s pinned state, so keep it unique and stable across sessions. IconPng (raw PNG bytes) is the preferred icon — it rasterises to a native-looking sprite; IconKey is the font-glyph fallback. OnOpen runs when the user clicks the tile. |
| enum LauncherGroup |
Which Full-mode section an entry sits in. |
| enum LauncherMode |
How the launcher menu lays itself out. |
| record LineChartElement |
Multi-series time-series line chart with labelled X/Y axes, axis titles, a legend, and an interactive visible-range (zoom/pan) window. The plugin owns the data and the visible window; the framework draws axes, grid, ticks, and lines, auto-scaling Y to the visible window’s peak (unless YMaxOverride returns a value). BCL-only: no Unity types in the contract. |
| record ListElement |
Variable-length list, bounded by Slots.Count. All slots built once; the first VisibleCount() are SetActive-shown each refresh. Columns>1 grids them. CellWidth/CellHeight (when > 0, multi-column only) override the grid’s default cell size — use to widen columns past the framework default (e.g. the StatInspector mini-HUD, whose icon+label+value row needs more than the default cell width). |
| record MenuButtonSpec |
A native-styled button injected at Anchor. |
| enum MeterLabelStyle |
Treatment of the value labels drawn on a meter row’s bar (LabelStyle). A player-facing choice (owner 2026-09-09: “it should be option for players: normal text, outline, smooth shadow”). |
| struct MeterRowData |
All data one CombatMeter row needs to paint, in framework-neutral types (no UnityEngine). The plugin computes this from its services each refresh; the framework’s BuildMeterRow reproduces the bespoke borderless meter row (HP spine, class crest, name·spec·share line, role-coloured metric bar with the per-second/total overlay, self highlight, offline scrim). A plain field struct (no big constructor) so it stays clear of the analyzer’s parameter/ctor-dependency caps and mirrors the plugin’s former MeterRowVisual. |
| record MeterRowElement |
One bespoke CombatMeter row — the borderless, role-coloured, animated meter row (HP spine + class crest + name·spec·share line + role-coloured metric bar with a per-second/total overlay + self highlight + offline scrim). The framework reproduces the custom visual that the IMGUI MeterRowView drew, so the meter keeps its distinct look (it does NOT ride the generic Row/Bar primitives). Data is re-pulled on the window’s capped refresh (poll-diffed) — the plugin snapshots its per-combatant state so the Func never allocates. Fixed 48-px row height; width fills the row. Compose inside a ListElement. |
| abstract record NativeUiElementSpec |
Base for a declarative mod-uGUI element. Unity-free so it lives in Abstractions. |
| enum NoticeTipAudio |
Audio event to play when the noticetip appears. |
| enum NoticeTipType |
The visual style of the noticetip bar to display. |
| enum NotificationKind |
Severity / intent of a transient toast, used by the framework to pick a colour. |
| record PanelElement |
A themed panel container: fills its area with the active theme’s menu background + a 1px border and lays out a single Child inside with uniform padding. Use it to give a borderless popup (e.g. a right-click context menu) a real panel look and to block click-through to whatever is behind. |
| record PanelSpec |
A themed panel containing declarative child widgets. |
| abstract record PanelWidget |
Declarative panel child widgets. |
| struct PhaseChange |
Payload for PhaseChanged. Carries both ends of the transition so a plugin needn’t track the previous phase itself. |
| record PillElement |
Rounded pill badge with dynamic text and optional tint colour. Suitable for short status labels (e.g. “Offline”, rank numbers). |
| record ProfileCardActionSpec |
A button a plugin contributes to the game’s native profile card action bar. The framework injects a styled button per registered spec into the card’s action row (icon over label, matching the native action buttons) and, on click, resolves the carded player and invokes OnClick with their EntityId. |
| record RenderTextureHostElement |
Hosts a live render texture in a fixed-size box (e.g. the Entity Inspector’s 3D portrait). The framework binds the boxed UnityEngine.Texture returned by Texture onto a uGUI RawImage and re-pulls it each frame, so a texture created after the window builds still appears. Renderer-neutral — the texture crosses the boundary as Object so Abstractions names no Unity type; null = blank box. |
| record RowElement |
Horizontal layout container: children arranged left-to-right with optional spacing. |
| enum RowJustify |
How children are packed horizontally within a RowElement. |
| record ScrollElement |
Vertical scroll viewport wrapping a child subtree + a themed thin scrollbar. By default the viewport uses Height only as a PREFERRED baseline and still GROWS to absorb slack height in a resizable window (flexibleHeight 1); set FixedHeight to pin it instead. |
| record SelectableElement |
Makes any Child subtree clickable as a whole and tints its background by interaction state — the rich-row analog of ButtonElement (which only wraps a single label). For list rows that are multi-line / multi-widget (a history session, a recent-lookup entry) where a per-row button would lose the layout. Rest = transparent; hover = faint accent wash; Selected() true (poll-diffed) = a stronger accent fill. A click anywhere on the row fires OnClick. Composes inside a List/Column like any leaf. |
| record SeparatorElement |
1 px themed divider (the faint row/section separator). Vertical = a 1 px-wide full-height divider for splitting columns inside a Row (else a 1 px-tall full-width line between rows). |
| record SliderElement |
Drag slider over [Min,Max]. Get reflects external state (poll-diffed); a drag calls Set. |
| struct SocialIdentity |
Affiliation/prestige extras from a full-mask social reply (the ID-card fetch requests mask 0 = all sections). Thin-mask replies (nameplate/avatar queries carry identity only) leave these at defaults on the decoded reply; the framework cache keeps each value from the last reply that carried its section (see Sections). |
| struct SocialLocation |
A player’s scene location as carried by SocialData.scene_data (zproto.SceneData). Every member defaults to 0 when its wire field is absent. |
| record SocialParty |
A player’s party as carried by SocialData.team_data (field 12, zproto.CharTeam). Every scalar defaults to 0 when its wire field is absent; the lists are never null. |
| struct SocialPartyMember |
One party member from team_data.team_member_data (zproto.TeamMemData + its TeamMemberSocialData). Fields default to 0/empty when absent on the wire. |
| struct SocialPresence |
A player’s online state as carried by SocialData.basic_data (zproto.BasicData). |
| [Flags] enum SocialSections |
Which top-level SocialData sections a SocialSnapshot holds data from. The game asks the server for a subset of sections per request (an ID card asks for all; nameplates and portraits ask for a few), and a reply simply omits the sections it wasn’t asked for. |
| record SocialSnapshot |
A player’s on-demand social-data reply (the game’s own Social.GetSocialData RPC, which the inspector triggers via the portrait path). Available for ANY player regardless of AOI proximity — the fallback source the inspector uses when the proximity broadcast is absent. Carries identity, ability score (fight point), profession, gear-by-slot, worn cosmetics and affiliation extras; NOT the secondary-stat breakdown or skills (those are AOI-broadcast only — see the design spec §2). |
| record SpacerElement |
Gap inside a Row. Width = 0 → flexible (expands to push following siblings to the far edge); > 0 → a fixed-width spacer (e.g. to balance a right-aligned control so a centred element is TRULY centred, not centred-minus-that-control). Height > 0 → a fixed-height gap (use in a Column for a little vertical margin between sections, no divider line). |
| record SpriteElement |
Sub-rect of a packed atlas PNG — the DrawTextureWithTexCoords analog. Atlas is the whole packed sheet (loaded once, mipmap-smoothed); Uv is the normalized sub-rect to show (x,y,w,h in 0..1, origin BOTTOM-left per Unity texture space); Width/Height are the on-screen pixel size. Use for icon atlases (e.g. a stat-icon sheet) where ImageElement’s whole-PNG display can’t pick one glyph. Atlas is poll-friendly (re-read each build). UvFunc (optional) makes the sub-rect DYNAMIC — re-pulled on the window refresh so one pooled/recycled slot can show a different atlas cell as its backing data changes (e.g. a stat-icon keyed to the attribute the row currently represents). When null, Uv is static (set once at build) — use that for a fixed icon (e.g. a gear). |
| static class StellarInterop |
Static IL2CPP-interop reflection floor shared by every plugin. Pure BCL reflection over the live AppDomain — no Unity / game / HarmonyX references — so it lives in the contract layer alongside VirtualListMath and can be called from static Harmony patch classes that hold no IPluginServices handle. |
| record SwatchElement |
Solid-colour box (the theme-editor colour swatch). Color is poll-diffed so it tracks live edits. |
| enum TextAlign |
Horizontal text alignment within the text’s cell. Default Left; Right is used for numeric table columns (so magnitudes line up against the right edge of a fixed-width CellElement). |
| record TextAreaElement |
Multi-line editable text box (wraps UGuiTextInput in multi-line mode). Enter inserts a REAL newline and KEEPS focus — it does NOT submit; give the plugin its own submit button that reads the current buffer via OnChange. The box is a FIXED height (Lines visible lines) that NEVER grows the window: text wraps within the width and overflows downward, clipped to the box and scrolled vertically to follow the caret. Esc defocuses and the cursor stays free, same as InputElement. Get seeds the text; OnChange fires per edit with the FULL buffer (newlines included). Set ReadOnly for a select/copy-only display box (e.g. a generated code the user copies out). Add any later options as init properties, never new positional parameters (see WindowBuilder-Patterns.md “Binary compatibility rules”). |
| record TextElement |
Themed text. Color Func null (or returns null) = framework default; a Func lets colour animate per-refresh (e.g. delta-flash). Width > 0 fixes the cell width (the text wraps within it) — use to form aligned columns (e.g. a plugin-name column so the version after it starts at a consistent x). Align sets horizontal alignment (Right for numeric columns). Shadow draws a dark outline behind the glyphs — for chrome-less overlays (a borderless HUD with no background) where light text must stay legible over arbitrary world backgrounds. ShadowDistance controls the pixel offset of the shadow (default 1). Increase for large font sizes where a 1-pixel shadow is invisible. NoWrap keeps the text on a single line (any overflow spills/clips at the cell edge rather than wrapping to multiple lines) — use in a fixed-width pane where a long label (e.g. a map name) must read as one row, not a 5-line block. |
| record TileElement |
Icon tile (launcher): a centred PNG Icon over an optional Label, no background. Hover brightens icon+label and grows the icon ~1.18× (the native rail feel). The whole tile clicks via OnClick. When Pinned != null, a ★/☆ toggle overlays the top-right corner (its own click → OnTogglePin). Label null ⇒ icon-only (title-bar mode/rotate toggles); a non-null Func ALWAYS builds the label cell (so a live label that is empty at build time — e.g. a plugin that registers later — still shows its name once available). |
| record ToggleElement |
Two-way toggle. Get reflects external state (poll-diffed); a click calls Set with the new value. |
| record ValueRowWidget |
Key/value row child widget for a PanelSpec; value is re-pulled each refresh. |
| static class VariableListMath |
Pure variable-height scroll-windowing math for a measured VirtualListElement (BCL only, unit-tested on CI). The uniform-height sibling is VirtualListMath; this one drives a list whose rows have DIFFERENT heights (wrapping chat bubbles), so the renderer maintains a per-index height model and a cumulative-offset array instead of multiplying by one fixed row height. Row Count is bounded (≤ a couple hundred), so rebuilding the whole prefix-sum each time a measurement lands is cheap and keeps the model trivially correct. |
| record VirtualListElement |
Scroll-windowed variable list: renders a small fixed Pool of K rows (K ≈ viewport rows + a few margin rows) over a logical list of Count() items that may be FAR larger than K. The framework sizes a scroll content spacer to Count()*RowHeight, tracks the scroll offset, computes the first visible logical index, calls OnWindow(first) BEFORE pulling any slot values (so the plugin’s row Funcs resolve item first+slotIndex), positions the pool rows at their logical offset, and SetActive-shows only rows whose logical index < Count(). Rows are uniform fixed-height (RowHeight) UNLESS VariableHeight is set — see below. Use for large pickers; the small ListElement (eager full pool) stays for short lists. Height is the viewport height. |
| static class VirtualListMath |
Pure scroll-windowing math for VirtualListElement (BCL only, unit-tested on CI). The renderer maps a ScrollRect’s content offset to the first logical row to bind. |
| struct VoiceInjectionStatus |
Capture-hook and format diagnostics. |
| static class WardrobeRegions |
The cosmetic wardrobe regions a saved outfit covers (weapon skins excluded). |
| enum WardrobeResult |
Outcome of ApplyAsync / ApplyWeaponSkinAsync. |
| record WardrobeWeaponSkin |
A worn weapon skin: the class (professionId) it is set for and the skin id (0 = the class’s default weapon look). Weapon skins are per class in the game and live outside the outfit’s FashionRegion map. |
| record WindowRegistration |
A registered interactive window: its spec + the root element to render. TitleLeading (when set) replaces the title-bar text (e.g. a logo + wordmark row); TitleTrailing is built right-aligned before the ✕ (e.g. mode/rotate toggles). Both null ⇒ the chrome draws the plain Title text. OnClose (when set) is invoked by the ✕ instead of just hiding the GameObject — wire it to the window’s SetVisible(false) so IsShown stays in sync (otherwise a rail/hotkey toggle needs two presses to reopen after a ✕ close). |
| static class WindowTopmostExtensions |
Discoverable access to IWindowTopmost from a plain IWindowControl. |
| record XYPadElement |
Two-axis pad: a square with a grid and a centre crosshair, and a dot at the current value. A click or a drag anywhere on the pad moves the dot to the pointer and calls Set with the pointer’s value, clamped to [Min,Max] on both axes. X grows to the right and Y grows UP (math convention: the top edge is Max), so an “up” arrow beside the pad means +Y. |