Changelog

Simpler topic navigation

Removed single-page category wrappers and redundant nesting. Progression and economy now opens directly to its overview and detail chapters. Static sidebars and Previous/Next links follow the same topic structure.

Added account, vehicle and data guidance

Focused reading chapters

• Organized broad reference articles into coherent chapters under their parent topics, preserving overview URLs, section links and complete examples. Tutorials, Practical Recipes and this changelog stay on single pages. Previous/Next now traverses an overview and its detail chapters before the next subject. Start with settings and persistence, recipes, or the analytics tutorial.

Account requests, prices and availability

• Added wallet balance availability guidance, separating masked zero amounts, raw versus clamped getters, absent-key defaults, currency field presence, local status and UI readiness.
• Added guidance on account request teardown and response preprocessing: local cancellation does not prove server rollback, and unmatched callbacks do not bypass earlier payload or synchronization handling; a short source excerpt shows that ordering.
• Added guidance on progressive customization sale counts: installed stock, relevant depot stock and configured automatic-grant allowance feed the quote and selected request counts.
• Added coverage distinguishing personal price baselines: independent vehicle discounts, current-quote selection and later rental compensation differ from premium-packet discount calculation.
• Added guidance distinguishing crew training XP horizons: the dossier uses a next-level cost, while a separate private results estimate uses the remaining cost to level 100; the dossier mean comes from external vehicle/account statistics and its premium comparison scales an already-computed estimate.
• Added explanations of blueprint fragment rounding: integer percentage, XP amount, final-fragment residual and cumulative unlock discount are separate projections.
• Added coverage distinguishing general availability from individual package capacity, using rental duration and term-specific admission checks.
• Added guidance distinguishing availability-window boundaries: daily and periodic helpers use different closing tests, signed offsets can be negative while active, and event-level date flags can consume truncated minute values.
• Added guidance on next-expiry amount grouping: amounts belong to one exact timestamp, separate from total reserve stock, calendar-day totals and active-effect duration.
• Added guidance on explicit zero prices and currency presence, separating Money truth tests, presence predicates, serialization and price formatting.
• Added guidance on legacy item-price projections: credits/gold tuples can omit paid currencies, while full quote dictionaries retain separate ownership and copy rules.

Vehicle statistics and aiming projections

• Added guidance on accuracy provider stages: module aggregate minima and configured vehicle values use different transforms, inputs and rounding stages.
• Added guidance on wheel rotation KPI units: the garage row is a relative adjustment, with separate availability and display filters, rather than an angular speed.
• Added coverage distinguishing shield coefficient rows from traversal gates: modern-HE classification and layer labels do not establish shield-penetration permission.
• Added guidance on rocket garage KPI projections: declared coefficients, provider bases and dynamic modifier snapshots are separate calculation paths.
• Added explanations of configured health stages: baseline assembly, battle modifiers and conditional tens-scale rounding preserve different values.
• Added guidance on garage angular-limit projections: unsigned yaw magnitudes and sorted pitch rows differ from signed, yaw-dependent aiming constraints.
• Added explanations of configured heated aiming endpoints: the final thermal-state multiplier and base value are distinct from current heat or numeric bounds.

Gun and shell contracts

• Added guidance on unlimited-clip timing rows: configured clip classification, loading duration and continuous rate are separate from ammunition and full-cycle behavior.
• Added guidance on burst component provenance: configured vehicle tuples and module first-pair/minimum-capacity projections preserve different identities.
• Added guidance on critical-hit category values: the shell provider publishes a qualitative enum and localized label, rather than a numeric probability.
• Added guidance distinguishing stored damage references from evaluated ranges: mutable-shell reference pairs differ from distance-sampled, randomized vehicle bounds.
• Added coverage distinguishing additional shell-row admission from formatting: parameter inequality, displayed text and mechanic state are separate contracts.
• Added guidance distinguishing twin-gun value identities: separately named module configuration fields differ from the projected vehicle duration pair and its tooltip title.
• Added coverage distinguishing dual-gun timing projections: derived reload durations, compound clip rows and charge/lock pairs are different contracts.
• Added explanations of the basic-shell comparison baseline: the named tooltip comparator uses the first configured shot, independently of the active shot index.

Battle and mission statistics

• Added explanations of biathlon success-count projection: retained qualifying flags and supplied completion state do not encode a consecutive streak or server award.
• Added guidance on profile chart scale values: percentValue is relative to the largest supplied row, not a share of total battles.
• Added explanations of the Battle Royale average-level denominator: stored level totals and placement-derived battle counts remain separate sources.
• Added explanations of mission average denominators: the average strategy divides by a linked counter goal, while distinct-target requirements can alter displayed counts separately from raw totals and completion.

Native module guides

• Grouped the Native reference into BigWorld, ResMgr and GUI subcategories while preserving article URLs.
• Added typed section-value selection and collection projection guidance, plus parser completion and shared-reader registry boundaries for ResMgr resource readers.
• Added GUI component ownership, pixel-mode and coordinate guidance, and device resetter lifetime; corrected the overlay example to use the source-demonstrated root and resetter pattern.
• Added a practical res_mods XML reread example, live GUI update and image-path examples, and a linked loose-resource development loop, separating data refresh from texture and framework cache requirements.
• Added image bytes, mapped texture IDs and UI-link contracts and mapped-image cache ownership, separating byte-request deduplication, mapping cleanup and late-view admission.

Notification ownership

• Clarified the session counter's observation and pending-summary contract, static validation and memory costs: resets can discard pending output, submission does not acknowledge display, and seen-arena history grows until reset with history-dependent clearing cost.
• Corrected the selection notifier’s rapid-carousel expectation: logical-change callbacks can coalesce intermediate choices; observed inventory IDs and visible message delivery are separate checks.
• Added popup queue lock ownership, with explicit source keys, transition-gated postponement/release and separate display gates.
• Added notification identity, eviction and model-owned removal, including the difference between retained record IDs and view-local Flash IDs.
• Added unread counter and list acknowledgement guidance, separating stored cards, set-based counting, count-once history and MVC counter lifetime.
• Clarified the battle-phase tutorial’s registration and package boundaries: source-wrapper limits, import/startup/creation lookup stages, exact staging roots and stored-member archive checks.
• Corrected the entity-census tutorial’s seed and event membership limits, including early visual-start returns, unstarted leave omissions, copied classification and observed transition counters.
• Clarified the entity-census tutorial’s model, DOM and surface contract: explicit property setters, publication-cache failure limits, zero fallbacks, sizing attempts and queued readiness cleanup.
• Qualified the entity-census tutorial’s owner, retry and cleanup limits, including stale callback handles, partial subscriptions, interrupted resets and page-hook restoration.

Text and resource formats

• Added guidance on text cleanup representations: descriptor-marker removal, angle-tag removal and literal HTML escaping have different contracts.
• Added guidance on resource content representations: model, visual and texture-animation suffixes do not distinguish converted structural text from installed packed bytes or complete assets.
• Added guidance on template reload retention: resource purging does not replace the Python mapping, so omitted entries can survive until explicit unload.
• Added explanations of realm-aware resource wrapper routing: variant-first opening, editor bypass and dual-path purge are distinct from delegated existence probes.
• Added guidance distinguishing normalized Unicode string limits from UTF-8 byte budgets, with multibyte examples and concrete client caller contracts.

Callbacks and async ownership

• Qualified the current-player function fragment: missing imports and enclosing-function context, lookup defaults, failure ordering and borrowed references do not provide readiness or lifetime guarantees. Its six-line body remains unchanged.
• Qualified the illustrative shared callback slot: failure ordering, borrowed payloads, stale admission, reentrant successors and lifecycle limits differ from action completion. Both authored code bodies remain unchanged.
• Qualified the loop/default-argument illustration: stored references and late helper lookup do not provide callback ownership, cleanup, context readiness, bounded work or completion. The authored body remains unchanged.
• Qualified the illustrative service lookup: lazy construction and failure latches, undefined refresh contracts, discarded return values and owner lifetime are separate from readiness and operation completion. The authored body remains unchanged; no service factory or client execution was tested.
• Reconciled the phase tutorial’s verification matrix and periodic-work description, distinguishing client-test targets, cached placement, failure diagnostics and additional publication paths from measured behavior.
• Clarified the phase monitor’s Python owner and failure boundaries: bounded parent attempts, separate readiness gates, cached placement, interrupted ticks, partial cleanup and conditional hook restoration.
• Clarified the phase monitor’s model-publication limits and frontend cleanup boundaries, separating initial JSON, cached submission, sizing attempts and queued readiness work.
• Added deferred widget adoption guidance, separating retained callback arguments, current-state rebuilds, pending flags and presenter-specific readiness.
• Added core adisp sequencing guidance: deferred callers, synchronous continuation, ordered batch results, exactly-once completion and distinct GUI decorator behavior.
• Added server population refresh guidance, separating response-driven scheduling, retained formatted counters and observer cleanup from sample freshness.
• Added shared request-slot ownership, separating callback replacement, cooldown waits, request timeouts and cleanup from queued admission or terminal delivery.
• Added async item-query result ownership, separating callback collections, Future values, wait budgets and partial traversal from current-owner readiness.

Configuration, data and diagnostics

• Qualified the named-logger fallback illustration: undefined loader behavior, unchanged helper returns, broad failure fallback and conditional traceback routing do not prove valid configuration, file recovery or report delivery. The authored body remains unchanged.
• Qualified the collection snapshot and saved-first baseline illustrations: shallow containers do not establish one source revision, and saved-first choice differs from live-first fallback. Clarified preference retry ownership and path helper limits. All authored bodies remain unchanged; no helper or client execution was tested.
• Added per-field copy-boundary guidance, distinguishing borrowed record fields, copied equipment projections and separately reconstructed configuration state.
• Added cached owner replacement guidance, separating first-read properties, service refresh gates, borrowed snapshots and token availability predicates.
• Added documentation for logging-level routing: the bridge uses exact numeric severities, while custom names, configuration and traceback attribution are separate contracts.
• Added coverage distinguishing passive observation from acknowledgement history: a getter can seed the initial viewed baseline, while explicit updates own later acknowledgement.
• Added explanations of filtered selection IDs versus traversed paths: received nodes can remain zero-cost intermediates even when omitted from the pending selection.
• Added guidance distinguishing projected range endpoints from the original inclusive membership bounds, with a concrete model-builder example.
• Added explanations of whole-section configuration precedence: schema defaults fill missing fields after source selection, rather than inheriting lower-priority values.
• Added coverage distinguishing HTTP success, JSON decoding and usable response data, including falsy-value normalization and a concrete consumer admission check.
• Added explanations of raw copy ownership and revision: a deep copy can still read class-level data that differs from the receiving parsed configuration.
• Added item-query criteria contracts: client-defined operators, true/false criteria, captured ID ownership, specialized metadata and candidate-traversal boundaries.
• Reconciled the journal tutorial’s schema, clock and failed-save contracts, separating retained memory, conditional recovery and repeated terminal/entry events from unexecuted test targets and crash-durability claims.
• Reconciled the snapshot bridge’s HTTP, sampled-context and companion boundaries, inclusive payload cap, freshness and restart/shutdown limits; current acceptance and concurrency scenarios remain unexecuted review plans.
• Reconciled the analytics dashboard’s lifecycle, sampling, model-delivery and history boundaries, replacing fixed-frequency, universal-cleanup and atomic-save claims with source-reviewed limits; authored code and historical evidence remain unchanged, and the full current matrix remains unexecuted.
• Reconciled the Level 10 recorder’s admission, clock, callback, writer and cleanup contracts; clarified attempt sequences, incomplete loss accounting, rotation overshoot and timed-join limits while preserving authored code and historical evidence. The full current runtime/fault matrix remains unexecuted.
• Qualified the worker handoff pseudocode: per-call daemon launch, borrowed context/results and callback scheduling do not supply concurrency limits, cancellation or delivery receipts; thread context must be verified per path.
• Clarified the local HTTP waiting pseudocode: a wait timeout does not cancel queued actions or establish no side effects; completion flags, original diagnostics, borrowed results and request-owner cleanup have separate contracts. Authored code remains unchanged; no server, wait or callback execution was tested.
• Qualified the background-request illustration: one-body byte admission and generation equality do not bound worker creation, cancel stale work, define a whole-operation deadline or acknowledge delivery. Authored code and historical inert checks remain unchanged.
• Qualified the controller illustration and loader-shell pseudocode: early flags can suppress failed-setup retries, cleanup can stop before invalidation, and placeholder hooks do not establish complete ownership. Code bodies remain unchanged; loader swallowing and shared generation state are explicit.
• Qualified the delayed-action illustration: a retained handle and generation equality do not establish cancellation acknowledgement, readiness or completion. Conditional old-closure admission and tracking loss, failure ordering and shared generation state are explicit; all code bodies remain unchanged.
• Qualified the event-ownership illustration: a shared flag does not retain the actual event/delegate pair, reconcile membership, reject snapshot delivery or prove cleanup. Failure ordering and packed borrowed payloads are explicit; all recipe code bodies remain unchanged.
• Qualified the method-wrapper illustration: one-slot admission, assignment receipts, post-original active checks, failure ordering and retained chains have separate limits. Raw class-dictionary identity does not cover every Python 2 binding case; all recipe code bodies remain unchanged.
• Qualified the JSON settings illustration: shallow defaults and unchecked schema, silent primary fallback, parse-only admission, staging and rotation failures, conditional restore and cleanup exception precedence have separate limits. All recipe code bodies remain unchanged.
• Reconciled the staging skeleton and backup writer illustration: pre-open work, parse-only admission, conditional restore, ignored or absent receipts, cleanup and diagnostics have distinct limits. Both code bodies are unchanged; historical controls retain their original scope.
• Qualified the recognized-field loader, migration loop and delegating configuration shell: supplied helpers own validation, progress, returned schema and mutable state. All three code bodies are unchanged and labeled Illustrative.

Added lifecycle, loading and UI guidance

Requests and networking

• Added documentation for busy downloader admission and retained results: RSS submissions can be dropped without joining callbacks, and completion can deliver earlier feed data.
• Made the background request recipe reject oversized reads and explicitly close acquired responses before publishing successful data.
• Added guidance on normal web-command callback payloads, including JSON null from void handlers and separate delivery/outcome limits.
• Added documentation for URL query marker ownership: blank-value retention, supplied-key replacement and query reconstruction.
• Added guidance on shared default cooldown-manager lifetime across request-controller replacement.
• Preserved original exception diagnostics in the networking, bridge and background-request examples while retaining their delivery and completion flows.
• Added coverage distinguishing page rows, navigation flags and saved queries and primary response success from enrichment outcomes.
• Added guidance on URL-only custom-file request grouping, display policy, branch-specific failure delivery and pending-write suppression.
• Added guidance distinguishing live service callback lists from snapshot events, including reentrant completion and timer-reset boundaries.

Resources and loading

• Added guidance on vehicle icon naming, output forms and per-helper fallbacks.
• Added coverage distinguishing derived summary invalidation and rebuild-failure state from item mappings, and asset catalog membership from per-variant availability and change notifications.
• Added explanations of background file-cache mutation, notification, freshness and cleanup ownership.
• Added explanations of partial work after a failed resource batch and the separate responsibilities of result admission, cancellation and cleanup.
• Added late-attached router context and command cleanup and stable request descriptions and foreground completion.
• Added guidance distinguishing loader existence, successful parsing and view refresh.

Lifecycle, services and hooks

• Added coverage distinguishing service availability, login completion and current-data readiness, and kept unexpected service-construction failures diagnosable.
• Hardened the owned hook installation example against duplicate installation beneath an intervening wrapper, recording ownership only after successful assignment.
• Added guidance distinguishing weak callback name lookup from original-function binding and corrected the census payload recount cost.
• Added guidance on plugin membership and lifecycle phases and backoff delay state versus retry ownership.
• Added guidance on partial state transitions after hook failures and file-open, write-result and persistence boundaries.
• Added guidance on collector registration and consumer refresh and dependency shutdown snapshot limits.
• Added explanations of shared client AOP cleanup and single-baseline settings override ownership and storage gates.
• Added guidance distinguishing completed cache updates, unsynchronized results and rejected updates.
• Added guidance on suspended queue failure and nested dispatch and cooperative iteration work boundaries.

UI, input and notifications

• Added explanations of announcer queue admission: captured priority, periodic lifetime pruning, deferred target eligibility and routed events are separate from audible playback.
• Corrected position-restoration preference state so the example publishes its module-owned read-completion flag instead of assigning an unused local.
• Added coverage distinguishing monitor-relative resolution option indices from dimensions, refresh rate and full display-mode selection.
• Corrected the Scaleform registration example to use the current GUI-loader-owned registry and explicit duplicate-alias contract.
• Added guidance on DAAPI attachment and release and length invalidation versus later row pulls and partial updates.
• Added explanations of shared listener collection dispatch and text styling, template context ownership and fallback results.
• Added explanations of GUI Waiting decorator state ownership and best-effort command payload conversion versus explicit validation.
• Added guidance on account GUI clock-anchor readiness and system-message facade, formatting and admission boundaries.
• Added explanations of engine versus Scaleform key numbers and keyboard option defaults, unbound values and publication order.

Gameface models and navigation

• Added guidance distinguishing machine shutdown from state exit and presenter deactivation from model release and data readiness.
• Added guidance distinguishing period-gate admission from async completion and corrected model versus array transaction failure boundaries, with deferred array-slice read boundaries.
• Added explanations of stable Python subscription owners, listener/restriction tuple contracts and partial view-cleanup failures.
• Added guidance on route selection versus reused-view context and readiness, with ownership checks during deferred cleanup.
• Corrected shared navigation-history ownership and separated requested routes, guard redirection and asynchronous hook completion.

Settings and persistence

• Corrected idle buffered-output flushing in the telemetry writer and aligned summary copy, cleanup and save ordering with the dashboard implementation.
• Added limits for packed settings field preservation: direct values must fit the concrete field domain before staging.
• Isolated nested settings defaults and clarified borrowed versus copied default accessors.
• Corrected journal startup schema admission so rejected documents do not arm empty event-driven writers, including backup-only startup.
• Corrected JSON validation versus backup-rotation failure handling and qualified backup-assisted writes and the replacement skeleton without an atomicity promise.
• Added guidance distinguishing field availability, default values and formatted placeholders.
• Added guidance on instance result storage versus shared, lazy memoization reset ownership.

Tutorial corrections and validation

• Added guidance on snapshot bridge timing limits: a timed final join does not bound earlier shutdown, daemon request threads have no request deadline, and sampled bytes may outlive the nominal sampling interval.
• Aligned the garage greeting tutorial with its retained-history reset on disconnect/finalization and its two lifecycle listeners; code is unchanged.
• Corrected snapshot bridge partial-startup cleanup: reset loaded state after bind failure and skip joining a thread that never started.
• Corrected snapshot and route normalizers to reject nonfinite and overflowed geometry before clamping.
• Corrected session-counter reconnect expectations to distinguish retained-session re-entry from disconnect resets.

Source evidence and localization

• Changed public source links to follow the latest default branch automatically, removed stale current-source build labels, and preserved historical test-build evidence.
• Corrected the localization fallback example to use numeric resource IDs and preserve tracebacks for unexpected failures.
• Added guidance on server-formatter replacement policy and contrasted missing arithmetic branches with retained source anomalies using scoped original Python bytecode.
• Resolved the readable-source AOP lookup sentinel omission using scoped original Python bytecode evidence.
• Expanded guidance on source-update scope verification and documented the current Scaleform messenger focus ownership path.

Gameface capabilities, resource readiness and ownership

• Expanded frontend capability limits, including query ordering, retained collections, CSS fallback guards and number formatting.
• Added owned JavaScript models, bounded virtual lists and exact engine-listener release.
• Clarified image request identity and stylesheet readiness, plus deferred event data, scrolling and resize measurements.
• Documented hidden-window scheduling, custom-element reconnection and explicit motion/observer disposal.
• Explained grouped action dispatch versus completion and updated settings-menu migration and release metadata.

Embedded-runtime observations retain their WG 2.4.1.0 #977 / Cohtml 2.2.8.1 scope; source checks and synthetic-event results do not establish live server behavior or full browser compatibility.

Common BigWorld functions and callback ownership

Added a practical starting table for common BigWorld functions. Clarified deferred callbacks and completed the illustrative cancellation and generation checks, including replacement work, teardown and readiness limits.

Game behavior and mechanics

Added a behavior reference with nested categories and versioned links to game files. Read about Vehicle Stats & Crew Effects, Reload, DPM & Aiming, Vehicle Presence, Health & Visibility, Mode Rules & Capability Overrides, Progression Costs & Vehicle Status, Result Revisions & Replay Time. Each article separates client calculations, received state and presentation from unverified server behavior, and links to the technical implementation references.

Clearer reference prose

Simplified Gameface guidance, frontend capabilities, source verification and tutorial introductions. Removed repeated audit notes and metadata badges so the explanations focus on API behavior, implementation choices and practical limitations.

Expanded client-system and Gameface contracts

• Added Gameface Communication and Updates, Battle State, Components and Feedback, Vehicle Calculation Contracts, Battle Results and Accounting, and Native Async Lifetimes.
• Expanded Gameface learning paths, asset-chain validation, structural injection and detachment, surface ownership, model/document lifetimes, and cross-layer acceptance.
• Detailed timer/notifier ownership, callable-ledger failure ordering and event ownership, state publication, requests and waiting UI, cache synchronization, typed schema materialization, and worker completion.
• Extended vehicle authority, battle state, result revisions, dossier provenance, resource/effect lifetimes, stateful provider reads, sound ownership, and minimap conversions.
• Expanded input-mode contracts, DAAPI completion, catalog/font readiness, decompiled-source verification, and the system reading path.
• Clarified contextual capability semantics, component/graph teardown, visual-script evaluation, and relational model keys.

Gameface capabilities and runtime boundaries

• Expanded the Gameface learning path with frontend capabilities, media and rendering, and transport and storage, with practical compatibility limits and clearly marked historical behavior.
• Updated layout and input, lifecycle and replay recovery, injected model ownership, handwritten model contracts, and capability diagnostics.
• Added bounded UI workload measurements, concrete settings readiness and migration limits, diagnostic provenance, and current-state versus event-history guidance.

Clearer search titles and descriptions

• Clarified the World of Tanks modding overview and topic titles for Python 2.7, Gameface overlays and Scaleform and Flash.
• Refined tutorial and reference summaries, synchronized search and social metadata, and aligned the sitemap homepage with its canonical URL.

WG 2.4.1.0 examples and current source

• Migrated Battle Phase Monitor, Battle Entity Census, Personal Route Trace, and Personal Battle Analytics to native declarations and matching Python accessors. Removed their standalone registration-helper dependency and retained historical runtime evidence.
• Updated all manifest-backed source links to the verified public 2.4.1.0 #974 snapshot.
• Expanded native resource diagnosis, window visibility, callback helper ownership, and entity, visual, and spotting boundaries.

Wargaming World of Tanks documentation

• Focused Gameface resource guidance and migration guidance on Wargaming World of Tanks, keeping older WG registration paths explicitly historical.

Direct client-source links

• Added manifest-driven GitHub links following the default branch throughout Source Navigation and Source Verification so core files and directories open on the latest public default branch.
• Linked the native owners in Embedded Browser & Native Bridge and the client entry points named by the battle entity, battle session, and garage vehicle tutorials.
• Centralized the repository, revision, client version, and named paths in source-links.js. It loads before the shared application script, which fills the real GitHub URLs into keyed anchors without a separate request, allowing future link updates without editing each page.
• Kept older tutorial provenance explicit: a newer browsable source link is an investigation aid, not retroactive runtime verification.

WG 2.4.1 Gameface migration and runtime contracts

• Documented the WG 2.4.1 native resource contract, unique declaration filenames, dotted R.mods... accessors, and the removal of legacy helper readiness on WG.
• Added compatibility warnings to the Gameface tutorial examples that still use the 2.3.1.3 legacy registration path; those examples were subsequently migrated on 15 October 2026.
• Clarified existing-view injection: gf_mod_inject and its child carrier remain, even though registration moves to the native tree.
• Expanded standalone window guidance with layer-7 popup ownership, hide(False)/show(False), full-statistics visibility, and offscreen-clamping limits.
• Added stale-safe post-render measurement, the Python 2 descriptor-binding trap, and the distinction between subhangar groups and complete feature scenes.

Feature routes and section search

• Added a feature chooser connecting common goals to existing tutorials and system references.
• Expanded documentation search to rank headings, prose, and code symbols, link to matching sections, and explain matches hidden by the difficulty filter.
• Corrected the wrapper recipe to preserve captured predecessors and disable retained wrappers safely, matching the hook composition guidance.

Calculation, preview, and diagnostics contracts

• Expanded Vehicles & Items with copied shell selection, progression identity, compatibility-cache inputs, and configured-value versus metadata boundaries.
• Expanded Gameface lifecycle with cached non-consuming observation, eligibility checks, and request-scoped hover previews.
• Expanded Gameface layout and input with bitmap painting limits, background sizing, and canvas alternatives, and existing-view injection with execution-boundary and packaged-font checks.
• Expanded Runtime Debugging with exception attribution and staged-work profiling, and Source Verification with region-portability checks.

Cross-runtime settings and hook lifecycle guidance

• Expanded Settings & Storage with optional settings-menu ownership, template-version migration, callback validation, and provisional live-change boundaries.
• Expanded GUI Frameworks with two-way DAAPI transaction checks, weak-proxy ownership limits, deferred native layout, and interactive Scaleform hit geometry.
• Expanded Hook Composition Rules with teardown rules for callables retained by downstream wrappers.
• Expanded Existing-View Injection with guarded page-level JavaScript patches, native fall-through, comparator ownership, and unload cleanup.

Expanded grounding, vehicle-model, calculation, and lifecycle guidance

• Expanded Spatial Coordinates & Projection with directed static collision queries, exclusion masks, ground probing, and the readiness boundary between point sampling and whole-vehicle grounding.
• Expanded Resources & Models with four distinct vehicle-visual ownership patterns, procedural bone animation, and model-generation cleanup.
• Expanded Vehicles & Items with shell-speed units, hidden-value sentinels, validated hypothetical layouts, component-level quality, and alternate-mode snapshots.
• Expanded Lifecycle and Dependencies & Services with gameplay-state and battle-session controller ownership.
• Expanded Battle Data Pipelines with bounded replicated-component pairing, and refined Gameface lifecycle and layout/input guidance for staged payloads, tooltip ownership, and CSS parser limits.
• Added bounded native-extension compatibility guidance to Tooling, Assets & Packaging without publishing an unverified external implementation as a reusable recipe.

Made production tutorial provenance auditable

• Added searchable client-build provenance to all ten Production tutorials and clarified full versus partial runtime-test coverage.
• Corrected stale version wording, tightened post-update maintenance checklists, and kept source lookups focused on callers, registrations, firing sites, payloads, and lifecycle behavior.
• Added a static provenance and metadata audit covering tutorial navigation, pager order, sitemap and structured-data dates, internal links, and site assets.

Added the Level 1–10 production tutorial series

1. Level 1: Configurable Garage Greeting introduces metadata, validated JSON preferences, account synchronization, diagnostics, and packaging.
2. Level 2: Vehicle Selection Notifier adds event semantics, inventory-ID deduplication, account-scoped ownership, and cleanup.
3. Level 3: Battle Session Counter develops source investigation, arena identity, avatar lifecycle, and honest observational semantics.
4. Level 4: Battle Phase Monitor introduces standalone Gameface/Wulf ownership, resource maps, payloads, sizing, and readiness.
5. Level 5: Battle Entity Census covers vehicle enter/leave events, reconciliation, area-of-interest limits, and Gameface projection.
6. Level 6: Personal Route Trace adds arena bounds, coordinate normalization, bounded sampling, callback generations, and SVG rendering.
7. Level 7: Battle Session Journal adds strict validation, schema migration, backup-backed writes, recovery, and bounded history.
8. Level 8: Local Battle Snapshot Bridge introduces authenticated loopback HTTP, immutable snapshots, companion timeouts, and worker shutdown.
9. Level 9: Personal Battle Analytics Dashboard composes lifecycle, entity observations, spatial analytics, persistence, and Gameface visualization.
10. Level 10: Replay-Aware Telemetry Recorder covers event schemas, JSONL, bounded queues, rotation, drop accounting, and replay time-warp recovery.

Expanded authority, identifiers, battle lifecycle, and API discovery

• Expanded Client Requests & State Synchronization with a client/server authority model and stale asynchronous-result boundaries, and expanded State & IDs with an evidence-backed identifier matrix.
• Connected battle creation, avatar and entity readiness, runtime, results, replay, observer, and teardown across the battle architecture pages.
• Expanded the BigWorld Symbol Index into an evidence-labeled discovery map spanning runtime, context, entities, cameras, input, resources, spaces, rendering, persistence, and diagnostics.
• Added searchable version-sensitive contract markers and expanded Gameface, resource/cache, and investigation guidance with focused cross-links.

Grouped Game Systems and added build provenance

• Organized Game Systems into runtime, battle, hangar, UI, resource, and diagnostic groups without changing page URLs.
• Added lightweight build and evidence provenance to version-sensitive pages including Hangar & Garage Runtime, Embedded Browser & Native Bridge, and Native Helpers.
• Clarified the distinct roles of Source Navigation, Source Verification, and the Source Evidence Ladder.
• Generalized feature-specific examples in Compatibility & Performance and Client Requests & State Synchronization, and corrected the Symbol Index empty state.

Expanded vehicle, lobby, CGF, and camera contracts

• Expanded Vehicles & Items with terrain-resistance, crew-KPI, module-health, and calculated-parameter producer boundaries.
• Expanded Account & Lobby with parallel state layers, transition selection, recorded history, serialized parameters, and view lifetime.
• Expanded Entity & Network Model with direct and network-ID CGF bridges plus component activation and deactivation ownership.
• Expanded Input, Cursor & Camera with the native gun-marker-to-crosshair flow and vehicle-selection camera readiness gates.

Added the hangar and garage runtime guide

• Added Hangar & Garage Runtime with current space and vehicle readiness, native subhangar groups, route handoffs, replacement spaces, selected-vehicle and camera ownership, CGF lifecycle, cleanup, and diagnostics.
• Linked the authoritative hangar lifecycle from Graphics & Display State.

Separated auto-shoot from conventional after-shot dispersion

• Expanded Vehicles & Items with the current auto-shoot gun tag and descriptor contract, including why per-shot auto-fire bloom must not be calculated through the conventional after-shot dispersion chain.

Documented the first-click focus fix

• Expanded Standalone Overlays with a copyable battle window example showing how WindowImpl._onReady() and show(False) prevent a passive Gameface panel from taking keyboard focus when it becomes ready.

Browser, window, packaging, and runtime inspection contracts

• Added Embedded Browser & Native Bridge for WebView ownership, browser lifecycle, handler capabilities, correlated responses, client-to-web events, safe JavaScript investigation, and external-browser limits.
• Expanded Standalone Overlays with the separate focus and stacking contracts for passive garage panels, native top windows, and battle overlays.
• Expanded Tooling, Assets & Packaging with the stored-member client requirement, process-owned package replacement, and payload-based rebuild comparison.
• Added current import-root verification to Source Navigation, mixed Wulf/Scaleform inspection and mode-owned layouts to GUI Frameworks, and the verified getFPS() vector shape to Native Helpers.

Gameface refresh, localization, and vehicle-calculation boundaries

• Expanded Lifecycle & Ownership with cancellable, coalesced payload refreshes that avoid rebuilding a child view during route teardown.
• Expanded Layout, Scaling & Input with explicit tooltip-anchor ownership and separate pointer versus keyboard-focus state.
• Expanded Resources & Localization with a stable translation-key boundary, locale normalization, key-level fallback, and translator template checks.
• Expanded Vehicles & Items with configured inventory vehicle versus preview-copy ownership, calculation-layer tracing, and unit-boundary checks.

Client lifecycle, data, and routing contracts

• Expanded Lifecycle with the current Login → Account → Avatar readiness sequence and cleanup ordering.
• Expanded Account & Lobby with account-diff synchronization, command and streamed-response ownership, and lobby state-machine navigation.
• Expanded Dependencies & Services, Events & Event Buses, and Callback Lifecycle Patterns with current service, controller, event-family, and wg_async contracts.
• Expanded Entity & Network Model with script-component registration, property callbacks, readiness, respawn, and CGF bridging.
• Expanded Settings & Storage and Data & Persistence with native settings-layer and typed game-parameter schema boundaries.
• Expanded Results & Replays with the separate contracts for recording gates, metadata tags, feature playback support, and replay settings snapshots.
• Added safe Vehicle Preview versus Vehicle Hub routing guidance to GUI Frameworks and updated Source Navigation for all newly documented systems.

Timer, model, dossier, and capability contracts

• Expanded Callback Lifecycle Patterns with replay-backed guidance for positive recurring timer delays and keeping polling clocks independent from expired state deadlines.
• Expanded Models & Native Projections with current-client failure evidence and conservative post-processing guidance for native-owned Wulf and Gameface collections.
• Added native field-shape and integer-boundary guidance to Dossier & Baseline Validity.
• Clarified in Optional Systems and Runtime Debugging that an expected missing optional package is a capability check, not automatically a traceback-worthy exception.

Resource cache, ResMgr, and ownership hardening

• Added Resource & Cache Invalidation as the canonical cross-system matrix for Python imports, VFS/package lookup, ResMgr, Scaleform, Gameface, generated contracts, reloads, and restarts.
• Added ResMgr & Virtual Resources as a discoverable named-system reference for virtual paths, package paths, DataSection cautions, and resource evidence limits.
• Expanded Runtime Ownership Glossary with process, session, lobby/hangar, controller, callback, Gameface, and Scaleform ownership vocabulary.
• Added lightweight evidence metadata to fragile entries in Native BigWorld Helpers and clarified the roles of Source Navigation, Source Verification, and Source Evidence Ladder.
• Generalized Dossier & Baseline Validity and reduced brittle hook-target inventory in Compatibility & Performance.

Scope, evidence, and canonicalization hardening

• Fixed Callback Lifecycle Patterns so the bounded readiness retry owns one cancellable callback handle and rejects stale generations.
• Clarified helper provenance in Existing-View Injection and Resources & Registration so illustrative Gameface helper names are not presented as native client APIs.
• Generalized Client Requests & State Synchronization, Optional Systems, Dependencies & Services, and Battle Data Pipelines away from feature-shaped examples and third-party infrastructure details.
• Reworked Testing & Update Migration around update-regression checks and linked detailed replay-rewind handling to Results & Replays.
• Added beginner source vocabulary to Source Navigation, extended Python 2.7 & Runtime Safety, and clarified navigation labels for Engine GUI Components and BigWorld Symbol Index.

Client lifecycle, service, and UI contracts

• Expanded Graphics & Display State with durable guidance for borrowing native hangar scene groups, preserving route ownership, and diagnosing camera, lighting, synthetic map-hangar, visual-entity, and model-transform recovery problems.
• Expanded Client Requests & State Synchronization and Results & Replays with stricter boundaries between presentation-only view-model updates and server-changing native requests.
• Expanded Spatial Coordinates & Projection with owned minimap-entry guidance for range, direction, matrix, callback, and plugin cleanup behavior.
• Updated Lifecycle, Hooks & Events, Dependencies & Services, and Events & Event Buses with loader-order, player-event, service-resolution, hook-ownership, and GUI event-bus guidance.
• Updated Settings & Storage, Input, Cursor & Camera, Sound & Notifications, Gameface Lifecycle, and Runtime Debugging with persistence, input dispatch, notification, Wulf window readiness, and traceback-reporting contracts.
• Expanded Practical Recipes and Settings & Storage with backup-aware staged JSON write examples.
• Clarified in Gameface Overview and Resources & Registration that Gameface assets and runtime surfaces are still owned by the mod lifecycle.

Readiness, callbacks, hooks, and verification patterns

• Added Readiness Matrix and Runtime Ownership Glossary to clarify owner-specific lifecycle validity.
• Added Callback Lifecycle Patterns and Hook Composition Rules for delayed work, cancellation, wrapping, and multi-mod compatibility.
• Added Source Evidence Ladder for ranking call sites, registrations, event emitters, generated resources, and runtime logs.
• Expanded Python 2.7 & Runtime Safety, Native Helpers, Settings & Storage, Gameface Troubleshooting, Resources & Localization, and Battle Data Pipelines.

Mode identifiers, source tracing, and native-action safety

• Added Arena Mode Identifiers for keeping GUI type, bonus type, queue type, and mode-tag namespaces separate.
• Expanded Source Navigation and GUI Frameworks with shared Scaleform-library and renderer-consumer investigation guidance.
• Expanded Client Requests & State Synchronization with a generic bulk-request safety pattern for per-target invariants.

Graphics, messaging, Gameface, and runtime safety

• Added Graphics & Display State for renderer ownership, display-mode changes, space readiness, world drawing, and visibility masks.
• Added Messenger & Chat for lobby and battle chat layers, channel readiness, outgoing-message boundaries, throttling, and diagnostics.
• Expanded Layout, Scaling & Input, Standalone Overlays, and Resources & Registration with stricter readiness, sizing, resource-map, and multi-panel guidance.
• Expanded Sound & Notifications, Tooling, Assets & Packaging, and Source Verification with more generic audio, filesystem, and producer-to-consumer validation guidance.

Spatial systems and documentation scope

• Added Spatial Coordinates & Projection for world, arena, minimap, camera, and UI coordinate ownership.
• Expanded BigWorld Overview, Input, Cursor & Camera, Resources & Registration, Standalone Overlays, and Source Navigation with generic system guidance.

Battle baselines and generic system scope

• Added Dossier & Baseline Validity for baseline ownership, dossier reconciliation, and safe result validation.
• Expanded Battle Data Pipelines, Battle Results & Replays, and Vehicles & Items with more generic battle-data guidance.

Beginner navigation pass

• Separated the short learning path from the larger Game Systems and BigWorld reference sections.
• Renamed Start Here to Plan Your First Feature so it no longer overlaps conceptually with First Mod & Safe Patching.
• Kept Single-File Structure, Python 2.7 & Runtime Safety, and Tooling, Assets & Packaging in the beginner route.

Native actions, battle data, Gameface models, and local tools

• Added Client Requests & State Synchronization with synchronized request chains, native processors, cache confirmation, busy flags, and failure semantics.
• Added Battle Data Pipelines covering authoritative sources, baselines, derived metrics, respawn state, final-result reconciliation, and estimate labeling.
• Added Gameface Models & Native Projections for composite roots, placeholders, host updates, ordering, and route-specific surfaces.
• Added Local Tools & Game-Thread Bridges with loopback HTTP, thread marshalling, browser hand-offs, local entities, and trust boundaries boundaries.
• Expanded Async & Networking, Sound & Notifications, Battle Results & Replays, Vehicles & Items, Gameface Overview, and Runtime Debugging with cross-linked guidance.

Scaleform, equipment actions, and optional integrations

• Expanded GUI Frameworks with the verified Scaleform/DAAPI registration path and current gun-marker event contract.
• Expanded Vehicles & Items with a source-traced optional-equipment workflow that inspects inactive setups without switching them.
• Expanded Dependencies & Services with optional settings and list API boundaries and cleanup requirements.
• Expanded Gameface Lifecycle and Troubleshooting with readiness stages and replay rewind recovery.
• Removed source-project branding from the public documentation footer.

Public changelog and footer improvements

• Added this public changelog so visitors can quickly see when the documentation changes.
• Added an automatically updating copyright year and a concise independence notice to the footer.
• Kept the client-version warning visible across the site.

Layout, input, lifecycle, and saved-position guidance

• Expanded Layout, Scaling & Input with physical-pixel coordinates, scaled Wulf coordinates, and delayed saved-position restoration.
• Expanded Lifecycle & Ownership with garage-route visibility for lobby-only overlays.
• Expanded Gameface Troubleshooting with drag and coordinate-space failure checks.
• Expanded Settings & Storage with preference readiness, bounded retries, and integer defaults for native readInt bindings.

Clearer first steps and terminology

• Reworked Plan Your First Feature and First Mod & Safe Patching around one successful loader check in game.log.
• Added clearer beginner guidance to Single-File Structure and Client Architecture.
• Added plain-language lifecycle and state explanations to Lifecycle and State & IDs.
• Grounded service readiness in observable client behaviour in Dependencies & Services.

Cache readiness and fallback data

• Updated Account & Lobby with reconnect-safe handling for early empty caches.
• Updated Vehicles & Items with disk-backed dossier fallbacks and confirmed local snapshots.
• Updated Data & Persistence with a small validated-snapshot pattern for context transitions.

Initial public guide structure

• Published the main Guide overview, Gameface, Game Systems, and BigWorld sections.
• Added page difficulty and page-type labels, search, maximum-difficulty filtering, and related-page navigation.
• Added dark mode, keyboard navigation, code-copy controls, heading permalinks, and page-level metadata.
• Established a practical path from a first mod through lifecycle, UI, debugging, packaging, and engine references.