| 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 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. |
| 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 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 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. |
| 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 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 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 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. |
| 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 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 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 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 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 five Lang/<code>.json catalogs (en, ja, th, id, fil) 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 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 IPlayerIdentity |
Identity and availability facet of the local player’s state. |
| interface IPlayerLocation |
Location facet of the local player’s state. |
| 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 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 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 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 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) through this single type; the split into IThemeBaseColors + IThemeHudColors + IThemeMenuColors 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 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 IUpdateRateScope |
Holds a dynamic update-rate request made via RequestUpdateRate. Dispose to release the request. Idempotent — safe to dispose more than once. |
| 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 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. |
| 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 (fixed Height) wrapping a child subtree + a themed thin scrollbar. |
| 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 — values are best-effort, last-reply-wins via the cache. |
| 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 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. |
| 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 MUST be uniform fixed-height (RowHeight). 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. |
| 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). |