Replace boolean output-parameter converters with UIValueResult so conversion failures can provide numeric codes and optional diagnostics without exposing partially converted values.
Expose observable converter error state from UIDataBind, UIProperty, and UIValueBinding.
Reject invalid widget input without changing the model or propagating it to sibling widgets, while keeping programmatic model updates authoritative.
Migrate ecode's custom output parser converter, expand binding tests, and document the data-handling architecture and next form-validation
phase.
- MSVC:
- Removed lambda-based eeNew expansion in favor of typed MemoryManager::trackNew().
- Added macro expansion indirection.
- Enabled MSVC’s conforming preprocessor with /Zc:preprocessor across Premake 4/5 static libraries, shared libraries, and executables.
- Verified generated VS2022 projects contain the flag, including eterm-static and eepp-maps-static.
- Added explicit standard-library includes to memorymanagerglobal.cpp.
- Linux/macOS release tests:
- MemoryManager.tracesPlainNew is now compiled only with EE_MEMORY_MANAGER, since global tracing is intentionally debug-only.
Added new plan to improve PropertyIdSet.
Model HTML images as replaced UIHTMLWidget elements with independent loading, sizing, and rendering behavior.
Resolve auto margins according to each element's formatting context, including normal-flow blocks, positioned elements, flex items, and grid items. Preserve intrinsic sizing for block-level images with width:auto and constrain them through CSS min/max dimensions.
Correct absolute-positioned containing-block coordinates and rich-text handling of atomic inline elements. Add regression coverage for centered images, deferred image loading, grid margins, positioned elements, and document flow after image loading.
Document the remaining work required for dynamically changing non-atomic inline elements.
Avoid saving eeiv configuration during destruction (fixes window state saving).
- move chrono implementation details out of the public Clock header
- define Sys system time as Unix epoch milliseconds
- add getUnixTimestamp() for epoch timestamps in seconds
- replace chrono wall-clock usage in ecode plugins with Sys APIs
- update existing Sys time callers for the new millisecond contract
- remove redundant chrono inclusion from HTTP tests
- remove the completed user-defined snippets plan
This prevents chrono and std::format internals from being instantiated across large portions of the project while preserving timestamp precision.
- implement per-side CSS border styles and patterned rendering
- preserve rectangular rasterization for thin dotted borders
- separate CSS and native-widget border defaults
- correct inline atomic-box and vertical-align baseline layout
- collapse adjacent block margins in rich-text flow
- preserve forced line breaks and formatting margins
- size HTML text inputs from font ascent and descent
- expose replaced-control text baselines to inline layout
- enforce single-owner painting for inline backgrounds and borders
- enable and update the old Reddit visual regression golden
- add generic layout, border, and form-control regression tests
- document spec-first HTML work and project build conventions
Resolve auto margins according to the element's formatting context instead of applying native block centering to every HTML child.
Inline-level replaced elements, inline-blocks, floats, and out-of-flow boxes now use zero-valued auto margins in rich-text measurement and positioning, while normal-flow blocks retain horizontal auto-margin resolution. This prevents asynchronously loaded images from feeding stale calculated margins back into their inline ancestors and producing unbounded document widths, as observed on the Asahi Linux site.
Add synchronous and threaded WebView regression coverage using the Asahi fixture, including its weighted host layout and asynchronous SVG loading.
Document the follow-up plan for explicit formatting-role margin resolution, shared image-content composition, and rebasing UIHTMLImage on UIHTMLWidget.
- batch asynchronous HTTP stylesheets and apply them in a single reload
- skip unsupported block at-rules without leaking nested rules
- prevent scripts nested in unknown custom elements from entering the render tree
- add regression coverage for unsupported at-rules and nested scripts
- document the Ninja release workflow for performance testing
- support runtime locator provider registration and removal
- filter snippets with workspace-relative include/exclude globs
- add the remaining VS Code-compatible snippet variables
- support camelcase, pascalcase, snakecase, and kebabcase modifiers
- reuse the existing insertion flow for locator-selected snippets
- expand snippet parser and store test coverage
- update the implementation plan and C/C++ example snippets
Refs: SpartanJ/ecode#111
- parse slash-separated background position and size without requiring whitespace
- recognize custom-property background images following an explicit size
- resolve root body and html minimum heights against the layout viewport
- avoid expanding semantic document boxes to the scrollable content extent
- handle auto margins and percentage offsets correctly for absolute positioning
- add DuckDuckGo layout and background shorthand regression tests
- document the Xvfb limitation with multisampled OpenGL contexts
- migrate themes, skins, icons, shaders, and shader programs to resource handles
- make UIThemeManager scene-owned and publish resources through scopes and catalogs
- retain shaders through their programs and expose non-owning GPU registries
- replace FrameBuffer and VertexBuffer factory ownership with unique pointers
- migrate engine, UI, tools, examples, tests, and eterm to the new ownership APIs
- remove the obsolete raw-owning ResourceManager templates
- document the completed Stage 7 architecture and remaining validation work
- add ownership, registry, and scoped shader-program coverage
- replace FontManager with per-ResourceScope FontService instances
- publish font factories into explicit or default resource scopes
- import default resources into UI scene scopes unless explicitly disabled
- keep related font faces strongly owned without hot-path weak_ptr locking
- add cached glyph advance queries without creating texture pages
- fix font picker preview ownership, cleanup, and rapid switching
- selectively evict TextLayout cache entries when referenced fonts unload
- document FontService, ResourceCatalog, and cache invalidation semantics
- migrate examples, tools, benchmarks, and tests to the scoped font API
- expand coverage for font ownership, texture release, and layout caching
- replace TextureAtlasManager and GlobalTextureAtlas with catalog-backed atlas ownership
- make TextureAtlas and TextureRegion creation return explicit resource handles
- let atlases retain their textures and regions through shared ownership
- add atlas publication, lookup, removal, and enumeration to ResourceCatalog and ResourceScope
- make TextureAtlasLoader publish atlases and regions into an explicit resource scope
- move theme atlas ownership into each theme resource catalog
- migrate maps, editors, examples, and tests away from the global atlas manager
- add scope-aware Sprite pattern-loading overloads while preserving default-scope compatibility
- fix re-entrant style-state invalidation when applying styles creates new widgets
- add atlas ownership, scoped Sprite lookup, and style-state regression coverage
- update the resource ownership plan and texture atlas editor launch configuration
Return shared handles from NinePatch creation and remove the process-wide
NinePatchManager singleton.
Extend ResourceCatalog with typed drawable-source ownership and expose
drawable publication, lookup, and removal through ResourceScope. Preserve
separate texture and drawable namespaces for direct typed lookup.
Give each UITheme its own resource catalog and have scene-owned theme
managers explicitly import and remove theme catalogs. Handle registered
themes and default-only themes without leaking stale resource visibility
between scenes.
Update theme loading, Engine teardown, platform source manifests, and
resource ownership tests for the catalog-based model.
Document that remaining singleton resource managers must migrate to
naturally owned catalogs and explicit scope imports instead of becoming
new process-global semantic namespaces.
Advance the web resource cache generation only when the replacement
document is installed, after the previous document and its asynchronous
loads have been detached. This prevents outgoing document nodes from
acquiring leases under the new generation.
Add UIWebView coverage for delayed document replacement, stale resource
release, and periodic cache pruning.
Make Texture Viewer thumbnails observe textures through weak handles and
retain them only for the duration of drawing. Keep explicit selection as
the only operation that pins a texture, so opening the diagnostic viewer
no longer prevents unused textures from being released.
Update the shared-resource ownership plan to document the replacement-time
navigation boundary.
Introduce WebResourceCache with partitioned sharing, per-document sessions,
navigation generations, leases, and canonical request keys.
Coalesce concurrent document, stylesheet, font, and image requests while
discarding stale navigation subscribers independently. Retain completed
resources with TTL/LRU and byte-budget policies, and periodically prune
expired unleased entries from UIWebView.
Route UISceneNode, UIWebView, UIImage, CSS background images, and remote
drawable resolution through the shared cache. Preserve ResourceScope entries
as explicit overrides and allow multiple WebViews to share a cache partition.
Keep image decode and texture replacement on the guarded graphics-thread
completion path. Exclude volatile Cookie and Referer values from cache
identity while preserving partition isolation and content-affecting variants.
Start TTL retention when the final document lease is released so Back/Forward
navigation can reuse resources regardless of how long the previous page was
open.
Avoid unstable pointers and iterators into unordered_dense storage when
tracking leases and pruning entries. Add ASan regression coverage for dense
map growth, navigation, eviction, partition isolation, request coalescing,
retry behavior, and cache retention.
Fully document cache partitions, sessions, generations, request identity,
ownership, threading, and maintenance behavior.
Add a scene-owned UI::DrawableResolver for resolving file, data, HTTP, and
named drawable references through each UISceneNode's current resource scope.
Move generic texture, atlas region, nine-patch, and sprite lookup into
Graphics::ResourceScope, preserving drawable resolution for pure Graphics
consumers without introducing a UI dependency.
Migrate UI images, sprites, menus, CSS parsing, and tests to the new resolver.
Resolve CSS icons through the requesting node's scene instead of the global
scene, preserving embedded-scene isolation.
Remove the obsolete DrawableSearcher API and update platform project manifests,
tests, and the shared-resource architecture plan.
Rename Drawable::createInstance() to clone() and update drawable implementations,
typed helpers, consumers, tests, tools, and external modules.
Avoid retaining private icon clones for immediate single-threaded rendering in the
code editor and ecode plugins. Borrow cached per-size icon sources instead, restoring
temporary color changes after drawing, while preserving owned clones for widgets,
menus, models, and other stateful consumers.
Reduce common drawable allocation overhead by lazily creating DrawableResource
callback state, using inline callback storage and notification snapshots, and safely
supporting callback disconnection during notification.
Lazily allocate UIImage and UINodeDrawable asynchronous lifetime tokens only when
an uncached asynchronous load is actually scheduled.
Document the distinction between borrowed immediate rendering and independently
owned drawable state.
Add ResourceCatalog and ResourceScope to provide explicit strong ownership
and deterministic semantic lookup independently from the live texture
registry.
Let Engine own the global catalog and default Graphics scope, and give
each UISceneNode an isolated scope that can be explicitly shared with
other scenes.
Remove TextureFactory's strong texture retention and name/hash lookup.
The factory now observes textures weakly for identity, diagnostics, and
deferred destruction without controlling their semantic lifetime.
Migrate drawable resolution, texture atlas loading, UI image caches,
tile maps, ecode resources, and related tests to scoped lookup and
publication.
Allow final TexturePtr release from worker threads while keeping actual
texture destruction deferred to the graphics thread. Fix mismatched
pixel deallocation uncovered by asynchronous texture loading tests.
Add ownership, scope isolation, scene sharing, worker release, and
decoder allocation regression tests, and update the shared-resource
architecture plan through Stage 3.
- introduce process-wide ResourceId, resource handles, and shared metrics
- manage textures through factory-owned control blocks and a weak live registry
- defer final texture destruction until display-time batch work is flushed
- diagnose externally retained textures during Engine shutdown
- migrate texture identity APIs and consumers from Uint32 to ResourceId
- decouple texture memory accounting from the TextureFactory singleton
- replace UITextureViewer callbacks with generation-based weak snapshots
- remove obsolete texture context-reload APIs and loader callback registry
- add registry, identity, memory, restart, and deferred-release tests
- mark Stage 1 complete in the shared-resource architecture plan
- add explicit open, closing, and closed states to the UISceneNode async delivery queue
- reject delivery execution during shutdown and purge retained captures after scene producers join
- reopen the queue cleanly when recreating Engine state in tests
- add regressions for stale deliveries, retained captures, concurrent producers, and Engine restart
- remove the obsolete and unused FrameBuffer context-loss reload API
- simplify redundant namespace qualification in UI tests and ecode declarations
- consolidate completed resource plans into the active ownership architecture
- defer TextureLoader callback removal directly to Stage 1 live-texture observation
- document the requirement to validate legacy lifecycles and prefer removing dead mechanisms
- retain asynchronous HTTP operations until execution or queue disposal
- make HTTP shutdown cancel and join queued and running shared-pool requests
- avoid deadlocks when callbacks clear the HTTP pool
- share atomic cancellation state across request copies
- detect socket creation failures before configuring TCP or UDP sockets
- release partially initialized mbedTLS state after failed handshakes
- replace retained FreeType faces with bounded LRU probe-result caching
- release non-trivial StaticLRU keys when clearing the cache
- resolve the Texture Viewer close icon through the configured icon theme
- add HTTP, TLS, UIWebView fan-out, font descriptor, and LRU regressions
- update resource-refactor prerequisite and ownership planning documents
- Pool-owned HTTP clients stop first.
- The active GL context is made current.
- Scenes are destroyed before batches and resource managers.
- Pending batches explicitly discard vertices and borrowed textures.
- TextLayout cache clears before fonts.
- Framebuffer/vertex managers and textures are released while Renderer/context remain alive.
- ShaderProgramManager is destroyed before Renderer.
- Windows and contexts are destroyed last.
The lifecycle test uncovered and fixed another bug: StaticLRU::clear() retained non-trivial values such as cached shared_ptr<TextLayout> objects. It now releases active values in LRUCache.
Destroy pooled HTTP clients after releasing the pool mutex so joined
callbacks can safely re-enter the global pool.
Add a regression test covering concurrent pool clearing and callback
re-entry. Document the revised texture lifetime architecture and track
the prerequisite bugs discovered during the resource ownership audit.
Inline frequently used scene and UI state accessors to reduce function
call overhead during layout, rendering, and rich-text traversal.
Add string-view numeric conversion support and parse CSS length values
without temporary number or unit strings. Preserve existing string
overloads for compatibility and keep CSS function parsing unchanged.
Add focused parsing coverage and benchmarks. Full-suite profiling showed
substantial reductions in layout invalidation, whitespace traversal, and
CSS length parsing costs.
Resolve standard property definitions and data-attribute classification
when selectors are parsed, avoiding repeated specification lookups and
attribute-name checks during matching.
Fast-path existence-only data selectors without retrieving their values,
while preserving all attribute operator behavior. Add standard-property
coverage and an attribute-focused benchmark showing a 41.7% reduction
in matching time.
Add a fast path that directly evaluates selectors containing one rule,
avoiding combinator traversal and switch overhead for common class, ID,
tag, and pseudo-class selectors.
Move complex selector traversal into a dedicated function and cache rule
counts in selector loops. Add focused matching coverage and document the
Phase 7 benchmark results.
Index class-anchored selectors by one mandatory class hash so widgets
only evaluate rules associated with their own classes instead of
scanning every class-only rule in the global bucket.
Preserve selector correctness by validating the complete rule after
candidate lookup, and retain stylesheet source order across independent
index buckets for equal-specificity cascade resolution.
Update index clearing, copying, marker removal, and style insertion
paths. Add focused candidate coverage and a legacy full-scan benchmark,
showing a 63% lookup-time reduction on a class-heavy stylesheet.
Cache tag, ID, and class hashes in selector rules and widgets to avoid
repeated string comparisons during selector matching.
Store widget class hashes in a single-element SmallVector so the common
zero and one-class cases remain allocation-free. Reorder UINode and
UIWidget members to recover padding, keeping UIWidget at its original
1144-byte size.
Add selector matching benchmarks and regression coverage for class
mutation, compound selectors, and hash cache synchronization. Document
the measured Phase 5 performance and memory results.
Apply @font-face weights to loaded variable fonts, preserve author
font-family names for internal font-face aliases, and re-resolve text fonts
when style or weight changes after initial font selection.
Also updates the font-weight native variant plan to reflect the current
architecture and remaining work around static native weight variants.
Move UIWebView documents into isolated UISceneNode instances, keep document viewport and extent metrics synchronized, and fix shrink/grow behavior after navigation, async CSS, and viewport changes. Scope author styles and font-face resources per document scene, ignore stale async callbacks after navigation or destruction, and add deterministic coverage for CSS, fonts, images, cookies, hit testing, and document extent updates.
Fixes in UIWebView -> doc -> html -> body resizing issues. Added a few tests to catch regressions.
Martín Lucas Golini