Skip to content
Version 2.32.0
↓ Get the launcher

Changelog

2.32.0 (minor) — mods can tell whether another player is online, a player’s profile no longer goes blank in mods after a quick lookup, and outfit areas reset to default no longer read as black. Adds SocialSnapshot.Presence / IsOnline / Sections and the SocialPresence / SocialSections types (Abstractions 2.32.0); additive, no plugin rebuild.

  • Mods can now tell whether another player is online, when they went offline, and the status they have set.
  • A player’s ability score, class, gear and outfit no longer disappear from mods after the game briefly looks that player up again (for a nameplate or portrait).
  • An outfit area the player reset to its default colour no longer shows up as black in mods.
  • SocialSnapshot.Presence (SocialPresence?, init-only), decoded from SocialData.basic_data:

    • OfflineTimeMs (field 9, Unix ms, 0 while online)
    • OnlineTimeMs (field 16)
    • PersonalStates (field 8, packed or unpacked; ChatStatusTable ids, never null)
    • ReceivedAtMs (stamped by the cache)
    • IsOnline (OfflineTimeMs == 0, the game’s own rule)

    The shortcut SocialSnapshot.IsOnline (bool?) is null when Presence is unknown. (#165)

  • SocialSnapshot.Sections (SocialSections flags) records which SocialData sections a snapshot holds. None means not reported (hand-built snapshot). (#165)

  • Cache merge: SocialDataCache now merges per section instead of letting the last reply win.

    • A section the reply carries replaces the cached one, even when it is present but empty.
    • A section the reply leaves out is kept.
    • Presence, Location and Party carry forward.
    • Sections == None keeps the old replace-everything behaviour.

    This fixes thin replies (basic-only, nameplate) wiping FightPoint / ProfessionId / Gear / Fashion / Identity. (#165)

  • Dye hue decoding (Stellar.Wire): a dye’s x is hue degrees only for a Board colour group (ColorGroupTable.Type == 3). For other group types it is a swatch id looked up in the group’s Hue rows. A miss, x == 0 or ColorGroupId == 0 decodes to hue 0, matching the client (fashion_data.lua:327-351).

    • New DyeHuePalette + DyeHueMapper, with additive Read(span, DyeHueMapper?) overloads on AttrFashionDataReader / SocialDataReader.
    • FashionDyePaletteResolver caches per fashion id and per group id, and reflects only on the main thread. A miss during an I/O-thread decode falls back to degrees.
    • In release_3.7 every dyeable piece uses a Board group, so this only changes the 4 group-0 pieces and guards future builds. (#164)
  • {-1,-1,-1} reset sentinel: a reset area is now dropped from FashionEntry.Dyes / DyeAreas (the piece’s default colour) instead of decoding to black. (#164)

  • Compatibility. All additions are init-only properties and new types, with no positional-record change, so existing plugins keep working. A plugin that reads Presence / IsOnline / Sections needs framework ≥ 2.32.0.

2.31.0 (minor) — the wardrobe 3D preview can show the weapon and each outfit’s own hidden pieces, and lists scroll with the mouse wheel while you drag a row. Adds IWardrobePreviewOptions (IWardrobePreview.ShowWeapon and a Show overload with a hidden-pieces map) (Abstractions 2.31.0); additive, no plugin rebuild.

  • Wardrobe mods can now show your weapon in the 3D outfit preview, including the weapon skin saved with an outfit.
  • The 3D outfit preview can now show an outfit exactly as saved, with its own hidden pieces, even when you are hiding a piece (like a hat) right now.
  • While you drag a row to reorder a list, the mouse wheel now scrolls the list, so you can move a row past what’s on screen.
  • Sliders that can’t be used right now look clearly switched off: a sunken track and a faded knob, at the same size.
  • IWardrobePreviewOptions — a new base of IWardrobePreview (which stays at the STELLAR0005 8-member cap; nothing moved, so compiled callers are unaffected; only the framework-internal WardrobePreviewService implements it). Reached as services.WardrobePreview:
    • bool ShowWeapon { get; set; } — default false (today’s weaponless preview). Live, no model rebuild. Global to the preview service, so set it before each Show. With an outfit that carries a weapon skin (WardrobeRegions.WeaponSkinPreview) the model wears exactly that skin (the existing social-data injection + CMount de-dupe); without one it wears the player’s current weapon.
    • void Show(EntityId self, IReadOnlyDictionary<int,int> outfit, IReadOnlyDictionary<int, IReadOnlyDictionary<int,float[]>>? dyes, IReadOnlyDictionary<int,bool>? hidden) — hidden = region → true (hidden) over the 14 WardrobeRegions.All regions; a missing region is shown, other keys are ignored. The framework writes the model’s own EWearSetting (all 14 regions explicit) after dressing, so the player’s current global hide setting no longer leaks into the preview. null = the existing Show exactly. The [WardrobePreview] weapon … log line gains hide=ok(rb=same) (or rb=<read-back> / hide=err:…) when a map was passed — check it on the first in-game test, the live client’s Lua can differ from the extracted one.
  • Reorder + wheel (#162): during an active ListElement.OnReorder / VirtualListElement.OnReorder drag the ticker applies Input.mouseScrollDelta.y to the list content with the ScrollRect’s own wheel step (scrollSensitivity), clamped, gated on the pointer being over the list viewport and FrontWindowBlocks. The press-drag scroll lock stays; a press that hasn’t become a drag yet still ignores the wheel. No allocation; no work on frames without a wheel delta.
  • Slider disabled look (#160): when SliderElement.Enabled returns false the slider paints the recessed rule-22 look — track [email protected] (translucent, blends with the surface), fill MenuMuted@0.30 (value still readable), knob MenuMuted@0.70, no ring, no size change. It flips live with Enabled, repainting only on a state change (no per-frame graphic writes) and on theme change. The stock Selectable disabled tint is set to white so it no longer multiplies on top. The enabled look is unchanged; plugins that faded or swapped a disabled slider themselves can drop that workaround on ≥ 2.31.0.
  • Compatibility. A plugin that sets ShowWeapon or calls the 4-argument Show needs framework ≥ 2.31.0.

2.30.0 (minor) — a redesigned Settings window and launcher, the Sakura theme, more movable game HUD parts, and less CPU in raids and crowded places. Adds IThemeStatusColors, ThemePreset.Sakura, TextElement.MaxLines, IFrameworkDeveloperMode, ICombatBuffEffectLookup, WindowSpec.Prebuild/Topmost/FixedHeight (Abstractions 2.30.0); additive, no plugin rebuild.

  • A new built-in theme, Sakura: rose-purple panels with a pink accent.
  • Your own themes can now change the text colour, the muted text colour, and the green, red and amber used for “on”, “remove” and “careful” states.
  • Mods can now show text over a set number of lines, ending in “…” when it is longer.
  • Drag your favorite plugins to put them in the order you like, in the Stellar menu’s Favorites tab or on the compact bar. Both use the same order.
  • Five more parts of the game HUD can be moved and hidden in the layout editor: Status Icons, Buff Timers, Item Bar, Action Buttons, and the location and line bar under the minimap (the line-recycle notice the game sometimes shows there moves and hides with it).
  • The layout editor shows a dashed placeholder for game HUD parts that aren’t on screen right now (for example the boss HP bar outside a boss fight, or the party panel while solo), so you can place or hide them at any time.
  • A “Hide others” switch next to the layout editor’s SHOW filter: while you edit one plugin or only the game UI, everything else is hidden so it doesn’t get in the way. It is never saved and everything comes back when you leave edit mode.
  • The Stellar Settings window has a new look: tabs down the left side, a short status line at the top of each tab, and a message at the bottom confirming every change you make. It keeps one size, so it no longer grows or shrinks between tabs.
  • Every setting has a “?” button that explains what it does.
  • Plugins show their own icons, and a plugin that failed to start is marked red with a Retry button.
  • Themes are picked from cards, with a live preview window that follows your theme, opacity and classic button style. Custom theme colours open in their own window.
  • Hotkeys are grouped by plugin, show “Not set” when unassigned, and ask before resetting everything.
  • Game UI shows which parts of the game HUD are moved or hidden, and each can be reset on its own.
  • Performance lets you pick each plugin’s rate from a list.
  • The launcher shows bigger plugin icons, five plugins per row, and every tile is the same size whatever its name.
  • New, sharper icons throughout Settings and the launcher, drawn for each size they appear at.
  • Buttons you can’t press now look sunken, so they are easy to tell apart from buttons you can.
  • The window opacity slider sits with your theme and is remembered per theme; font and UI size moved to the General tab.
  • The compact bar shows plugin names in normal white text, and its Settings tile matches the other tiles.
  • Dropdowns in Settings use the same colours as the other buttons.
  • Switching between Settings tabs, and opening or closing Settings and the launcher, is much smoother.
  • Mods use less CPU in raids and other crowded places, so busy fights run smoother.
  • The “Reset selected to default” and “Reset all in this slot” buttons on the Layout tab, which did nothing. The layout editor’s own toolbar resets windows.
  • Your own themes based on a theme that this version doesn’t know are now kept, instead of disappearing the next time settings are saved.
  • You can now have up to 12 of your own themes. Before, a 13th theme was saved but never shown, so you couldn’t select, rename or delete it.
  • A custom theme can no longer be named like a built-in theme (for example “Default”), so it can’t be mistaken for it. Existing themes keep their names.
  • Scrolling lists in mod windows is smoother.
  • Text in mod windows stays sharp when you just click a window or a list without moving it, and moving, resizing or drag-scrolling slowly no longer flickers between sharp and soft.
  • The Stellar Settings window and the Stellar launcher open instantly the first time, instead of freezing the game for a moment.
  • Plugins can now have their big windows prepared while you log in, so they open without a freeze the first time.
  • Scrolling with the mouse wheel now stops a list that is still gliding after a drag.
  • Fewer small stutters from mod windows while you stand idle, for example when a new chat message arrives.
  • Scrolling a mod window list with the mouse wheel no longer stutters on every step.
  • Dragging or scrolling the Stellar menu, Settings or chat no longer makes other mod windows stutter.
  • Thai text in mod windows now stacks tone marks above vowels correctly (for example ปลั๊กอิน), and all Thai text uses the same font.
  • Renaming one of your own themes keeps its colours, and Duplicate copies the selected theme’s colours instead of starting from its base theme.
  • Settings hints now show the keys you actually set in Hotkeys, not the default keys, and say so when a key is not set.
  • Game HUD parts you moved no longer jump back to their default spot for a moment after a scene change, a menu or a cutscene; the chat window in particular stays where you put it.
  • Game HUD parts you hid no longer flash back on when the game shows them again.
  • The skill bar and the player HP bar can now be hidden too. Skills and HP keep working normally while they’re hidden.
  • A hidden chat window no longer opens an invisible input box when you press Enter.
  • The skill bar’s edit outline now covers the whole bar, including the dodge buttons.
  • Native game-UI wrapper ownership (NativeUiService / PandaHudAdapter, framework-internal). Moved/hidden game HUD nodes are now owned through a framework stellar_wrap_<id> RectTransform (outer wrap for in-prefab nodes; inner wrap — wrapper as the element’s only child, adopting late children — for view roots chat / target frame and the class gauge). Position = wrapper offset, hide = wrapper scale 0 (never SetActive on game nodes; chat also blocks input via a CanvasGroup on the wrapper). Removed: the 1 Hz re-assert + idempotent guard + Resources.FindObjectsOfTypeAll resolve scan; replaced by a 10 Hz alloc-free intact check and scene-enter re-wrap. Saved rects migrate once to offset keys (.ox/.oy, marker .mv). Allowlist RectChild specs gain a - exclude token; * unions walk through plain Transform holders. Layout editor: placeholders, “Hide others” (IWindowEditHide, transient, never persisted). No Abstractions/SDK change.
  • Developer mode readable by plugins (IFrameworkDeveloperMode, a new base of IFramework): bool DeveloperMode { get; } and event Action<bool> DeveloperModeChanged, reached as services.Framework.DeveloperMode. Read-only — plugins cannot switch it. Meant for showing a plugin’s debug tools / verbose logs only while the user has developer mode on. The event fires on the main thread on every flip (Settings, or a hand edit of stellar.framework.config.json → developer.developerMode), not at subscribe time. PerPluginFramework holds ONE subscription on the shared FrameworkService and fans out to the plugin’s handlers; Unregister (plugin disable / unload / failed ctor) drops it and clears the plugin’s handlers. Each plugin’s handlers are isolated (a throw is logged with the plugin guid; other handlers and plugins still run). IFramework stays at the STELLAR0005 8-member cap (nothing moved, so compiled callers are unaffected; only implementors — the framework-internal FrameworkService / PerPluginFramework — change). Needs framework ≥ 2.30.0.
  • Hotkey hints follow the live binding (HotkeyHintText, internal). The Settings texts that named a framework hotkey hard-coded its default: About footer (Shift+Home), Layout footer + the “Edit mode” panel caption (Shift+— never even the default, which is Alt+E), the Developer tab's perf label + its help (Shift+End). They are now{0} templates (settings.foot.about, settings.foot.layout, developer.perf.label, help.developer.perf) filled with the action's current KeyBinding.ToString()(exactly the Hotkeys key pill), with*.unboundlines for a cleared key; the Layout caption shows the binding orhotkeys.notSet. Cached per template, dropped on BindingChanged, a language switch, or a new declaration (the directory's action-list snapshot changes — a later default can silently take a framework chord). Render-driven only. The unused layout.editEnter/layout.editExit` keys (dead since the hub redesign) are removed. All six languages.
  • Buff effect ids (ICombatBuffEffectLookup.TryGetBuffEffectIds(EntityId, int buffUuid, out IReadOnlyList<int>)), a new base of ICombatLookup (which stays at the STELLAR0005 8-member cap; nothing moved, so compiled callers are unaffected; only implementors — framework-internal CombatService and the test StubCombat — change). The combat wire readers now keep what they used to drop: PlayEffect effect_ids (logic type 0), BuffEventCustomize(1002) values, BuffEffect.HostUuid, BuffEffectSync.Uuid, BuffInfo.HostUuid (4) and BuffInfo.LogicEffect (13, incl. inside an AddBuff(18) payload), plus the appear Entity.buff_effect (field 8, ids only — its buff upserts stay ignored). Rules = resonance-logs-cn decoder.rs (AddBuff payload ids → outer PlayEffect ids when an AddBuff/BuffChange entry is present → Customize values; Remove / a RemoveLayer that ends the buff drops them), with the Experiment McBuffEffectPatch quirks kept (absent PlayEffect RawData = id 0; whole-buffer effect_id probe before the 1-/2-byte customize fallback). Stored in a CombatService side table keyed by (uuid >> 16, BuffUuid), own lock, 4096-entry valve, cleared with ClearAllBuffs (scene change / logout); NOT a field on ActiveBuff (positional record = binary break). New internal sink member ICombatBuffSink.ApplyBuffEffectIds. Allocation: an int[] (and the update list) only when an effect actually carries ids; decoding uses stack buffers. Lets Mechanic Callouts drop its three game hooks (parseBuff / OnAddBuff / OnBuffEffectSync prefixes). Needs framework ≥ 2.30.0.
  • Later 2.30.0 additions (this branch). ConditionalElement.Prebuild/PrebuildName (time-sliced background build, 3 ms/frame), ConditionalElement.KeepAlive (parked branches keep their nested canvas, bindings gated; instant re-show) and ConditionalElement.ContentRevision (background refresh of a parked branch when its content changes). Settings hub: background warm off-screen until settled, soft park on hide (canvas off + off-screen instead of root SetActive(false)), hidden visible-tab refresh. Launcher re-warms in the background when its content signature changes while hidden (e.g. world entry). Per-size pixel-hinted framework icons (Resources/icons/<12|16|24|32|64|128>/, LauncherIcons.Get(name, px); exact size draws 1:1, else next larger with mips). Thai: TMP mark/mkmk positioning + one-batch Thai glyph seeding + un-wrapped GPOS lookups in the shipped Thai fonts; legacy Text showing Thai renders through a TMP twin in the shipped face. Hidden Developer tab (developer.developerMode config key or 7 clicks on the About version; Shift+End perf overlay is developer-only). Theme store: IColorOverrideStore.RenameTheme/CopyTheme/RemoveTheme, CustomThemeStore.Duplicate; ThemeOverrideSnapshot for Save/Discard. All additive; measured in game at 2560×1440 (tab switch +10–15 ms, open/close one ~2× frame).
  • IThemeStatusColors (Success, Danger, Caution) is a new facet on IThemeColors (IThemeMenuColors stays at 5 members). Only the framework implements these interfaces, so this is additive. Dark presets return exactly the old hard-coded house values #5FD38D / #FF4D4F / #FFCC73; Light returns #1E8A4C / #D13438 / #A86A00. Status indices 18..20 are appended to ThemePresets.Tables.
  • Editable framework slots: Theme.MenuText, Theme.MenuMuted, Theme.Success, Theme.Danger, Theme.Caution (labels theme.color.* in all six languages), so custom-theme overrides feed the MenuText/MenuMuted/status reads. Older frameworks keep but ignore these override entries (ColorOverrideStore never prunes unknown slots).
  • ThemePreset.Sakura = 4 (appended). Menu #2E2433 / #E8DCEF / #9B8AA5 / accent #C8508F, gradient #2E2433 → #291F2E → #30242F, default window opacity 0.90. A plugin that registers per-preset colours without a Sakura entry gets its Default colours. ColorRegistryService.Register(key, label, defaultAll) now fills every enum value.
  • CustomThemeStore: an unparsable (or undefined numeric) base preset loads as Default and its original string is written back on save. MaxCustomThemes = 12 + CanCreate; a 13th Create throws ArgumentException; existing configs with more load in full.
  • TextElement.MaxLines (int, init, default 0 = unlimited). The framework breaks the lines itself (WordWrapCap, shared by the TMP and plain Text paths): only at spaces, after hyphens and between CJK characters; a word wider than the line is cut with “…” on its own line, never split across lines; the last line ends in “…” when more text follows. The engines’ own wrap is OFF for such text (never TMP’s Ellipsis mode). Re-fitted on a string, font-size or width change.
  • TextElement.Height (float, init, default 0 = the text’s own height): a hard-fixed box height (min = preferred), lines centred in it; pair with MaxLines.
  • ScrollElement now registers its content with the pixelPerfect-while-scrolling logic (previously only virtual lists did), so scrolling no longer re-snaps and rebatches the whole canvas every frame. Internal, no API change.
  • pixelPerfect vs drag/resize: WindowInteractionTicker.TickWindowMotion latches real motion of the dragged window (anchoredPosition) or resized target (sizeDelta + position) frame to frame (> 0.5 px), seeded on the first held frame and cleared on release, so a press on a drag handle / resize grip without movement never flips pixelPerfect. Held-gesture rule (HeldMotionRule, unit-tested), shared by window move, window resize and list drag-scroll: the gesture’s FIRST real move (> 0.5 px) turns its canvas’s pixelPerfect OFF, and every frame of the rest of the hold counts as motion, pauses included, until the mouse button is released; then it comes back ON 0.15 s after the release (lists: after the glide ends; a wheel tick during the glide still StopMovement()s it). Press-and-release without movement = no flip. Replaces the earlier “re-crisp 0.15 s after holding still mid-drag”, which flipped at every pause: one slow drag-scroll of the launcher grid logged 17 flips on canvas=settings.hub (≈2 ms write + 15 ms rebuild each, 71728ac). Per-view hold state is ScrollView.Engaged (cleared with Pressed); the window gesture’s is _motionEngaged (cleared when the drag/resize ends). Per-canvas routing and flip logging unchanged. Internal, no API change.
  • Internal house-style kit Stellar.Infrastructure.UI.Style (StellarStyle, StellarHelpPopover, StellarFeedbackLine) for the upcoming Settings hub and launcher redesign. No public API.
  • Disabled pills are recessed (user-approved option A, replaces the transparent + 1 px muted ring look): a disabled PillButton / NeutralButton / PrimaryButton / SmallPill keeps its size and radius and draws a SUNKEN fill, StellarStyle.DisabledFill(surface) = black @28 % over the surface it sits on (the panel for 28 px pills, the list tile for 22 px row pills), faded by window opacity like every fill, with the label at theme Text @32 % alpha, raised in 4 % steps until it reaches 2:1 on that fill (DisabledLabel(surface)). No outline ring (DisabledOutline removed). No inner top shadow: a Bubble has one child and no top-only stroke, so it would need an extra overlay layer per pill.
  • ImageElement.Live (bool, init): re-pull Png every refresh and swap the texture when the returned array reference changes (the launcher TileElement IconBinding path, decode deduped per window). ImageElement.Tint (Func<ColorRgba?>?, init): poll-diffed RawImage.color for flat white glyph PNGs (null = untinted). Both default off = unchanged.
  • Launcher redesign (house style, approved prototype): LauncherView split into .Full/.Tabs/.Tile/.Compact partials over the internal StellarStyle kit; list logic in LauncherMenuModel (tabs, Find above 16 plugins, Favorites ghost). New launcher config key tab (Favorites/All; missing = Favorites); pins unchanged (favorites = pins).
  • Settings hub redesign (phase 2). SettingsHub (+ .Rail) builds the fixed 800 × 612 window (1 px height strut + VerticalFill flex fillers; tabs lazily built per Conditional), SettingsKit hands every panel the kit, help popover, footer feedback line and StellarRowFlash; each panel exposes Describe(SettingsKit) + Status(SettingsKit) (the one status builder). “Edit colours” is a child window (stellar.settings.colours, opened centred on the hub and fronted); help popover window stellar.settings.help. Recon walk moved to About → “Save HUD paths”. Internal BootstrapPlugin.OpenSettingsAt(string tabKey) (keys plugins / layout / themes / hotkeys / gameui / performance / about) for the launcher. IPluginDisplayNames.IconOf (default member) feeds plugin launcher icons to the list. Kit additions: SmallPill (22 px), SmallCloseButton (24 px), FilledTile, VerticalFill, TopColumn, MinHeight, Border(); fixed-width pills now set MaxWidth. All new strings in the six framework languages (additive keys only; superseded keys are left in place).
  • Settings hub pre-warm. The hub (stellar.settings.ugui) is mounted once in the background (Wiring.Settings.Prewarm.cs: a transient _hubPrewarming flag AND-ed into its ShouldRender and HubShown; Visible for 3 ticks, then parked). It starts once the window canvas scale is ready, outside the loading screen, past GamePhase.Startup, and once the client language is latched (ClientLanguageLatch.IsKnown, or at CharSelect). The cold first open measured a 316 ms frame (mount 235 ms, build:firstApply 230 ms) at 2560×1440. The mount’s first apply also builds the starting tab’s Conditional. It is never fronted (ZFront stays 0); real opens still go through ShowSettingsHub (un-park = fresh ZSeq, then BringToFront). Skipped when STELLAR_AUTO_OPEN names the hub.
  • Launcher pre-warm (same recipe, now shared). The one-shot logic moved into WindowPrewarm (Host; Warming / Settled / Tick(control, ready) / EndForRealOpen), pumped by Wiring.Prewarm.cs (was Wiring.Settings.Prewarm.cs) for both windows, ONE at a time: the launcher (settings.hub) first, the hub only after the launcher has settled, so the two builds never share a frame. The launcher’s cold first open measured a 193 ms frame (build:firstApply 149 ms, mount:settings.hub 149 ms). Its ShouldRender ANDs !Warming into the loading gate; ToggleLauncher treats a warming launcher as closed (opens it, never hides it), ends the warm-up before SetVisible(true), then fronts as before. It builds the persisted Full/compact mode and Favorites/All tab (Conditionals on LauncherRegistry, visibility-independent). Same gates as the hub (canvas scale ready, not loading, past Startup, language known or CharSelect); skipped when already shown or named in STELLAR_AUTO_OPEN.
  • Wheel / press stops list inertia. WindowInteractionTicker.TickScrollInput (.ScrollViews.cs) calls StopMovement() on a coasting Stellar ScrollRect (ScrollElement / virtual / variable list / dropdown viewports) on any wheel delta or mouse press over it. uGUI only zeroed the velocity on BeginDrag. The internal RegisterScrollView hook now also passes the ScrollRect. It respects FrontWindowBlocks and an open dropdown popup. The game’s own ScrollRects are untouched (no Harmony patch).
  • pixelPerfect flips only on USER scrolling. Before, TickScrollActivity counted any content anchoredPosition move over 0.5 px as scrolling, including programmatic ones (a chat re-pin to the bottom, a list growing or shrinking, rebinds). Every such move flipped the root canvas pixelPerfect off and back on, which is 2 whole-canvas rebuilds. The fw 69a41c4 log showed 88 idle [Hitch] lines in about 10 minutes (ui:canvasRebuild 30–50 ms, ui:ticker around 8 ms in the same frame). Now motion counts only while the user moves that view continuously (IsUserScrolling): the left button held since a press on it (content or scrollbar drag), or fling velocity (ScrollRect.velocity, which only a user drag creates; our views are Clamped, so no elastic velocity). The mouse wheel never counts: a tick moves the content once, one ordinary re-snap with pixelPerfect ON, while counting it cost OFF + ON per tick (measured pixelPerfect OFF reason=scroll:settings.hub write=5.3ms canvasRebuild=25.0ms, back ON 0.3 s later ≈ 60 ms of stutter per tick). A wheel during a glide still calls StopMovement() (zeroes the velocity), so pixelPerfect comes back ON after the normal 0.15 s settle. The per-view WheelTime / 0.3 s wheel window is gone. The drag/resize motion latch is unchanged. Scroll views are now one entry each (ScrollView: content, motion and input state; AddScrollView), replacing the parallel ScrollContents / _scrollPrevY lists.
  • Flip instrumentation ([UiPerf], armed with HITCH / diagnostics). Each flip counts as ui:ppFlip on the [Hitch] line and as ppFlips=N in the 10 s summary. A throttled line (at most one every 2 s) logs it on the next frame: [UiPerf] pixelPerfect OFF reason=scroll:<windowId> write=0.4ms canvasRebuild=41.5ms frame=63.2ms (+2 flips not logged). The reason is drag: / resize: / scroll:<windowId> / rest, and write is the pixelPerfect setter itself.
  • Window stacking is no longer sticky (WindowStacking, unit-tested). Before, BringToFront set a separate monotonic ZFront tier that outranked category and mount order forever, so once the launcher and Settings hub fronted themselves on every open (this branch), plugin windows that never front themselves opened UNDER them. The renderer token now carries one global activation value (ZAct), and the sort is (bottom → top): popups (DismissOnOutsideClick) > Topmost > ZOrder > layer > activation. The layer is HUD below Tools/Debug; a HUD window that was BringToFront’d is lifted into the Tools/Debug layer until it is next hidden (Park clears ZLifted), which keeps the documented “HUD above Tools” use without stickiness. Activation happens on: first mount; a REAL show from hidden, meaning SetVisible / SetVisiblePersist rising edge (Entry.ActivateOnShow makes the un-park call the new IWindowOrder.Activate); BringToFront (any category); and SetTopmost(true). Re-activation is NOT triggered by visibility restores (ApplySavedRect(applyVisibility) on mount / slot switch, ResetRect), which use the new internal Entry.SetVisibleRestore, so they never reshuffle z. Un-parking no longer refreshes order by itself. Tools and Debug now share one layer (Debug no longer always sits above Tools). A HUD shown from hidden still goes on top of the HUD layer only, as its old fresh ZSeq did. Explicit BringToFront is unchanged for callers: still needed for an already-visible window, harmless otherwise. BringToFrontPending (front before the first mount) still applies at mount. FrontWindowBlocks and every ticker hit-test read sibling indices, so input follows the new order. OverrideSortingOrder windows and the dropdown popup root canvas are separate canvases above all of this, unchanged. The pre-warm never fronts; a real open mid-warm-up fronts explicitly.
  • WindowSpec.Topmost (bool, init) and IWindowTopmost (bool IsTopmost { get; }, void SetTopmost(bool)), implemented by every framework window handle. It is a separate interface because IWindowControl is at the STELLAR0005 8-member cap. Call it through the WindowTopmostExtensions.SetTopmost(this IWindowControl, bool) / IsTopmost(this IWindowControl) extensions, which cast and are a no-op/false on the inert duplicate-id handle. A runtime toggle before mount, or across a scene-change remount, is re-applied at mount. Intended for small pinned overlays/alerts. Needs framework ≥ 2.30.0.
  • Per-canvas pixelPerfect. A window with its own nested canvas (WindowSpec.IsolateCanvas, or OverrideSortingOrder) now gets Canvas.overridePixelPerfect = true + pixelPerfect = true at attach (WindowRenderer.AttachNestedCanvas), so at rest it looks exactly as before. The ticker (WindowInteractionTicker.PixelPerfect.cs) keeps one switch per canvas (PpTarget: the root, plus one per isolated window, registered via AddLocalPixelPerfect, pruned with the window). Each motion source is routed to the innermost isolated window it lives under (Transform.IsChildOf): a window drag/resize target, or a user-scrolled/gliding scroll view’s content. Only THAT canvas is flipped OFF and settled back ON; the shared root canvas, and every other window on it, is not rebuilt. Motion in non-isolated windows flips the root as before, and each canvas settles independently (same 0.15 s settle and user-motion rules). Flip logging now names the canvas: [UiPerf] pixelPerfect OFF canvas=root|<windowId> reason=… write=…ms canvasRebuild=…ms (UiPerfStats.PixelPerfectFlip gained a canvas argument). The rebuild probe times Unity’s whole canvas update, so nested canvases are covered. IsolateCanvas is now ON for the launcher (settings.hub), the Settings hub (stellar.settings.ugui) and the “Edit colours” child (stellar.settings.colours). That is a good reason for any big scrolling plugin window to set IsolateCanvas too. With overrideSorting false, a nested canvas still stacks by sibling index (stacking / FrontWindowBlocks unchanged) and has its own GraphicRaycaster. FireOnClickWithRect and PositionDropdown now read rootCanvas.scaleFactor, since the nearest canvas can be a window’s nested one.
  • Launcher favorites drag-to-reorder. The Full menu’s grid is now one 5-column ListElement (94 × 102 cells, Gap 6: the same geometry as the old pooled rows) with OnReorder; CanReorder = LauncherMenuModel.CanReorderShown (Favorites tab, no Find text, not a ghost). Reordering is OFF while Find narrows the grid (a filtered grid hides tiles, so the drop slot in the full order is ambiguous). The compact bar’s favorites are one ListElement (1 column, or Horizontal for the horizontal bar) with OnReorder; Settings sits outside it, so it is never dragged nor a drop target. Order persistence: new launcher config key favorite_order (string[] of titles) next to the unchanged pinned set, an ordering only (LauncherFavoriteOrder.Sort: saved ids first, then pins it lacks in registration order, so a config without the key looks exactly as before). A new favorite appends at the end (which writes the order the first time); un-favorite removes it; a pin migration renames it in place; favorites whose tile is hidden right now keep their slot (LauncherFavoriteOrder.Apply); a ghost keeps its slot across a reorder and re-starring puts it back there. Feedback: the dropped tile flashes; the footer shows launcher.feedback.moved, and the Favorites idle hint becomes launcher.hint.idle_favorites (all six languages). The framework’s press lock on the ScrollRect means a reorder drag never scrolls the grid and never counts as list motion for pixelPerfect. 13 tests (LauncherFavoriteOrderTests).- ListElement gained three init properties (Abstractions 2.30.0, additive): CanReorder (Func<int,bool>?, polled on the press: false = the press stays an ordinary click, still a drop target; a throwing predicate locks the item), Gap (float?, null = the old 2-unit spacing, both axes for a grid), Horizontal (bool: one HorizontalLayoutGroup row sized to its active items; a fixed-column GridLayoutGroup would reserve every pooled column; reorder insertion is left/right).
  • StellarStyle.ConfirmPanel is exactly ConfirmSpec.Width wide (new init property = the panel’s OUTER width where it sits). The bubble gets MaxWidth = Width and both texts a fixed Width of the content (Width − 20), so they wrap; the pills are a plain left-aligned row at a fixed label width (min(96, (content − 8)/2 − 24)) instead of PillPair’s weighted cells. Before, a confirm nested in a column panel hugged its one-line sentence and pushed the column wider (Themes delete confirm: text past the edge, pills ~165 px each into the right column, the caption hint clipped to “2 of”, the card grid’s scrollbar poking out). All four confirms set it: Themes delete and Layout remove = ColumnWidth − 20, Hotkeys / Game UI reset all = MainWidth − 20.- CustomThemeStore.IsBuiltInName: Create / Rename throw for a ThemePreset name (any case, trimmed); the Settings rename field also refuses the preset names as shown in the current language, with themes.nameError.builtin (all six languages). Loading never drops an existing theme with such a name.
  • Colour picker child window (stellar.settings.colourpicker, option B). ThemesPanel.Picker.cs registers it next to Edit colours (GlassMenu, no title bar, Draggable, IsolateCanvas, fixed 260 wide = ThemeEditorBody.PickerContentWidth 236 + 2 × 12); content = ThemeEditorBody.DescribePicker: title strip (slot name, ellipsized, + round ✕) over the unchanged shared ColorPickerElement (live edit, persist on release). A row’s Edit pill reports its screen rect (StellarStyle.WithClickRect → SelectableElement.OnClickWithRect); ThemeEditorBody.EditRow records EditAnchor + bumps EditSeq. TickPicker (from TickColoursWindow): every fresh open DOCKS it at Edit colours’ right edge + 8 (left when there is no room), top at the clicked row (pill centre − 13, screen px × Canvas/Screen), clamped on screen, re-asserted for 4 ticks (first-mount DefaultRect); docked, it follows Edit colours each tick; a rect that differs from the last one set = user drag → undocked until it closes; Edit on another row while open re-targets in place (docked → realigned) + BringToFront (already visible). Closes via the row’s Close, its ✕, Done / Edit colours closing, the hub closing; its position is never persisted (colours.picker.title for the layout lists, all six languages). Edit colours is fixed height now: “Other colours” scrolls in a fixed 6-row area (166) and the open “+ Add colour override” section replaces it in the same height (its list 132).
  • WindowSpec.FixedHeight (bool, init, default false): a GlassMenu window keeps DefaultRect.Height instead of content-fitting its height (vertical ContentSizeFitter off; ignored when Resizable). A body taller than that is squeezed toward its min height (list viewports have min 0) rather than growing the window. The Settings hub uses it (800 × 612), so no tab can resize it; the Performance tab used to (its per-plugin list reserved 7 rows, now 5, and the tab’s preferred height ran past the 478 px tab budget).
  • WindowSpec.Prebuild (bool, init, default false) + WindowSpec.PrebuildSignature (Func<int>?, init): build a hidden plugin window ahead of its first open. Framework-driven (plugin ticks don’t run at the login screen): the element tree is built at login / character select WITHOUT any value pull (only build-time callbacks run: button Label/Icon, slider Get, TitleProvider), then one off-screen fill (every value lambda, Conditional, list) per world login — back to back behind the world-entry loading screen, else in play outside combat 3 s apart. Also fills a window that is Visible but held hidden by ShouldRender and never drawn yet (targetlens.bufflist / statinspector.mini-hud firstshow 74 / 45 ms); its takeover is ShouldRender turning true. The window stays hidden (IsShown false for a hidden one, nothing persisted, no clicks/hover); a real open mid-fill takes over; a changed PrebuildSignature refills while hidden. Raid log 11-10 first opens it targets: dungeonhub.confirm.raid 418 ms, dungeonhub.hub 204 ms, chattools.main 160 ms, combatmeter.main 121 ms. Register the window at start-up, not lazily. Needs framework ≥ 2.30.0 to set.
  • Launcher re-warm behind the loading screen. The 240 ms mount:settings.hub in the 11-10 raid log was the launcher’s own title-screen warm (settings.hub = launcher), not an open. What reached play was its world-entry re-warm (1 → 22 tiles, apply:settings.hub 76.9 ms, frame 111.7 ms): it waited for the loading screen to clear. The framework warms (launcher, Settings hub) may now run behind a loading screen once IsWorldActive is true under it.
  • DropdownElement.FillColorFn / HoverFillColorFn / LabelColorFn (Func<ColorRgba>?, init, default null = the built-in look): Pill-style trigger colours, polled every refresh (final colours — apply window opacity yourself). Null hover = the built-in 8 % text wash over the custom rest fill; a custom label also tints the ▾ (diffed per refresh). Classic and the option list are unaffected. SettingsKit.Dropdown passes the house Neutral fill / hover / label, so every Settings dropdown (Language, per-plugin Rate / Self-rate, theme preview) matches the Hotkeys key pill. Needs framework ≥ 2.30.0 to set.
  • Compatibility. A plugin that reads the status colours, selects Sakura or sets MaxLines / TextElement.Height needs framework ≥ 2.30.0. Setting ImageElement.Live/Tint, WindowSpec.Topmost or calling SetTopmost/IsTopmost also needs ≥ 2.30.0.

2.29.1 (patch) — PR #151. Mod buttons in the Esc menu’s side bar stack under the Stellar button with their own icons, and several mod-window drag and slider problems are fixed. No API change, no plugin rebuild.

  • Buttons that mods add to the Esc menu’s side bar now line up one below another under the Stellar button, instead of sitting on top of it.
  • Mod buttons in the Esc menu’s side bar now show their own icon in its original colours, like the game’s own buttons; only the Stellar button keeps its glowing star.
  • Large round slider knobs now look perfectly round, instead of like rounded squares.
  • Dragging a slider in a mod window that has no title bar now changes the slider, instead of moving the whole window.
  • Dragging a mod window by its title bar no longer sometimes does nothing when a closed mod window used to sit in the same spot.
  • A slider scrolled out of view in a mod list no longer stops you dragging the window around that spot.
  • Click-through mod overlays, such as a raid alert banner, no longer stop you dragging or hovering the mod windows underneath them.
  • Clip-aware scrollbar/slider exclusion. PointerOnScrollbar ignored RectMask2D/Mask clipping, so a slider registered via RegisterScrollbar (e048f00) that was scrolled out of a ScrollRect viewport still claimed presses past the viewport edge and suppressed window drags there. It now goes through PointerHitRule.AcceptsPress with OnInflatedBar && !OutsideClip (same rule as hover/HitTest/HitSlot); the 6 px horizontal inflation is unchanged.
  • Passive windows no longer cover in FrontWindowBlocks. A visible WindowSpec.Passive (click-through) window in front counted as covering, so e.g. RaidManager’s wide raidmanager.mech.alert banner blocked drag + hover on windows behind it. WindowRenderer.Mount now records Passive roots in the ticker’s PassiveRoots; FrontWindowBlocks skips them unless LayoutEditGate.IsEditing (PointerHitRule.FrontWindowCovers) — in edit mode they stay selectable/draggable and still cover. Internal only, no public API change.
  • Hidden windows no longer steal title-bar drags. HitWindowHandle was the one ticker press hit-test without an activeInHierarchy guard. A hidden window is parked (root SetActive(false), drag registrations kept) or ShouldRender-suppressed, and its handle still hit-tests at its last geometry; a parked Tools window sorts above HUD and has no active window in front, so FrontWindowBlocks passed and the press dragged the INVISIBLE window (the visible one stayed put, the hidden one moved silently). Now routed through PointerHitRule.AcceptsPress like the other press hit-tests. Pre-existing since window parking (62fd71b, v2.16.0), not a regression of this branch.
  • Slider drag-exclusion. On a title-bar-less Draggable window the whole frame is the window-drag handle, and WindowInteractionTicker only exempted scrollbars, so a press on a SliderElement started a window drag. BuildSlider now registers its rect through the same RegisterScrollbar exclusion hook (FrontWindowBlocks-checked).
  • Slider: the SquareHandle knob is now a true circle at any HandleSize. The knob reused the Capsule 9-slice (fixed 7-texel corners), so anything over 14 px drew as a rounded square. The SquareHandle path now sets Image.pixelsPerUnitMultiplier = 14 / HandleSize (CapsuleGeometry.CircleMultiplier) so each corner is HandleSize/2. The default stretched knob is unchanged.
  • Rail stacking. PlaceBelowRail measured only native template siblings, so every MainMenuRail MenuButtonSpec got the same y. UGuiInjectionService now passes an internal UGuiInjectContext(RailSlot, Branded) to IUGuiCanvasAdapter.Inject; slot N sits N+1 steps below the native top group. Slots come from the registration list (branded first, then registration order; removed registrations free their slot), not from which siblings exist at inject time, so re-injects can’t swap or overlap. A Warning logs if a slot reaches the bottom Support/Unstuck/Exit group.
  • Branded vs plain. The framework’s Stellar rail button registers through the internal UGuiInjectionService.RegisterBranded; it alone gets the accent tint + pulsing stellar-glow halo. Plugin buttons (public INativeUiHost.Register) draw IconPng untinted with no halo, and keep the hover scale-up. No public API change (MenuButtonSpec untouched); LoginSidebar unchanged.

2.29.0 (minor) — PRs #148, #149. The mod framework now supports fully rounded pill dropdowns, drag-to-reorder in long lists, and more player party data for mods to read. It also fixes dropdown hover highlighting the window behind and centres pill dropdown text. Adds DropdownElement.CornerRadius, VirtualListElement.OnReorder and SocialSnapshot.Party (Abstractions 2.29.0); additive, no plugin rebuild.

  • The mod framework now supports fully rounded ends on pill-style dropdowns, so mods can show capsule-shaped dropdown menus.
  • The mod framework now supports drag-to-reorder in long lists, so mods can let you rearrange items by dragging them, and the list scrolls on its own when you drag near the top or bottom.
  • The mod framework now provides more of a player’s party data, so mods can read that player’s party info.
  • The mod framework no longer highlights the window behind an open dropdown when you hover one of its options.
  • The mod framework now centres the text on pill-style dropdowns vertically.
  • Release scope. PRs #148, #149. The Added items show up only once a plugin uses them. The first users are Maestro (dropdowns, reorder) and EntityInspector’s Party tab. The hover fix applies to every dropdown, Classic and Pill, so ChatTools and MultiTool pick it up as soon as players update. The caption fix applies to every Pill dropdown.
  • DropdownElement.CornerRadius (#148) (float, init, default 0, Pill only). 0 keeps the current 3 px chip corners. A value above 0 sets the trigger’s corner radius. It is capped at height/2 − 1 (13 for the 28 px trigger) because the 9-slice bubble sprite’s minimum size is 2r+2, so r = 14 drew a 30 px trigger. Any value ≥ 13 gives an exact 28 px capsule. Classic ignores it, and the option list keeps its radius-8 card and radius-5 rows. BubbleElement.CornerRadius docs now note r = S/2 − 1 for a round bubble.
  • Pill caption (#148). The bold-13 caption sits 1 px below the centred text box so the capital letters line up with the pill’s centre. The ▾ chevron stays centred. The pill is still 28 px tall.
  • Open-dropdown hover (#148). The popup sits on its own root canvas, but the ticker’s hover test only knew window z-order, so cells under the pointer in the window behind also hovered. While a dropdown is open, only cells in the popup layer hover now (HoverBlocked). Popup rows skip FrontWindowBlocks, because sibling indices from two different canvases can’t be compared.
  • VirtualListElement.OnReorder (#148) (Action<int,int>?, default null, uniform rows only, ignored when VariableHeight is set). It works like ListElement.OnReorder (remove-then-insert item indices, never fires on a no-op, Esc or a drop outside the list cancels, 6 px drag threshold) and uses the same ticker state machine. The drag follows the ITEM index across recycled rows (VirtualListBinding.First, pure VirtualReorderMath). Edge auto-scroll speeds up linearly to 8 rows/s within one row of the top or bottom edge. ListElement behaves the same as before: its drop math moved into the shared VirtualReorderMath.RemoveInsertTo.
  • SocialSnapshot.Party (#149) (new init-only property; additive, binary-compatible). Decodes SocialData.team_data (field 12, CharTeam) into SocialParty { TeamId, LeaderId, TeamTargetId, TeamNum, MemberType, CharIds, Members } and SocialPartyMember { CharId, Name, Level, ProfessionId, TalentId, FightPoint, OnlineStatus, SceneId, EnterTime }. New Stellar.Wire/SocialTeamReader handles packed and unpacked char_ids and falls back to the map key for a member’s char id. SocialIdentity.PartySize is unchanged. SocialDataCache keeps the last non-null Party when a thin nameplate/avatar reply follows, the same rule as Location. A [TeamDiag] line is logged only with STELLAR_DIAGNOSTICS=1. Member order is random on every reply (proto map), so consumers must sort. MemberType 0 = 5-player party, 1 = 20-player. A carried-forward party has no timestamp and may be stale.
  • Compatibility. A plugin that uses any of the three new members needs framework ≥ 2.29.0.
  • Validation. #148: the build passes against the game interop and the CI stubs, and all tests pass except the 42 known Windows-only ReShade tests, including 28 new VirtualReorderMathTests and 11 BubbleGeometryTests. The corner radius, hover fix, caption alignment and virtual-list drag-reorder were all tested in-game. #149: 24 new or extended social tests pass. In-game on 2026-11-04, the server sent the full roster for a player in a party you are not in: 5/5 and 9/20 parties showed every member’s name, level, class, online status and scene. A solo player comes back empty.

2.28.1 (patch) — PR #146. The framework’s server clock now follows the real game server instead of your PC’s clock, so mods that time things against the server stay correct on a PC whose clock is wrong. No API change, no plugin rebuild.

  • Mods that rely on server time (band sync, countdowns, cooldown timers) now stay accurate even when your PC’s clock is set wrong.
  • Release scope. PR #146.
  • ServerNowMs was the PC clock. World notify 43 SyncServerTime is {client_milliseconds = 1 (our own PC time echoed back), server_milliseconds = 2}; PandaCombatStubProbe.OnServerTime anchored on field 1. New Stellar.Wire/SyncServerTimeReader.TryRead parses the body in any field order and returns field 2, falling back to field 1 only when field 2 is missing or ≤ 0. ICombatSnapshot docs now state the source and that CombatEvent.TimestampMs is stamped from the PC clock (UtcNow), so the two differ by the PC’s clock error.
  • Effect. On a synced PC ServerNowMs moves by about one ping (~20–30 ms). On a PC with a wrong clock it now matches the game’s Z.ServerTime; consumers comparing it to PC-stamped event timestamps (CombatMeter settle/history/replay cap) shift by that error — optional plugin cleanup later.
  • Validation (in-game, 2026-11-03). PC clock deliberately 1.7 s slow: Maestro Link’s logged Z.ServerTime − ServerNowMs went from +1742ms (2.28.0) to -3ms, and Link plays in sync. 6 new SyncServerTimeReaderTests.

2.28.0 (minor) — PRs #143, #144. Mod dropdowns can use the rounded pill look from the Stellar Design Language, and a mod can give one of its windows its own background opacity instead of the global Window Opacity setting. Adds DropdownStyle / DropdownElement.Style and WindowSpec.FrameOpacity (Abstractions 2.28.0); additive, no plugin rebuild.

  • Mod dropdown menus can now use a rounded “pill” look that matches the newer Stellar windows. Dropdowns that don’t opt in look the same as before.
  • A mod can now let you set the background see-through level for one of its windows, separate from the global Window Opacity setting. Text and buttons stay solid.
  • Release scope. PRs #143, #144. Neither change shows up for players until a plugin uses it: the first users are MultiTool (Band Mute “Mode” dropdown) and ChatTools (a “Custom window opacity” slider), and both are released separately.
  • Pill dropdown (#143). New public enum DropdownStyle { Classic = 0, Pill = 1 } and the DropdownElement.Style init property, default Classic. It is not a primary-ctor parameter, so the record stays source and binary compatible (same pattern as MaxVisibleRows). New WindowBuilder.Dropdown.Pill.cs:
    • Trigger: a 28 px rounded pill filled Over([email protected], Over([email protected], MenuBackground)), with a bold 13 caption whose contrast is checked against the fill. Hover adds [email protected]. Width is honoured (0 = hug). Colours are read live from the theme, so a theme switch repaints it.
    • Chevron: an 8×5 anti-aliased triangle image. The bold TMP face has no “▾” glyph, so a text chevron gets a zero preferred size and never draws.
    • Popup: a rounded panel with a 1 px edge and 4 px padding, and 26 px rows. The selected row gets a [email protected] wash. MaxVisibleRows scrolling still works. Positioning, the blocker, dismiss on Esc or an outside click, and the popup canvas are shared with Classic.
    • Refactor: BuildDropdownScroll now takes a (float H, float Gap) row tuple to stay under the STELLAR0003 five-parameter cap. Classic passes its old values.
  • Per-window frame opacity (#144). New WindowSpec.FrameOpacity, an init property of type Func<float?>?, for GlassMenu windows only (Borderless windows already have BackgroundOpacity).
    • Values: the delegate returns an override, or null to follow the global IChromeStyle.WindowOpacity, so a plugin can switch between the two live. A null delegate keeps today’s behaviour.
    • Implementation: ConfigureGlassRoot gets its provider from FrameOpacityOf(spec), which returns Clamp(own() ?? global, 0.3, 1) (the same 0.3 floor as the global slider). That feeds the existing FrameOpacityBinding. Only the frame Image’s alpha changes, and ForceOpaque / ChromeKill are still honoured. If the delegate throws, the global value is used.
  • Validation (in-game, 2026-10-29).
    • #143, on a local 2.28.0 package with the Default theme: MultiTool’s Band Mute “Mode” dropdown in Pill style showed a centred caption and chevron in a 140×28 pill, hover worked, the open list showed the selected-row wash, and picking a mode applied it. ChatTools’ “Translate to” dropdown kept the Classic look.
    • #144, on a local 2.29.0 package with #144 rebased on #143, global opacity at 100%: ChatTools’ chat window frame followed the slider live (85% → 30% → 100%) while its text and input stayed solid. Other GlassMenu windows, including ChatTools’ Settings window, stayed at the global value, and returning null reverted the window.
    • Tests and gates: #143’s build had 0 errors, and its tests ran 3035 passed / 42 failed (all 42 are the known Windows-only ReShade tests). Neither PR ran check-standards.sh or #144’s unit tests locally; CI covers both.

2.27.2 (patch) — PR #141. The Korean 한/영 key and live IME composition (Korean, Japanese) now work in Stellar text boxes, and the F1/F2/F3 quick-use item bar no longer disappears while you type in one. No API change, no plugin rebuild.

  • The Korean 한/영 key now switches input language in a mod’s text box, the same as in the game’s own chat.
  • Korean and Japanese text now shows while you are still typing it in a mod’s text box, instead of only after it is finished.
  • The quick-use item bar (F1, F2, F3) no longer disappears while you type in a mod’s text box. The keys still type text and do not use items.
  • Release scope. PR #141.
  • IME forced off every frame. ZMouseManager.Update → updateMouseLock calls Panda.ZInput.DefaultMousePointer.HideMousePoint() every frame unless a game view registered a show-mouse source; its body sets Cursor.lockState = Locked, Cursor.visible = false and Input.imeCompositionMode = Off. The setter icall is inlined, so it can’t be patched, and re-asserting On every frame (a01d827, reverted in 4ac9b6e) defeats the IME. New ImeKeepOnPatch is a Harmony prefix on HideMousePoint: while a Stellar field has focus (AnyFieldFocused, the same signal KeyboardInputGate uses) it re-applies the cursor lock + hide and skips the original, so IME Off is never written; otherwise the original runs. Installed from ApplyLifecyclePatches, unpatched by the framework Harmony host. AddShowMouseView was rejected: it switches InputMode to UI and shows the cursor.
  • Composing text drew nothing. TMP draws one font per string, and TmpRichInputField picked it from the committed text only, while TMP appends the composition string to the label, not to text. TickComposition() now re-picks the font from committed text + composition while focused; the re-pick after a commit waits one tick so it doesn’t blink, and a cancelled composition falls back to the Latin font.
  • Quick-use item bar. Regression from 2.27.1 (a2483bc): the narrowed “UI” prefix rule stopped sparing QuickUseItem (previously spared by accident via the bare ui substring), and the game hides that HUD while its input mask is ignored. QuickUseItem is now in a MaskExcludeHud exact-name set; the keys stay blocked by the Rewired keyboard disable.
  • Validation (in-game, 2026-10-27). ChatTools composer, 한/영 simulated as VK_HANGUL: before, 한/영 + gks gave ggks; after, it gives 한, drawn live as ㅎ → 하 → 한; backspace-cancel leaves g; Japanese nihonn shows にほん while composing and Space converts to 日本; game chat unaffected. Item bar stays visible while focused, and F2 while focused used no item. Not checked: whether Alt still frees the cursor while a field is focused (screenshots don’t capture the cursor; Alt goes through the unpatched Show path).

2.27.1 (patch) — PR #139. Auto Combo no longer stops while a Stellar text field is focused; ellipsized labels in virtual lists no longer flash a wrong cut while scrolling. No API change, no plugin rebuild.

  • Auto Combo keeps fighting while you type in a mod’s text box. Before, it stopped casting until you left the box.
  • Release scope. PR #139. The ellipsis fix is only visible through the unreleased ChatTools whisper list, so it is deliberately left out of the player notes.
  • Auto Combo while typing. KeyboardInputGate masked almost every EInputMask via ZIgnoreMgr.SetInputIgnore (EUIView) while a field was focused. The auto-battle AI cast path (ClientClickSlot → ZBattleUtils.ClickSlot → ZSkillInputMgr.onPress(isAIPress:true)) honours those masks. New exact-name exclusion set: NormalAttack, Skill, SkillWithWhiteList, DoByFuncId, Resonance1, Resonance2, Move, AutoMove, Walk, Run, LockTarget. Keyboard gameplay stays blocked by the Rewired keyboard disable and PlayerInputController.IgnoreKeyboard. QuickUseItem was wrongly excluded by the bare "ui" substring rule and is now masked. Removed the dead curFocusInputTextName lookup (not a PlayerInputController field).
  • Ellipsis on rebound rows. TmpStyledText.MeasureAndFit wrote the new string (layout only marked dirty), then FitToRect read the stale rect.width left by the slot’s previous string. The ~10 Hz re-apply corrected it about 100 ms later. Now, when the new string is wider than the rect, RelayoutForNewString runs LayoutRebuilder.ForceRebuildLayoutImmediate on the group picked by LayoutRootFor (climbs at most 4 levels while the width is content-driven) before fitting. Strings that fit cost nothing extra. The first attempt (0360b92) was a no-op in-game: transform.parent is RectTransform is usually false on IL2CPP, and 845cdf8 uses TryCast<RectTransform>(). Known leftover: one stale cut for about 10 frames when a tab first opens.
  • Validation. In-game: with the ChatTools composer focused and Auto Combo ON it kept casting (IsInputIgnore(Skill) = false, Jump = true), and W/2 typed into the field without moving the character. The whisper list had no wrong cuts in a ~125 fps capture or in the owner’s scroll test.

2.27.0 (minor) — PRs #135–#137. An opt-in setting keeps the mouse cursor free after you Alt + click a Stellar window. Clicks on Stellar windows no longer reach the game’s press-checks underneath. Also includes groundwork for the unreleased ChatTools redesign: the rich input caret, virtual-list row culling and a scroll anchor. Adds VariableListMath.TopVisibleIndex / FindRowById (Abstractions 2.27.0); additive, no plugin rebuild.

  • New option in Settings → Layout → Cursor: “Keep cursor after clicking a Stellar window”. When it’s on, Alt + click a mod window and the cursor stays free after you let go of Alt, so you can keep using the window without the camera turning. Click the game world or press Esc to go back to the camera. That click or Esc only releases the cursor: it won’t attack, select a player or open the game menu. Off by default.
  • Release scope. PRs #135–#137. Fixes that are only visible through the unreleased ChatTools redesign (the press-check leak into the hidden chat input, the rich-input caret, row culling, the scroll anchor) are deliberately left out of the player notes. They become player-visible when that ChatTools ships.
  • Rich input caret (#135, #136). TmpRichInputField sets caretWidth = 2. TMP’s default of 1 scales to about 0.05 × line height, which rasterized to nothing at the 13 px chat font. Separately, TMP’s own PageUp/PageDown scroll moved the caret rect and our text pin never re-synced it; AssignPositioningIfNeeded now does. A focus request restarts the blink (SetCaretVisible + ForceLabelUpdate).
  • Virtual-list row culling (#135). New WindowBuilder.VariableList.Cull.cs, plus the same cull in uniform-height WindowBuilder.VirtualList.cs. Latched rows fully outside the viewport are SetActive(false). The margin is max(2 estimated rows, 160 px) plus scroll velocity × 0.25 s. Rows keep their latched height and slot, so showing one again needs no re-measure. The pass runs only when the scroll position, viewport height or moving state changes; InvalidateHeights forces it. Measured in-game at 2560×1440 with ChatTools open: Stellar renderers 835 → 427, clipCull 0.60 → 0.27 ms/frame, mean frame time ≈ −0.2 ms.
  • Scroll anchor on trim/rebuild (#136). With RowId set, the top-visible row is tracked by identity and put back at the same screen offset after the consumer trims or rebuilds the list. New pure helpers in VariableListMath: TopVisibleIndex (the top row without FirstIndex’s pool clamp) and FindRowById (bounded outward search, at most 2·radius+1 rowId calls). Both are unit-tested. RowId == null behaves as before. The natural >500-message ring trim has not been reproduced in-game yet.
  • Sticky cursor (#136). StickyCursorService (Application) + IStickyCursorBackend → StickyCursorBackend (Infrastructure). It holds the game’s own show-mouse state (Z.UIMgr:AddShowMouseView). It arms on Alt + click on a non-HUD Stellar window and releases on a world click, Esc, world exit, setting off, or no Stellar window open. World-click swallow: a Harmony prefix skips Panda.ZInput.ZTouchManager.simulateTouch (WorldPointerGate), and the Rewired mouse controller is disabled while armed (RewiredMouseGate) so the basic attack doesn’t fire. Esc is swallowed through HotkeyKeyBlockPatch. Persisted as ui.layout / sticky_cursor, default off, strings in all 6 locales. Tests: StickyCursorServiceTests.
  • Game press-check shield (#137). Panda.ZUi.ZUIPointPressCheck (press_check on about 90 Lua views) polls presses in Update and calls isPointerOverGameObject(Vector2). That method tests containment against every EventSystem.RaycastAll hit, not just the topmost, so a Stellar canvas on top didn’t stop it. Observed symptom: main_chat_pc was activated under ChatTools, and later hotkeys were typed into it. GamePressCheckShield prefixes that method: when the topmost hit at the press point is a Stellar canvas, it returns false. It uses the same test as IInputShield.IsPointerOverGameUi, so passive click-through windows stay click-through. It runs on press frames only, falls back to the original on error and is removed on teardown. It logs [PressShield] blocked game press-check under <windowId> (rate-limited). Side effect: a Stellar click now counts as an outside click for game views that close through press_check. Not shown in the player notes, because in-game the name card already closed on an outside click before this change.

2.26.0 (minor) — first stable release since 2.23.1; rolls up the never-published 2.24.0–2.25.5 development versions. Lets mods show the game’s chat emoji inline in text and input boxes, rounded speech bubbles, smooth long scrolling lists, right-click menus and drag-to-reorder on picker cells, a “new messages” jump bar, per-person whisper conversations, the friends and private-chat lists, the game’s system notices and the chat send cooldown; injected name-card buttons get native dividers and fire on release only; config saves survive a transient file lock; fixes a multi-second login freeze. Adds API for plugins (BubbleElement, VirtualListElement variable-height mode, IPlayerProfile, IFriends, ChatMessage.PeerId/TargetId/SystemLabel/SystemType/SystemRefId, IChat.TryGetSendCooldown/SendResult, TextElement/InputElement.RichEmoji, InputElement.FocusRequest, InputElement.Placeholder/Locked, VirtualListElement.OnAtBottomChanged/ScrollToBottomRequest/RowRevision, SelectableElement.OnRightClick/Bare/OnClickWithRect, ListElement.OnReorder, RowElement.ConstrainsWindowMinWidth/OnHover, TextElement.Ellipsize/CenterGlyphs, BubbleElement.OutlineColorFn, IWindowHost.PrewarmText, HitchProbe.Count; Abstractions 2.26.0); additive, no plugin rebuild.

  • Mods can show rounded, coloured speech-bubble cards that fit snugly around their text, including see-through colours, to match the game’s own look.
  • Long scrolling lists of differently-sized rows now stay smooth however much history there is. Lists can start at the newest entry and stay pinned to the bottom unless you’ve scrolled up.
  • Mod windows can now show the game’s own emoji as pictures inside text, and inside a text box while you type.
  • Emoji added from a mod’s picker now go where your text cursor is, instead of always at the end of the text.
  • Mod windows can show a “new messages” bar while you’re scrolled up; clicking it jumps back to the newest.
  • Mods can now group whispers into one conversation per person, and show your friends list and private-chat list with unread counts.
  • Mods can now show the game’s own system notices, such as “Obtained Guild Fund ×40”.
  • Mods can now show how long until you can post again in World or Current chat, and tell you when a message was sent too quickly.
  • A mod hotkey can now work only while that mod’s window is open. The rest of the time the key goes to the game.
  • Grids of picker items (such as a sticker or emoji picker) can open a menu on right-click, and you can drag items into your own order.
  • Menus a mod opens from a button (such as a channel picker) can appear right next to that button.
  • Buttons that mods add to a player’s name card, like Inspect, now have the same divider lines as the game’s own buttons.
  • Buttons that mods add to a player’s name card no longer go off when you press on them to drag-scroll the card. They only respond to a normal click, like the game’s buttons.
  • Mod settings are no longer sometimes lost when another program, such as antivirus, briefly locks the settings file during a save.
  • Older chat messages that load when you log in now show under the correct channel in mods.
  • Fixed a freeze of up to several seconds right after logging in while your recent chat history loads into a mod.
  • Pop-up menus in mods no longer flash somewhere else and close the first time you open them after starting the game.
  • Chat messages, whispers and who you whisper are no longer written into the mod log file.
  • After switching characters, whispers the new character received while offline are no longer missing from mods.
  • Replying to a whisper you sent now goes to the person you were talking to, not back to yourself.
  • Mod windows can no longer be made too narrow for their own tabs or buttons, which cut them off in some languages.
  • Hovering or clicking just outside a scrolling list no longer highlights or activates a half-hidden row.
  • Release scope. First stable since 2.23.1 = PRs #130–#133. The 2.24.0–2.25.5 sections were development versions that never reached the CDN; their developer notes are kept below, prefixed with their old version. Player-facing fixes to features that never shipped (2.25.3–2.25.5 list jitter/gap/overlap, rich-input centring, StableSlots redraw, notice ring, MarkPrivateRead badges, reorder ghost) are deliberately left out of the player notes.
  • Name-card action dividers (#130). The game draws the thin divider as a static child of each native action item’s prefab (ui/prefabs/idcard/idcard_item_tpl_pc); injected IProfileCardActions buttons are built from scratch, so they had none. PandaProfileCardActionInjector.Divider.cs finds the divider on a native sibling (name contains line/div/sep, else a Graphic ≤ 6 px wide) and Object.Instantiates it onto each stellar_action_* button as stellar_divider, stripped to visuals with raycastTarget = false. Missing divider → buttons build exactly as before (never throws). One-shot item-hierarchy diagnostics behind STELLAR_DIAGNOSTICS=1. Validated in-game (release_3.7).
  • Name-card actions fire on release (#132). Injected name-card buttons fired on mouse DOWN, so pressing one to drag-scroll the action bar triggered it. New PandaProfileCardActionInjector.Click.cs: still manual + level-based (GetMouseButton, the idcard canvas doesn’t dispatch EventSystem clicks to injected children), but press records button/position/row anchoredPosition; the press is cancelled if the pointer moves > max(EventSystem.pixelDragThreshold, 10) px, the row scrolls > 2 units, or the button dies; release fires only inside the SAME button (drag checks re-run at release). Pending state resets on card close / re-inject. Cancelled presses logged under STELLAR_DIAGNOSTICS=1. Validated in-game (release_3.7).
  • Config write retry (#131). FileConfigStore.AsyncWrite.cs dropped a write on IOException (seen in-game: an external transient lock, most likely Defender scanning the just-written file, lost a plugin’s “Clear all”). The writer thread now retries with backoff 50/100/200/400/800 ms (~1.55 s), abandoning the attempt if a NEWER save for the same path is queued (coalescing preserved); Info on a successful retry, one Warning (save failed after N attempt(s)) only when all fail. UnauthorizedAccessException etc. unchanged (no retry). Shutdown drains share a 300 ms retry budget over ≤ 3 passes. The hash/stat ledger still records only after a successful write. Tests: FileConfigStoreRetryTests.
  • Whisper peer identity. ChatMsgInfo.target_id (field 2, a charId) is now decoded (WireProtocol.TryParseChatMsgInfo 5-arg overload; ChitChatMsgResult.TargetId) and surfaced as init-only ChatMessage.TargetId. Init-only ChatMessage.PeerId = the other party of a Whisper, decided on the main thread in ChatService.Drain with the game’s own rule (chat_main_vm.lua:796-807 — sender, or target when the sender is self; self = IPlayerIdentity.CharId). A record with no target can’t be our own echo, so peer = sender even before self is known; with a target and self unknown it stays 0 (the plugin decides). Private HISTORY batches: the ZRpcImpl.SendBytes capture also reads GetChipChatRecordsRequest.target_id (field 5, new TryParseGetChipChatRecordsRequest) keyed by call_id beside the channel, and channel-5 batches are tagged with that peer (the reply rows carry none); the batch log line gains hasPeer= (whether a peer was captured — never the charId). ChatTarget.Reply on a whisper now targets PeerId when known. ChatTarget.Whisper/WhisperTarget docs corrected: the id is a charId, not an entity id.
  • System notices. The game’s “Obtained …” / item-cap / broadcast lines are CLIENT-generated (never ChitChat). SystemNoticeService (Application) installs a Lua wrap of Z.VMMgr.GetVM("chat_main").SetReceiveSystemMsg that calls the original, formats with Z.ChatMsgHelper.GetSystemType and appends a preformatted record to a Lua queue (cap 64); C# polls every 0.25 s from the IsWorldActive-gated framework Update (one tiny DoString + one ReadGlobalString, \x1e/\x1f-separated) and publishes through the normal chat queue: Channel=System, Type=System, IsHistory=false, no sender, framework-made NEGATIVE MsgId, Timestamp = interpolated server clock at drain. New init-only ChatMessage.SystemLabel (e.g. “Obtained”), SystemType (E.ESystemTipInfoType: 1 item, 2 message, 3 dungeon roll), SystemRefId. Text keeps the game’s rich-text colour tags (TMP rich text). The wrap marker lives on the VM table; each poll re-checks it and re-wraps when the VM table/method was replaced (scene reload / reconnect); a re-entrancy flag guarantees one push per notice. Logs [ChatProbe] system-notice hook installed once (… re-installed (…gen=N) on a re-wrap). No Lua→C# callback.
  • Send cooldown (server-driven). SendChitChatMsgReply {show_msg=3, int64 cd_end_time=4, err_code=5} is parsed (WireProtocol.ChitChat.Send.cs) and correlated by call_id to the channel its request named — framework sends are recorded at dispatch, the game’s chat-box sends from the SendBytes prefix (SendChitChatMsgRequest.channel_type, field 2). cd_end_time and show_msg.timestamp are both Unix SECONDS. IChat gains two DEFAULT-implemented members (external implementors keep compiling): bool TryGetSendCooldown(ChatChannel, out double remainingSeconds) (measured against the interpolated server clock; a local Stopwatch deadline from the reply’s own stamp before the clock syncs) and event Action<ChatSendResult> SendResult (main thread). New readonly record struct ChatSendResult(Channel, Ok, ErrorCode, CooldownEndUtc) + init-only ViaFramework / ServerTimeUtc, const ErrorTooFrequent = 5211. An accepted reply without a cooldown (Party/Guild) clears the channel’s slot; a refusal carrying cd_end_time updates it. Logs [ChatProbe] first send reply: … once and [ChatProbe] send refused: … per refusal. ⚠️ A plugin that CALLS these needs framework ≥2.26.0 (the defaults on an older host report “no cooldown” / never fire).
  • Friends. New IPluginServices.Friends (IFriends, 7 members): Friends (FriendInfo(CharId, Name, Remark, Level, ProfessionId, GroupId, IsOnline, AvatarUrl) from friend_main_data:GetFriendDic(), Shield group skipped, sorted by charId), PrivateChats (PrivateChatTarget(CharId, Name, IsTop, UnreadCount, LatestText, LatestMsgType, LatestSenderId, LatestTimestampUtc, IsOnline?) from chat_main_data:GetPrivateChatList(), game display order), event Changed, and queued actions RequestPrivateHistory / MarkPrivateRead / CreatePrivateChat / ClosePrivateChat that run as the game’s own coroutine VM calls (AsyncGetPrivateChatRecord(id,0,true), AsyncSetPrivateChatHasRead(id, latestMsg.msgId), AsyncCreatePrivateChat + char-info + history like chat_service.createPrivateChat, AsyncDeletePrivateChat) inside Z.CoroUtil.create_coro_xpcall. FriendsService polls every 2.5 s in-world (0.75 s after an action): one tiny DoString + two string reads; each list is rebuilt only when its serialized string changed; ids cross as decimal strings (int64-exact). Lists keep their last contents outside the world. Logs [Friends] friend/private-chat poll active once and [Friends] <Action> issued (no charId).
  • All chat/friends additions above are additive (init-only props, new types, a new aggregator property, default-implemented IChat members) — binary-compatible with plugins built against ≤2.25.5. Built + unit-tested; NOT yet in-game validated.
  • Chat privacy in the log. The chat probe and chat service never log message text, sender names or whisper peers any more — only channel, counts and text LENGTHS ([Chat] first received, [Chat method=3] first received, [Chat] history batch received (textLen=, hasPeer=), the STELLAR_DIAGNOSTICS per-message lines (senderId=/textLen=), [Friends] <Action> issued). The first-correlated-Return line dumps its leading payload bytes only in diagnostics mode (they are the first history record: sender name + text). The diagnostics-only [Chat method=3 HEX] forensic dump (first 5 payloads, raw hex) is unchanged.
  • Local send failure. A send that never left the client (no probe, TrySend/TrySendSticker refused — no live chat connection, unsupported target — or threw) now raises IChat.SendResult with new const ChatSendResult.ErrorNotSent = -1 (Ok=false, ViaFramework=true, no cooldown, no server reply follows). Raised SYNCHRONOUSLY inside Send/SendSticker when called on the main thread (ChatService learns the main thread id in Drain), so a chat box can keep its draft instead of clearing it; queued for the next Drain from any other thread or before the first Drain. A const — inlined into callers, no runtime dependency on this build.
  • System notices get their own ring. IChat.RecentMessages is now two bounded rings merged on a global arrival number (ChatService.Ring.cs): wire chat keeps the 500-entry ring, the CLIENT notices published by SystemNoticeService (ChatMessage.SystemLabel != null) a separate 100-entry one, so a farming burst of “Obtained …” lines no longer evicts World/Guild chat or the login history. Server System lines (TopNotice/Play, SystemLabel null) stay in the main ring. The snapshot is still ONE list in pure arrival order (notices interleaved where they arrived), rebuilt only when either ring changed. No API change.
  • Lazy chat background work. SystemNoticeService and FriendsService no longer run for everyone. Notices: nothing (no wrap install, no poll) until ChatService.HasConsumers() — a MessageReceived subscriber or a RecentMessages read in the last 30 s; when the last consumer goes, one DoString clears a new Lua flag __stlr_sys_on (the installed wrapper stays as a pass-through, its push returns at once) and drops the queue, and the poll stops; a new consumer raises the flag again with an empty queue (no stale notices published late). Friends: polls only while a Changed subscriber exists, an action is queued, or Friends/PrivateChats was read in the last 30 s (the first read starts it; data follows on the next in-world tick). A plugin that subscribes at load (ChatTools) starts both at once, as before.
  • VirtualListElement.StableSlots (init bool, VariableHeight mode, default false): row l lives in pool slot l % Pool.Count instead of slot l - first, so a one-row shift of the window (every append to a bottom-pinned list longer than the pool, every scroll step) recycles ONLY the slot whose row left — the other slots keep their content, so their texts/avatars/bubble width-solves are not redone. PlanAdmission/Reposition walk the window by row offset and address slots through SlotOf; consumers resolve slot→row with the new pure helper VariableListMath.StableSlotRow(first, slot, poolSize) (unit-tested). Latched heights are keyed by data index as before, so nothing is re-measured by the remap.
  • IFriends.MarkPrivateRead now clears the game’s badges. The queued read mirrors the native friend_chat_item_pc.lua setRead: runs AsyncSetPrivateChatHasRead(cid, latestMsg.msgId, CancelSource:CreateToken()) ONLY while maxReadMsgId < latestMsg.msgId (read at run time), and on success refreshes Z.RedPointMgr.UpdateNodeCount(E.RedType.FriendChatTab, GetPrivateChatUnReadCount(), true) (the native 3rd arg was missing), CheckMainUIFriendNewMessage and dispatches Z.ConstValue.Chat.PrivateChatRefresh — the VM itself refreshes none of them. Previously the refreshes ran even when the RPC failed and the RPC ran with nothing unread. Debounced per charId (1 s) in Enqueue: it is a server write and an RPC error < 1000 makes the proxy Disconnect.
  • Chat session reset at logout. PandaChatProbe’s history/live dedup (WhisperDedup, key (senderId, msgId, send_time)) lived for the whole process — and a whisper’s key is IDENTICAL on both sides, so after character A saw a whisper live (its own echo), character B’s history copy of it in the same game session was dropped (history batch fully deduped; repro: A whispers offline B, relog as B, open the conversation). Host OnLogout now calls ChatService.ClearSession() after the IClientState.Logout subscribers: empties both rings + the undrained queue + the send-cooldown slots and calls new framework-internal IChatProbe.ResetSession() (dedup + per-sender channel hints). RecentMessages is now really “since the last login”. Plugins that cut their view at a ring entry at logout keep working (the entry is gone = everything left is newer).
  • Click-away popups on first mount (WindowService): ApplySavedRect restored the persisted visibility, and a popup’s saved flag is usually false (Entry.SetRect persists the CURRENT Visible, and plugins place a parked popup with SetRect before SetVisible(true)). So the first mount of a session re-hid the popup straight away: one frame at the old saved spot, then parked, while the plugin still thought it was open (needed an extra click). DismissOnOutsideClick windows now never take visibility from storage (any applyVisibility caller, including a slot switch), and a SetRect issued before their mount (Token == null, previously dropped) is kept as Entry.PendingRect and applied right after ApplySavedRect in the mount, so the first painted frame is already at the requested spot. Non-popup windows are unchanged. Tests: WindowPopupMountTests.
  • Rich input vertical centring (TmpRichInputField): the typed text/hint drew top-aligned under TMP_InputField (screenshot: baseline = box top + face ascender, ~4 px above centre at 13 px) although the TMP texts were set to middle-left. Text and Placeholder are now TopLeft with an explicit margin top = bottom = (28 − face line box)/2, line box = (faceInfo.ascentLine − descentLine) · fontSize / pointSize · scale, recomputed on every face swap (Latin/Thai shipped face vs system CJK face). Caret follows the line. Affects only InputElement.RichEmoji fields (legacy InputField path untouched). New Infrastructure reference UnityEngine.TextCoreFontEngineModule (for FaceInfo).
  • HotkeyAction.IsActive (init Func<bool>?, default null = unchanged behaviour): an “only while” gate. While false the action is dormant — HotkeyService.Tick skips its dispatch AND SyncBlockedKeys leaves its chord out of the Rewired block set, so with “Don’t pass hotkeys through to the game” on the press still reaches the game. Gates are polled once per tick (HotkeyService.Conditional.cs RefreshConditionalBlocks, only while block-all is on and a gated action exists) and the static block set is rebuilt only on a flip — never evaluated inside the hot Rewired.Keyboard prefix. Dispatch evaluates the gate live; a throwing gate = inactive (rate-limited error log). An init property, not a record ctor param, so every compiled new HotkeyAction(...) keeps binding. Unit-tested (HotkeyConditionalTests).
  • InputElement.InsertRequest (init Func<(int Seq, string Text)>?): a change of Seq inserts Text at the caret the field last had while focused (replacing a selection; a bound inside a <sprite=N> tag moves out of it — pure SpriteTagEdit.InsertAt, unit-tested), then focuses with the caret right after it; unknown caret (never focused / text replaced from Get) = end. The caret is remembered per frame while focused (UGuiTextInput.Insert.cs) because the picker click deactivates the field and TMP resets its caret on deactivation; it is placed once focus is confirmed (the FocusRequest path). Written through the field setter, so OnChange reports it. TMP string-index caret behind new optional IRichInputCaret (8-member cap on IRichInputField).
  • RowElement.ConstrainsWindowMinWidth (init bool, default false): the row’s natural width becomes a floor on a Resizable window’s minimum width. Per marked row, required = windowWidth + (LayoutUtility.GetPreferredWidth(row) − row.rect.width) (the delta carries all chrome/padding — nothing hardcoded); effective min = max(WindowSpec.MinWidth, ceil(max required)) over shown rows, capped at MaxWidth. Measured at mount (after the forced first layout, BEFORE the saved-rect restore) and then from the window’s apply — every 5th apply (~0.5 s) or the apply after a structural change / reskin; reads cached layout only, no allocation. Enforced through the existing paths: the window’s DragResizers Min is rewritten (resize-grip clamp), and SetRect already clamps size to it (so a saved narrower layout is widened on load and persists through the normal settle-persist); a runtime growth widens once (>0.5 unit hysteresis), sliding left if the widened edge would leave the screen. Never shrinks. Logs [Window] <id> min width from content: N on each change. A BubbleElement inside a marked row hugs its natural width uncapped (BubbleBinding.NoCap) — otherwise its parent-width cap lowers the row’s preferred width as the window squeezes and the measurement ratchets down. SetRect now clamps size before position, so the on-screen clamp sees the final width. Non-Resizable windows ignore the flag.
  • New service IPluginServices.PlayerProfile (IPlayerProfile, Abstractions 2.26.0) with one member: void RequestAvatarUrl(long charId, Action<string?> onResult). Fire-and-forget; onResult fires exactly once on the main (Unity) thread with the full https://…png URL, or null when the player has no custom photo / the request failed. It returns the URL only — the consumer owns download, disk cache and Texture2D creation. May be called from any thread (it only enqueues); every game interaction and the callback run on the framework tick. charId is the same id a received ChatMessage carries as its sender id, so a chat consumer passes it straight through.
  • Sourcing (PlayerProfileService + .Reflection.cs, Infrastructure, all by reflection — this layer has no compile-time game refs): the request is GetSocialDataRequest{ CharId = charId, Mask = 2 } (Mask bit 2 = SocialDataTypeAvatar), issued on Zproxy.SocialProxy.GetSocialData(request, 0u) → Cysharp.Threading.Tasks.UniTask<GetSocialDataReply> (Social service uuid 901134105, methodId 1). The proxy is acquired through the game’s OWN accessor Zservice.ServiceRegister.GetSocialProxy(IRpcCtrl ctrl, true) fed ZRpcCtrl.Instance (a ZSingleton, via StellarInterop.GetSingleton) — fetch-or-create of the registered proxy, resolved fresh each request so a reconnect can’t leave a stale transport (mirrors the chat probe’s resolve-live-on-demand doctrine). The URL is read off reply.Data.AvatarInfo.Profile.Url; null on a faulted/canceled task, ErrCode != 0, or any null link / empty URL.
  • The framework has no compile-time UniTask reference, so the returned task is POLLED on the framework Update tick via reflected Status/GetAwaiter()/GetResult() (UniTaskStatus 0=Pending 1=Succeeded 2=Faulted 3=Canceled) — the exact pattern GameAssetsService already proved for the Addressables UniTask, not an await. The callback is marshalled with IFramework.Post. Additive (new interface + new sub-service property on the IPluginServices/PluginServices/PerPluginServices aggregator) — binary-compatible, no plugin rebuild.
  • Window-element additions below are all init properties or a default-implemented interface member, NOT record ctor params — binary-compatible with plugins built against ≤2.25.5. See KB WindowBuilder-Patterns.md for each.
  • TextElement.RichEmoji (bool): hosts the text in TextMeshPro with rich text on and the GAME’s own chat sprite asset (TmpEmojiSprites, resolved lazily once in-world), so the game chat’s 1-based <sprite=N> tags draw as emoji images. Uses the framework TMP faces (style flags still apply; one face per string, so mixed Thai + CJK shows boxes for one script). Falls back to plain uGUI Text off-game / when TMP is unavailable (worst case the literal tag shows). Window surfaces only; ignored on HUD-overlay and Shadow text.
  • InputElement.RichEmoji (bool): builds a TMP_InputField (TmpRichInputField, behind the IRichInputField adapter) instead of the legacy InputField, so <sprite=N> shows as a picture while typing; one Backspace removes a whole tag (SpriteTagEdit), focusing does not select-all, submit is accepted only while editing. Falls back to the legacy field (logs [Window][emoji] RichEmoji input fell back to the plain field) if the rich field can’t be built.
  • InputElement.FocusRequest (Func<int>?): counter token — whenever the value CHANGES vs the value captured at build, the field takes focus like a click with the caret at the END (e.g. after an emoji-picker insert). Focus is confirmed on the next tick (both field types activate in their own LateUpdate) and retried; a request on a hidden/collapsed field is dropped after ~30 frames rather than grabbing the keyboard later.
  • InputElement.Placeholder (Func<string>?): dimmed hint text shown while the field is empty, polled with the window refresh and diffed (return a cached string). The RichEmoji field fills the TMP_InputField Placeholder it already had (face picked per string, so a CJK hint doesn’t draw boxes); the legacy field gets a Text placeholder (italic, same font/size/padding, half-alpha text colour) created only on the first non-empty hint, so fields without one build exactly as before. Ignored by TextAreaElement.
  • InputElement.Locked (Func<bool>?): live read-only + dimmed state (text alpha 0.45) for a “busy” field, polled and diffed. Stock readOnly on both the legacy and the RichEmoji (TMP_InputField) field, so typing/paste/delete and the default mode’s Enter-submit are blocked while focus, caret and the Get() re-seed keep working; the box keeps its size. Null = unchanged.
  • VirtualListElement.OnAtBottomChanged (Action<bool>?) / ScrollToBottomRequest (Func<int>?): VariableHeight + StickToBottom lists only. OnAtBottomChanged reports exactly the internal stick-to-bottom pin decision (within 2 px of the bottom; content that fits = true), once initially and then on each flip (≤1 refresh late) — for a “new messages” bar. ScrollToBottomRequest is a counter token (baseline = value at build) whose change FORCES the bottom pin for a refresh so not-yet-measured rows are followed until the view settles on the true bottom.
  • SelectableElement.OnRightClick (Action?): right-button-down over the row, from the same ticker hook as MeterRowElement.OnRightClick (honours FrontWindowBlocks). Never fires OnClick; the left-click path is unchanged.
  • ListElement.OnReorder (Action<int,int>?): drag-and-drop reordering of visible items (WindowInteractionTicker.Reorder.cs, ticker-polled — no uGUI drag-handler injection). ≥6 px = drag (ghost + insertion bar), else an ordinary click; fires OnReorder(from, to) with REMOVE-THEN-INSERT indices, never for a no-op; Esc or an outside drop cancels; the click after a real drag is swallowed; the enclosing ScrollRect is locked for the press. Every hit-test calls FrontWindowBlocks.
  • Reorder ghost fix (WindowInteractionTicker.Reorder.cs, MatchGhostToSource/PlaceGhost): the ghost was pinned centre-on-cursor and sized from src.rect.size (cell-LOCAL units, wrong when the cell sits under a scaled chain below the ghost’s Canvas parent). Now everything is in the ghost parent’s local space: size = the source’s world corners mapped through parent.InverseTransformPoint; anchors fixed at centre, pivot = source pivot, scale 1, ignoreLayout + any root ContentSizeFitter/AspectRatioFitter disabled; grab = InverseTransformPoint(src.position) − ScreenPointToLocalPointInRectangle(parent, pressPoint) taken from the PRESS point (not the 6 px threshold point); each frame localPosition = local(pointer) + grab. Placed in the same frame as the clone, before it renders. Drop target, insertion bar, clipping, FrontWindowBlocks, Esc-cancel and click-vs-drag unchanged.
  • IWindowHost.PrewarmText(string text) — new interface member with a default no-op implementation ({ }), so existing IWindowHost implementors keep compiling. The framework’s host queues the text (TmpGlyphPrewarm, ≤1024 texts) and rasterizes its missing glyphs ahead of layout from the window ticker’s per-rendered-frame update: ≤8 glyphs or ~3 ms per frame, face chosen by the same rule styled text uses (TmpFontAssets.FaceFor) then its fallbacks and TMP’s global fallbacks; atlas pages uploaded explicitly. Best-effort — unwarmed glyphs render exactly as before. Any thread. ⚠️ A plugin that CALLS it needs framework ≥2.26.0 (MissingMethodException on older hosts) — ship them together.
  • HitchProbe.Count(string name, int n): per-frame event counter for [Hitch] attribution, reported as name=#N on a hitch line and reset each frame (kept apart from the time buckets so a zero-ms counter is never folded into rest). Main thread only; no-op while hitch diagnostics are off. The framework’s own glyph prewarm reports its time as tmp:prewarm.
  • TMP dynamic faces now sample at 48 pt / padding 5 instead of TMP’s default 90 / 9 (TmpFontAssets.Sizing.cs): same pad/pt ratio (SDF spread unchanged), ~3.5× cheaper per glyph raster, visually equivalent at UI sizes; 1024² multi-atlas pages kept. The shipped faces use the sized CreateFontAsset overload resolved by reflection (its GlyphRenderMode lives in an unreferenced assembly) and fall back to 90 / 9 with a [Window] TMP sized … log; the system CJK / Hangul faces take the point size via the family overload (TMP picks their padding).
  • Variable-height VirtualListElement: at most 8 not-yet-latched rows are active (bound + measured) at once (MaxUnlatchedRows, WindowBuilder.VariableList.Measure.cs); further unlatched slots stay SetActive(false) until a latch frees budget, nearest the anchor first (bottom-up while pinned), so a login history batch or a tab switch fills in over a few applies instead of binding ~40 bubbles in one. Rows already in flight keep their admission; rows that latched before a width/count invalidation are exempt. Conditionals inside an inactive slot no longer poll or lazy-build (CondBinding.Gate). Trade-off: a long jump into never-shown history can show an empty viewport for ~0.1–0.2 s while rows latch.
  • Login freeze (measured 2026-10-23, worst apply:chattools.main 0.9–4.3 s → ~70 ms in-game): caused by TMP rasterizing ~60 new glyphs at pt90 inside one window apply, plus every visible row’s lazy branch building at once (and, plugin-side, synchronous avatar decodes). Fixed by the three items above together with the ChatTools plugin moving avatar decode off the apply path and calling PrewarmText for incoming messages. See KB Chat-System-Architecture.md.
  • RowElement.OnHover (Action<bool>?, init): pointer enter/leave over the row’s rect, from the window ticker’s existing hover list (TickHoversAndPulses — RectangleContainsScreenPoint + FrontWindowBlocks, false when the row goes inactive). Registered in WindowBuilder.BuildRow only when set; it adds no Image, raycast target, tint or padding, so a row with it lays out and draws exactly like one without. For hover-revealed controls that must not move anything (ChatTools’ per-message translate button). Rows that leave it null are untouched.
  • TextElement.Ellipsize (bool, init): one line, cut with a trailing “…” to the text’s own laid-out width and re-fitted when the string or that width changes (TextBinding.EllipsizeToRect + UGuiPrimitives.EllipsizeFit, a binary search over the cut length so a window-resize drag stays cheap; the text also gets a RectMask2D). Styled / RichEmoji (TMP) text uses TextOverflowModes.Ellipsis instead (StyledTextSpec.Ellipsis; a face without U+2026 hard-truncates); Shadow / HUD-overlay ignore it. For a phrase in a weighted cell next to fixed controls (ChatTools quick phrases). Texts that leave it false are untouched.
  • TextElement.CenterGlyphs (bool, init): vertically centres the DRAWN geometry in the text’s rect instead of the font line box — StyledTextSpec.CenterGlyphs → TMP TextAlignmentOptions.Midline / MidlineLeft / MidlineRight (Midline centres the mesh extents; the default Center/Left/Right are the Middle row, which centres ascender..descender). A lone <sprite=N> sits on the baseline, so under Middle it drew above its box centre (ChatTools’ emoji tab icon / ☺ button / emoji grid). No fixed offset → scales with any font size; preferred size (layout) is unchanged. TMP path only (styled / RichEmoji); plain, Shadow and HUD-overlay text ignore it. Texts that leave it false are untouched.
  • SelectableElement.Bare (bool, init): a click target with no visuals — no sprite, every tint state Color.clear (the Image stays as the alpha-0 raycast target), zero VLG padding/spacing, flexibleWidth 0 so it hugs its child; SelectedBar ignored. Click, OnHover, OnRightClick, FrontWindowBlocks and the reorder click-swallow are unchanged. For link-styled labels (ChatTools’ clickable whisper names). Selectables that leave it false are untouched.
  • SelectableElement.OnClickWithRect (Action<WindowRect>?, init): fires on a left click right after OnClick with the row’s live rect in screen PIXELS, top-left origin (same space as ButtonElement.OnClickWithRect), so a plugin can anchor a popup to the clicked element (ChatTools: channel chip, 文A language menu, “+ New chat”). Computed with RectTransform.TransformPoint of the local rect corners — folds in every scale on the chain and avoids the IL2CPP GetWorldCorners(new Vector3[4]) copy-out trap. Gated by ClickSuppressed like OnClick. SetRect takes CANVAS units: multiply by CanvasWidth / ScreenWidth. Selectables without it are untouched.
  • BubbleElement.OutlineColorFn (Func<ColorRgba?>?, init): a per-refresh 1-px rounded ring along the bubble edge (colour = ring on, alpha honoured; null = off). WindowBuilder.AddBubbleOutline adds an ignoreLayout, non-raycast, stretched Image child AFTER the content child, using WindowThemeAssets.BubbleOutline(radius) — a white RoundedTextureBaker.RoundedBordered ring (transparent interior, 1 px border) baked once per radius at the same radius as the fill sprite (≤0 → the 3-radius chip), kept across theme re-bakes and freed in DestroyAll. BubbleBinding.ApplyOutline diffs the colour, so idle bubbles write nothing. Never measured → toggling it can’t resize the bubble. Bubbles that leave it null create no ring at all.
  • VirtualListElement.RowRevision (Func<int,long>?, init; VariableHeight only; the record moved to its own VirtualListElement.cs — pure move): a per-data-index CONTENT revision. VariableListBinding stamps the revision a row latched at (_hRev); when a latched, active row’s revision differs, RemeasureRevisedRow (WindowBuilder.VariableList.Measure.cs) arms an in-place re-measure (deferred one apply, like the RowId verify, because the slot’s content refresh runs after MeasureActiveSlots), re-reads it with the same two-read StableEps confirm as a first latch, and replaces _h only on a confirmed change → one offset rebuild through the normal measuredChanged path (bottom pin / top-row anchor unchanged). Unlike the RowId verify it never drops the latch, so the row is NOT parked off-screen: it stays visible at its old height for the ~2 applies the confirm takes (content may overlap/underfill the slot that long), then snaps. Independent of RowId (a dropped RowId latch takes precedence). _remeasure is cleared by InvalidateHeights/ResetState and on re-latch. Null = byte-identical behaviour.
  • Clip-aware ticker hit-tests (WindowInteractionTicker.Clip.cs, OutsideClip): the ticker’s manual RectangleContainsScreenPoint hit-tests now also require the pointer to be inside every enabled ancestor RectMask2D / Mask of the registered cell — hover (TickHoversAndPulses: tile hover, SelectableElement hover incl. Bare, RowElement.OnHover, dropdown items), right-click (TickRightClick), raid-slot drag source/target (HitSlot/HitDropTarget), voice-click exclusion, colour-picker drag areas, render-host drag/zoom and chart pan. Before, a row scrolled half out of a ScrollRect viewport still hovered / took right-clicks over its clipped part (e.g. a whisper-list row lighting up while the pointer sat on the composer below the list). The EventSystem path (Button clicks) was already correct: RectMask2D and Mask are ICanvasRaycastFilters, so Graphic.Raycast rejects a press on a clipped part. The per-cell clip chain is resolved once and cached by native pointer (no per-frame allocation; cache cleared in Prune). FrontWindowBlocks checks are unchanged; the reorder path keeps its own equivalent viewport check. Cells with no clipping ancestor behave exactly as before.
  • (dev 2.25.5) A ResetScroll (tab/channel switch) on the variable-height VirtualListElement clears every row’s latched height (ResetState), so for the 2-3 applies it takes MeasureActiveSlots to re-latch them each row falls back to the seed/running-average ESTIMATE (the chat consumer seeds RowHeight: 28f, shorter than a real wrapping bubble). VariableListMath.BuildOffsets then packed the rows at that too-short estimate while Reposition sized each slot to its real content height — so adjacent rows visibly OVERLAPPED inside the clipped viewport until the real heights latched and the offsets rebuilt (“brief overlap before it shows correctly”). A burst of new messages hit the same path more briefly.
  • (dev 2.25.5) Fix (WindowBuilder.VariableList.cs, VariableListBinding.Reposition): a row whose height is not yet latched (!_measured[logical]) is PARKED off-screen (new OffscreenY = 1_000_000f, a large positive y — content/slots are top-anchored pivot y=1, so a big positive y sits above the viewport top, where the ScrollRect viewport’s RectMask2D clips it) instead of being drawn at its wrong estimate offset. The slot stays ACTIVE and is still sized to the estimate rowH so the VLG lays it out and MeasureActiveSlots can read its preferred height (measurement requires activeSelf, so we hide by position, NOT SetActive(false)). As each row latches, measuredChanged becomes true that apply → Reposition re-runs and snaps the just-latched rows on-screen at their true offsets; StickToBottom re-pins to the true bottom as offsets grow. Net: the viewport briefly blanks (~2 frames, ~33ms) on a tab switch instead of flashing overlapped rows; a measured row always takes the on-screen branch, so steady state and scrolling are byte-identical. VariableListMath and the VirtualListElement API are unchanged — binary-compatible, no plugin rebuild. See KB WindowBuilder-Patterns.md (VARIABLE-HEIGHT section).
  • (dev 2.25.4) 2.25.3 made the variable-height VirtualListElement height model a measure-ONCE cache to stop scroll jitter, but it latched a row’s height from the FIRST reading the slot was active for. BubbleElement’s width-solve (BubbleBinding) settles a tick AFTER that first measurement, so the first LayoutUtility.GetPreferredHeight was read while the bubble was still ~0 wide — the text wrapped to ~1 char per line → a far-too-tall preferred height that _measured[] then locked in permanently. The text corrected visually when the width solved, but the row’s reserved height stayed stuck tall → a large empty gap below every message. (The pre-2.25.3 re-measure-every-apply code self-corrected, which is exactly what caused the jitter 2.25.3 removed.)
  • (dev 2.25.4) Fix (WindowBuilder.VariableList.cs, VariableListBinding.MeasureActiveSlots): latch a height only after it is STABLE across two consecutive measurements. New per-index _provH[]/_prov[] hold the last apply’s provisional (unconfirmed) reading; a reading commits to _h[]/_measured[] only when it matches the stored provisional within StableEps (1.5px — above sub-pixel uGUI wobble, far below the pre-width-solve tall-vs-real gap). A pre-width-solve tall reading never matches the next (settled) reading, so it stays provisional and never locks in; a genuinely settled row matches its own next reading and latches on the 2nd measure, after which it is never re-measured — so 2.25.3’s no-jitter property is preserved (a settled row still never churns the offsets or scroll). While a row is only provisional it keeps using the running estimate in the offsets (no measuredChanged), so the settle window adds no offset churn. _prov is cleared alongside _measured on a viewport-WIDTH change / Count DECREASE (InvalidateHeights) and ResetScroll (ResetState), and grown with the cache in EnsureCapacity. VariableListMath and the VirtualListElement API are unchanged — binary-compatible, no plugin rebuild. See KB WindowBuilder-Patterns.md (VARIABLE-HEIGHT section).
  • (dev 2.25.3) The variable-height VirtualListElement (2.25.0 measured/wrapping list — chat logs of BubbleElement rows) re-read every visible slot’s uGUI preferred height on EVERY apply (MeasureActiveSlots → LayoutUtility.GetPreferredHeight, with a Mathf.Abs(h - _h[l]) > 0.5f re-measure branch). Sub-pixel uGUI layout jitter — compounded by BubbleBinding’s width-solve running later in the same tick (ApplyValues) and marking layout dirty, so a freshly (re)bound row was measured a tick before its wrap settled — made a SETTLED on-screen row’s measured height cross the 0.5 px threshold frame-to-frame. Each crossing set measuredChanged → rebuilt the cumulative offsets (VariableListMath.BuildOffsets) → re-drove Content.anchoredPosition.y via SetScroll, fighting the ScrollRect’s own inertia. The anchor compensation only pins the topmost-visible row, so mid-viewport rows visibly shifted (“back and forth”).
  • (dev 2.25.3) Fix (WindowBuilder.VariableList.cs, VariableListBinding): the per-data-index height model is now a measure-ONCE cache. MeasureActiveSlots skips any index already in _measured[] and the re-measure branch is gone — a settled row’s height can no longer change, so it can’t churn the offsets or the scroll. A stored height is dropped + re-measured (InvalidateHeights) only on a viewport-WIDTH change (new _lastViewportW compare — rows re-wrap → every height changes), ResetScroll (existing ResetState), or a Count DECREASE (count < _lastCount — rows dropped/filtered/rolling-buffer front-dropped → indices remap); invalidation runs BEFORE the measure so active slots re-measure the same apply and only off-screen rows fall back to the estimate. An append (Count INCREASE) keeps the cache and measures only the new tail indices. measuredChanged → the topmost-visible anchor compensation now fires only on a row’s one-time estimate→measured correction as it scrolls into view, not every tick; append, StickToBottom, and tab-switch paths are untouched. VariableListMath and the VirtualListElement API are unchanged — binary-compatible, no plugin rebuild. Known residual: a rolling buffer that front-drops WITHOUT changing Count remaps indices undetectably, leaving cached heights one row stale until the next width/shrink/reset invalidation (bounded, self-heals; the old per-apply self-heal is traded away to kill the jitter). See KB WindowBuilder-Patterns.md (VARIABLE-HEIGHT section).
  • (dev 2.25.2) 2.25.1 moved the per-request channel capture to a Harmony prefix on ZTcpClient.Send(ReadOnlySpan<byte>) (PandaChatProbe.Send.Hooks.Tcp.cs, TryCaptureHistoryChannel parsing the framed packet). In-game that prefix NEVER fired: the one-shot [ChatProbe] Send PREFIX first invocation line (emitted on the first invocation regardless of payload) had zero occurrences, so _historyChannelByCallId was never populated and every login history batch resolved batchChannel=Unknown. Root cause: the game’s own outbound RPC does not use that 1-arg ZTcpClient.Send overload — it is a plugin/helper entry (PandaWireTap.Send.cs already documents this, and on release_3.7 only the 1-arg overload exists). Lua RPCs (ChitChat chat sends + the GetChipChatRecords history fetch) go ZRpcImpl.ProxyCall(…byte[]…) → ProxyCallInternal → ZRpcImpl.SendBytes → transport, and the World channel can be TCP OR UDP/KCP (ZUdpClient.Send), which a TCP-send hook could never see. No ProxyCall overload returns the call_id (all return UniTask<IProxyReturn>), so a ProxyCall-only hook can’t key by call_id either.
  • (dev 2.25.2) Fix: capture at the transport-agnostic ZRpcImpl.SendBytes(ulong uuid, uint stubId, uint callId, uint methodId, byte[] pbData, uint pbSize, bool framePack) -> ZRpcError (new PandaChatProbe.Send.Hooks.Rpc.cs, prefix OnRpcSendBytes). It sits above the TCP/UDP split, is public + cold (PosingSendTap already patches it in release_3.7 and proved it fires; arg layout verified UuidArg=0/MethodArg=3), has no in/ref struct param (no trampoline crash), and carries BOTH the call_id and the raw pre-framing (uncompressed) protobuf body as plain params. The channel is parsed straight off the body argument via WireProtocol.ParseChannelTypeFromGetChipChatRecordsRequest (the proven pre-2.25.1 source — the retired ZRpcImpl.ProxyCall hook parsed the same bytes) and stored call_id -> channel_type in one invocation, so no thread-local/positional/cross-site correlation is needed. The call_id-keyed Return resolve (unconditional _historyChannelByCallId.TryRemove(callId) at the top of ProcessChitChatReturnPayload), the map bounding, and the _senderLastChannel per-sender fallback are unchanged. The dead ZTcpClient.Send capture prefix was removed; that overload is still resolved as TrySend’s dispatch target and its connection-close hooks are untouched. Confirm next deploy via [ChatProbe] SendBytes PREFIX first invocation, first ChitChat outbound Call observed (SendBytes), first GetChipChatRecords channel captured, and a non-Unknown batchChannel= per login batch. See KB Chat-System-Architecture.md §7.
  • (dev 2.25.1) Login chat history carries no wire channel; the framework back-fills it by correlating each GetChipChatRecords reply to the channel that was requested. That correlation was a positional FIFO (_pendingHistoryChannels, a ConcurrentQueue<int>) whose dequeue ran only AFTER the empty-batch / invalid-shape early-returns in ProcessChitChatReturnPayload. So the first requested channel whose login history was EMPTY returned early WITHOUT dequeuing, leaving its channel stuck at the queue head; the next non-empty batch dequeued that stale head and was mislabeled (e.g. empty World left “World” for the following Party batch). It also broke under out-of-order RPC replies and enqueue/dequeue count drift.
  • (dev 2.25.1) Fix: correlate by RPC call_id instead of position. The ZTcpClient.Send prefix (TryCaptureHistoryChannel, PandaChatProbe.Send.Hooks.Tcp.cs) now records call_id -> channel_type in a bounded ConcurrentDictionary<uint,int> (_historyChannelByCallId, evict-oldest via a companion order queue, both capped at MaxPendingChatCalls) — it already had the call_id and the framed request payload, so it parses channel_type there via a new zero-alloc ReadOnlySpan<byte> overload of WireProtocol.ParseChannelTypeFromGetChipChatRecordsRequest (compressed payloads skipped — a tiny GetChipChatRecords request is never compressed). The Return resolves the channel with an UNCONDITIONAL _historyChannelByCallId.TryRemove(callId) at the TOP of ProcessChitChatReturnPayload, before the early-returns, so an empty batch removes its own entry (poisoning no other) and the map never leaks; a Return with no recorded id stays Unknown and falls through to the existing _senderLastChannel per-sender hint. The now-redundant ZRpcImpl.ProxyCall channel-capture hook (PandaChatProbe.Send.Hooks.cs) and the _pendingHistoryChannels queue were retired, removing a Harmony patch from a game-critical RPC method. The live Notify path was already correct and is unchanged. See KB Chat-System-Architecture.md §7.
  • (dev 2.25.0) VirtualListElement gains two init props (additive, binary-compatible with ≤2.24.0): VariableHeight (measured rows) and StickToBottom (newest-at-bottom scroll). In VariableHeight mode the renderer measures each pooled slot’s uGUI preferred height (LayoutUtility.GetPreferredHeight after a layout pass — the same fit a BubbleElement/ContentSizeFitter performs) once it binds to a data index, keeping a per-data-index height model + cumulative-offset array; un-measured rows use RowHeight as a running-average estimate, so the scrollbar is approximate immediately and refines as rows scroll into view. The consumer drives it exactly like the uniform list (Func<int> Count, a recycled Pool, Action<int> OnWindow(first), viewport Height) — the only extra requirement is sizing the pool to cover the viewport at the shortest row.
  • (dev 2.25.0) Scroll stability: a measurement that replaces an estimate anchors to the current topmost visible row (its top edge is held under the viewport top) so the view does not jump; rows below reflow. StickToBottom pins to the bottom on append while at the bottom and preserves position when scrolled up. New pure helper VariableListMath (BuildOffsets/FirstIndex/MaxScroll, BCL-only, unit-tested) mirrors VirtualListMath. Renderer: WindowBuilder.VariableList.cs (VariableListBinding, behind the new IVirtualListBinding alongside the uniform VirtualListBinding). XML-documented (CS1591). See KB WindowBuilder-Patterns.md.
  • (dev 2.24.0) New element (additive): BubbleElement(HudElement Child) with init props FillColor (ColorRgba?, alpha honoured; null = themed menu-accent default, re-tinted on theme change), MaxWidth (0 = clamp to parent/available width), CornerRadius (0 = reuse the SelectableElement/SwatchBg chip; > 0 bakes a cached rounder sliced sprite), PaddingX (10), PaddingY (6). Background is the rounded sliced SwatchBg sprite tinted to FillColor; raycastTarget = false (click-through-neutral — wrap in a SelectableElement for clicks).
  • (dev 2.24.0) Content-hug: LayoutElement.flexibleWidth = 0 + a per-apply BubbleBinding that pins the bubble width to min(child natural preferred width, cap). The child’s natural width is wrap-independent (uGUI Text.preferredWidth), so pinning narrower never feeds back/oscillates; a vertical ContentSizeFitter grows the height when the child wraps. Needs a width-respecting parent (a RowElement); dropped directly into a ColumnElement it fills the column (same force-expand gotcha as a fixed-size icon). XML-documented (CS1591). See KB WindowBuilder-Patterns.md / Chat-System-Architecture.md §6.

2.23.1 (patch) — restores the Module Optimizer after the latest game update; no API change, no plugin rebuild.

  • Module Optimizer: clicking Optimize returns ranked module combos again. After the latest game update it had stopped showing any results.
  • release_3.7_2 added per-attribute module leveling and relocated each part’s magnitude: Mod.ModInfos is now empty at runtime; the values live in Item.ModPartLevel.Levels (MapField<int,int>, keyed by attrId — proto stru_mod_part_level.proto → message ModPartLevel { map<int32,int32> levels = 1; }). No type/field was renamed (static dump-diff identical); a pure runtime data relocation, so the old positional read (Mod.ModInfos[uuid].InitLinkNums[i] paired with ModNewAttr.ModParts[i]) returned 0 for every part and the optimizer scored every combo at ~0.
  • PandaInventoryPullReader now sources each part’s value from Item.ModPartLevel.Levels[attrId] (for each attrId in ModNewAttr.ModParts), falling back to the positional InitLinkNums[i] path for pre-3.7_2 builds. ModulePart shape unchanged — only the value source moved. Unchanged: Mod.ModSlots (equipped), the pool walk, the is-a-module filter, category lookup, all public API / domain types.
  • Framework-only; StellarModuleOptimizerPlugin needs no change (already SlotCount = 5, consumes only IInventory). Validated in-game on live release_3.7_2. PR #129.

2.23.0 (minor) — mods can mix sound into your party voice chat with your mic; chat no longer crashes or drops a message after a reconnect; and the layout editor gains a draggable toolbar with per-plugin filtering, arrow-key nudging and show/hide. Adds API for plugins (IVoiceInjection, Abstractions 2.23.0); additive, no plugin rebuild.

  • Mods can now mix their own sound — a file or generated speech — into your party voice chat alongside your microphone, so teammates hear both. Several can play at once.
  • The layout editor has a new toolbar you can drag anywhere, with drop-down menus, filtering to one plugin’s windows, and arrow-key nudging to place things exactly.
  • You can now show or hide individual overlay elements right from the layout editor.
  • “Reset” in the layout editor now also brings back anything you had hidden, and is split into “Reset filtered” and “Reset all”.
  • Windows like Settings, the data inspector and the combat-meter history now keep one position across all your layout slots instead of moving per slot.
  • Sending a chat message right after the game reconnects (switching lines, changing scenes, or recovering from a dropped connection) no longer crashes the game.
  • Chat messages sent immediately after a reconnect now go through instead of silently failing until the next message you received.
  • Fixed a multi-second freeze the first time settings were saved or you entered layout edit mode.
  • New API (additive): IPluginServices.Voice → IVoiceInjection (Available, Status, LoadFileAsync(path) WAV natively / MP3/WMA/M4A via Media Foundation, LoadPcm(ReadOnlySpan<short>, rate, channels) for TTS/generated audio, CreateSource() → IVoiceSource?, SetUplinkPolicy(disableNoiseSuppression?, disableAgc?, disableVad?, bitRateBps?)); IVoiceSource (Clip/Volume/Loop/Playing/Position, Play/Stop/PlayOnce); IVoiceClip (Duration); the VoiceInjectionStatus record. XML-documented (CS1591).
  • Backed by a process-wide native DirectSound capture hook on GCloudVoice.dll (IAT slot +0x6190D8 = DSOUND ordinal 6 DirectSoundCaptureCreate → CreateCaptureBuffer +0x18 → capture-buffer Lock +0x40), promoted into Stellar.Infrastructure.Game from the in-game-validated StellarExperimentPlugin single-clip prototype and generalised to a fixed 16-source allocation-free mixer. The Lock hook runs on GVoice’s native capture thread (no alloc/lock/log/IL2CPP, whole-body try/catch, always returns the original HRESULT). Installed at boot from BootstrapPlugin.ApplyLifecyclePatches (title screen, before login’s GCloudVoice_Init), mirroring InstallInstrumentToneRelay; a ProbeInstall fallback (opens the mic briefly) covers hot-reload late attach and is surfaced via Status, not the public API. Clips keep their source PCM and are re-resampled to the live capture format off-thread; the uplink DSP (GCloudVoice_invoke NS/AGC/VAD + GCloudVoice_SetBitRate) is applied while any source plays and restored when all stop, driven from a main-thread maintainer on the framework Update tick. Sources a plugin creates are auto-disposed on plugin teardown (PluginVoiceInjection, mirroring IHarmonyHost). DLL offsets are pinned to GCloudVoice.dll 4.3.0.253999397; guards fail safe (no patch, logged) on a version change. See docs/design/framework-2.23-voice-injection.md and KB Voice-Chat-GVoice.md.
  • Chat: IChat.Send resolves the live chat ZTcpClient on demand at send time via ZSingleton<ZRpcCtrl> (Gateway/World RPC transport); the passive packet cache + Close/CloseAndDelayDispose hooks are kept as a fail-soft fallback. A stale freed client can no longer be used (was a DEBUG-only CheckValid → access violation) and the post-reconnect send window is closed. No API change, no plugin rebuild. PRs #126, #128; KB Chat-Send-Connection-Lifetime.md.
  • Layout editor: toolbar migrated to a draggable uGUI window on a dedicated root canvas (capped at 32766); the per-plugin filter gates outline/select/drag/resize; dropdown controls (slot, selection readout, filter); arrow-key nudge with the game keyboard gated via KeyboardInputGate; per-element show/hide; Reset split into filtered/all and now restores visibility; non-HUD free-drag windows (Settings/DataInspector/launcher/CombatMeter history) persist in a global slot-independent bucket; config disk writes moved off the game thread (cfg-save 3378ms → <2ms) and the toolbar is pre-warmed to remove the first-edit-enter freeze; strings localized en/fil/id/ja/ko/th; binary-compatible (init props / internal interfaces / optional params). PR #127.

2.22.1 (patch) — clicking a mod window’s buttons no longer steals your keyboard; no API change, no plugin rebuild.

  • After clicking a button or row in a mod window, WASD moves your character again instead of typing into the chat box.
  • Every window click path now calls ClearSelectionAfterClick() (already used by the base Button/Toggle): BuildSelectable, BuildTile + pin-star toggle, the dropdown blocker, both chrome close buttons, the cooldown-tile clicker, and the meter voice/debuff cells. A clicked uGUI Button used to stay EventSystem.current.currentSelectedGameObject, and the game routes keyboard input to UI/chat while a uGUI object is selected (the launcher rail already handled this via ClearRailSelection).
  • Window Buttons also get Navigation.Mode.None (DisableKeyboardNav) against arrow/d-pad focus; that alone does not stop pointer-click selection. UGuiTextInput is untouched — text fields legitimately hold focus. PR #124.

2.22.0 (minor) — fixes window text that could occasionally turn into garbled letters, keeps centred / edge-anchored windows in place across resolutions and width changes, and lets a free camera leave clicks on the game’s own windows to the game (IInputShield.IsPointerOverGameUi, Abstractions 2.22.0; additive, no plugin rebuild).

  • Plugins with a free camera can now let you use the game’s own windows and sliders while the camera is on.
  • Fixed window text (close button, HUD-style overlays) occasionally showing garbled letters.
  • Windows that sit at the top centre, the middle or a screen edge now stay there at every resolution and after a plugin update changes their size (they could drift off centre).
  • Anchored window layouts (WindowAnchor ≠ TopLeft): a save also stores the offset of the window’s anchor point from the canvas anchor point in design units (slots.<n>.windows.<id>.<res>.anc/.ax/.ay, beside the unchanged x/y/w/h — rollback-safe), and every restore re-places the window from that offset at the current canvas, UI scale and size (AnchoredPlacement, WindowService.Anchor.cs). A legacy exact-resolution save keeps the anchor point it had. Root cause: a Top-anchored window kept its saved absolute left edge when its width changed (Photo Studio’s free-camera HUD 800 → 1240 px sat 220 px right of centre at 2560×1440). Pinned in WindowAnchorLayoutTests (5 resolutions × 3 UI scales).
  • IInputShield.IsPointerOverGameUi: one EventSystem.RaycastAll per rendered frame (only when asked); true when the TOP-MOST hit sorts below Stellar’s band (sortingOrder < 32749), so a Stellar window over a game window answers false. With STELLAR_DIAGNOSTICS=1 every flip logs [FreeCam] pointer over game UI=yes|no hits=N top=<object> order=<n>. Hidden game HUD may still answer the raycast — consult it only while the game interface is shown.
  • WindowRenderer.OnFontTextureRebuilt no longer filters to MenuFont: it refreshes, on every live window, the legacy Text bound to whichever font rebuilt (WindowToken.RefreshFontTexture(Font)). HudOverlay text intentionally stays on ConfigureText’s builtin font (native-HUD look), and that font’s atlas repacks were previously ignored → stale glyph UVs.
  • Window chrome close buttons (✕, title-bar and overlay-corner) and the legacy-Text title fallbacks (title bar, Tracker/Party overlay) now get MenuFont at build time instead of only on the first theme switch.
  • New rate-limited (≤1/s) [Window] font atlas rebuilt: … log line: font name, atlas size, Text refreshed, suppressed count.

2.21.0 (minor) — Korean UI language. Adds "ko" as a language code plugins can receive and WindowSpec.TitleProvider for live-localized window titles (Abstractions 2.21.0); additive, no plugin rebuild. Plugins can also see where another player is (zone, line and position) once their profile card has been opened (SocialSnapshot.Location, additive).

  • Korean (한국어) is now a language option — pick it under Settings → Themes → Language, or keep “Follow game client” on a Korean game client.
  • The Stellar launcher’s Plugins and Settings labels now follow your language.
  • More of the Stellar settings and theme editor now follow your language.
  • Pinned launcher tiles stay pinned after plugins update.
  • Hotkey names in Settings now follow your language.
  • Plugin names in Settings now follow your language.
  • Plugins can now show where another player is — their zone, line and spot on the map — once you’ve opened that player’s profile card, even when they’re far away or in a different zone.
  • Follow game client now picks your game’s language reliably (it could fall back to English).
  • Coloured text on HUD bars, windows and notifications is no longer blurred by its shadow.
  • Hotkeys with no key set now say so in your language.
  • Turned-off plugins keep their proper name in Settings instead of a file name.
  • Twin Striker gear details (advanced stats) now show correctly.
  • New ko catalog code; plugins ship Lang/ko.json (embedded as <Ns>.Lang.ko.json). The framework’s own UI ships a full Korean catalog (Stellar.Infrastructure/Lang/ko.json).
  • Supported languages now come from one list (UiLanguages) shared by the engine, resource scan and Settings dropdown; a test fails the build if a listed language lacks a complete catalog.
  • The client-language mapping (ClientLanguageLatch.SupportedLanguage, formerly ClientLanguageProbe) maps LanguageType.ko = 4. Hangul font coverage: Noto Sans CJK KR + Malgun Gothic appended to the END of the OS-font chain (OverlayFontFamilies.Chain, used by WindowThemeAssets), and Malgun Gothic is attached as a TMP fallback asset of the chosen CJK face (TmpFontAssets) — Yu Gothic UI / Meiryo carry no Hangul, so on real Windows Korean styled text would otherwise render as boxes. On Proton, Source Han Sans already covers Hangul.
  • Pre-release font regression caught in owner testing (never shipped): the first Korean pass inserted Noto Sans CJK KR + Malgun Gothic BEFORE the Latin tail of the OS-font chain. Font.CreateDynamicFontFromOSFont takes each glyph from the first family that has it, and Malgun Gothic also carries Latin — so on a Proton prefix with Liberation Sans + Arial + malgun.ttf (no Noto/DejaVu) every English glyph switched from Liberation Sans to Malgun Gothic, and on real Windows Malgun would have replaced Arial. The Hangul families now sit after “Arial”, so Latin/Thai/Japanese resolve exactly as in 2.20.0 and only glyphs no earlier family has (Hangul) fall through. The chain moved into a Unity-free OverlayFontFamilies type so FontFamilyOrderTests can pin both rules (every Latin family precedes every Hangul family; the 2.20.0 chain is an unchanged prefix). The TMP path (TmpFontAssets) is unaffected: Latin styled text uses the shipped Noto/Thai faces, and Malgun Gothic is only the last CJK candidate / a Hangul fallback asset of the CJK face.
  • LauncherView’s “PLUGINS” section label and “Settings” tile were hard-coded English in every language — missed by the Korean pass because they don’t go through a Settings panel. Fixed: LauncherView now takes an ILocalization text (same pattern as ThemesPanel/PluginsPanel), resolved each frame via _text.T("launcher.plugins") / _text.T("launcher.settings"); wired from Wiring.Launcher.cs using the existing _frameworkLocalization. New keys in all six catalogs.
  • Remaining framework hard-coded English, found from an in-world Korean check: the Settings hub window title + its Shift+Home hotkey description (settings.window.title/settings.hotkey.toggle, resolved in Wiring.Settings.cs via _frameworkLocalization); the theme-editor’s colour-slot labels (Accent, Panel background/accent/border, Warning, HUD accent — theme.color.*), Edit/Reset/Remove buttons and the two name-validation errors (ThemeEditorBody/.Describe.cs); the Themes tab’s button/scrollbar style names (Outline/Filled/Glass, Thumb/Track — themes.style.*), preset names (Default/Dark/Light/Crimson — themes.preset.*, display label only, never the persisted ThemePreset value) and the Stamina preview caption (ThemesPanel.cs; “HP” stays a kept symbol); the Shift+` layout-edit toolbar (heading, filter chips, Slot/Selected/Reset selected/Exit — layout.toolbar.*, reusing hotkeys.filter.all/tab.gameui/common.resetAll where the text already matched) and the Settings → Game UI list + its edit-mode outline label (10 native-UI element names — gameui.entry.*). FrameworkColorRegistration.RegisterAll runs in Load() before the hot-update assemblies (and so the real “follow” client language) are resolvable, so it still registers the English fallback label; a new ColorRegistryService.Relabel + FrameworkColorRegistration.RelabelAll re-applies the correct label, and ThemeEditorBody (not Host, not a per-tick poll) owns WHEN: the first relabel is folded into its own slot-list cache refresh (SlotAt), which runs only when this editor’s element-tree Funcs are actually pulled by WindowService — a pull that is skipped entirely while the Settings window is hidden (if (!e.Visible) { ParkOrDestroy(e); return; }, no value-pull at all) — so this relabel’s first client-language read happens only after the player has opened Settings, never merely “N ticks after boot”; the second trigger is a later explicit LanguageChanged switch. (An earlier pass of this fix polled it from every framework tick regardless of window visibility, which still read the client language before the game finished its own init — caught in owner review and corrected.) A new IThemeOverrides.Revision counter (bumped by Register/Unregister/Relabel) fixes the editor’s slot-list cache, which was keyed on SlotCount alone and so missed a Relabel (the count never changes); a small pure SlotCacheRefresh.ShouldRefresh(count, revision, cachedCount, cachedRevision) helper in Stellar.Application pins that decision with a test the inline ThemeEditorBody check alone couldn’t get (Unity types block unit-testing that class directly). The row prefix for the framework’s own colour slots (“Theme · Accent”) is display-mapped to the active language (theme.owner.framework) without touching the Owner identity field the picker/system-slot checks compare against. LayoutEditorOverlay takes its ILocalization via a new SetLocalization setter (its constructor is already at the 6-dependency cap), wired from Wiring.Settings.cs alongside SetNativeUi/SetWindows. NativeUiAllowlistEntry/NativeUiEntryDescriptor now carry a DisplayNameKey (a gameui.entry.* catalog key) instead of literal display text; GameUiPanel and the layout-editor’s native-UI outline label resolve it through ILocalization at render time. (The earlier known limit — Settings hub title and hotkey descriptions baked once at wiring — is fixed: see the WindowSpec.TitleProvider and framework-hotkey relabel notes below.) Left English (reasons in the task report): the perf-harness overlay (stellar.perf-overlay, dev-only diagnostic, gated on PerfProbe.IsEnabled); the Themes-tab live preview’s decorative sample data (“Lv 78”, “Ribery / Wind Knight” — mock character name/class, same category as its neighbouring numeric placeholders); the “Stellar” wordmark and the ✕/▾ glyphs (already-established intentional exceptions).
  • Framework hotkey descriptions follow the language: the five actions the framework declares for itself (framework.layout-edit, framework.hud-toggle, framework.hud-hold, framework.perf-toggle, framework.settings-toggle — ids unchanged, now constants in Stellar.Application.Services.FrameworkHotkeyIds because they are persisted config keys) are declared during wiring, before hot-update / Game.Init, so they keep an ENGLISH description at declaration — DeclareSettingsHotkey previously called T("settings.hotkey.toggle") there, an early client-language read in OnHotUpdateReady that could latch the wrong language index for the session; it now declares English too. (The hub’s window TITLE was a second eager read in the same WirePhase9Ui — see the WindowSpec.TitleProvider note; with both fixed, no framework wiring path reads the client language before Settings is shown.) A new internal HotkeyService.Relabel(id, description) replaces only the description (binding, suggested default, callback and persisted config untouched; unknown id = no-op; IHotkeyAction.Description is read live by the panel, so no cache/revision is needed), and Stellar.Infrastructure.UI.SettingsPanels.FrameworkHotkeyLabels maps each id to a catalog key (hotkey.framework.* + the existing settings.hotkey.toggle). HotkeysPanel owns WHEN, same pattern as the theme-colour labels: the first relabel is folded into its action-row label Func (RowLabel), which WindowService only pulls while the Settings window is shown with the Hotkeys tab branch active (hidden windows are parked with no value-pull; Conditional branches build lazily), and again on every ILocalization.LanguageChanged. Nothing on a per-tick path (PollCaptureUgui, HotkeyService.Tick) reads the language. The perf-overlay toggle’s description is included because it costs one map entry. Pinned by HotkeyRelabelTests (Relabel touches only the description; unknown id no-op; the map covers exactly FrameworkHotkeyIds; every key exists in all six catalogs; ids equal the shipped persisted values).
  • WindowSpec.TitleProvider (Abstractions, additive) + WindowSpec.DisplayTitle: an optional live-localized display title, mirroring LauncherEntry.TitleProvider (Title stays the fallback; identity is Id). The window chrome (WindowBuilder.BuildTitleText, and the tracker/party overlay chromes) reads it when it BUILDS the window — which WindowService does only once the window is first shown — and the title-bar and tracker/party overlay chromes re-read it in a reskin action, which runs on InvalidateTheme (theme change and LanguageChanged), never per frame; a throwing provider falls back to Title and is logged once per window id. docs/plugin-development.md § Localizing now tells plugin authors to localize window titles / launcher tiles via TitleProvider and never call T() at registration. The Settings hub now registers with Title “Stellar Settings” + TitleProvider → settings.window.title (SettingsHubSpec, Infrastructure), removing the last eager client-language read in OnHotUpdateReady (RegisterSettingsHub’s T("settings.window.title")) and letting the hub title follow a live language switch. The hotkey relabel trigger moved into FrameworkHotkeyRelabeler (constructed by HotkeysPanel, which is not unit-constructible — its capture partial loads UnityEngine). Pinned by RenderDrivenRelabelTests (counting fake ILocalization: building the hub spec and the relabeler performs no T(); first row render relabels once; LanguageChanged relabels again).
  • Plugin names in Settings (Plugins tab, Hotkeys group headers, Performance → per-plugin update rate) are display-mapped to the plugin’s own localized launcher tile: new internal PluginDisplayNames (IPluginDisplayNames, Application) returns the DisplayTitle of the FIRST launcher entry that plugin registered, else its internal name. Ownership is recorded at registration: a new PerPluginLauncher (same decoration as PerPluginHotkeys, wired through PerPluginScope.Launcher by PluginHost) forwards ILauncher.Register to LauncherRegistry via the internal ILauncherOwnedRegistrations sink tagged with the plugin guid (per-INSTANCE, reference-keyed: LauncherEntry is a record). LauncherRegistry‘s dispose now removes by reference, so disposing one of two value-equal entries can no longer evict the other plugin’s. Resolution is render-driven only (the panels’ row/header Funcs, which WindowService never pulls for a hidden window); a throwing TitleProvider falls back to the internal name, logs once, and is not invoked again for that plugin. A plugin that disposes its launcher tile when disabled keeps the last title it showed while disabled, until a language switch (then its remembered declared name — see the disabled-plugin note below). DISPLAY ONLY: ids, enable/disable, config keys, rate prefs, logs, collapse state and sort order all stay on the internal identity (Hotkeys groups still sort by plugin guid, the Plugins/Performance lists keep registration order) — so a list does not reshuffle when the language changes. The panels take the resolver as an init property (DisplayNames), not a constructor argument, keeping their constructors under the STELLAR0004 cap; WirePhase9Ui builds them in a new BuildSettingsPanels helper (STELLAR0002). Not covered: theme-editor colour-slot owner prefixes (the owner there is a plugin-chosen key prefix, not plugin identity). Pinned by PluginDisplayNamesTests.
  • Eight released plugins (AutoFishing, PhotoStudio, RaidManager, Wardrobe, CustomProfileImage, AutoGather, MinimalNameplate, LoadoutSwitcher) used to pass a TRANSLATED string as LauncherEntry.Title; their new builds (this i18n train) pass a fixed English Title + a TitleProvider for display instead. LauncherRegistry/LauncherPrefs persist pins keyed by Title (LauncherRegistry.cs, LauncherPrefs.cs), so a ja/th/id/fil user who pinned one of these under its old translated title would silently lose the pin on update. Fixed: LauncherRegistry.Register now calls a new LauncherPrefs.MigratePinIfNeeded(entry.Title, entry.DisplayTitle) — a pure LauncherPinMigration.Migrate decides whether the saved pin set holds the OLD displayed title but not the new Title and, if so, rewrites that one entry in place (same position) to the new Title; a no-op (no allocation) in the steady state, via two HashSet.Contains checks before anything is converted to an ordered list. If a user had somehow already pinned under both the old and new title, the stale old one is dropped rather than leaving a duplicate. Reading entry.DisplayTitle (which invokes the plugin’s TitleProvider) synchronously inside Register is deliberate, not a new early read: it reproduces the exact moment in plugin load the OLD build read its (translated) Title at, which is what makes the saved key match, and every TitleProvider in the current catalog is itself just _loc.T(key) already resolved no later than this point by the plugin’s own Register call. Because it runs plugin code, LauncherRegistry.Register now takes an IPluginLog (fail-safe like WindowService.SafeApply’s ShouldRender guard): a throwing TitleProvider is caught, logged once, and only skips that entry’s migration — it can never abort the plugin’s Register call. A collision guard skips migration entirely when the stale displayed title is actually another already-registered entry’s own Title (not reachable with today’s catalog — every entry has a unique Title and DisplayTitle in every shipped language — but a future name clash must not silently steal or drop a DIFFERENT plugin’s pin). Pinned with LauncherPinMigrationTests (pure helper) and LauncherRegistryTests (end-to-end through Register, including a reload-from-config check that the migration was actually persisted, a throwing-provider case, the collision guard, and a steady-state “no Save” assertion).
  • Follow-game-client latch fix (pre-existing since at least 2.20.0): PandaClientLanguage cached the FIRST LocalizationMgr.CurrentLanguageTypeIndex read ≥ 0, but that static’s backing field reads 0 (zh_Hans) until the game’s LocalizationMgr initialises — after the framework wires its UI — so a wiring-time T() read latched index=0 designLanguage=True for the session (measured on an en_TH client and a ja client): follow served English and the Chinese NameDesign fallback was armed. Now Stellar.Application.Services.ClientLanguageLatch owns the decision: reads are a field read that never touches the game and never latch (unknown → "en", IsDesignLanguage false); a non-zero value latches whenever seen (only the game writes one); a 0 latches only on a game signal — a postfix on the game’s own setter (set_CurrentLanguageTypeIndex + SetLanguage, which also tracks an in-game switch) or the Game.OnLogin backstop (character select). A signal only records the index and sets a pending flag (it runs inside the game’s setter postfix); the framework tick’s un-gated drain (ClientLanguageLatch.DrainPendingChange, a flag check) raises IClientLanguageProbe.Changed on the main thread, and LocalizationEngine raises LanguageChanged when follow’s resolved code actually changes — never from a T() read or inside game code. Both LanguageChanged raise paths (Settings switch, client change) share one per-handler-guarded helper. PandaGameDataProbe reads the latch through the read-only IClientLanguageInfo port. PandaClientLanguage is now only the raw IClientLanguageReader. Verified on the test client: hook-install read raw=0, then source=game-setter raw=11 right after Game.Init, before the title screen UI. Pinned by ClientLanguageLatchTests.
  • SocialDataReader now parses SocialData.scene_data (field 10) instead of skipping it: map_id, scene_layer, line_id, pos, scene_area_id, level_map_id, level_pos, level_area_id (field 19, signed). New float reader WireProtocol.TryReadFloat (wire type 5) in Stellar.Wire.
  • New SocialSnapshot.Location (SocialLocation?) — an init-only property, not a positional ctor parameter, so plugins compiled against the old SocialSnapshot constructor still bind. null = the reply carried no scene_data; a present-but-zeroed value is kept distinct. SocialLocation adds ReceivedAtMs (server-now ms when the reply arrived; 0 pre-sync) and CurrentSceneId / CurrentPos / CurrentAreaId, which prefer the level_* trio (observed in-game: level_map_id/level_pos are live, map_id/pos stay at the last saved world spot, e.g. while the player is in a dungeon). Position.dir was always 0 in-game, so there is no facing for far players.
  • Only full-mask replies (the ID card fetch, mask 0) carry scene_data; nameplate/avatar thin-mask replies do not. SocialDataCache therefore carries the previous Location forward when a newer reply for the same char has none (a present-but-zeroed one still replaces it), and stamps ReceivedAtMs from the framework’s interpolated server clock (injected in Wiring.Core, read lazily). IEntityDetail.RefreshSocialSnapshot already requests mask 0, so it returns a location too.
  • Diagnostics: [SocialLocation] char=… name=… present=… map=… layer=… line=… pos=(…) dir=… area=… levelMap=… levelPos=(…) levelArea=…, logged by PandaSocialDataProbe once per change per char.
  • Tests: SocialDataReaderTests (present / empty / absent scene_data, field 19, Current*) and SocialDataCacheTests (carry-forward, stamping, zeroed replaces, no clock → 0).
  • Settings → Hotkeys: the unbound cell ([ unbound ]) resolves hotkeys.unbound (new key, all six catalogs); HotkeysPanel drops its per-action binding-label cache on LanguageChanged. Disabled plugins no longer list under their assembly name: PluginRegistry remembers each plugin’s declared Name from its last successful enable (plugins section, key name.<id>, written only when it changes; a save failure only logs) and seeds a later boot’s disabled slot with it; PluginDisplayNames keeps the last localized tile title it resolved for a plugin whose tile was disposed by disabling it (ForgetRemembered on LanguageChanged — the remembered title is in the old language); a plugin never constructed on this install shows PluginNameFallback.FromAssemblyName (StellarMahiruUtilityPlugin → Mahiru Utility). Display only — ids, config keys and enable state are unchanged. Pinned by PluginRegistryDisplayNameTests / PluginDisplayNamesTests.
  • ProfessionSpecs.TalentSchool: Twin Striker’s two specs (30001 Formless, 30002 Crimson) mapped to talent-school ids 124/125 — data/StarResonanceData/tables/TalentSchoolTable.json (release_3.7) has no row 124, and 125 is “Hand Cannon” (an unrelated school). Fixed to the real ids, 128 (“Formless Spec”) and 129 (“Crimson Spec”); every other sub-profession → school mapping was checked against the table and is correct. This table feeds EquipAttrSchoolLib.TalentSchoolId-gated gear rolls (GameDataEquipService/PandaGameDataProbe advanced-stat resolution), so a Twin Striker’s spec-dependent advanced gear rolls were being matched against the wrong (or a nonexistent) school. Pinned by ProfessionSpecsTalentSchoolTests (all 18 known sub-profession ids against an embedded release_3.7 table snapshot, plus a local-only cross-check against the live JSON when the data submodule is present).

2.20.0 (minor) — plugins can hide everything the game’s own photo screen can hide, and use the [, ] and backslash keys as hotkeys. Adds API for plugins (Abstractions 2.20.0); additive, no plugin rebuild.

  • Photo plugins can now hide each thing the game’s own photo screen lists on its own: you, your Spirit Echo, other adventurers, friends, party, guild, non-players, enemies, weapons, collectibles and other players’ Spirit Echoes.
  • Hiding friends, your party or your guild now really hides them, even while other adventurers stay visible. A hidden group always wins: a guild mate who is also your friend is hidden when you hide your guild. Party members stay visible while you show your party.
  • Hiding weapons now hides every player’s weapon, not only yours, and they stay hidden when a weapon is swapped or a player comes back into view.
  • The [, ] and backslash keys can now be used as hotkeys.
  • New VisibilityLayers (one bit each, through ISceneVisibility.Hide like every layer): SelfCharacter (1024), OwnSpiritEcho (2048), Strangers (4096), Friends (8192), Party (16384), Guild (32768), NonPlayers (65536), Enemies (131072), Weapons (262144), Collectibles (524288), OtherSpiritEchoes (1048576); sets VisibilityLayerSets.PlayerGroups (the four player groups) and VisibilityLayerSets.World (every world layer). Each drives the game photo screen’s own CameraFrameCtrl.SetEntityShow type, transcribed from its show list (camerasys_data.lua ShowEntityCfg): Oneself 1, SelfPet 14, Stranger 6, Chum 2, Team 3, Union 4, FriendlyNPCS 7, Enemy 9, WeaponsAppearance 10 (the game’s Weapon toggle never writes AngelWeapons 8), Collection 12, OtherPet 15.
  • Legacy layers are unchanged in value AND meaning: OtherPlayers = the master switch 11, OtherPlayers | KeepParty = Stranger + Chum + Union, Self = Oneself + SelfPet. Plugins built against 2.16–2.19 behave exactly as before. A new plugin can split “Me” into SelfCharacter / OwnSpiritEcho, and replace KeepParty with Strangers | Friends | Guild.
  • The game shows a player while ANY group they belong to is shown, and OtherPlayers (11) is checked before the groups: while it is hidden no group brings anyone back. Anyone no shown group rescues falls back to Strangers (Nearby), so hiding all four PlayerGroups hides every other player (static RE of ZEntityMgr.isCharVisibleBySource).
  • Per-character hides (the game’s switches cannot express them): Friends / Party / Guild hide a player who is in ANY hidden group (hide wins) — even while Strangers is shown, and even when another group they belong to is shown; the one exception is a party member, who stays visible while Party is shown; Weapons hides every other player’s weapon on top of the game’s own (local-only) switch. Body = ZEntityHelper.SetModelRenderVisible(entity, false, (EVisibleSource)28, withSummon:false, withEffect:true) — a private bit of the per-source mask no game path writes; weapon = ZModelHelper.SetVisilbe(model, 0x6000, false, EModelAlphaSourceType.EPhoto) (every game EPhoto writer targets the local player only). Event-driven: one pass over ZEntityMgr.CharIdList on a request change / re-assert / membership change (party roster, LuaDataMgr friend + guild caches), a postfix on ZEntityMgr.checkIsRenderVisible for players entering view and on WeaponModelComp.onWeaponModelLoaded for rebuilt weapons (re-applied next tick); hooks install on first use. Release shows back only the characters the framework hid (CharacterHideLedger). Rules: CharacterHideRules (truth table pinned in CharacterHideRulesTests).
  • EntityShowPlan.TryHideTypeFor now maps the five counters measured on the owner’s client and read from the native switch table: FriendlyNPCS 7 → Npc 1, Enemy 9 → Monster 2, Team 3 → Team 4, Collection 12 → Collection 9, OtherPet 15 → OtherPet 13 (a counter reset under a held hide is now re-hidden for them too). Me (Oneself 1) and Weapon (WeaponsAppearance 10) are per-entity on/off flags, not counters (EntityShowPlan.IsFlagType): every re-assert (game photo screen closed, scene entry, local player re-created or its weapon rebuilt) re-writes them (RewriteHeldFlags), idempotently. New diagnostics lines: [PhotoVis] flag re-assert types=[…], [PhotoVis] characters pass=…, [PhotoVis] character entered …, [PhotoVis] weapon rebuilt …, [PhotoVis] local player rebuilt …, [PhotoVis] membership changed ….
  • Internals: the visibility backend now drives every world layer through ONE EntityShowPlan holding the union of the requested layers’ camera types (EntityShowTargets), so two layers sharing a type (Self + SelfCharacter) hold it once; a layer is reported in Hidden only when every type it needs is held. The party refresh (ForceRefreshCharVisible) now runs while any player-group type is held without the master switch. The diagnostics line [PhotoVis] holds after Self … became [PhotoVis] holds after entity write target=[…]: … and covers every world layer.
  • New IHotkeys.IsActionHeld(string actionId) — the level query the framework’s own hold-to-hide-HUD already used, now for plugins (poll it from Update for repeat-while-held). Default-implemented (returns false) so existing test doubles still compile.
  • New StellarKeyCode.LeftBracket (91), Backslash (92), RightBracket (93), Unity KeyCode values; the input gateway polls them like every key, and a chord captured in Settings → Hotkeys now saves and displays by name.
  • Dev tooling: tools/install-stellar.sh now copies DLLs with cp --remove-destination (a new inode), so a deploy into a running client never rewrites the copy the game has mapped.

2.19.1 (patch) — expired potion and food buffs leave the meter again. No API change, no plugin rebuild.

  • Potion and food buffs now disappear from the CombatMeter’s Buffs & Debuffs icons when they run out. In 2.19.0 they could stay there after expiring.
  • BuffEffectSyncReader: a RemoveLayer(6) that leaves no layers (no payload, or a payload whose Layer is 0 / absent) now removes the buff; one that leaves layers is still an upsert (the 2.19.0 re-eat time extension). 2.19.0 upserted EVERY payload-carrying RemoveLayer, but the consumable’s final expiry also arrives as RemoveLayer + payload with no layers left, so the expired buff stayed in ICombatLookup.BuffsFor forever. Pinned by BuffEffectSyncReaderTests (re-eat keeps, zero-layers removes).
  • Diagnostics: with STELLAR_DIAGNOSTICS=1, every raw BuffEffect is logged as [CooldownBar][diag] raw entity=… type=… uuid=… payload=… payloadUuid=… layer=… dur=… create=… (BuffEventBatch.Trace, collected only when diagnostics are on).

2.19.0 (minor) — one-line and multi-line text boxes for plugin windows, plus per-row bar colours, and re-eaten potion/food buffs no longer vanish. Adds API for plugins (Abstractions 2.19.0); additive, no plugin rebuild.

  • Plugins can now use one-line text boxes that stay one line. Long or pasted text scrolls sideways instead of making the window grow.
  • Pressing Enter in these one-line boxes no longer briefly opens the game chat.
  • A new multi-line text box for plugins, with a scrollbar and mouse-wheel scrolling. It can also be read-only, so you can select and copy its text without changing it.
  • Bars in plugin lists can now change colour on each row, for example red for a boss and yellow for an elite.
  • Eating a potion or food again to add more time no longer makes that buff disappear from the CombatMeter’s Buffs & Debuffs icons, for you and for party members. The buff stays and shows its longer time.
  • Buff fix: BuffEffectSyncReader now treats a BuffEffect of type RemoveLayer(6) that carries a buff payload (AddBuff/BuffChange) as an UPSERT, not a removal. The game re-applies a stacking consumable on the SAME buff uuid and announces the extended duration as RemoveLayer + BuffChange. The reader used to drop that payload and remove the still-live buff, so ICombatLookup.BuffsFor, CombatEvent.BuffChanged (a spurious Removed) and everything downstream (CombatMeter’s buff spool and uploads) lost it until the next AOI re-seed. Measured on a real spool: Potion 2033179 was “removed” at the re-eat, then expired by the game at create + 2×600 s. Remove(2) still removes, and a bare RemoveLayer with no payload keeps the old removal behaviour. Pinned by BuffEffectSyncReaderTests.
  • New InputElement.SingleLine (init, default false; existing fields unchanged). A true one-line field that never grows: it uses uGUI LineType.SingleLine, because MultiLineNewline makes InputField.EnforceTextHOverflow() force Wrap. Long text scrolls sideways in uGUI’s draw window, clipped by a RectMask2D. Pasted \r/\n are stripped in onValueChanged and forwarded as a change, never a submit. Enter submits AND ends editing (one press = one submit). The field deactivates while Enter is still held, and the keyboard gate samples IsFocused on the throttled tick, so a submit arms a grace: UGuiTextInput.IsFocused stays true while Enter/KeypadEnter is held plus 0.15 s after release, and the game never opens chat. The grace also covers a submit that hides (parks) the window. Esc and click-away blur report unfocused immediately. Validated in-game.
  • New TextAreaElement(Func<string> Get, Action<string> OnChange, float Width = 260f) : HudElement, with Lines (init, default 4; the visible line count sets the fixed box height) and ReadOnly (init). Enter inserts a newline and keeps focus. There is no submit: give the window its own button that reads the buffer captured from OnChange (full text, newlines kept). The box is a ScrollRect (themed scrollbar, mouse wheel, 8 px / 6 px inner padding) around a field that grows to its wrapped text, so uGUI’s draw window never slices it. A focused caret move or edit scrolls the minimum needed to keep the caret line in view. Caret and selection are clipped to the viewport with CanvasRenderer.EnableRectClipping, because RectMask2D doesn’t clip InputField’s raw caret renderer. ReadOnly maps to InputField.readOnly: focus, caret, selection, Ctrl+A and Ctrl+C work; typing, paste, cut and delete are blocked. Get still replaces the text and may echo through OnChange, so pass a no-op there. The read-only background is slightly more translucent. When the text fits, the wheel over the box does not reach an enclosing ScrollElement. Built; only the no-growth layout is validated in-game so far.
    new TextAreaElement(() => _draft, s => _draft = s, Width: 320f) { Lines = 6 },
    new ButtonElement(() => "Import", () => Import(_draft))
  • Layout fix: uGUI InputField is itself an ILayoutElement (priority 1), and on a priority tie LayoutUtility takes the MAX, so a sibling LayoutElement at the default priority could not stop wrapped text from growing the field (height, or width once it overflows). Fixed-box fields (SingleLine, and the outer box of TextAreaElement) now pin layoutPriority = 2. The default InputElement mode keeps priority 1 and is unchanged.
  • New BarElement.FillColorFn and BarElement.LabelColorFn (both Func<ColorRgba?>?, init, default null). They are evaluated per refresh, so a pooled or recycled list row can follow the item it currently shows; the static Fill / LabelColor are captured once at build. Returning null falls back to Fill, or to LabelColor and then white. FillColorFn is honoured on both the BarStyle.Modern and the Default window bar paths; LabelColorFn only on Modern (the primary left/inside label).
  • Internal file-size splits, no behaviour change: WindowBuilder.WindowToken moved to WindowBuilder.Token.cs, UGuiTextInput.Build was split for the 50-LoC method gate, and the TextArea mode lives in UGuiTextInput.TextArea.cs.

2.18.0 (minor) — a two-axis pad control for plugin windows. Adds API for plugins (Abstractions 2.18.0); additive, no plugin rebuild.

  • A new control for plugins: a square pad you click or drag to set two values at once — for example, where a character looks in Photo Studio.
  • Dragging inside a colour picker (the colour square or the hue bar) no longer scrolls the window at the same time.
  • Drag sink: UGuiPrimitives.AddDragSink puts a non-interactable Slider (no target graphic, transition and navigation off) on the raycast target of the XY pad and of the colour picker’s SV square and hue bar, so uGUI drag events stop there instead of bubbling to the window’s ScrollRect; the mouse wheel still scrolls the window over them. The pointer itself is still read by the window interaction ticker.
  • New XYPadElement(Func<(float X, float Y)> Get, Action<float, float> Set, float Min = -1f, float Max = 1f, Func<bool>? Enabled = null) : HudElement, with Size (init; square side in px, 0 = fill the cell width) and GridLines (init; divisions per axis, default 8; the centre crosshair is always drawn). X grows right, Y grows UP (the top edge is Max). A press or a drag anywhere on the pad sets the value from the pointer, clamped; Set runs on press and on every drag frame, like SliderElement (no release callback — persist from Set). Get is poll-diffed, so the dot follows external changes; Enabled false dims the pad and ignores the pointer. Window surface only (like the slider). Pointer mapping: Stellar.Application.Services.XYPadMapping (tested); the uGUI builder is WindowBuilder.XYPad.cs (drag via the window interaction ticker, as the colour picker’s SV square).
    new XYPadElement(() => (_aim.X, _aim.Y), (x, y) => { _aim = new(x, y); SaveAim(); }) { Size = 120f, GridLines = 8 }

2.17.1 (patch) — stable release of the 2.17 line. Identical code to the 2.17.0 testing build; the number moves only because 2.17.0 was already published to the testing channel and a taken version is never re-minted. No API change; binary-compatible with plugins built against 2.17.0.

  • Stable release of the 2.17 line: ReShade support for Photo Studio. With Photo Studio 1.5.1 you can install ReShade from Photo Studio’s page in the Stellar launcher (this needs launcher 2.1.1), pick effect packs inside Photo Studio, and turn effects on and off there. Your photos get the same effects you see on screen.
  • Effects that only work at your screen size (many bloom, sharpening, depth-of-field and AcerolaFX effects) are drawn at the photo’s own size in 2x and 4x photos and in other photo shapes, so they look right. Big photos no longer make such an effect switch itself off on screen.
  • Portrait, square and wide photos turn off depth-based effects for that photo only, so nothing is drawn in the wrong place. If ReShade is not ready in time, the photo is taken without its effects and Photo Studio tells you so.
  • Promotion only — no source change besides FrameworkVersion.Value 2.17.1 (and its exact-version test pin). What the 2.17 line adds (IPluginDownloads, IReShade, IReShadeUniforms, CaptureRequest.ApplyReShade, CaptureResult.Notes, isolated capture with bridge 1.1.0) is under the 2.17.0 entry below.
  • 2.17.0 cannot be re-used for the stable publish: Stellar-2.17.0.zip is already on the CDN under the bundle-immutability guard and a GitHub pre-release tagged v2.17.0 exists, so the stable promotion rides a patch bump.

2.17.0 (minor) — ReShade support for plugins: effects live and in photos, plus checked downloads into a plugin’s own folder. Adds API for plugins (Abstractions 2.17.0); additive, no plugin rebuild.

  • With Photo Studio 1.5.0 or later, you can install ReShade from Photo Studio’s page in the Stellar launcher (this needs the launcher update), pick effect packs inside Photo Studio, and turn effects on and off there. Your photos get the same effects you see on screen.
  • Some effects (many bloom, sharpening, depth-of-field and AcerolaFX effects) only work at your screen size. With the updated ReShade bridge, 2× and 4× photos and photos in other shapes are drawn in a separate copy of ReShade at the photo’s own size, so these effects look right (effects that use depth are left out of those photos). With the older bridge, or if that fails, a 2× or 4× photo is taken at 1× and a photo in a different shape leaves those effects out. Photo Studio tells you when this happens. Big photos no longer make such an effect switch itself off on screen.
  • Photos in a different shape than your screen (portrait, square, wide) turn off depth-based effects for that photo only, so nothing is drawn in the wrong place; they come back right after.
  • A photo takes a brief moment to be prepared for your effects, and waits while ReShade is still loading them. If ReShade is not ready in time, the photo is taken without its effects and you are told so in Photo Studio.
  • New IPluginServices.Downloads (IPluginDownloads): https-only downloads pinned by sha256 (verified before anything is written), with a size cap and optional zip extraction filtered by IncludePrefixes, to DownloadRequest.TargetPath (a file, or for a zip a folder that is replaced) inside the calling plugin’s own data folder (DataFolder, shared with IPluginDataStore), which a request can never escape. A malformed request returns “invalid request” instead of throwing. One download per plugin at a time; completes and reports progress on the main thread.
  • New IPluginServices.ReShade (IReShade): State (ReShadeState: NotInstalled, Loading, Ready), Enabled, Techniques (ReShadeTechnique: name, effect file, enabled, UsesDepth), SetTechnique(effectFile, name, enabled) (a technique is identified by effect file + name, saved to the current preset), CurrentPreset / SetPreset, SetSearchPaths and Changed. Talks to ReShade through the Stellar ReShade bridge add-on (looked up, never loaded); without ReShade and the add-on it reports NotInstalled and every member is a no-op. Setters are asynchronous (applied at ReShade’s next frame, visible after Changed); SetSearchPaths replaces ReShade’s search paths, persists them and reloads every effect (identical paths are not re-sent). UsesDepth comes from a scan of the effect source with its includes (ReShade’s standard headers skipped); an effect that cannot be found or read counts as using depth.
  • CaptureRequest.ApplyReShade (init, default true): when State is Ready and its effects are on, the capture has ReShade draw its active techniques into the photo’s render target before the readback. Each photo is first prepared for its size (up to 5 s, one ReShade pass per frame; a bridge error ends it at once); alpha is forced opaque after ReShade draws. In a non-screen Aspect, enabled techniques that use depth are switched off for that capture only (never saved) and restored afterwards, also on failure.
  • CaptureResult.Notes (init, default empty): player-readable remarks on a successful capture, e.g. “ReShade was not ready — photo taken without it.”
  • ReShadeTechnique.SizeLocked (init, non-positional): the effect declares a texture sized from the screen (BUFFER_WIDTH/BUFFER_HEIGHT, BUFFER_SCREEN_SIZE, ReShade::ScreenSize, … directly, through a #define/const, or through an include; : COLOR/: DEPTH textures excluded). ReShade 6.8.0 keeps named textures in one global list, so such a texture created by the screen-size permutation is reused by a larger photo’s permutation, whose passes then read its top-left 1/scale region magnified (runtime.cpp:2035-2084). Unknown counts as locked. While an active technique is size-locked, a window-shaped 2×/4× photo is taken at 1× with ReShade (Width/Height are the real 1× size) and a shaped photo switches the size-locked techniques off for that photo; notes: “Some ReShade effects only work at screen size, so this photo was taken at 1×.” / “Some ReShade effects only work at screen size, so they were left out of this photo.” No size-locked effect is ever compiled at a non-screen size, so a large-size compile failure (AcerolaFX AutoExposure numthreads(3600,1,1) at 4×) can no longer disable it on screen (runtime.cpp:2164, 3763-3775).
  • Isolated capture (StellarReShadeBridge 1.1.0+, detected per export with GetProcAddress; rsb_version() stays 1): when the photo is not screen-sized and an active technique is SizeLocked, the photo is drawn in a separate effect runtime sized to the photo (rsb_isolated_*), with every UsesDepth technique requested off (that runtime has no game depth). Config: <game>/stellar/reshade-capture/StellarPhoto.ini (+ StellarPhoto.ini.preset.ini, written by the bridge). Bounded at 20 s; any failure (missing exports, a refused begin, a negative state, state 4, a render error, the timeout) ends the session and takes the 1×/skip guard above with its note; the session is ended on every exit path (plan, throw, host loss). New note on a window-shaped isolated photo that left depth techniques out: “ReShade effects that use depth were left out of this photo.” Warm-up: a fresh isolated runtime has no history, so adaptive effects start from zero (prod80 Bloom’s previous-frame average luma turned a 4× “Stella Medium” photo almost white). When an active effect is temporal — a frametime/timer/framecount uniform or a Prev/Last/History/Accum/Adapt-named texture, unknown = temporal; 20 of the 67 size-locked effects in the measured packs — the isolated runtime renders once per frame for ≥ 2 s and ≥ 30 frames before the real render, inside the 20 s bound. The camera is rendered once; every render starts from a pristine copy (the bridge writes the result back into the queued texture), and both targets are released on every exit path. Diagnostics: [PhotoCapture] reshade isolated=1 … outcome= state= renderCode= framesWaited= warmups= … addon=; the game-runtime line now reads isolated=0.
  • New IPluginServices.ReShadeUniforms (IReShadeUniforms): bool SetUniformOverride(string? effectFile, string variable, string? value) and void ClearUniformOverrides(). Holds a uniform at a value in the game’s ReShade runtime and in the isolated capture runtime, re-applied by the bridge after every effect reload, preset switch and runtime re-creation (bridge 1.1.0+ rsb_set_uniform_override / rsb_clear_uniform_overrides, bound optionally via GetProcAddress). Null/empty effect = every effect; values are 1–16 comma-separated numbers or true/false (validated before sending); a null/empty value removes. False for bad input or a 1.0.0 bridge; overrides set before the bridge binds are held and sent on bind. Per plugin: ClearUniformOverrides removes only that plugin’s overrides, and all of them are removed on plugin unload. (IReShade is at the 8-member cap, hence the separate interface.) First use: AcerolaFX’s _MaskUI, which discards its output in this game.
  • Capture warm-up: waits (draws nothing) while the bridge reports ReShade loading, and a frame’s drawn count only counts when no load followed it — ReShade’s preset re-apply after the first draw at a new size can switch on further techniques whose compile then starts (runtime.cpp:3722), and a render during it draws 0 (runtime.cpp:3810). A real render that drew nothing (no hard error) is discarded and warmed up again. Deadline: 5 s not counting loading, 20 s at most. Each failure has its own note: “ReShade was not ready — photo taken without it.” (timeout), “ReShade could not draw into the photo — photo taken without it.” (bridge error), “ReShade drew nothing into the photo in time — photo taken without it.” (real render kept drawing nothing), “None of the active ReShade effects work in this photo shape — photo taken without them.” (every active technique had to be switched off — before, this waited out the 5 s).
  • The effect scans no longer follow an #include written inside a /* */ comment (SweetFX FXAA.fxh documents one), which had made FXAA count as using depth.

2.16.0 (minor) — Photo mode: hide yourself and hide effects by whose they are. Adds API for plugins (Abstractions 2.16.0); additive, no plugin rebuild.

  • Photos can now hide your own character — together with your pet and your Battle Imagine — on your screen only. You can still move and fight, and other players still see you.
  • Photos can hide skill, buff and hit effects by who caused them: yours (including your pet’s and Battle Imagine’s), your party’s, other players’ or monsters’ (including boss warning areas). Scenery like waterfalls and lamps is never hidden, and everything comes back when you turn the switch off.
  • VisibilityLayers gains Self (32), EffectsMine (64), EffectsParty (128), EffectsOthers (256), EffectsMonsters (512) and VisibilityLayerSets.Effects; all go through ISceneVisibility.Hide like the existing layers. Values of the old layers are unchanged.
  • Self uses the game’s own photo entity-show counters (Oneself + SelfPet). Effects are classified by the effect’s caster (FromUuid, else BelongUuid); a summon resolves to its owner via EntitySummonAppeared, else the entity’s own TopSummonUuid/SummonUuid; an effect with no resolvable owner is never hidden. Only effects that were visible when hidden are ever shown again; ZEffect pooling is guarded by a uid read-back.
  • Effect creation hooks (ZEffectManager.AddEffectDisplay, ZEffect.Init) install lazily on the first effect-layer hide. A failed show-back is retried on the next re-assert (IVisibilityBackend.HasPendingRestore).
  • With STELLAR_DIAGNOSTICS on: [EffectHide] apply/classified/unresolved/zero-caster/born-hidden/owner-lookup and [PhotoVis] holds after Self lines (all capped).

2.15.0 (minor) — Photo mode support for plugins: screenshots and looks, a free camera, posing, a scene freeze, photo shapes and lights. Ships the never-released 2.13.0 and 2.14.0 (the release tooling folds their notes in). Adds API for plugins (Abstractions 2.15.0); additive, no plugin rebuild.

  • Free camera posing: pick a person — you, another player or an NPC — and set their pose, the exact moment of it, a facial expression that stays, where their head and eyes look, and which way they face. Other players and NPCs are posed as a copy only you can see. Posing works with the free camera off too, and leaving the free camera keeps everyone as you posed them — they return to normal when you change zone, a cutscene starts or you disconnect.
  • The free camera orbits the copy you are posing, and freezing the scene freezes posed copies too.
  • Freezing the scene now pauses the whole world, your own character included: skills stop mid-cast, effects and animations hold still, and players and monsters stay where they were, in the pose they had. While frozen your character ignores movement and skill keys (the camera still turns). The free camera, the Photo Studio panel, screenshots and all your plugin windows and hotkeys keep working while paused, and leaving the free camera keeps the world paused until you unfreeze. The game itself keeps running on the server: a fight goes on, and damage taken meanwhile shows when you unfreeze. If something hits you while frozen, your own character may still flinch in place.
  • Picking someone who is already doing an emote shows that emote and how far along it is, and pausing holds it right where it is.
  • Photo lights: place lamps around the people in your shot — each with its own colour, strength and reach — that light the ground and scene, let characters take their light, and give anyone a key light from one side and a coloured rim. Lights stay when you leave the free camera and are gone, with everything back as it was, when you change zone, a cutscene starts or you disconnect.
  • Screenshots can now be taken in other shapes — portrait, square or wide — at full detail: the camera draws the photo in that shape instead of cropping a wide shot, and very large sizes are reduced to what your graphics card allows.
  • In the free camera you can now click NPCs to orbit them, not just players.
  • Release note: the launcher manifest for 2.15.0 shows three player bullets twice — the 2.13.0/2.14.0 bullets were folded into this section by hand AND by changelog.py, which already folds never-published versions. Published manifests are immutable; this section is corrected for the record.
  • ColorPickerElement.ShowAlpha (init, default true): false hides the Opacity slider for colours with no alpha (Photo Studio lights). Additive — the two-argument constructor is unchanged.
  • New IPluginServices.Lights (ILights: IsAvailable, AddLamp, UpdateLamp, RemoveLamp, PeopleLevel, SetPersonLight, ResetAll, Released) and domain types LampId, LampSettings, KeyLight, RimLight, PersonLight, LightLimits (spec devkit 2026-10-03-photo-studio-lights; recon free-camera-recon.md § Run 13). Lamps = a GameObject with a Unity point Light + the game’s Bokura.Rendering.MultiLight (lightLayer = Everything, type = Common, maxDistance = 128), set up inactive then activated so MultiLight.OnEnable adds it to the light cluster; off = inactive; removal = inactive + Destroy. The cap (8 per plugin) is enforced framework-side. The character gate is CameraManager.weatherParamsVolume_.creaturePointlightColorIntensity: raised = snapshot all parameterList override flags (101 on release_3.7) + the parameter’s value + active, every flag off, only the gate overriding, active = true; restored (value, flags, active) exactly when no lamp is on or every level is 0 (LightGate, LightGatePolicy). Key light = RenderCompBase.SetFixedLight(ref ModelFixedLightData{LightParms}, 0x3FFFFFFF) → _CameraLightParm (a camera-space direction, w = 1); rim = SetFresnelEffect(1, colour × strength, (−0.7, 1, 1, 1), All); both written back from a per-material snapshot taken before the first write (ModelLightSnapshot; the game’s own Fresnel “off” leaves colour + params). Plain reflected calls only — ModelFixedLightData is by-ref and is never HarmonyX-patched. The posed copy / NPC stand-in comes from the posing backend; lit people are re-resolved on every IPosing.Changed. FreeCameraReleaser releases lights after the camera and before posing (people written back while their copy lives → lamps → gate); ReleaseAll is idempotent and raises Released only when it ended something; the per-plugin facade ends a plugin’s lights on unload. Diagnostics (STELLAR_DIAGNOSTICS=1): [Lights] lamp add|remove, [Lights] gate raised|restored …, [Lights] person <uuid> key|rim written|restored. Hardening (lights review 2026-10-03): every key / rim apply first reads any material the model gained since (equipment) so it is written back too; a posed copy cloned from a lit person saves that person’s originals for the values we wrote; a gate write that throws is rolled back from the snapshot and the restore attempts every write; the gate is put back only while the volume still holds exactly what we wrote — if the game wrote it since (a cutscene, its own weather) it is left to the game — and a volume the game already has active keeps its own overrides (only ours is added); lamps live on a persistent root (DontDestroyOnLoad), never in a streamed scene chunk.
  • New ICameraOverride.TryProjectToScreen(Position3D, out ScreenPoint) + domain ScreenPoint(X, Y, InFront): where a world point appears through the camera rendering now (the free camera while held, else the game camera), in screen pixels top-left (the IEntityPicker space) — for on-screen markers (Photo Studio’s lamp markers). A plugin that IMPLEMENTS ICameraOverride must add it.
  • WindowSpec.Passive (Borderless windows): a visual-only layer with no content padding and no click blocker, so presses reach the game and every window behind it — for full-screen guides/overlays (Photo Studio’s frame guide). IScreenCapture.PlanSize is a new interface member: a plugin that IMPLEMENTS IScreenCapture must add it.
  • Photo shapes (spec 2026-10-03 photo-studio-portrait-capture): new CaptureRequest.Aspect (CaptureAspect?, a width:height ratio of whole numbers, valid 1:4 … 4:1; null = the window’s shape, unchanged) and IScreenCapture.PlanSize(CaptureRequest) (the real output size before the shot — scale caps, shape and the GPU’s SystemInfo.maxTextureSize included; empty for an invalid scale/shape). Pure maths on the new CaptureSizing (OutputSize, EffectiveScale, GuideRect, VerticalFieldOfView, MaxLongSide, MaxPixels) with CaptureSize / NormalizedRect: a shape’s long side = the window’s long side × Scale, the short side follows the shape rounded to an even pixel count (2× on 1920 × 1080: 9:16 = 2160 × 3840, 4:5 = 3072 × 3840, 2:3 = 2560 × 3840, 1:1 = 3840 × 3840, 21:9 = 3840 × 1646); over the long-side limit (16384 or the GPU’s, whichever is smaller) or 64 MP both sides shrink by the same factor (a window-shaped capture keeps its 4× → 2× → 1× halving). The camera renders straight into a target of that size with Camera.aspect set to it for that one render (and, for a shape wider than the window, fieldOfView narrowed so the horizontal angle is kept) and both put back before anything else renders (CaptureLensOverride: automatic aspect again when it was the window’s) — so the photo frames exactly GuideRect, the largest centred rectangle of the shape. Property writes only, no new hook. An invalid shape fails with a readable error; a failed shaped 4× grab retries once at the 2× shape. A PHYSICAL camera (usePhysicalProperties, which the game sets) stays physical for the shaped render: the framing rule is applied through an explicit Vertical gateFit + the matching focalLength (never fieldOfView, which would move the focal length), computed from the on-screen gate fit (Vertical/Horizontal/Fill/Overscan/None) by the pure CaptureLensPlanner; every property it changed is put back exactly once, even when a write or a restore step throws. Diagnostics log the lens set/restore and whether the next frame’s whole lens equals the pre-shot one ([PhotoCapture] lens next-frame ok=…). New IScreenCapture.MaxTextureSize (the GPU limit PlanSize applies — pass it to CaptureSizing.EffectiveScale).
  • New IPluginServices.Posing (IPosing: IsAvailable, NearbyPeople, Expressions, Select, ResetAll, Changed; IPoseTarget: State, PlayAction, Moment, SetExpression, SetLook, Aim, Yaw, Reset) and domain types PersonKind, PersonInfo, ExpressionInfo, LookMode, LookPart, PoseTargetState, PoseResult. IPosing.IsAvailable = IClientState.IsWorldActive and outside the posing scene-change settle window (~2 s after a leave/enter) — no camera override needed; a camera release resets nobody. The scene end (FreeCameraReleaser.Release: Game.OnLeaveScene prefix / SceneChanged, cutscene, game photo mode, logout, framework unload — the reasons the scene freeze already ends on) resets every touched person in the same call, a ZEntityMgr.RemoveEntity prefix releases a despawning person, the per-plugin facade releases a plugin’s people on unload, and a scene-freeze end re-applies held pauses.
  • Game calls (devkit docs/recon/photo-posing-recon.md runs 4–5): you = live model, ZAnimActionPlayMgr.PlayAction(id, syncServer: false, …) / SetActionPersistTime / ResetAction and LuaAsyncBridge.SetEntityRotation (an action start and a reset each ride one NewMove — the game’s own photo behaviour); players = CloneModelForPhoto + CameraFrameCtrl.SetTargetEntityVisible(e, false) … RecyclePhotoModel; NPCs = NpcTable.ModelID → LuaAsyncBridge.GenerateNormalModelAsyncByLua(…, isCameraScene: true) with ApplyModelBaseIdleByLua, removed by ZModelManager.RecycleModelByLua (the live NPC is never posed); held expression = ZModel.SetLuaAttrEmoteInfo(faceId, -1, true); head/eyes = ZModelHelper.SetLookAtIKParam / SetLookAtTransform / SetLookAtPos / LuaWorldPosToLocal. Copies and NPC models send nothing.
  • IPosing.TryGetVisiblePosition (the copy / stand-in position for an orbit centre, allocation-free); copies are capped at the game’s PhotographTeamMemberLimit (PC [1], 30 in release_3.7: you + 29 players; NPC models 30) with PoseTargetState.Full / PoseResult.Full beyond it; while ISceneFreeze is frozen, posed copies/models get the model-level freeze stage (AnimComp.Speed 0, prior restored on unfreeze and before release).
  • ISceneFreeze is a global time pause (Photo Studio scene-stays spec amendment 2026-10-02 late; devkit recon free-camera-recon.md § Run 9): GameClockPause saves Time.timeScale and sets 0; a HarmonyX prefix on UnityEngine.Time.set_timeScale(float) (TimeScalePatch, by-value float — allowed by Il2CppPatchSafety) holds the game’s own writes while paused (hit-stop ZTimeScaleShowInfo.OnStop writes 1.0) and keeps the latest as the restore value (else the saved one; never ≤ 0). A watchdog (TimePauseWatchdog) at the framework’s global rate, OUTSIDE the world gate beside the login / loading-screen probes (never on the world-gated IFramework.Update), re-asserts 0 if the clock was set behind the hook, resumes a pause its freeze already dropped and releases a pause outside the world; a stall check after every paused frame’s tick (no framework tick for 10 s, persisting over 3 checks and 1 s — one long hitch is no stall) and the paused driver’s destruction release too. Every such release is the FULL release path (FreeCameraReleaser: camera, posing, every freeze token → animation replay + gate disarmed, hold stopped, clock resumed, input shield), never a bare clock resume; framework unload resumes as well. While paused the framework tick runs from real time (StellarPausedTicker, enabled only while paused; TickPacer keeps one dt and one tick per frame across both drivers — the InvokeRepeating path is unchanged), and the free camera’s acquire / release cut (CinemachineBrain.m_DefaultBlend = Cut for the pause, the game’s blend put back on resume). Kept from the per-entity freeze: the ModelGoComp position + rotation hold for remote movers (never the local player or their own mount) and the deferred removal of a monster killed while frozen. New (owner report on the TEST window, recon runs 11–12): at timeScale 0 the ECS animator’s clock is frozen (0 animation events over a 20 s pause) but the game keeps REQUESTING states for movers (a walking monster: 9 PlayBaseState in 20 s), and one request re-poses a model with the clock stopped (45 % of its region changed). So a run-original gate on ECSAnimController.Play{Base,Upper,Additive}State / PlayManualClip and their internal play… twins holds the requests of the press’s entities’ controllers (never the local player, their mount or a posing copy) and replays the latest per layer on unfreeze, each only while its entity still serves the same (pooled) controller (AnimRequestGate; kill switch STELLAR_FREEZE_ANIM_GATE=0). The gate is four TYPED HarmonyX prefixes (AnimGatePatch, by-position arguments, exact-signature check) on the internal playBaseState / playUpperState / playAdditiveState / playManualClip only — the public, sequence and state-end requests all funnel through them (release_3.7 ISIL) — so an unfrozen call costs a counter and a field check and allocates nothing; installed on the first freeze for the session. A press that does not know the local player tracks nobody. The local player’s movement / combat input is masked while paused (ZIgnoreMgr.SetInputIgnore, mask ShieldMask.PauseBits = 0x10FFB6679, camera bits open) as a second layer of the free camera’s EGm source: InputShieldService owns that one source and moves it between unions by the difference only (the game counts each bit per source). Removed: the attr factor freeze, the AnimCompBase.set_Speed gate, the ECS layer gate and its native play detours (EcsPlayDetours), the effect freeze at AddEffectDisplay / ZEffect.Init, the appear / ride-up re-checks and the combat-freeze diagnostics capture; diagnostics keep one freeze on/off summary (time scale saved/restored, game writes held, drifts, positions held, animation requests held / replayed / stale, the gated entry points’ calls this freeze and since install, deferred removals).
  • While frozen, Unity’s scaled time stops for every plugin, not just the game: Time.deltaTime is 0 and Time.time stands still, WaitForSeconds, UniTask.Delay (default DelayType.DeltaTime) and anything else on scaled time wait until the unfreeze. Use Time.unscaledDeltaTime / Time.realtimeSinceStartup, WaitForSecondsRealtime or DelayType.Realtime / IFramework timers for anything that must keep running. The position hold covers players and monsters within 80 m of you (FreezeKinds.HoldRadius); farther ones may glide in their paused pose. ISceneFreeze.Changed handlers each run on their own (a throwing one is logged once); one throwing IFramework.Update subscriber no longer stops the others.
  • Known limits: the server keeps driving the local player’s hit reactions while frozen, so your own character can still re-pose in stop-motion when something hits you (its requests are not held — holding them would also hold your own movement); a disconnect ends the freeze only through the game’s logout (IClientState.Logout).
  • IPosing.TryGetCurrentAction(person, out actionId, out moment): the running action (posed copy/model first, else the live entity’s model) via compiled ZModel.GetLuaAttrActionInfo{ActionId,TotalTime,PassedTime} reads, liveness- and settle-gated, 0 sends; setting IPoseTarget.Moment 0–1 before any PlayAction adopts and holds that action without re-playing it (a reset only releases the hold on an adopted action). The read reports the posed model’s own state whenever one exists; an adopted action the opened model lacks is dropped. Diagnostics: [Posing] action-raw (≤ 5/s).
  • IEntityPicker also returns NPCs. HarmonyGameMethodHooker skips abstract overloads (they cannot be patched).
  • Diagnostics (STELLAR_DIAGNOSTICS=1): [Posing] open … / [Posing] npc model … loaded=… lines, a [Posing] despawn prefix fired on managed thread … line on every ZEntityMgr.RemoveEntity prefix, and [Posing.Send] svc=… method=… for every outgoing RPC while a person is selected.
  • Whole-feature review: Expressions and the photo-member limit read are each behind a bounded retry latch (NegativeProbeCache, same pattern as GameVisibilityBackend’s probes) — an empty/zero answer or a throw is cached and retried at most every 5 s instead of re-running the Lua query (and re-warning) on every 10 Hz panel poll.
  • HarmonyX patch safety (unreleased-code fixes, review of the freeze-crash fix): the hooker now refuses — logged as an error, never patched — any method with a by-ref value type other than an integer primitive (blittable struct, enum, float, double, char) or a register-sized / unknown-size IL2CPP struct RETURN, besides the by-value 1/2/4/8-byte and by-ref IL2CPP struct parameters it already refused. Measured on the game’s CoreCLR 6.0.7 (TEST): Il2CppInterop’s trampoline hands a by-ref Vector3/Quaternion/QualityData to the original with only its first 8 bytes and writes 8 garbage bytes back over the caller’s; a ref float makes it throw so the original never runs. By-value blittable structs were byte-identical. QualityGradeSetting.ApplyAllData(ref QualityData) (the render-quality re-assert signal) is therefore a native detour (QualityApplyDetour, original first, then the signal), the diagnostics-only MoveComp.MoveGo / MoveGoByCurve / MoveGoBySpeed prefixes are gone, and every native detour (QualityApplyDetour) goes live only on its full exact interop signature (NativeSignature), else an error line.

[2.14.0] - 2026-10-01 (never released — shipped in 2.15.0)

Section titled “[2.14.0] - 2026-10-01 (never released — shipped in 2.15.0)”

2.14.0 (minor) — Free camera support for plugins. Adds API for plugins (Abstractions 2.14.0); additive, no plugin rebuild.

  • Free camera support for plugins: move the camera freely around your character, freeze the moment (characters, NPCs, pets and effects stop), and strike a pose with your own emotes.
  • A hotkey you set yourself can no longer end up sharing its key with another action’s default.
  • New IPluginServices members: CameraOverride (exclusive Cinemachine vcam takeover; 60 m hard cap from the local player; framework release on zone change / cutscene / game camera mode / disconnect / unload / frame-handler exception with CameraReleaseReason; LookAtCamera() snapshot-restore), InputShield (ref-counted ZIgnoreMgr mask under EIgnoreMaskSource.EGm plus the text-field KeyboardInputGate for every game key, raw key/mouse reads), SceneFreeze (every EntityDict entity: effects via SetEffectFreeze + AddEffectDisplay postfix, animation via SkillStageTimeFactor then AnimComp.Speed where the drawn speed stays above 0, drawn-position hold of movable kinds within 80 m in LateUpdate with a 0.3 ms/frame self-check and a release snap, entities appearing while frozen via an AddEntity postfix), Emotes (the emote wheel’s unlocked list and check-then-play path through the Lua VM), CombatState (attr 104 + SetLocalCombatData/SetLocalAttrInBattleShow postfixes, no polling), EntityPicker (chest projection).
  • Kill switches: STELLAR_FREECAM_OFF=1, STELLAR_FREEZE_NO_POSITIONS=1.
  • IHotkeys.MigrateSavedBinding(actionId, from, to) (SavedBindingMigration): one-time move of a player-saved chord. Resolution now lets a saved binding beat a suggested default whatever the declare order (it used to skip the collision check); default-vs-default is unchanged.
  • A per-frame FreeCameraFrameDriver MonoBehaviour exists but is disabled unless a camera override or a position hold is live.
  • IInputShieldHandle.TextFieldFocused: true while a Stellar overlay text field has keyboard focus (the same source as the keyboard gate), so a free-camera consumer can ignore movement/edge keys typed into a panel search box. False once disposed.

[2.13.0] - 2026-09-30 (never released — shipped in 2.15.0)

Section titled “[2.13.0] - 2026-09-30 (never released — shipped in 2.15.0)”

2.13.0 (minor) — Screenshot support for plugins. Adds API for plugins (Abstractions 2.13.0); additive, no plugin rebuild.

  • Screenshot support for plugins: hide the interface, take high-resolution screenshots and apply camera looks.
  • Plugins can now sharpen the picture for screenshots (supersampling, sharper shadows) and set the time of day; your own graphics settings come back exactly when they stop.
  • Four new services on IPluginServices: ScreenCapture (IScreenCapture — PNG/JPG at 1×/2×/4×, long side capped at 16384 px, a 4× failure retries once at 2×, never throws), SceneVisibility (ISceneVisibility — reference-counted hiding of the game HUD, the Stellar overlay, nameplates and other players; a plugin’s tokens and Changed handlers are released when it unloads), RenderLook (IRenderLook — one active look framework-wide; PlayMode strips depth of field and film grain) and PhotoMode (IPhotoModeState — the game’s camera / selfie mode and cutscene state).
  • Looks: the framework owns one global Volume (priority 10000, runtime VolumeProfile) and writes the game’s own ZRenderPipeline components into it — ZDofVolume (Bokeh), ZColorAdjustmentVolume, ZWhiteBalanceVolume, ZColorLookupVolume (256×16 / 1024×32 PNG strips), ZBloomVolume (intensity_UE/threshold_UE), ZUnityVignetteVolume, ZFilmGrainVolume (every parameter written, as the game’s cutscene grain track does: filmType Custom + a framework-generated 256×256 linear mid-grey noise texture in R=G=B=A, Tiling (1,1), white Color — the bundled Thin1 texture showed no visible grain). It never edits the game’s profiles; omitted groups drop their overrides and revert to the game’s value. Evidence: devkit docs/recon/photo-studio-render-recon.md (DXVK section).
  • Capture renders the main camera into an N× RenderTexture at end of frame (clean: no game UI, nameplates or overlay) and reads it back as RGBA32; PNG encoding is a managed encoder run off the main thread; the result completes on the main thread.
  • Hide switches: ZUiRoot.SetUIInvisible, HudMgr.SetHudSwitch(…, ECamera), CameraFrameCtrl.SetEntityShow (per-type hold counters shared with the game’s camera panel: 11 OtherPlayer hides everyone; keep-party hides Stranger 6 + Chum 2 + Union 4 and never writes 11, because 11 is a master switch checked before Team; one show per hide issued; ZEntityMgr.ForceRefreshCharVisible(ETakePhotos) on a party change while keep-party is held), and the framework’s window + layout-edit canvases (the toast canvas stays visible). Photo mode: CameraFrameCtrl.Record/ResetCameraInitialParameters + CameraStateSelfPhoto.OnEnter/OnExit; cutscene: CutsceneManager.Play / afterStop, seeded from InCutscene. Every game member is resolved by name at runtime and fails open with one warning.
  • Two more services on IPluginServices: RenderQuality (IRenderQuality — Request(RenderQualityRequest) returns a token; reference-counted union across plugins: Supersample = render scale 2.0 + TAA on, HighShadows = 4096 shadow map, 3 cascades, soft shadows; Live read-back, Capabilities per lever) and TimeOfDay (ITimeOfDay — Pin(hour) returns an ITimePin; newest pin wins, disposing falls back, the last dispose hands time back to the server; SetHour on a held pin). A plugin’s tokens and pins are released when it unloads.
  • Each lever captures the game’s value before the first write and restores it when the last token goes; a value the game writes while a lever is held (its grade re-apply, the settings panel) becomes the restore target. Every write happens only when the live value differs. Levers: ZRenderPipeline.asset.renderScale; QualityGradeSetting.EnableAA + applyEnableAA; ZShadowCastPass shadowSettings.shadowmapResolution / cascadesCount / supportsSoftShadows; time of day through Panda.LuaAsyncBridge (SetWeatherIsUpdateFromServer, SetCurWeatherTime, GetCurWeatherTime24, GetWeatherIsUpdateFromServer) — ZServerTime is never touched.
  • Re-assert is event-driven (no timer): scene/phase change, postfixes on the game’s quality-apply entry points (QualityGradeSetting.ApplyAllData, applyRenderScale, applyShadowGrade, the resolution/grade setters and the settings panel’s Lua wrap), ZShadowCastPass.OnInitialize, the game’s own LuaAsyncBridge time calls (bridge + Lua wrap), and the end of the game’s photo mode or a cutscene; it drains on the next tick once IsWorldActive. Hook list and known gaps: devkit docs/recon/photo-studio-render-recon.md § Render quality + time of day recon.
  • Capture render-scale guard (drops a supersampled render scale to 1.0 for the grab frame) ships OFF; STELLAR_CAPTURE_SCALE_GUARD=1 turns it on for the in-game measurement. HarmonyGameMethodHooker.PostfixStaticOverloads added for static game methods. The render-quality / time-of-day game hooks install lazily on the first Request / Pin (never at boot); STELLAR_RQ_NO_APPLYALLDATA=1 skips just the by-ref ApplyAllData hook.

2.12.0 (minor) — Showing and hiding the Combat Meter no longer freezes the game, the meter opens much faster, and layout edit mode no longer lags. Adds a diagnostics API for plugins (Abstractions 2.12.0); binary-compatible, no plugin rebuild.

  • Hiding and showing the Combat Meter (or any mod window) no longer freezes the game for a moment. Toggling it quickly is now instant.
  • The Combat Meter appears much faster when it first opens, without the short freeze it used to cause.
  • Layout edit mode no longer makes the game lag while it is open.
  • Measured on the owner’s client with the new [Hitch] recorder: every meter show was a 350-476 ms frame (mount:combatmeter.main, 9/9 toggles, no GC) and CooldownBar 57-72 ms. After: the meter’s first build is 14.7 ms for its 20 raid rows (29 ms first paint), and hide/show triggers no rebuild.
  • WindowRenderer implements IWindowParking: SetVisible(false) deactivates the built tree instead of destroying it; a re-show reactivates it on top of its stacking tier. Remove() still destroys.
  • ConditionalElement branch content is built the first time its branch becomes active (the active branch still builds inside the first paint). The CombatMeter main window previously built its list view and both party layouts (49 meter rows) to show one of them.
  • Meter-row debuff cells are created the first time a slot is visible (default 4 of the 12-cell pool; none while the block is hidden), with their click wiring.
  • IWindowControl.SetRect skips the persist when the rect equals the saved one: the layout toolbar’s per-tick re-centre was rewriting the whole framework config ~28x/s.
  • New HitchProbe (Abstractions, diagnostics-gated via STELLAR_DIAGNOSTICS or a HITCH flag): a rendered frame over 60 ms logs a [Hitch] line with the framework tick and its segments, each plugin’s Update, window mount/apply/destroy and build phases, font-atlas refreshes, config saves, hook time, and managed + IL2CPP GC counts.

2.11.0 (minor) — Mods can now tell which spec nearby players are playing, the moment they come near you, and know the buffs players already have when they arrive. Adds API for plugins (Abstractions 2.11.0).

  • Mods can now see which spec a nearby player is playing as soon as they come near you, even in town before any fight. Combat Meter uses this to show specs straight away.
  • Mods now know the buffs a player already has the moment they come near you, instead of only after those buffs change.
  • Spec from talent root buffs: each of the 18 specs has exactly one root talent buff (“<Spec> Spec”); the map is derived at runtime from TalentStage → TalentTree → TalentTable effects (18 pinned fallback constants). Buff-derived spec is authoritative over cast inference; the swap gap holds the previous spec (expires after 10 s); a snapshot with no root clears it; Battle Imagine transform ids are not class changes. Evidence: devkit docs/recon/spec-from-public-wire-data.md (2,111/2,111 snapshots; owner-confirmed live).
  • New API (additive): ICombatSpec.TryGetTalentSpec(EntityId, out int); CombatEvent.SpecChanged(TimestampMs, TargetId, OldSubProfessionId, NewSubProfessionId, FromTalent) (once per real change, never for the swap gap); CombatEvent.EntityBuffsSeeded(TimestampMs, TargetId, Buffs) — SyncNearEntities / EnterScene now decode Entity.buff_infos and replace the entity’s buff set silently, one seed event per entity (live deltas unchanged; a later delta for a seeded buff arrives as Refreshed, its expiry as Removed). BuffsFor/LocalBuffs return cached read-only snapshots.
  • STELLAR_WIRECAP debug capture is now lossless for large frames (node budget 4096 → 262144, hex for short opaque byte fields, raw base64 when a frame still truncates).

2.10.0 (minor) — Lets plugins save the loadout you’re wearing into another loadout slot through the game’s own Save, and tell whether you have unsaved loadout changes. Powers Loadout Switcher’s new copy button. Adds API for plugins (Abstractions 2.10.0).

  • Plugins can now copy the loadout you’re wearing into another of your loadout slots, using the game’s own Save, so the game confirms it with its usual “Loadout saved successfully!” message.
  • New ILoadoutSave on IPluginServices (LoadoutSave): SaveCurrentToAsync(index) runs weapon.AsyncSaveRolePlan(index) on the main-thread drain (refuses without dispatch when the target is the worn plan, unknown, or a switch/save is in flight; 8 s timeout; re-arms the SyncProjectList refresh on success). HasUnsavedChanges = the game’s CheckRolePlanIsChange(), carried as an UNSAVED row on the existing LiveStateChunk/RefreshChunk (event-driven, no timer). Measured on the owner’s client: SaveProject accepts a non-current plan id and copies the LIVE setup (class, gear, modules, skills, talents, Battle Imagines); the plan name is not copied.

2.9.0 (minor) — The party meter gains shields, buffs & debuffs, and voice controls; plus a dungeon-teleport archive fix and a band-instrument tone relay. Adds render/data API for plugins (Abstractions 2.9.0).

  • The party meter can now show each member’s shield (a band over their HP bar) and their active buffs and debuffs as icons.
  • You can click the voice icon on your own meter row to cycle your team-voice mode, and open a party-voice menu from the meter.
  • A dungeon fight is no longer split into two separate records when you get teleported within the same instance mid-fight.
  • MeterRowData status-effect channel (DebuffSlot + IsBuff, Debuff0..11, DebuffColumns, DebuffOverflow, ShowDebuffs, DebuffCellSize, BarShieldFraction, OnDebuffClick); WindowBuilder renders the 2-row colour-coded block (variable columns, per-cell click). IGameDataCombat.AllBuffs() enumerates the buff table; GameTextureElement.Fill stretches an icon to its box. Shield via AttrShieldList → EntityVitals → HP-spine band; InstrumentToneRelayPatch relays band tone listener-side.

2.8.5 (patch) — Settings → Hotkeys now lists numbered actions in natural order, so “Apply Loadout 10” sits after 9 instead of between 1 and 2. Cosmetic; binary-compatible, no plugin rebuild.

  • In Settings → Hotkeys, an action numbered 10 or higher now appears in the right place in the list (after 9), instead of being sorted as if it came right after 1.
  • FrameworkVersion.Value → 2.8.5. HotkeysPanel sorts within a plugin group by NaturalOrder.Compare (numeric-aware) instead of an ordinal string.Compare on the action id — digit runs compare as integers, so loadout.apply.10 sorts after loadout.apply.9. Bindings are unaffected (keyed by id, unchanged). +8 NaturalOrderTests.

2.8.4 (patch) — Loadout Switcher Deep-Slumber fixes: switching builds now rebuilds the whole Psychoscope tree reliably, and shared factors are no longer taken from your other build unless there’s truly no other way. Application-only; binary-compatible with every existing plugin, no plugin rebuild.

  • Switching between builds now rebuilds the whole Psychoscope tree properly instead of sometimes leaving part of it locked.
  • When you switch to a build, a Phantom Factor it shares with another build is no longer pulled out of that other build if you already have a spare, or if the build you’re switching to already has it in place.
  • FrameworkVersion.Value → 2.8.4. Application + Infrastructure only; no public API change, so no plugin rebuild.
  • DeepSlumberReconciler.FreeForeignSharedFactors now frees a cross-loadout copy only up to a real deficit (demand − target-area reset/replace refunds − free bag copies); a new Application-internal IFactorBagProbe (PandaInventoryProbe.ReadFactorBagCounts, over the existing CharSerialize.ItemPackage walk) supplies the free-inventory counts. Elaina 2026-09-22.
  • Tree rebuild: DeepSlumberService.ActivatePhaseAsync converges anchor activation on the prerequisite refusal 5126 (ErrTalentPreTalentNodeNotActivated) — each pass requeues the blocked anchors until the tree self-orders parent-before-child; a class round-trip no longer half-builds and locks the tree. Validated in-game (18 recovered 5126 across 9 rebuilds).
  • Reactive backstop: DeepSlumberService.SocketPhaseAsync frees a foreign copy and retries when — and only when — a socket is refused 7561 (ErrSeasonTalentIntermediateNodeClassNumExceeded; a copy in an inactive tree counts toward the per-type limit, which a bag spare cannot clear). So a foreign copy is freed only when the bag lacks it (predictive) or the game itself refuses (reactive). DeepSlumberWriteCode.PreTalentNodeNotActivated (5126) / ItemClassNumExceeded (7561).

2.8.3 (patch) — new character-portrait controls for mods (hide the weapon, custom portrait lighting) and a per-bar label-colour option for mod HUDs. Additive API; binary-compatible with all existing plugins (EntityInspector is rebuilt alongside).

  • Mods that show a 3D character portrait (such as Entity Inspector) can now hide the character’s weapon and light the portrait with a custom, fixed look that doesn’t change with wherever your character happens to be standing. The portrait keeps its lighting entirely to itself, so characters in the world around you look exactly the same as before.
  • Mods can now set the colour of the small number or label drawn inside a HUD bar, so it stays readable over any bar fill colour.
  • Stellar.Abstractions: IEntityPortrait gains ShowWeapon (bool; default hidden — matches the prior always-hide behaviour) and LightPreset (int; -1 = Scene/dynamic, 0..4 = custom profiles rebased on the real HDR scene scale). The camera controls (Orbit/Zoom/Pan/SetViewport) are factored onto a new base IEntityPortraitView (IEntityPortrait : IEntityPortraitView) to keep each interface under the STELLAR0005 8-member cap. This is additive for consumers of the aggregate interface, but moving members to a base type changes their declaring interface — a plugin that CALLS the camera methods and is not recompiled would hit MissingMethodException; the only consumer is EntityInspector, released in tandem.
  • World isolation: creature lighting is a global shader register shared with in-world characters. Infrastructure (PortraitModelHost.Lighting / PortraitCmdRenderer) captures the 5 creature-light globals (Shader.GetGlobalVector/Matrix of ZModel2RTLight’s prop-id handles) before the portrait’s CommandBuffer draw and restores those exact values (cmd.SetGlobalVector/Matrix) after, so the global state ends byte-identical to what the world left it regardless of frame timing. Weapon-hide excludes the subject’s loose ch_wp_* MountComp GameObjects by name from the custom draw and re-asserts on a throttle (the weapon streams in after the body).
  • Stellar.Abstractions: BarElement.LabelColor (ColorRgba?) — a per-bar override for the inside-label colour that wins over the theme’s muted reskin registration; WindowBuilder.Preview honours it. Default null keeps every existing bar byte-identical.
  • FrameworkVersion.Value 2.8.3. Consumed by StellarEntityInspectorPlugin (separate PR).

2.8.2 (patch) — fixes stat readouts stuck on “—” for a whole play session after a fast login. Infrastructure/Application only; no API change, binary-compatible with all existing plugins.

  • Fixed tracked stats showing “—” instead of a number for the rest of the session. If you got into the world quickly, the mod could read your character before the game had filled in its stats, decide those stats did not exist, and never look again — Stat Inspector’s mini HUD then showed a dash on every row until you restarted the game. It now waits until your stats are actually there before giving up on one, and re-ticking a stat in the picker (or logging out and back in) re-checks it straight away. A stat the game only starts reporting a little later is picked up on its own within about a minute; a stat your character genuinely does not have — one the game never reports at all — keeps showing a dash, which is correct.
  • Root cause: PandaPlayerStatsProbe._attrUnreadable was a process-lifetime negative cache with no invalidation. The local-player entity exists for several ticks before its FightAttr sheet is populated, so a sampling pass taken inside the login window missed TryGetAttr<long>, <int> AND <float> for every subscribed id, and ProbeAndMemoizeAttrType latched them all. PlayerStatsService.ClearSession did not touch probe state and Subscribe had no reset hook, so only a client relaunch cleared it. All-or-nothing by construction — which is why the owner saw eight of eight rows dash (2026-09-21) and why the 2026-09-09 boots, which won the same race, latched only the genuinely absent 11760/11980.
  • Fix: the decision is now the pure, BCL-only AttrReadabilityMemo in Stellar.Application (unit-pinned in Stellar.Application.Tests), one instance shared by PlayerStatsService and PandaPlayerStatsProbe from the composition root. The probe reports each read as an AttrReadOutcome into a reused per-tick buffer and Record(pass, sheetReady) commits the misses only when the attribute sheet is known to be populated — either because an id in the same pass read live, or because the caller’s EXPLICIT readiness signal says so. An all-miss pass before readiness means “the sheet is not ready”, never “these ids are absent”. Readiness is deliberately not inferred from the pass: the pass covers only the plugin-subscribed union, and a CombatMeter-only client subscribes exactly 11760 + 11980 — both genuinely absent from the wire sheet — so every pass there is all-miss forever and those ids would never latch, re-probing three reflective invokes each per tick for the process lifetime. PandaPlayerStateProbe.IsAttrSheetPopulated(entity) answers it from an always-present attribute (max HP, then level — the same evidence IsUseful uses) on the SAME entity the pass sampled, so it cannot disagree with the pass and goes false again during a mounted blackout; AttrReadabilityMemo.NeedsReadinessSignal(pass) keeps that read to the ambiguous window only (all-miss AND holding a first-read probe), so steady state pays nothing. A miss through an already-locked storage-type memo (mounted blackout) is readiness evidence only and can never latch. Subscribe calls Forget(id); ClearSession calls Clear(). One STELLAR_DIAGNOSTICS-gated line in PandaPlayerStatsProbe.Diagnostics.cs reports each memo decision (the previous silence is what made this a full investigation). Reads stay lock-free (copy-on-write) so the per-tick sampler is unaffected. FrameworkVersion.Value 2.8.2. Dossier: devkit .superpowers/sdd/statinspector-dashes-investigation.md.
  • An “unreadable” verdict is a BOUNDED negative cache, not a process-lifetime one: AttrReadabilityMemo.RetryAfterTicks = 60 s. _unreadable is now a copy-on-write Dictionary<int, long> (id → the clock reading that latched it); IsUnreadable(id, nowTicks) is true only inside that window, and Record(pass, sheetReady, nowTicks) re-stamps a miss that misses again (the window restarts) or drops the verdict outright when the id finally reads — the probe’s storage-type memo (_attrPrefersLong / _attrFloat) is untouched either way. PandaPlayerStatsProbe.TrySample reads the clock ONCE per pass (Environment.TickCount64 × TimeSpan.TicksPerMillisecond — monotonic, so a wall-clock adjustment can neither freeze nor shorten a window) and hands it down; Stellar.Application stays pure. Measured trigger: the 2026-09-22 TEST-client run latched 11951 (versatility %, a SELECTED id on that client) alongside the genuinely absent 11760/11980 — a hit pass at login condemned an attribute the game had simply not published yet, and with a permanent verdict the row dashed until relaunch. Cost of the retry: ~3 reflective invokes per absent id per MINUTE (pinned: no re-probe inside the window across 3 599 consecutive passes), versus 3 per tick without any memo. Two logging rules follow from the expiry, both required — (1) the UNGATED attr {id} unreadable … line is now first-sighting-only per id (_unreadableLogged), else every user would collect one line per absent id per minute for the whole session; (2) the STELLAR_DIAGNOSTICS-gated memo: latched=… via=… line’s expected cadence is once per id set per window, not once per process — more often means verdicts are being dropped early, and an id that stops appearing has started reading. Four new pins in Stellar.Application.Tests: a_latched_id_is_re_probed_after_the_ttl_and_not_before, a_re_probe_that_still_misses_re_latches_and_restarts_the_window, the_anti_spam_bound_holds_inside_the_window, a_re_probe_that_hits_clears_the_id (PR #88 review, fix 3).
  • A pass taken while the attribute sheet is DARK (all-miss and sheetReady false) no longer discards its evidence wholesale: AttrReadabilityMemo.RefreshExisting restarts the window of every fully-probed miss that ALREADY holds an entry, while an id with no entry still latches nothing (the F1 rule is untouched, and Latched stays empty — no verdict is new). Without it the expiry introduced the mirror of the bug it fixed: an id whose window lapsed during a blackout kept its already-expired stamp, so IsUnreadable read false and the probe re-probed it — three reflective invokes plus up to three Unity arr type err lines — on EVERY tick until the sheet answered, instead of once a window. The gated memo: skipped-all-miss-pass … line now ends latching nothing; existing verdicts held; the refreshed ids are deliberately not listed (the line is deduped per streak, the refreshes recur per window). Three new pins: a_not_ready_pass_refreshes_an_existing_verdict_but_never_creates_one (RED before the fix), the_retry_window_ends_at_exactly_sixty_seconds (age < RetryAfterTicks, so 60 000 ms is already expired) and a_clock_reading_behind_the_stamp_reads_as_expired (PR #88 review, fix 4).

2.8.1 (patch) — fixes a startup crash on the Steam version of the game when a mod that draws its own overlay is left enabled. Infrastructure/boot-order only; no API change, binary-compatible with all existing plugins.

  • Fixed the game crashing on startup on the Steam version of Star Resonance when a mod that draws its own overlay (such as Minimal Nameplate) was left enabled. Turning it on while already in-game had always worked; only having it enabled before launch could crash. (The standalone launcher version was not affected.)
  • The 2.7.4 Steam Class::Init injection guard (Il2CppClassInitFix.EnsureSeeded) was armed only inside UnityTickHost.Install(), which BootstrapPlugin.OnHotUpdateReady() calls AFTER LoadUserPlugins(). That protected the framework’s own first IL2CPP type injection (StellarTicker) but not a user plugin that injects a type in its constructor. Minimal Nameplate, when enabled, calls ClassInjector.RegisterTypeInIl2Cpp<LateUpdater>() in its ctor during LoadUserPlugins — the real first injection in the process — before the seed was armed, hitting the unguarded FindClassInit and fatally crashing the StarSEA_STEAM build (0x80131506). Fix: call EnsureSeeded(log) immediately before LoadUserPlugins(log); it is _seeded-guarded/idempotent, never throws, and needs only GameAssembly.dll exports (available before plugins load). The existing UnityTickHost.Install call becomes a harmless backstop. FrameworkVersion.Value 2.8.1; no-op on the standalone build. Root-cause dossier: devkit docs/recon/steam-client-classinit-injection.md.

2.8.0 (minor) — damage-meter bar numbers can now be drawn plain, with an outline, or on a soft shadow; the meter plugin exposes the choice. Additive API; binary-compatible with all existing plugins.

  • Mods can now choose how the numbers drawn on a damage-meter bar stay readable over the bar colour: plain text, the same thin dark outline the stat HUD uses, or a soft dark shadow under the numbers. CombatMeter 2.10.0 offers this as an Appearance option, useful with its new class-coloured bars (yellow, green and orange fills made plain white numbers hard to read). Nothing changes until a mod asks for it.
  • Stellar.Abstractions: MeterRowData.LabelStyle (MeterLabelStyle Plain = 0 / Outline / Shadow). Default Plain keeps every pre-2.8 plugin’s rows byte-identical.
  • WindowBuilder.MeterRow builds all three treatments per row and the binding toggles them from the row data: Outline = the framework’s existing readability outline (TextElement(Shadow: true)’s recipe, StatInspector’s stat HUD: uGUI Outline, black @ 0.85, effectDistance (1.1, -1.1); factored into UGuiPrimitives.AddReadabilityOutline and shared by both call sites — the 1.1 px sub-pixel offset is what keeps a small bold glyph’s halo smooth; exactly 1.0 px stair-steps); Shadow = two RawImage fades under the values (64 px × font scale, plateau + SmoothStep ramp, mirrored for the right end) whose alpha lerps 0.12 → 0.52 with the fill’s relative luminance (LabelFadeTint, retinted whenever the fill colour changes). Measured trigger: with CombatMeter 2.10.0’s class palette the fill can be #f2dc3a / #5ccf36 / #f5761c, where white text has a WCAG contrast of 1.4–2.0. Owner 2026-09-09 after four in-game rounds: “it should be option for players: normal text, outline, smooth shadow”. FrameworkVersion.Value 2.8.0. Design record: devkit docs/superpowers/specs/2026-09-09-game-class-palette-and-gauge-color-design.md.

2.7.4 (patch) — fixes a mod-caused startup crash on the Steam version of the game. Infrastructure-only; no API change, binary-compatible with all existing plugins.

  • Fixed the mod crashing the game on startup on the Steam version of Star Resonance. (The standalone launcher version was not affected.)
  • Il2CppInterop’s IL2CPP type injector (InjectorHelpers.FindClassInit) finds native Class::Init by scanning GameAssembly.dll for a hardcoded x86-64 call-site byte-signature. The Steam StarSEA_STEAM build — a separate SKU compile, identical Unity 2022.3.59f1 / IL2CPP metadata v31.1 — has codegen that scan mis-resolves to a bad pointer, hard-crashing the CLR (0x80131506, an uncatchable ExecutionEngineException) at the framework’s FIRST ClassInjector.RegisterTypeInIl2Cpp (StellarTicker). Reproduced identically on Il2CppInterop 1.5.1 and 1.5.3, so a BepInEx bump does not fix it.
  • Fix: new Il2CppClassInitFix.EnsureSeeded (Infrastructure), called at the top of UnityTickHost.Install before the first injection, reflectively pre-seeds the process-global InjectorHelpers.ClassInit with Il2CppInterop’s own documented substitute export (il2cpp_class_has_references) so the ClassInit ??= FindClassInit() guard skips the broken scan. Always-on (all builds): harmless where the scan already worked — the substitute is the library’s own fallback for injected classes — verified in-world on the standalone with all injections (StellarTicker, WindowInteractionTicker, ChartGraphic) succeeding. Idempotent, never throws. FrameworkVersion.Value 2.7.4; no API change. Root-cause dossier: devkit docs/recon/steam-client-classinit-injection.md.

2.7.3 (patch) — stable release of the 2.7 line. Identical code to the 2.7.2 testing build; the number moves only because 2.7.2 was already published to the testing channel and a taken version is never re-minted. No API change; binary-compatible with plugins built against ≤2.7.2.

  • Stable release of the 2.7 line. Same code as the 2.7.2 testing build — the buff and stat recording the logs site’s experimental raid-contribution view needs (Own / Given, and the Buffs tab), plus everything from 2.6.4. Nothing else changes for players coming from 2.6.4 beyond that recording.
  • Promotion only — no source change. The merged tree is byte-identical to feat/attr-changed-event@73f349e (the build on the testing channel since 2026-09-09); origin/main (2.6.4, d6a51db) contributed no content because the branch had already merged the v2.6.4 tag lineage. FrameworkVersion.Value 2.7.3.
  • 2.7.2 cannot be re-used for the stable publish: Stellar-2.7.2.zip is already on the CDN under the bundle-immutability guard, and a GitHub pre-release tagged v2.7.2 already exists — so the stable promotion rides a patch bump. What the 2.7 line actually adds is under the 2.7.2 / 2.7.1 / 2.7.0 entries below.

2.7.2 (patch) — the testing-channel framework now carries the 2.6.3 and 2.6.4 fixes. Additive; binary-compatible with plugins built against ≤2.7.1.

  • Mods can now tell which of your characters you are currently playing, so features that save things per character keep each character’s data separate.
  • Fixed moved HUD elements (quest tracker, boss health bar, and others) jumping to the wrong position after you change your screen resolution.
  • Fixed the boss health bar drifting out of place after you repeatedly hide and show it in Settings.
  • HUD elements you have repositioned now fall back to their normal in-game position at a resolution you have not customized yet, instead of getting stuck off to one side.
  • Merge of v2.6.4 (d554236, built on v2.6.3) into the 2.7.x line (feat/attr-changed-event, on top of 2.7.1 = 2.7.0 + v2.6.2); FrameworkVersion.Value 2.7.2. Brings long IPlayerIdentity.CharId and the native game-UI repositioning fixes; the 2.7.0 CombatEvent.EntityAttributesChanged groundwork is unchanged. Details under the 2.6.4 / 2.6.3 entries below.

2.7.1 (patch) — the testing-channel framework now carries the 2.6.2 loadout fix. No new API; binary-compatible with plugins built against ≤2.7.0.

  • Switching between two loadouts that share a Deep-Slumber (Psychoscope) factor no longer stops partway with “Deep-Slumber partly applied” — the 2.6.2 fix, now included in the testing channel.
  • Merge of the v2.6.2 hotfix (hotfix/deepslumber-cross-loadout-2.6.2, off v2.6.1) into the 2.7.0 line (feat/attr-changed-event); FrameworkVersion.Value 2.7.1; no source change beyond the merge and the version constant.

2.7.0 (minor) — no player-visible change yet; internal groundwork for an upcoming raid-contribution DPS (rDPS) feature. Additive, binary-compatible with plugins built against ≤2.6.1.

  • CombatEvent.EntityAttributesChanged: a player’s numeric attributes changed (one event per wire packet, stamped like the packet’s buff events) — enables the CombatMeter stat-sheet track for rDPS.
  • Entity attribute capture now stores a genuine zero value (single 0x00 varint) instead of dropping it; non-varint payloads are still skipped.

2.6.4 (patch) — new plugin API so mods can tell which of your characters is logged in. Additive interface member; binary-compatible with plugins built against ≤2.6.3. Requires updating LoadoutSwitcher + Wardrobe to their per-character builds to take effect.

  • Mods can now tell which of your characters you are currently playing, so features that save things per character keep each character’s data separate. This makes the LoadoutSwitcher and Wardrobe updates possible: your Deep-Slumber loadout bindings and your saved outfits are now remembered per character instead of one shared set that switching character would overwrite.
  • Adds long IPlayerIdentity.CharId (Stellar.Abstractions/Services/IPlayerState.cs): the local character’s stable id, char-record-backed so it is known before the world entity syncs (like Name/Level/Profession), 0 when not yet resolved; NOT gated by IsAvailable. PlayerStateService exposes the already-tracked _identityCharId (fed from IPlayerStateProbe.CharId, cleared to 0 on logout / character change) — no probe change. MockPlayerState returns a fixed id for tests/sandbox.
  • Additive (a new interface member + getter): binary-compatible with plugins built against ≤2.6.3, but a plugin that calls CharId requires this framework — so LoadoutSwitcher and Wardrobe bump their min framework to 2.6.4. Abstractions/Application surface only; built on v2.6.3 (native-UI layout fixes), which also carries the 2.6.2 Deep-Slumber cross-loadout factor-move fix.
  • Pinned by PlayerStateService identity test CharIdReflectsIngestedIdentityAndResetsOnLogout (CharId reflects the ingested identity, resets to 0 on logout / character change).

2.6.3 (patch) — moved HUD elements stay where you put them across resolution changes and Settings toggles. Infrastructure/Application-only, binary-compatible with plugins built against ≤2.6.2.

  • Fixed moved HUD elements (quest tracker, boss health bar, and others) jumping to the wrong position after you change your screen resolution.
  • Fixed the boss health bar drifting out of place after you repeatedly hide and show it in Settings.
  • HUD elements you have repositioned now fall back to their normal in-game position at a resolution you have not customized yet, instead of getting stuck off to one side.
  • All in the native game-UI repositioning path (PandaHudAdapter / NativeUiService / INativeUiAdapter). The SetRect idempotent guard was reworked to key on (target, anchoredPosition, curatedSize) equality, fixing three defects plus a new position-only fallback: (1) reflow-freeze — a moved HUD element dropped to the bottom after a resolution round-trip (translate applied against a transient/collapsed size, then froze when the element reflowed); (2) toggle-ratchet — the boss HP bar crept left on repeated hide/show in Settings; (3) off-edge churn — elements whose curated rect sits past a screen edge re-applied every tick (harmless, now skips); (4) unconfigured-resolution fallback — new INativeUiAdapter.RestoreOriginalPose returns a moved element to the game’s default position at a resolution with no saved layout (previously it stayed stranded at the prior resolution’s offset). Scope: src/Stellar.Infrastructure/Game/PandaHudAdapter.cs, src/Stellar.Application/Services/NativeUiService.cs, src/Stellar.Application/Abstractions/INativeUiAdapter.cs, tests/Stellar.Application.Tests/NativeUi/NativeUiServiceTests.cs. INativeUiAdapter is an Application-layer outbound interface, not the public plugin surface — no plugin API or behavior change outside native-UI positioning. Compile clean; 1394/1394 tests pass (incl. a new unconfigured-resolution fallback test); all four cases in-game validated by the owner. Temporary round-trip diagnostics were added during development and stripped before release (repo grep clean).

2.6.2 (patch) — switching loadouts now moves a shared Deep-Slumber factor instead of half-applying. Application-only, binary-compatible with plugins built against ≤2.6.1.

  • Switching between two loadouts that share a Deep-Slumber (Psychoscope) factor no longer stops partway with “Deep-Slumber partly applied”. Because a factor exists only once, if the loadout you are leaving is still holding one the new loadout needs, the switch now takes it out of the old loadout first and puts it into the new one — so the switch completes. Nothing is reset and it costs no season points; the factor simply moves, the same as if you had moved it by hand.
  • DeepSlumberReconciler gains a foreign-free pass (FreeForeignSharedFactors): after the per-target-area reconcile, any factor the target wants that is still socketed in a CURRENT-season area the target does not bind is unsocketed (into the existing enable→reset→unsocket→activate→socket phase, ahead of every socket), so the target socket finds it in the bag instead of failing game code 7561 (“still socketed elsewhere”). Scoped to the current season (currentLine), to areas OUTSIDE the target (AreaId not bound — the per-area logic already reconciles the target’s own areas, so re-touching them would double-emit), and to items the target actually wants (never disturbs the other loadout’s non-shared factors); deduped by (AreaId, node) so a node id repeated across different foreign areas never drops a wanted factor. Unsocket is free + non-consuming, so this never spends reset currency. Confirmed in-game on the owner’s MAIN (2026-09-07): worldProxy.UnInstallItemToMiddleNode({nodeId}) returns code 0 against a NON-active line’s node — unsocket needs no active line, superseding the 2026-08-24 “area-relative” inference — and a real Smite↔Tank switch (12 factors) reads [LoadoutSwitcher] DS apply -> Success, with every DS op code 0 and no 7561/7555. Pinned by DeepSlumberReconcilerTests (cross-loadout free, two-foreign-areas-same-nodeid, replace+foreign coexistence, prior-season-not-freed, not-wanted-left-alone). Toir report via the owner, 2026-09-07.

2.6.1 (patch) — “no weapon skin” is saved as no weapon skin again. Infrastructure-only, binary-compatible with plugins built against ≤2.6.0.

  • Saving an outfit while your weapon wears no skin now records “no skin”. It used to record whichever skin the wardrobe was showing you at the time, so applying that outfit later put that skin back — even after you had changed to a different weapon, and even though you had never chosen a skin. Now an outfit saved with no weapon skin always shows your current weapon’s own look, whatever weapon you are holding. Outfits you already saved keep the skin they recorded until you use Update on them.
  • Capture-side half of the SkinId 0 ⇄ origin contract. The game has no “skin 0”: the Weapon Skin tab builds its tiles with isEmpty = value.Original == 1 and marks worn the tile whose Id == weaponSkillSkinVm:GetWeaponOriginSkinId(curProfessionId) (fashion_weapon_skin_select_view.lua:116-120), so picking ⊘ sends UseProfessionSkin(pid, <that origin row id>) and the server stores a CONCRETE WeaponSkinTable row whose look happens to be the weapon’s native one. Measured on the owner’s report: stored outfit 9 held WeaponProfessionId=5, WeaponSkinId=7350002 = “Mirrorlight Ring”, ProfessionId 5, Original: 1 — and profession 5 has four Original==1 rows (7350002, 7350006, 7351061, 7351062), one per weapon family, so the raw id pins the outfit to the weapon it was saved with. PandaFashionProbe.WeaponCaptureLua now normalises a worn skin equal to GetWeaponOriginSkinId(cur) back to 0, where cur is CharSerialize.professionList.curProfessionId — exactly the id profession_vm.GetContainerProfession returns, which that VM method requires to match or it returns nil. Both consumers already resolved 0 → origin at USE time (BuildWeaponSkinChunk for apply, mirroring AsyncUseProfessionSkin:199; PandaWardrobePreviewProbe.WeaponSkinSourceLua for the 3D preview), so only the producer was wrong; ParseWeaponSkin and the "<pid>:<skin>" global format are unchanged, and the IWardrobe.GetWornWeaponSkin XML doc now states why 0 is the honest value. The origin lookup sits in its OWN pcall nested inside the weapon block’s, so a nil VM, a throwing GetVM, a throwing GetWeaponOriginSkinId or an origin that resolves 0 all keep the RAW id rather than losing the capture. Verified against real Lua 5.3 with stubbed Z.ContainerMgr.CharSerialize + Z.VMMgr.GetVM('weapon_skill_skin'), 9/9 cases: worn 7350002 / origin 7350002 → "5:0"; worn 7350003 / origin 7350002 → "5:7350003"; origin call throws → "5:7350002"; UseSkinId nil → "5:0" (no VM call at all); plus VM-nil, GetVM-throws, origin-0, float-typed UseSkinId and no-current-class. Pinned by WardrobeWeaponSkinTests.CaptureChunk_ReportsTheCurrentWeaponsOriginSkin_AsNoSkin. Owner report 2026-09-05, after the 2.6.0 release.

2.6.0 (minor) — saved outfits can now carry your weapon skin, and the outfit preview shows both head accessories. Additive, binary-compatible with plugins built against ≤2.5.0.

  • Plugins can now read the weapon skin your current class is wearing and switch it for you, through the same game action as the Wardrobe’s Weapon Skin tab. The Wardrobe plugin uses this to save and re-apply your weapon skin together with an outfit.
  • The outfit 3D preview now shows the weapon skin a saved outfit carries, so you see the whole look before you switch. Weapon skins belong to one class, so the preview shows it when the outfit’s weapon skin is for the class you are currently playing — otherwise the weapon is left as it looks now.
  • The outfit 3D preview no longer shows two weapons at once. When a saved outfit carried a weapon skin, the preview drew that skin and the weapon you are currently holding; it now shows only the saved one, the way the game’s own wardrobe and shop previews do. Outfits saved before weapon skins existed still preview with the weapon you are wearing.
  • The outfit 3D preview now shows both head accessories at once. An outfit with two head pieces used to preview only the second one — the first appeared for a moment and was then replaced.
  • No more freeze when a plugin saves its settings. Saving an outfit in the Wardrobe used to lock the game up for about a third of a second and then stutter for a few seconds afterwards — the more you had saved, the worse it got. Saving is now instant, however many outfits you keep.
  • Switching to the loadout you are already wearing no longer re-equips everything. Pressing it a couple of times in a row used to freeze the game for seconds and then stutter; it now does nothing but tell you that loadout is already on.
  • On-screen notices no longer hitch the game when several arrive at once. Saving a few outfits in a row, or tapping a loadout hotkey repeatedly, used to drop frames for every notice it put on screen; notices now reuse the banner that is already up, and a notice repeating word-for-word while its own copy is still visible is left alone instead of stacking.
  • Loadout switches now respect the game’s own three-second switch cooldown, exactly like the in-game dropdown does: a second press right after the first is refused — with the game’s own “you switched too recently” message — instead of piling another full re-equip on top of the one still running.
  • IWardrobe gains GetWornWeaponSkin() → WardrobeWeaponSkin(ProfessionId, SkinId) (read from CharSerialize.professionList.professionList[curProfessionId].UseSkinId in the same capture chunk as the outfit) and ApplyWeaponSkinAsync(professionId, skinId) (drives WorldProxy.UseProfessionSkin exactly as weapon_skill_skin_vm.AsyncUseProfessionSkin does: skin 0 → the class’s origin skin, OnWeaponSkinChange dispatch on ok; shares the single in-flight slot with ApplyAsync, so await the outfit before sending the skin). Weapon skins stay OUT of the outfit region map (WardrobeRegions.All unchanged) — they are a per-class game system. Pinned by WardrobeWeaponSkinTests + WardrobeServiceTests.
  • PandaWardrobePreviewProbe now stamps each SingleWearData.SlotID with the piece’s FashionRegion — the shape of the game’s own fashion_vm.GetFashionWearList (data.SlotId = region). SlotID routes head pieces to their mount (713 → HeadWear, 718 → HeadWear2); SlotID=0 put both on one mount so the second overwrote the first. Pinned by WardrobePreviewChunkTests. Discord report 2026-09-03.
  • Weapon-skin preview: WardrobeRegions.WeaponSkinPreview (731) is a preview-only key on IWardrobePreview.Show’s outfit map — IWardrobe.ApplyAsync ignores it and it stays out of WardrobeRegions.All (still 14). A weapon skin can never travel in EWearFashion (the game’s own fashion_vm.GetFashionWearList skips 731), so PandaWardrobePreviewProbe keeps 731 out of the SingleWearData list and instead re-skins the social data the model is built from: socialData.professionData.weaponSkin = skin, written before Z.ModelManager:GenModelByLuaSocialData. SocialData.professionData is the {profession_id, weapon_skin} block the server fills for SocialDataType.SocialDataTypeWeapon (const_value.lua:117), and socialData is a plain Lua table (world_proxy.GetSocialData:21831 returns pb.decode output with camelCase keys), so the field is directly writable. The display-override attr (m:SetLuaIntAttr((Z.ModelAttr).EModelDisplayWeaponSkinId, skin)) is still emitted last as a secondary, but it is NOT the mechanism: all three game call sites dress the cached PLAYER model (GetCachePlayerModel — fashion_system_view:831, shop_fashion_sub_view:300, competency_rating_main_view:253), never a social-data model, and the owner’s in-game test showed the preview keeping the live weapon for every outfit. The injection alone renders TWO weapons (owner, 2026-09-05: “it show with currently weapon using … previewer show player have 2 weapons skin rendered”, with social=set(prof=2,was=nil) in the log): a social-data model carries two independent weapon renderers — the CMount attachment (EModelCMountWeaponL/R, string model paths that ride in with the social data; Panda.ZGame.WeaponOriginData bundles ModelCMountWeaponL/R beside WeaponSkinId/MainModelId) and Panda.ZGame.WeaponModelComp, which owns its own weapon GameObjects (mainWeaponModel_/subWeaponModel_, getWeaponMount/clearModel) and is driven by the profession+skin data. So the chunk now does what every game view that shows a weapon skin on a preview model does — clear the CMount first, then ask for the skin: fashion_system_view.initPlayerModel:844-845 (the screen hosting the weapon-skin tab whose SelectStyle:26 sets the override) and shop_fashion_sub_view.initPlayerModel:319-320 (ShowPlayerWeaponModel:275 sets it), the same SetLuaAttr(EModelCMountWeaponL/R, "") pair every weaponless social view uses (investigation_clue_window_view:942/944, rank_main_view:503/637). The clear is emitted only when the outfit carries a weapon skin and is skipped at run time when the resolved skin is 0, so no outfit can leave the model unarmed. Skin 0 = the class’s default look and resolves through GetWeaponOriginSkinId exactly as AsyncUseProfessionSkin:199 does. Class-match is the caller’s rule (every WeaponSkinTable row is ProfessionId-scoped; the game’s own tab refuses other classes at fashion_weapon_skin_select_view.lua:100-106). All three weapon pcalls CAPTURE their result and every preview writes a one-line outcome the host logs unconditionally: [WardrobePreview] weapon none / … weapon skin=<id> social=set(prof=2,was=nil) mount=cleared(L:<path>,R:<path>,skinModels:<WeaponSkinTable.WeaponModelId list>) disp=ok / … mount=skip(skin0) / … social=err: | mount=err: | disp=err:. The mount values are read BEFORE the clear, in their own nested pcall so a read failure can never block the clear, and the skin’s own weapon model ids sit beside them — one owner log now says which renderer held which weapon. The 2.6.0 silent pcall made the failure undiagnosable from the owner’s log. Pinned by WardrobePreviewChunkTests. Owner reports 2026-09-05.
  • Plugin-config save path taken off the large-object heap. Owner report 2026-09-05: every click of Wardrobe’s save button (53 outfits, 57 KB config) froze a frame for 287-366 ms and then stuttered for seconds. Measured on the owner’s real config, 53 saves × 3 watcher events, running the actual PluginConfigService + FileConfigStore: 1,169 KB/save and 7 full gen2 GCs → 130 KB/save and 0 GCs of any generation (CPU 1.67 → 0.64 ms/save; gen2 pauses on this client are 100-475 ms, per the 2026-07-25 jitter investigation). Three causes, all fixed: (1) FileConfigStore.HandleFileTouch did File.ReadAllText + Encoding.UTF8.GetBytes + SHA256 for EVERY FileSystemWatcher event (Wine delivers 2-4 per write) before the self-write check — a 106 KB LOH string + 54 KB array just to recognise our own write; a new SelfWriteLedger now answers that from one FileInfo ((Length, LastWriteTimeUtc)) with the content hash kept as the fallback for events that race File.WriteAllText. (2) PluginConfigService.SaveSection deep-cloned the whole root (ToJsonString + Parse) only to hand it to a store that serializes it again — it now passes the live root under the existing lock, and IConfigStore.Save documents the serialize-synchronously / retain-nothing contract. (3) Config files are now written compact, not indented — the owner’s nested config inflated 20 K → 55 K chars when indented, putting every save’s string over the 85 KB LOH threshold; readability of the on-disk file is the deliberate trade, and reading still accepts indented files (rollback-safe, process rules § 6). Pinned by SelfWriteLedgerTests (11), FileConfigStoreEchoTests (9, incl. zero-read echo suppression and a same-length external edit that must still be detected) and PluginConfigServiceTests.Save_HandsTheStoreTheLiveRoot_NotAFreshClonePerSave.
  • WindowBuilder.LoadIcon now dedups Texture2D decodes through the token’s byte[]-keyed AtlasCache — previously only SpriteElement and the live tile-icon binding did, so every other icon leaf (button chips, images, brand logo, pin stars) re-decoded per widget: the Wardrobe’s 20-row × 9-chip pool built ~180 textures from 8 distinct PNGs on each window open. Dedup now lives in exactly one place (BuildSprite and IconBinding dropped their own copies). Safe to share because tinting is per-graphic (.color) and sub-rect selection per-RawImage (.uvRect) — nothing is baked into the texture; IconTextures remains the single owner, so disposal is still one Destroy per texture.
  • Loadout switch pre-dispatch gates (owner report 2026-09-05: three same-loadout presses = a 3,261 ms frametime spike, then stutter; log showed eight consecutive [LoadoutSwitcher] Switched to Beam). The removed fast-path comment in PandaLoadoutProbe.CallApplyAsync claimed the game “cheaply no-ops a switch to the already-active loadout” — REFUTED by weapon_vm.lua:509-514, which builds {oldProjectId=CurPlanId, newProjectId=planId} and fires WorldProxy.SwitchProject unconditionally, then (:536-542) stamps SwitchRolePlanTime, saves currentProjectSyncData and dispatches OnRolePlanChange — a full server re-equip. The game’s own dropdown never allows it: role_plan_loop_item.lua:66 ignores the click when CurPlanId == PlanId, :118-121 refuses inside Global.lua:1703 CombatStrategySswitchCd = 3 (tip 150208), :122-125 refuses in battle (tip 150206). New pure PandaLoadoutProbe.DecideSwitch mirrors the first two: same plan → LoadoutResult.Success with nothing dispatched ([Stellar][Loadout] switch to <id> skipped: already active), within 3 s of our last dispatch → Rejected (… refused: within the game's 3s switch cooldown). Combat is unchanged — the server + the game’s own wrapper still own that refusal. PendingSwitch now records whether the live plan already matched at dispatch and skips the vacuous _currentId == TargetId completion fallback in that case, so a switch can no longer “complete” on the first ~33 ms poll and let the caller’s single-flight guard start an overlapping burst. Pinned by PandaLoadoutProbeSwitchGateTests. A cooldown refusal also shows the game’s OWN tip rather than only a log line (the LoadoutSwitcher plugin’s Report toasts only on Success): BuildShowTipsChunk emits pcall(function() Z.TipsVM.ShowTips(150208) end) — the exact dot call role_plan_loop_item.lua:119 makes, localized by the game — queued on the probe’s existing main-thread dispatch queue and drained by the same DrainPendingDispatches pass (no new thread hop). One tip per refused press, capped at MaxQueuedTips and dropped on ClearSession.
  • The per-class gear/module resolve is now debounced on the TRAILING edge of the delta burst. The walk is whole-item-container (uuid index over every package + a gear read per slot per plan) and a re-equip burst re-arms it on every CharSerialize delta, so ungated it ran at the full ~30 Hz drain rate through each burst — the ~1.8 MB/s allocation class behind the 2026-07-25 A/B’s 100-475 ms GC frames. A leading-edge cooldown (walk now, then wait a window) bounded the rate but still walked THROUGH the burst, twice for a ~1 s burst, both times against half-applied state. TryResolvePerClassDetailsIfDue now consumes _resolvePending once per tick into a sticky _resolveArmed (the arming sites live in sibling partials and a bool cannot carry “again”), restarts a quiet timer on every new arm, and walks only after ResolveQuietTicks (15 ≈ 0.5 s) of silence — one loadout switch = ONE walk, against the burst’s final state. DEFER, NEVER DROP: the arm survives in _resolveArmed until the walk runs, and ResolveMaxDeferTicks (60 ≈ 2 s, counted on EVERY armed tick so a saturating stream cannot starve it) forces a walk during an endless stream, so “late, never stale” keeps a hard ceiling. The pure PandaLoadoutProbe.DecideResolve now takes (resolveArmed, resolverAttached, hasInputs, quietTicks, deferTicks); the gate still wraps TryResolvePerClassDetails rather than living inside it, so every existing live-state / Deep-Slumber resolve pin drives the unchanged inner method. New always-on, self-limiting line [PerClassLoadout] walk {ms}ms plans={n}, emitted only above 33 ms (zero volume in normal play, no diagnostics restart needed to attribute a reported spike). Pinned by PandaLoadoutProbeResolveGateTests (10, incl. a burst replay that scores 1 walk where the leading-edge form scored 2, and a saturating-stream starvation pin).
  • Notice tips no longer re-open noticetip_pop per tip. Owner reports 2026-09-05: (1) holding a loadout hotkey on the already-active loadout gave 4-5 frames of 100-185 ms over 3-5 s even though the framework SKIPPED every switch (no RPC) — the toast was the only game-engine touch left on that path; (2) repeated “Save current outfit” still stuttered (max 428 ms), and those toasts carry DISTINCT text so a dedupe alone could never have fixed it. Root cause: Z.UIMgr:OpenView('noticetip_pop') once per tip, run synchronously on the main thread inside the service tick. On an ALREADY-OPEN view that is not cheap (ui_manager.lua:112-161): the open list is re-ordered (:137-145), Z.UICameraHelper:OpenUICamera runs (:151), and ui:Active (:152 → ui_base.lua:45-59) reaches SetAsLastSibling (:53 → ui_view_base.lua:80-85 = a transform re-parent PLUS Z.UIMgr:UpdateDepth over the layer, i.e. a canvas rebuild) before it ever gets to OnRefresh (:55), then ViewStatusSwitchMgr:TrySetStateActive (:158) and a global EventMgr:Dispatch(UIOpen) (:160) fire. The view already drains its own queue — OnRefresh dequeues one item when it has no viewData (noticetip_pop_view.lua:80-86), showPopTip holds three at a time and re-enqueues the overflow (:130-133), each item’s OnEnd pulls the next (:210-214) — so BuildPopChunk / BuildPopTipChunk now enqueue and then refresh the LIVE view (GetView + SetViewData(nil) + CallLifeCycleFunc(OnRefresh), the same tail Active would have reached), keeping OpenView only as the else fallback for when there is no active/loaded/visible view — so no tip can be stranded in the queue. Two service-side bounds on top: the drain takes ONE tip per tick (a lone tip still shows on the very next tick), and a chunk byte-identical to one still inside its own delay+duration window is dropped by the pure NoticeTipService.DecideShow — the same call the game’s own checkConfigRepeat makes (noticetip_data.lua:8-22), which never fires for us because our tips carry Id=0 and so have no MessageTable row. DIFFERENT content is never dropped. New always-on, self-limiting line [NoticeTips] slow show {ms}ms, emitted only above 33 ms. Pinned by NoticeTipSpamTests (10).

2.5.0 (minor) — the Loadout Switcher can switch your whole Deep-Slumber (tree and all), plugins get accurate raid boss health, and raid runs record as one run. Additive, binary-compatible with plugins built against ≤2.4.1.

  • Plugins can now read a boss’s exact health straight from the game, and can tell when a raid boss has actually gone down even when the game never shows its health hitting zero. The Combat Meter uses this for accurate boss health in raid replays.
  • The Loadout Switcher now switches your entire Deep-Slumber when you change loadouts — its tree, not just the phantom factors. Switching to a loadout whose Deep-Slumber uses a different tree now rebuilds the tree for you instead of stopping half-done, and it no longer stutters while it applies.
  • Raid runs are recorded as one continuous run again, instead of being split into pieces when the game’s own timers reset partway through the fight.
  • DeepSlumberAreaBinding gains a non-positional NormalNodes init member (the tree / Anchor allocation — kept off the primary constructor so it stays binary-compatible with ≤2.4.0). DeepSlumberReconciler now diffs the tree and, when it differs, drives ResetAllNodes + ActiveNormalNode (whole-area reset — the game has no per-node anchor removal, owner ruling 2026-09-01) before re-socketing factors; legacy bindings with a null tree stay factor-only. Both new worldProxy RPCs were validated in-game (code=0, zoneId=areaId). New Kind-phase order: enable → reset → unsocket → activate → socket.
  • The loadout live-state refresh now defers its full-container walk while a plugin Deep-Slumber apply is in flight (PandaLoadoutProbe.DecideRefresh gated on PandaSeasonTalentProbe.HasPendingWrites), collapsing the per-op CharSerialize burst into one refresh after the apply settles — removes the 3-5 frame hitches a tree rebuild otherwise caused. Mirrors the existing combat-defer; a manual in-game switch is unaffected.
  • Native boss-HP tap: IBossVitals + EntityVitalsService read boss HP from the game’s own entity, with EDisappearType-aware AOI eviction and an AttrMaxHpTotal(11321) fallback; a raid boss whose HP never reads 0 is detected as HP≈1%-then-vanish. IRunTimer latch-epoch gives upgrade-proof run identity so an evidence-less belt resolution cuts a segment without resetting the run’s identity (raid run-split fix; spec 2026-08-26).

2.4.1 (patch) — stops a repeated combat popup during long fights. No API change; binary-compatible with all existing plugins.

  • No more repeated “Cannot perform this action during combat” popup during long fights. It could appear every few seconds in sustained combat, even with no plugins installed.
  • PandaLoadoutProbe now defers only the combat-gated SyncProjectList RPC (AsyncGetRolePlanData) while the local player is in combat, using the game’s own in-combat check (GetLuaLocalAttrInBattleShow()/GetLuaIsInCombat(), fail-safe to not-in-combat), and fires exactly one refresh at combat end; the RPC-free live-state re-read keeps running in combat. Root cause: every CharSerialize merge re-armed _refreshPending, and the server rejects the RPC in combat (ErrStateIllegal 3202), which the game’s own wrapper toasts (~every 5s as deltas drip in). Infrastructure-only (PandaLoadoutProbe, PandaLoadoutProbe.Resolution); no API change — binary-compatible with all existing plugins. +7 PandaLoadoutProbeRefreshGateTests. (#72)

2.4.0 (minor) — plugins can now save your outfits and switch between them, with a live 3D preview. Additive, binary-compatible with plugins built against ≤2.3.0.

  • Plugins can now save the outfit you’re wearing and switch you back to it later, and show a live 3D preview of a saved outfit on your own character. The new Wardrobe plugin uses this for instant hotkey outfit switching.
  • New plugin surface: IWardrobe (capture the worn outfit as a region→fashionId map; apply through the game’s own WorldProxy.FashionWear, keeping every server-side check) and IWardrobePreview (dress a fresh self-model with an arbitrary saved outfit via GenModelByLuaSocialData + SetLuaAttr(EWearFashion, …), rendered through a second PortraitModelHost; orbit / zoom / pan). FashionEntry gains DyeAreas — parallel to Dyes, carrying each dye’s EFashionColorAreaType so multi-area pieces preview on their real areas; AttrFashionDataReader now reads both the base (field 2) and attachment/socks (field 3) colour maps. RE: docs/recon/wardrobe-fashion-preview.md.

2.3.0 (minor) — plugins can now apply a Deep-Slumber setup for you, and applying one is fast and self-healing. Additive, binary-compatible with plugins built against ≤2.2.0.

  • Plugins can now change your Deep-Slumber Psychoscope for you — its cultivate line and its phantom factors. The Loadout Switcher uses this to re-apply the Deep-Slumber you bound to a loadout the moment you switch to it.
  • Applying a Deep-Slumber setup is much faster. A switch that moves a lot of factors used to take a few seconds; now it finishes in a fraction of that, and if the game drops one of the changes it quietly retries instead of stopping half-done.
  • New plugin surface: IDeepSlumber.ApplySetupAsync(DeepSlumberSetup, CancellationToken) returning DeepSlumberApplyResult, plus DeepSlumberSetup/DeepSlumberAreaBinding. The live→target diff (DeepSlumberReconciler) lives in Application; the write path drives the game’s season_talent worldProxy RPCs (Approach A — raw RPC returns the bare EErrorCode inline) via PandaSeasonTalentProbe. Docs: docs/driving-game-actions.md § Deep-Slumber.
  • Apply overlaps its server round-trips: a bounded in-flight window (5) with one-dispatch-per-tick pacing, run in Kind-phases (enable → unsocket → socket) with a barrier that preserves the scarce single-copy unsocket-before-socket invariant. Only transient (did-not-land) ops retry (initial + 2, 250 ms backoff); a positive game refusal (7555/7561/combat) is never retried.
  • LauncherEntry.TitleProvider (Func<string>?): an optional live-localized tile title. The launcher renders DisplayTitle (TitleProvider?.Invoke() ?? Title) each frame, so a tile whose plugin sets TitleProvider = () => Localization.T(key) re-localizes immediately on a language change; Title remains the stable pinned-state identity. Plugins pass a captured string today, which is why their tiles were stuck in the registration-time language.

2.2.0 (minor) — the live-build release. Stellar now notices the moment your setup changes and reads it live, and exposes the Deep-Slumber Psychoscope to plugins. Additive, binary-compatible with plugins built against ≤2.1.0.

  • Stellar now notices the moment you change your build — swapping a piece of gear (including with the Replace button), changing modules, respeccing talents, switching a Battle Imagine, or editing your Psychoscope. Plugins that record your setup, such as the Combat Meter, can now save the exact build you fought each boss with instead of whatever you happened to have on when the run started.
  • Your Psychoscope (Deep Slumber) is now available to plugins — season level, lines, socketed cards and node levels, read live from the game rather than from a saved profile.
  • Plugins can now show a second value on the same on-screen bar — for example a boss’s shield alongside its health, either as a see-through band laid over the health fill or as extra length past the end of it. Whether a plugin uses this is up to each plugin.
  • Less background work while you play. Stellar used to re-check your equipment, talents and dungeon death count on a timer every moment you were in the world; it now waits for the game to tell it something changed. Same information, noticeably less work per frame.
  • Swapping a Battle Imagine now takes effect straight away. Before, Stellar kept showing the pair you had equipped when you logged in.
  • Changing a piece of gear with the Replace button is picked up again — it used to go completely unnoticed.
  • The dungeon death counter no longer gets stuck. If a later run reached the same number of deaths as an earlier one, it used to report none at all.
  • Logging out and back in on another character no longer shows the previous character’s Psychoscope.
  • Fixed a case where the game sent several changes at once and everything after the first one was thrown away.
  • ILoadout.LiveState (LiveLoadoutState): the local player’s LIVE class + talents, parsed from the live line — never a saved plan. Refreshed with the loadout data; a respec re-fires the refresh through the new dirty-delta trigger.
  • ILoadout.LiveStateChanged: ONE game-tick event for the whole build — equipped gear/module slots, class, talent stage/nodes, the equipped Battle Imagine pair, and IDeepSlumber.GetState(). Raised only after a re-read actually CHANGED what the service serves (structural, order-insensitive compares; a not-yet-read surface is no-signal). Published from the RESOLVE step, not the raw slot read, so it can never fire while GetSlots() still describes the previous setup; an unresolvable change is held and delivered on the tick the data lands (LATE, never STALE). Raised on the game Update thread, unlike IInventory.SelfGearChanged. Deep-Slumber joined this event in 8e5a7b2 (owner staging run sea/dXkw1PSyOG: a psychoscope factor unequipped between two archives and re-equipped after — the framework re-read it correctly but told nobody, so the consumer kept one stale snapshot across two materially different builds).
  • IPluginServices.DeepSlumber (IDeepSlumber) + DeepSlumberState/DeepSlumberLine/DeepSlumberArea: live reflection reader over CharSerialize.SeasonCultivateLineData/SeasonRoleLevelData, seeded through the tolua# bridge because the C# mirror populates lazily and is a stale latch on a fresh session. zcontainer maps are iterated the game’s way — __pairs yields nil VALUES, so the reader indexes per key (owner run O1jJepsgKC). Session state clears on logout.
  • IInventory.SelfGearChanged widened to the self BUILD-state signal: generic ContainerDirtyDeltaReader.TouchesField + semantic wrappers fire it on talent (professionList, field 61) and Deep-Slumber (seasonCultivateLineData, field 101) method-22 deltas. Still network-thread — flag there, read on the tick, or subscribe to LiveStateChanged instead.
  • IResonanceState.Installed keeps its shape but changes SOURCE and id space: equipped Battle Imagines are read from the skill hotbar’s aoyi slots 7/8 as aoyi SKILL ids (IGameDataResonance.GetImagineForSkill resolves them). CharSerialize.resonance (wire field 28) is never re-serialized on an in-session swap, so the old field-28 source could not see a swap at all (owner run sea/pNhmVQvVmV).
  • Wire fix: the top-level delta scan died after the first SKIPPED field because it never consumed that field’s trailing END tag — every change after the first in one packet was dropped.
  • The framework’s last two per-tick game reads are gone. Live-state capture is driven by the container-merge event (replacing a field allowlist + a 1 s poll), and IDungeonState.LastDefeatedCount now rides WorldNtf 3 EnterScene (EnterSceneInfo.SceneAttrs, the seed) + WorldNtf 7 SyncSceneAttrs instead of a four-layer IL2CPP reflection read of ZWorld.GetWorldLuaAttr(348) on every main-thread beat — the same carrier the game’s own dungeon HUD watches. It also fixes a latent probe-side memo that never reset across runs (a second run reaching the same count reported 0 forever). StubRouter.Register is now MULTICAST with registration order preserved (WorldNtf 3 has two subscribers and the order is load-bearing).
  • BarElement.Overlay01 / OverlayColor / OverlayInFront (BarStyle.Modern only, #66): an optional SECOND fill fraction 0..1 on the SAME track as Fraction01, re-pulled each refresh through its own BarBinding. OverlayInFront: true draws it over the main fill as a translucent band (the label overlay texts still sit on top); false (default) SetAsFirstSiblings it behind the opaque main fill so only the excess shows as an extension cap (e.g. Overlay01 = (hp+shield)/max). A null Overlay01 renders the bar exactly as before, and BarStyle.Default ignores all three. Init-props only — additive, binary-compatible.
  • tools/install-stellar.sh gains STELLAR_FRAMEWORK_ONLY=1 (deploy the framework set, plugin slots untouched) and STELLAR_ONLY_PLUGINS=<slots> (deploy only the named plugin slots, framework slot untouched).

2.1.0 (minor) — Stellar’s own menus now speak your language. Adds a plugin localization API; additive, binary-compatible with all existing plugins.

  • Stellar’s settings menus now display in English, 日本語 (Japanese), ไทย (Thai), and Bahasa Indonesia. Pick your language in Settings → Themes → Language, or leave it on “Follow game client” to match your game.
  • IPluginServices.Localization (ILocalization): a plugin-scoped UI-text localizer. Ship four embedded Lang/{en,ja,th,id}.json catalogs (<EmbeddedResource Include="Lang/*.json" LogicalName="Lang.%(Filename)%(Extension)" />) and call Localization.T("key") / TFormat("key", args); resolution is active-language → English → the key literal (a missing key renders visibly as the key). The framework auto-discovers each plugin’s catalogs at plugin-load (namespaced by plugin GUID, matched by the Lang.<code>.json suffix) — no registration code. ILocalizationControl (Settings-facing, NOT on IPluginServices) drives the setting localization.language (default follow); ClientLanguageProbe maps the game client’s LanguageType (en=1,ja=2,th=5,id=6, else en) to a supported code, and the setting live-switches (labels re-poll, baked renderers flush via LanguageChanged). Catalog completeness is validated by tools/i18n-catalog.py <repo> (used/undefined/incomplete/orphan, --seed). See docs/plugin-development.md § Localizing your plugin. New service only — additive, binary-compatible with plugins built against ≤2.0.3.
  • Section headers now stand out by accent colour (the theme’s MenuAccent) instead of bold weight — crisp and clearly a header in every language. Why: under Proton/IL2CPP the overlay can’t render a readable bold for Thai/CJK — a real bold FACE will NOT load (Font.CreateDynamicFontFromOSFont verified across a host bold family name and a distinct normal-weight family installed both in the Wine prefix and as a host fc-list font — none render), and Unity’s synthetic bold blurs their tight loops/counters. So emphasis is carried by colour (WindowBuilder sets emphasis text to MenuAccent; RegisterTextReskin re-applies it on a theme change), with weight kept CRISP — Latin still gets real FontStyle.Bold (it survives synthetic bold cleanly), complex scripts (CJK/Thai) stay regular. Titles take the crisp weight but no accent (already prominent by position). GlyphScript picks Latin-bold vs complex-regular per string, so it tracks a live language switch.

2.0.3 (minor) — readable text inputs, plus internal groundwork for the CombatMeter Discord run-card and a reconnect fix that keeps a mid-dungeon disconnect from splitting your run in two.

  • Text boxes in Stellar windows are readable again — they show the dark themed background instead of white-on-white.
  • IGameAssets.LoadByPath — load an arbitrary game asset by its ZResLoader address (#61); backs the in-game image rendering for the CombatMeter Discord run-card.
  • Mid-dungeon reconnect party recovery: PandaTeamInfoRefreshProbe invokes the game’s own WorldProxy.GetTeamInfo({}) via the tolua# Lua bridge when in a dungeon with IPartySnapshot.PartyId == 0 (a reconnect drops the party id until the game lazily re-delivers it — measured arriving only after a whole run). Bounded (≤3/run, 2.5 s throttle, world-gated main-thread); the reply is decoded by the existing PandaPartyStubProbe → PartyId. Enables CombatMeter’s reconnect run-split fix by making the party id available during the run instead of after it.
  • Plugins can now show more of your character’s stats — this powers the new Illusion-Breaking Strength readout in CombatMeter.

2.0.1 (patch) — summoned-companion (imagine) damage now resolves to the right creature in combat data. Data-resolution only; no API change, binary-compatible with all existing plugins.

  • Damage from your summoned companions now shows up correctly in the combat meter and on the logs website. Some newer companion abilities weren’t being recognised, so their damage went uncredited.
  • GetImagineForSkill gains ImagineAoyiRule. Newer battle imagines flag their damage skills as SlotPositionId [0]/[6] (not the aoyi 7/8 slots) with no SkillFightLevelTable row, so resolution rejected them and player-attributed summon damage never mapped back to the imagine (measured on jp/RXALtMH6J3: Celestial Flier 1008440, Rorola 2900840, Venobzzar 1007741, Kartgriff 111069 — all invisible while their damage sat in the run’s own perActorSkills). The new rung is gated to ids with no fight-level row of their own (baseId == 0): it decomposes MonsterId*100+NN over a lazy SkillAoyiTable MonsterId→aoyi index (GameDataResonance.Aoyi.cs) plus a curated companion-arcane map (Boyce/Rorola/Fafala, table-evidenced). The gate is load-bearing — leveled player ids share the numeric namespace (140116 = Windborne Grace lv16 AND an Igoreus monster skill), and an own fight-level row wins. Negative memoisation stays pre-load-safe. Documented residuals: Igoreus/Denvel bands are ambiguous by construction; Dorothy/Lucy/Natsu have no evidenced rows and are never guessed. Also documents the NN=00 composite probe as a sanctioned CombatMeter consumer contract (summon-entity appear-sourced imagine capture). Pinned by ImagineAoyiRuleTests (23 cases incl. the collision band).

2.0.0 (major) — the interface overhaul: resize the whole mod UI, a redesigned move-and-resize editing mode, a hotkey to hide the on-screen displays, and the Stellar menu on the login screen. One rendering engine now draws every window and overlay. Breaking for plugins that draw their own on-screen display (HUD) — the old HUD API is removed and those plugins must be rebuilt against the 2.0 SDK; all other plugins stay binary-compatible. Also bundles the 1.17.0–1.18.1 player fixes for anyone updating from an older build.

  • A UI Scale slider in Settings → Themes that resizes the entire mod interface from 75% up to 150% (5% steps, default 100%). Every window and on-screen display scales together, and it previews live as you drag. Useful on very high-resolution screens where the panels felt small, or just to make everything bigger or more compact to taste.
  • The mod interface now sizes itself to your screen resolution, so it stays proportional on any display instead of being tied to raw pixels.
  • A redesigned layout-editing mode for moving and resizing the mod’s windows and on-screen displays. Turn it on with Alt+E, or with the new “Enter layout editing” button in Settings → Game UI; a bar across the top with an Exit button shows you’re editing. While editing: every on-screen display is shown — even ones you normally keep hidden — so you can position them; any window you can resize shows a small square in its bottom-right corner you can drag; and dragging stays smooth at any UI scale. When you leave edit mode, windows lock in place again.
  • A hotkey to hide or show all of the mod’s on-screen displays at once, set to Alt+H by default (this resets each time you restart the game). There’s also an optional hold-to-hide key, unbound by default, that hides them only while you hold it — handy for a quick clean screenshot.
  • The mod’s on-screen displays now automatically get out of the way while a game confirmation or OK pop-up is open, so they never sit on top of it.
  • You can now open the Stellar menu right from the game’s login screen — a Stellar button sits in the login side bar, matching the in-world one — and the mod’s own windows now work at the title and login screens too, not only once you’re in the world.
  • Settings now show each plugin’s proper name instead of its internal file name, and the Hotkeys screen groups shortcuts under the plugin that owns them, each with a short description of what it does.
  • This is a major update to how the mod draws its interface. Most plugins are unaffected, but a plugin that adds its own on-screen display may need an updated version from its author to work with 2.0.
  • What this means for your existing setup: your saved window and on-screen-display positions are kept, and are remembered separately for each screen resolution. Because the interface now scales to your resolution, the windows may look a little smaller or larger than they did in the old version — most noticeable if you don’t play at 2560×1440 (smaller below that, larger above). Nothing is lost; use the new UI Scale slider and the layout-editing mode to set the size and positions you want.
  • You now move and resize the mod’s windows only after entering layout-editing mode (Alt+E). Previously you could drag them at any time; locking them outside edit mode stops windows getting nudged by accident during play. Your positions are unchanged.
  • The option that stops the game from also reacting to your mod shortcuts is now turned on by default. If you never changed this setting, the game will no longer also respond to a key that one of your mod hotkeys uses. If you had already set it yourself, your choice is kept exactly as it was.
  • The default shortcut for layout-editing mode is now Alt+E (it used to be Shift+backtick). This only changes things if you never rebound it — a custom binding is kept. The block-hotkeys option is also now clearly worded: “Stop the game from also reacting to these keys.”
  • Plugins can now build taller, wider, or full-width bars, put a larger label centred on top of the bar, and use a flatter “meter” look with an optional soft moving shine — so a plugin can present a prominent bar like a target’s HP bar or match the Combat Meter’s style. Whether a plugin uses this is up to each plugin.
  • Your own class icon (the profession crest) now shows correctly.
  • Switching game accounts no longer briefly shows the previous account’s character data — it’s cleared when you log out.
  • Your window and on-screen-display positions now survive entering a dungeon or changing zones, instead of jumping back to their defaults.
  • Class, skill, buff, and item icons that occasionally loaded blank now retry and appear reliably.
  • An on-screen display you’ve hidden now stays hidden after you restart the game.
  • Breaking — the separate HUD toolkit is removed; there is now ONE UI path. IHudHost/IHudHandle/HudSpec/HudAnchor, HudService(+.Layout), IHudRenderer/HudRenderer, HudElementBuilder(+.Meter), and HudBarAnimator are deleted. On-screen overlays register through the window API: Windows.Register(new WindowRegistration(new WindowSpec(..., WindowCategory.HUD, WindowPanelStyle.Borderless){ Surface = SurfaceStyle.HudOverlay, Draggable = true, EditModeDragOnly = true, ShouldRender = ... }, root)). The shared HudElement record tree is unchanged. New enum SurfaceStyle { Menu, HudOverlay } (default Menu → every existing window byte-identical); HudOverlay reproduces the old HUD look (always-shadowed twin text honouring FontSize/DynamicFontSize/ShadowDistance, the rounded 9-slice smoothed-fill bar, the transparent pill) by reusing HudThemeAssets, now owned by WindowRenderer. IThemeHudColors retained (Toast + the HudOverlay bake still use it). First-party PlayerHUD / RaidManager countdown / DebugInfo migrated in lockstep, pixel-identical. Only plugins that called IPluginServices.Hud.Register(HudSpec) are affected; all others are source- and binary-compatible.
  • Source-breaking rename BarStyle.Meter → BarStyle.Modern (enum value unchanged, Default=0/Modern=1 → binary-compatible for compiled plugins). BarElement gains init-only geometry (Height/Width/FillWidth/LabelFontSize/LabelInside) plus the opt-in Modern meter style with optional Sheen/SecondaryLabel; the original positional constructor is untouched (source- and binary-compatible, unset fields default to the old render byte-for-byte). Both the HUD-overlay path and the window path (WindowBuilder.BuildBar / WindowBuilder.Preview BuildBarModernWindow) honour every new field.
  • UI scaling. Window overlay canvas gets a CanvasScaler (ScaleWithScreenSize, reference 2560×1440, match 0.5). At the reference resolution scaleFactor = 1.0 (byte-identical to pre-2.0); other resolutions convert drag/resize/on-screen-clamp/dropdown-placement/click-rect between screen px and canvas units. The UI Scale slider sets referenceResolution = (2560/u, 1440/u), persisted as theme.uiscale, quantised to 5% so the font atlas repacks only at boundaries; canvas.pixelPerfect toggles off at fractional scaleFactor to kill dragged-window jitter. LayoutStorage.Get reads saved rects as canvas units (scaleFactor-corrected) while the KEY lookup stays raw, so pre-2.0 per-resolution layouts are still found.
  • Game-phase model. GamePhase { Startup, TitleScreen, CharSelect, World } and [Flags] GameUIState (+GameHudHidden/AnyMenu/Blocking/Popup presets) on IClientState (Phase/PhaseChanged/IsWorldActive/UiState). The framework tick now runs UI/input/hotkeys every phase (so plugin windows work at title/login); game-state work self-gates per-unit on IsWorldActive, enforced by new STELLAR0006 analyzer (a [WorldGated] method must early-return on !IsWorldActive). Window visibility is plugin-owned via required WindowSpec.ShouldRender (IRenderGated), replacing AutoHideBehindGameMenus/HideUntilInWorld; the gate fails safe (null/throwing predicate → hidden + warned) so a stale pre-2.0 plugin can’t NRE the tick. Loading/Popup are driven by dedicated un-gated probes (reliable across loading screens / confirm dialogs tips_common_popup/tips_sys_dialog).
  • Login-screen integration. NativeUiAnchor.LoginSidebar injects the Stellar rail icon into login_main’s sidebar; uGUI injection is un-gated with per-anchor phase-relevance (LoginSidebar=TitleScreen, MainMenuRail/HudTopRight=World) so there is no out-of-phase probing cost. LauncherEntry.ShouldShow gates individual launcher tiles by phase; framework chrome hides over the loading screen.
  • New members (all additive/binary-compatible): GameTextureElement.CornerRadius, CooldownTileElement.FallbackLabel, IWindowHost.IsLayoutEditing.
  • Plugin identity/hotkeys. The framework adopts each plugin’s declared IStellarPlugin.Name as its display name (Plugins panel, per-plugin Performance rows, Hotkeys group header); hotkeys group by owning plugin via an internal owner-tagged declaration sink, and IHotkeyAction gains PluginId+Description. HUD-visibility adds internal IInputGateway.IsKeyHeld + HotkeyService.IsActionHeld.
  • Interop foundation (toward v2.1), additive, framework-only-implemented: StellarInterop (cached reflection floor), ILua (IPluginServices.Lua), IHarmonyHost (IPluginServices.Harmony, auto-unpatch on plugin dispose), and IFramework/IFrameworkTiming (Post/Every/TimeNow, skew-corrected ICombatSnapshot.ServerNow).
  • Icon-load resilience. Failed icon slots retry with bounded backoff (~0.5–2s, up to 4×) instead of memoizing Failed for the session; a first request that beats the HybridCLR loader registration self-heals. Fixes blank profession crest / skill / buff / item icons.
  • Other fixes: profession-crest projection falls back to ProfessionSystemTable.Icon and guards against table-not-ready; account/character data clears on logout (account-switch leak); mod-window and native-game-HUD positions survive scene change; a persisted layout-editor hide survives relaunch. Throwaway phase-diag overlay removed. Merged from main: Steam client region detection (1.18.1) and loadout talent-spec correctness (1.18.0).
  • Test suite: 1012 passing.

1.18.1 (patch) — Steam client region detection fix so runs from the Steam build upload again. Detection-logic only; no API change, binary-compatible with all existing plugins.

  • If you play the game through Steam, your dungeon runs now upload to the logs website again. The mod couldn’t recognise the Steam version of the game and was holding those runs back.
  • GameEnvironmentService now matches the running executable by name PREFIX (StarSEA → SEA, StarASIA → JP) instead of exact filename, so the Steam build’s StarSEA_STEAM.exe resolves to SEA instead of Unknown — Unknown made CombatMeter’s RegionKnownOrWarn withhold every upload. One row per region covers StarLauncher, Steam, and future store builds. Regression test SteamSeaExecutable_DetectsSea; the existing UnknownExecutable_DetectsUnknown still pins non-matches. The Steam install dir is flat (no release_<ver> segment) so GameVersion reads “unknown” there — cosmetic, not gated on for uploads. Commit 5f976ea.

1.18.0 (minor) — one additive loadout fix on top of 1.17.0: the talent specialization shown for a saved build is now read consistently with that build’s own talent nodes. Binary-compatible with plugins built against ≤1.16.1.

  • Your saved talent build now shows the correct specialization on the logs website, instead of sometimes showing a different one than the talents you actually picked.
  • PandaLoadoutProbe.Resolution now sources a saved plan’s talent stage from the live per-profession container (talentList[prof].talentStageCfgId) so the stage id agrees with the plan’s own talent nodes — fixes a stale talentStageCfgId that mislabeled the spec (e.g. run sea/ZEEJjddKHN). Single-file change to PandaLoadoutProbe.Resolution.cs; cherry-picked from e73b99b. The exploratory NotifyShowTips (m42) win-tip tap from the same session was dropped as inert — vaults do send a real settlement message, so the actual vault fix lives plugin-side (CombatMeter 1.6.1). The SquareHandle slider knob referenced in FrameworkVersion already shipped in the 1.17.0 tree and is unchanged here.

1.17.0 (minor) — kill detection from the game’s own logic, a run-id fix for instanced dungeons, per-class equipped-loadout capture, and a mounted-state stats-survival fix. Additive; binary-compatible with plugins built against ≤1.16.1.

  • The Combat Meter can now tell exactly when an enemy dies — including bosses finished off by a cutscene or scripted move, not just a normal killing blow — so fights are timed and scored correctly.
  • The logs website can now show the gear, modules, and talents you currently have equipped, for each class you play.
  • Some dungeon runs weren’t being saved to the logs website — they’re recorded correctly now.
  • Your character’s stats and info no longer disappear while you’re mounted.
  • Run-id: 3.7 instanced/Mistveil scenes whose scene uuid is below 2^53 were misclassified by magnitude; now classified by SceneType and early at the wire via AttrSceneBasicId (341). Fixes “No run id” (ranked runs not uploading). Commits 4683d8d, 9cb72c8.
  • LIVE per-class loadout: parse the refresh chunk’s LIVE row (_StellarLiveProbe) so a played class exposes its currently-equipped gear/modules/talents, and it is the sole source when a class has no saved plan. Commit ba74dd3 (+ the per-class gear/modules/talents series a513b29..c1a9d65).
  • Player-state: rescue the local player entity when it goes dark while mounted so PlayerStats/identity survive mounting; identity served from the char record, not the world entity. Commits 1107646, 615042d, 7a40e28.
  • New Stellar.Abstractions.Domain.ActorState enum (Dead=9, Breaking=23, Unknown=0 for any other/future wire value) and CombatEvent.EntityStateChanged(TimestampMs, TargetId, ActorState), riding the existing ICombatEvents stream — no service interface gains a member, so STELLAR0005’s 8-member ceiling is untouched. Field-proven after three recon rounds — see recon/entity-state-death-signal-notes.md. Round 1’s spec’d leaf, Panda.ZGame.EntityCtrlDead.OnEnter, installed cleanly but stayed silent across all ten deaths in the owner’s confirming run: disproven. Round 2 tried the wider Panda.ZGame.ZStateMachine.onStateChanged/EnterState hooks on top; onStateChanged never fired (a real negative result), but EnterState fired correctly for every one of the ten deaths and resolved Dead correctly — it was not broken, just costlier (it fires on every actor’s every transition, not just the one we care about), so round 3 drops it in favour of the cheaper leaf and keeps it on record as a field-proven fallback if ZStateDead is ever removed/renamed. The shipped design patches exactly two sites: Panda.ZGame.ZStateDead.OnEnter (PROVEN — all ten deaths) and Panda.ZGame.ZStateBreaking.OnEnter (untested, not disproven; kept as the direct sibling of the proven hook, and as a timestamp source for an open frametime-spike investigation). Each site resolves/installs independently and degrades to “signal off” (logged) rather than throwing if a type/accessor is missing after a future game patch — see PandaEntityStateProbe. The site-attributed, per-scene-budgeted ungated observation line survives the cut-down unchanged. 2026-07-28 entity-state-death-signal spec; retires the HP-inference gone-timeout for ArchiveReason.BossKill on the plugin side (follow-up work, not in this release).

1.16.1 — same code as 1.16.0, re-cut under a fresh bundle filename because a CDN cache mismatch left some 1.16.0 downloads stuck at 100%. Carries the full 1.16.0 patch notes so players updating straight from 1.15.0 see what changed.

  • Update download no longer gets stuck at 100% for some players (a caching problem on our download server with the 1.16.0 file — this version uses a fresh file).
  • Much higher FPS in dungeons and busy areas. The framework was quietly doing heavy background work several times per second — on our test machine that alone cost up to 50 FPS in a dungeon (86 to 144 after the fix). This work is now nearly free.
  • The regular micro-stutter is gone. If your frametime graph showed small spikes about 5 times every second — even with no plugins installed — that was us. Fixed.
  • No more short freezes every few seconds. The framework re-checked your whole inventory once per second and threw the result away, which piled up memory and caused brief frozen frames (worst on lower-end PCs). It now only does that work when your inventory actually changes.
  • Smoother big fights. Network and combat data is now processed with far less memory churn, so crowded areas and boss fights cause fewer hitches.
  • Zero input overhead unless you use key-blocking. The hotkey “block from game” feature used to sit on the game’s keyboard input all the time; now it activates only while you actually have a blocked hotkey or are recording a new one.
  • Identical framework code to 1.16.0 (only FrameworkVersion + this changelog differ). The 1.16.0 manifest republish (player-facing patch notes, PR #46) rotated the bundle sha256 while CDN edges still held the previous zip (max-age 14400); launchers on those edges failed the hash check and hung at 100%. A fresh Stellar-1.16.1.zip filename has no cached copies anywhere, so every edge serves consistent manifest+bundle. Lesson (now in docs/release-process.md): a same-version republish requires an immediate CDN purge; prefer a patch bump instead.
  • Patch-note bullets are now plain text (the launcher renders no markdown — 1.16.0’s ** showed literally).

1.16.0 (minor) — the frametime-jitter release: eliminates the framework’s in-dungeon FPS loss and frame-spike comb, root-caused by matched A/B on a live client (PR #44). Additive; binary-compatible with plugins built against ≤1.15.0.

  • Much higher FPS in dungeons and busy areas. The framework was quietly doing heavy background work several times per second — on our test machine that alone cost up to 50 FPS in a dungeon (86 → 144 after the fix). This work is now nearly free.
  • The regular micro-stutter is gone. If your frametime graph showed small spikes about 5 times every second — even with no plugins installed — that was us. Fixed.
  • No more short freezes every few seconds. The framework re-checked your whole inventory once per second and threw the result away, which piled up memory and caused brief frozen frames (worst on lower-end PCs). It now only does that work when your inventory actually changes.
  • Smoother big fights. Network and combat data is now processed with far less memory churn, so crowded areas and boss fights cause fewer hitches.
  • Zero input overhead unless you use key-blocking. The hotkey “block from game” feature used to sit on the game’s keyboard input all the time; now it activates only while you actually have a blocked hotkey or are recording a new one.

These details never appear in the launcher — full technical background lives here and in PR #44.

  • Anchor probe: PandaUGuiAdapter ran a path-form GameObject.Find (full scene walk, ~30 ms/hit in dense scenes) every 200 ms while the game menu was closed; now cached zuiroot + relative Transform.Find, active-only contract preserved. A check-standards blocker now bans path-form GameObject.Find literals (exemptions: devkit tech-debt D-26).
  • Inventory: the 1 Hz poll rebuilt the full module inventory via reflection (~1.8 MB/s garbage → 100–475 ms stop-the-world GC frames on low-spec); now generation-guarded on actual inventory syncs. Measured avgUpdAlloc 55 → 9.8 KB/tick.
  • Wire tap: handler snapshot resolved before payload materialization (unsubscribed AOI/world traffic no longer copied), zero-copy reassembly drain, cached per-thread zstd decompressor with exact-size output, quiet-connection eviction + drained-buffer shrink.
  • Input: Rewired.Keyboard.GetKey* prefixes (~8–25k calls/s at render rate) install on first block/capture and uninstall when cleared; primary-key pre-filter before modifier interop reads.
  • Combat parse: AOI attr payloads slice the per-packet array (−45% alloc per combat packet), lazy cooldown list, positions cache uses an Interlocked counter instead of per-update ConcurrentDictionary.Count, compiled delegate replaces MethodInfo.Invoke for the IL2CPP span extractor.
  • New PERFHUD diagnostics: PerfProbe.HookEndRewired + hook:rewired=ms/calls in the [Perf] line, and BeginSeg coverage for the previously unsegmented tick items.

1.15.0 (minor) — adds per-plugin binary file storage, the substrate for CombatMeter’s byte-for-byte re-upload. Additive; binary-compatible with plugins built against ≤1.14.0.

  • IPluginServices.Data (IPluginDataStore) — per-plugin binary file storage (Write/Read/Delete/List) for data too large or opaque for IConfigSection. Never-throws; names are path-traversal-safe (rejects .., rooted paths, backslashes, >1 separator). Each plugin’s store is rooted at <gameRoot>/stellar/plugindata/<guid>.data/ — a sibling of, and deliberately OUTSIDE, the recursive stellar/plugins/ DLL scan path (FrameworkPaths, with a pinned non-nesting test), so a plugin’s stored files can never be shadow-loaded as assemblies.

1.14.0 (minor) — CombatMeter sync-fix surface: honest death inference, live party status transport, and dungeon flow-state. Additive; binary-compatible with plugins built against ≤1.13.0.

  • EntityVitals.HasHpObservation — true only once a real current-HP value has been observed; a MaxHp-only attr delta now reads “alive, HP unknown” instead of dead. AOI appear packets now seed vitals directly (previously the first delta after appear defined them).
  • PartyMember.FastSyncState — raw TeamMemberFastSyncData.state (field 6), previously parsed and dropped; the game client itself ignores this field, so semantics are calibrated empirically and consumers must treat unmapped values as “no signal”.
  • IDungeonState.CurrentFlowState + FlowStateVersion — the dungeon flow state machine (EDungeonState: Active/Ready/Playing/End/Settlement/Vote) surfaced from both the method-23 full sync and the method-24 dirty delta, with a monotonic transition counter as the poll-friendly change notification.
  • Party fast-sync deliveries that change ONLY the member’s status field now fire MemberUpdated.

1.13.0 (minor) — adds live Trading-Center membership so exchange plugins categorize new items without a rebuild. Additive; binary-compatible with plugins built against ≤1.12.0.

  • IExchange.GetStallSubcategoryMap() — item config id → Trading-Center subcategory leaf (101-104 Growth / 201-209 Life Skills / 301 Modules / 401-405 Appearance), read live at runtime from the game’s StallDetailTable. Empty when the table isn’t loaded yet; consumers fall back to their own data. Lets the Exchange Buyer plugin surface Season-3 (and future) items with no rebuild.
  • Game config tables keyed by id in the ZTable<int, row> key (rather than a value column) — e.g. StallDetailTable — are now read via a key-aware path; the previous value-only table loader silently returned 0 rows for them.

1.12.0 (minor) — adds the game-environment identity service for SEA/JP region-aware uploads (spec: server-region partitioning). Additive; binary-compatible with plugins built against ≤1.11.0.

  • IGameEnvironment — region (GameRegion SEA/JP/Unknown, lowercase RegionCode wire form) + installed GameVersion, detected once at boot from install markers (StarSEA.exe → SEA); framework config environment.region overrides. Boot log prints [Stellar] region=… version=… source=….

1.11.0 (minor) — consolidates the portraits/replay feature line onto main (merge ad173a0): every addition is a new service, init-only property, or defaulted parameter under the plugins-consume-never-implement contract, binary-compatible with plugins built against ≤1.10.0. Note: the IEntityTransforms / IGameDataWorld.GetMonsterByEntity entries listed under the 1.10.0 sections below were documented there but did not ship in the 1.10.0 bundle; they ship in this release.

  • IDungeonState — dungeon lifecycle + settlement service: run outcome (DungeonOutcome), DungeonSettlementInfo (PassTimeSeconds, MasterModeScore, TotalScore) with the achieved total-score carried end-to-end, defeated count, and run-identity gating for fail-outs.
  • IEntityTransforms — live world transform (position + facing) reads of arbitrary entities by id (main-thread), for replay/position capture.
  • IEntityDetail.RefreshSocialSnapshot — self social-data refresh (drives the game’s AsyncGetSocialData via Lua) so plugins can re-read the local player’s social snapshot (e.g. master score) after a settlement without waiting for cache expiry.
  • SocialSnapshot.MasterScore and related identity fields.
  • IGameDataWorld.GetMonsterByEntity(EntityId) + MonsterInfo.MonsterType/IsBoss — entity→monster-table resolution through the shared combat entity tracker.
  • Skill-phase CombatEvent cases (cast phases 101–105) for forensic capture.
  • GearInstance.BreakThroughTime; PartyMember additions; IPluginServices exposes the new toolkit services.

1.10.0 (minor) — pure interface additions under the plugins-consume-never-implement contract (IEntityTransforms, IGameDataWorld.GetMonsterByEntity); MonsterInfo’s new MonsterType/ IsBoss are init-only properties, not primary-ctor params, so the type stays binary-compatible with plugins built against ≤1.9.1 (see the SliderElement/1.7.1 precedent below).

  • IEntityTransforms — toolkit service reading the live world transform (position + facing) of an arbitrary entity by id, for replay/position capture. TryGetTransform returns false (leaving the out-params at their defaults) when the entity isn’t resolvable this frame; reads must happen on the main thread.
  • IGameDataWorld.GetMonsterByEntity(EntityId) — resolves a live entity to its MonsterInfo table row via the entity’s cached attr-10 (config-id) attribute, routed through a shared CombatEntityTracker so combat and game-data probes read the same cached attribute set instead of each maintaining their own.
  • MonsterInfo.MonsterType / MonsterInfo.IsBoss — numeric monster classification (EMonsterType-mirrored; 0=Monster, 1=Elite, 2=Boss) and a derived boss flag, loaded from the MonsterTable row. Confirmed by recon on the Ancient Purifier run: entity attr 10 → MonsterTable[33301].MonsterType == 2.
  • Run-identity leak across non-instanced scenes. IDungeonState.CurrentRunId (and the internal DungeonRunIdGate) now clears to 0 on entering a non-instanced (town/field) scene, instead of letting a previous dungeon run’s id linger and get attributed to unrelated open-world activity.
  • Recon scaffolding for boss identification (the entity → monster-config-id spike diagnostic and the short-lived IMonsterCatalog/MonsterCatalogService probe path) — superseded by the GetMonsterByEntity
    • MonsterInfo.MonsterType/IsBoss resolution above and no longer needed.
  • Window-framework support behind the CooldownBar overlay (all additive + binary-compatible). (#32)
    • WindowSpec.BackgroundOpacity (Func<float>?) — poll-diffed black backdrop on the borderless root’s click-blocker Image; fills the full window rect and expands on height resize.
    • ColumnElement.Padding (int) — uniform inner padding on all four sides.
    • RowElement.Justify + RowJustify enum (Left/Center/Right) — ships a 2-arg compat overload for plugins built against the old signature.
    • BackdropElement — stretch-fill ignoreLayout backdrop (place first in a column so siblings draw on top).
    • VirtualListElement.ResetScroll (Func<bool>?) — polled each refresh; true snaps the list to the top.
    • CooldownTileElement.OnClick (Action?) — whole-tile click action.
  • Atomic game-asset icons — GameTextureElement moved to WindowBuilder.GameTexture.cs; icon rebind is now a WindowToken binding applied in the same Apply() pass as the virtual list, removing the one-frame wrong-icon blink while scrolling. Buff icons resolve as atlas Sprites instead of Texture2D.
  • ConditionalElement flex clamp — a Cond node inside a row no longer sets flexibleWidth=1 (it was stealing all slack, centring fixed content in a borderless bar); column parents still force-expand.
  • VirtualList viewport inset 9px on the right so the scrollbar no longer overlaps content.
  • Framework deploy target moved out of the csproj into Local.props.
  • AutoHideBehindGameMenus windows now hide behind more full-screen game screens. PandaMenuStateProbe was extended to detect NPC dialogue, loading screens, the dungeon-enter confirm popup, the line-selector panel, and story cutscenes as full-screen menu states. (#29)
    • The dungeon-enter confirm view instantiates as team_copy_popup on UILayerFuncPopup (not common_matching on UILayerTop), so detection now scans UILayerFuncPopup (AnyChildActive) and checks the main_line_window prefix on UILayerMain.
    • Removed the probe’s diagnostic-logging infrastructure (Log, DumpZuiroot, DumpActiveCanvases); the layer map is documented in GameMenuState.md instead.
  • IWindowControl.BringToFront() — explicitly raises a window above others via a ZFront counter that sorts above category (ZCat), so cross-category fronting works (e.g. a HUD window surfaces above a Tools window). A BringToFrontPending flag covers the still-hidden case, so SetVisible(true) + BringToFront() in the same line always surfaces on top. (#27)
  • Interaction pass-through to covered windows. A FrontWindowBlocks guard now wraps every hit-test in WindowInteractionTicker (hovers, resize grip, drag areas, scrollbar suppression, chart pan/zoom, chart navigator, render-host drag/zoom), so back-window elements (chart, 3D portrait, scrollbar) no longer receive interaction when a front window covers the pointer. (#27)
  • Dropdown item styling now matches SelectableElement: rounded SwatchBg chip, transparent rest / [email protected] hover / [email protected] active selection, VLG 6/4 padding, ContentSizeFitter. Hover is ticker-driven (Unity EventSystem ColorTint doesn’t fire reliably alongside the ticker). (#27)
  • DropdownElement — a reusable compact dropdown for a small, fixed set of mutually-exclusive choices. The trigger shows the current option (caption + ▾); clicking it opens a themed floating option list that floats above the window’s scroll clip (parented to the canvas root, so a dropdown inside a ScrollElement is not clipped by its RectMask2D). Picking an option calls back with its index; the list dismisses on pick, outside-click (a full-screen invisible blocker), or Escape. Drop it into any window element tree like the other widgets.
  • The Settings → Performance per-plugin Self-rate control (Off / Boost / Self-managed) is now a DropdownElement instead of a click-to-cycle button.
  • Binary-compatibility regression from 1.7.0. SliderElement’s new Width / HandleSize were added to the record’s primary constructor, which changed the generated constructor signature and broke the old positional ctor. Plugins compiled against framework ≤1.6.0 that construct a SliderElement (e.g. Stellar.AutoFishing) failed to load on 1.7.0 with a TargetInvocationException wrapping MissingMethodException. Width / HandleSize are now init-only properties (the original primary ctor is restored), so those plugins load again.
  • Per-plugin & dynamic update rate. Each plugin’s IFramework.Update now ticks at its own rate instead of being welded to the single global rate. In Settings → Performance a new “Per-plugin update rate” section lets the user set each plugin’s rate (default Follow global) and grant a per-plugin Self-rate permission (Off / Boost / Self-managed).
  • IFramework.RequestUpdateRate(int hz) → IUpdateRateScope — a permitted plugin can temporarily ramp its own tick rate (e.g. a market snipe’s fast-retry window) and revert by disposing the scope. Returns an inert no-op scope unless the user granted the plugin permission. “Self-managed” exempts the ramp from the 10 s leak-guard for plugins that hold an elevated rate indefinitely.
  • SliderElement.Width / SliderElement.HandleSize for compact, fixed-size sliders; ToggleElement.Enabled is now honored by the renderer; fixed-width NoWrap text now clips to its column.
  • The framework tick is now a single variable-speed clock at max(global, all active plugin rates) (clamped [10,240], realized ≤ frame rate). The Lua-bridge probe drains ride the master tick so a ramped plugin’s RPC round-trips complete proportionally faster; expensive draw/refresh work stays gated to the global rate. Idle behaviour (nothing ramped) is unchanged from 1.6.0.
  • Perf overlay no longer freezes its per-window timings when the master rate exceeds the global rate.
  • IExchange — player Trading-Center market access, exposed as IPluginServices.Market. Plugins can query the live market and buy through the game’s own trade flow — no packet construction; every purchase is built and validated server-side. Driven via the game’s WorldProxy exchange RPCs (“Approach A”, headless — the trade page never needs to be open).
    • Reads: QueryListingsAsync(itemId) (live listings, cheapest-first), QueryCatalogAsync(category) (category browse — the request’s type is the StallCategory family, derived from the leaf id), QueryCareListAsync(kind) (watch list + availability), QueryNoticeAsync(itemId) (scheduled/pre-order listings).
    • Buy: BuyAsync(itemId, quantity, price) → ExchangeBuyOutcome (Success / NoItemAvailable / InsufficientFunds / Rejected / Timeout).
    • DTOs: ExchangeListing, ExchangeCatalogItem, ExchangeCareItem, ExchangeNoticeListing, ExchangeItemKind.
  • Extensible toast notifications. INotifications.Create() fluent builder (WithMessage / WithKind / WithDuration / WithIcon) with custom-icon support — render a supplied texture (e.g. a game item icon) in the toast’s icon slot; null falls back to the baked per-kind glyph. The existing Notify(string, kind, seconds) shortcut is unchanged.
  • Team voice & dungeon ready-check, surfaced as typed party events. The framework decodes the game’s voice and ready-check wire traffic and exposes it through IPartyEvents / IPartyRoster, so plugins consume clean events instead of touching IL2CPP or Lua. (#21)
    • Ready-check: WorldNtfLuaStubDispatcher (HarmonyX postfix on ZLuaStub.OnCallStub) catches methods 70/71, which flow through the Lua stub rather than WorldNtfStub; NotifyReadyCheckReader decodes NotifyAllMemberReady (70) / NotifyCaptainReady (71) into IPartyEvents.ReadyCheckResponded / ReadyCheckPhaseChanged.
    • Team voice: GrpcTeamNtf methods 25/26 (mic mode / speaking) decoded in NotifyTeamVoiceReaders; voice_is_open (TeamMemData f7) + mem_real_time_voice_infos (GetTeamInfoReply f4) parsed for correct state on join/relogin (incl. the OpenSpeaker edge case the bool can’t express). New MicrophoneStatus enum + IPartyRoster.GetMicStatus / IsSpeaking — additive; PartyMember stays binary-compatible.
    • Meter row (MeterRowData): NameColor (ready-check vote tint), VoiceIcon / VoiceIconTint / ShowVoiceIcon (mic icon), RowBorder (green while talking), CrestTint.
  • UI primitives for click-away popups.
    • WindowSpec.DismissOnOutsideClick — Escape or press-outside invokes OnClose and hides the window; IsShown stays in sync.
    • PanelElement — themed popup container (2 px border + lifted background + padded content host).
    • Deterministic z-ordering (ReorderWindows): draw order follows (ZOrder, Category, Id) regardless of plugin mount order, so click-away popups always render on top.
  • Meter row border now draws all four edges (previously only the top edge was visible).
  • WindowRenderer.SetRect clamps programmatic resizes to MinWidth / MaxWidth. Previously only drag-resize was clamped, so mode switches, RefreshPartyFocusHeight, and prefs restore could silently push a window below its registered minimum.
  • Non-ASCII text input (e.g. Thai) truncated in uGUI fields. Switched from onValidateInput (per-char ASCII gate) to onValueChanged, so multi-byte / IME input is preserved. (#19)
  • Periodic ~200 ms in-game freeze from the rail-button template lookup. The lookup walked the entire UI tree on a timer; it’s now scoped to the menu-panel subtree. (#17)
  • IWindowControl.SetVisiblePersist(bool) — show/hide a window AND persist the choice to the active layout slot (per resolution), so it survives relaunch. This is the single source of truth the framework reapplies on launch (the layout-editor eye-toggle writes the same slot). Plugins should use it for user-driven visibility toggles (hotkeys, close buttons) instead of SetVisible plus a private config key, which desyncs from the slot and loses to it on relaunch. SetVisible is now documented as session-only (non-persisting).
  • Native-UI edit-mode grab-boxes dropped to the bottom-left corner during loading / cutscenes. The game collapses its HUD to ~1px stubs during those transitions and the edit outline followed them down. It now holds each element’s last real-size rect (carried across the scene-change re-resolve) and never caches a collapsed stub.
  • Repositioned game-UI elements flung off-screen / left at the game default after a cutscene. SetRect no longer runs on an inactive element (its world-corners are garbage mid-cutscene), caps any bogus translate, and re-applies the saved position once the game resets the element; the 1 Hz re-assert no longer force-shows elements the game is hiding for a cutscene.
  • Native notice banners (INoticeTips on IPluginServices) — trigger the game’s own notice system (dungeon bars, win/fail banners, pop tips) with full control over content and audio via a fluent builder (Create/WithContent/WithAudio/WithDuration/Show). NoticeTipService.Show() is thread-safe: it enqueues the pre-built Lua chunk to a ConcurrentQueue drained on the main-thread tick, so plugins may call it from async continuations or any thread without marshalling boilerplate. (#15)
  • Consume hotkey keypresses (Settings → Hotkeys) — a global toggle that blocks bound keys from reaching the game via Rewired while the framework still receives them through UnityEngine.Input. Blocking is modifier-aware (Ctrl+F1 bound does not also block bare F1), and all keys are suppressed while a rebind cell is open. Backed by IHotkeyBlockDirectory + HotkeyKeyBlockPatch. (#15)
  • Loadout API (ILoadout on IPluginServices) — read the player’s saved in-game loadouts (the game’s “Role Plan” system: class + gear + spec + modules) and switch to one. Drives the game’s own AsyncSwitchRolePlan (the path the in-game dropdown uses), so all server-side validation (combat lock, etc.) is respected, never bypassed. Backed by PandaLoadoutProbe over the tolua# Lua bridge + WorldProxy.
  • Notification toasts (INotifications on IPluginServices) — transient on-screen toasts any plugin can raise (Notify(message, kind, seconds)), rendered top-centre with a Pop+Scale animation, per-kind colour, and a countdown bar. First consumer: the LoadoutSwitcher plugin.
  • Launcher tile icons are now live-bound: a plugin icon that loads after the launcher is built (plugins register asynchronously, and the Full / Minimal layouts materialise their tiles at different times) no longer stays baked to the generic puzzle-piece fallback — it now appears in every launcher mode. Fixes a plugin icon showing in expanded mode but the puzzle-piece in minimal mode. (#11)
  • Game-data name resolution: locale-gate the empty-Name → NameDesign fallback so the design-name fallback only kicks in where it should, instead of leaking into clients that do have a localized name. (#12)
  • Plugin SDK on NuGet.org — Stellar.Abstractions, Stellar.PluginContracts, and Stellar.Plugin.InteropRefs (the Unity/Il2Cpp/BepInEx compile-time reference stubs) are published via Trusted Publishing, so plugins build with just <PackageReference>s — no framework checkout and no game install. First step toward per-plugin repos (see the DevKit’s DIP17 migration plan).
  • Framework runtime is unchanged from 1.1.0 (this release adds the SDK + contributor docs only).
  • LineChartElement — multi-series time-series line chart with labelled X/Y axes, axis titles, a legend, auto-scaled Y, and interactive zoom (scroll/drag + −/+/Reset buttons + range scrollbar). Rendered via an injected MaskableGraphic mesh (ChartGraphic). First consumer: CombatMeter history charts.
  • Generic inter-plugin exchange: IPluginExchange (Provide<T> / Consume<T>) on IPluginServices, brokered purely by Type, plus the new Stellar.PluginContracts assembly that cooperating plugins reference (alongside Stellar.Abstractions) for shared contracts — FrozenEntity and IFrozenEntityViewer. (#5 Phase 2)
  • HUD text enhancements on TextElement: FontSize, DynamicFontSize, ShadowDistance, and NoWrap, plus TextAlign (Left/Center/Right). Existing 6-argument call sites stay source- and binary-compatible via explicit secondary constructors.
  • HUD centering anchors HudAnchor.ScreenCenterX / ScreenCenterY / ScreenCenter (resolution- independent via the RectTransform anchor system) and HudSpec.DynamicDefaultRect.
  • IFramework.ScreenWidth / ScreenHeight, refreshed once per frame, for resolution-aware layout.
  • ICombatSpec combat-spec lookup; MeterRowData.SelfAccent.
  • Buff/skill NameDesign fallback; leveled skill_level_ids now resolve to their base skill names.
  • Icon-only overlay buttons are centered and equal-size.
  • Hotkey handling, layout-editor input leak, combat-spec resolution, and theme-name sync (in-game hotfix batch, #2).
  • Programmatic SetRect is clamped on-screen so windows can’t be placed unreachable.
  • BarElement fill width now tracks Fraction01.
  • Per-frame GameObject.Find leak that decayed FPS across dungeon re-entries.
  • In-game plugin launcher overlay
  • Party roster for raid groups
  • Native HUD element editor (move / hide)
  • PlayerHUD demonstrator