* Serialize tracked realloc and free bookkeeping to prevent cross-thread
address reuse from corrupting the memory tracker during tab teardown.
* Add concurrent allocation and terminal close/resize regression coverage.
* Install a macOS-only File, Edit, and Window menu that mirrors eterm
keybindings without binding Cmd+W.
* Keep the native menu outside the splitter layout and document the canonical
macOS build workflow.
Introduce UIScrollController to provide frame-rate-independent wheel
interpolation, touch dragging, and momentum for code editors, terminals,
scroll views, and scrollable widgets while preserving the legacy instant
scrolling path.
Add a UISceneNode-level smooth-scrolling policy. Embedded scenes inherit
the root scene setting, new widgets snapshot it during construction, and
setSmoothScrollEnabled() can optionally apply changes to existing widgets
across the complete embedded-scene hierarchy.
Move native macOS scrolling and title-bar helpers into PlatformHelper,
enable native momentum from UIApplication, and explicitly enable it in
ecode. Preserve precise SDL2 and SDL3 wheel deltas for fractional momentum
events without changing normal integer wheel steps.
Replace the separate editor and terminal preferences in ecode and eterm
with one global smooth-scrolling setting, including legacy configuration
migration, live updates, and localized settings text.
Improve UITouchDraggableWidget momentum handling and add regression tests
for scrolling interpolation, pixel-aligned editor positions, scene
inheritance, widget overrides, and immediate policy application.
- add reusable-buffer String::toUtf8() conversion
- extract shared find-bar CSS into UIFindBarStyle
- reuse the shared style from UIDocFindReplace
ecode:
- enable terminal find, next, and previous shortcuts
- install terminal bindings after conflicting editor bindings are removed
eterm:
- add searchable terminal history with plain text, RegEx, and LuaPattern modes
- support case-sensitive and whole-word matching across wrapped rows
- debounce searches and avoid unnecessary string allocations
- add an animated find bar with status and wrapped result navigation
- expose find commands through configurable keybindings and the context menu
- render and navigate search matches in terminal history
- forward right-button releases when applications capture the mouse
- fix UITabWidgetSplitter ownership during shutdown
tests:
- cover UTF-8 buffer reuse and terminal search behavior
- verify wrapped lines, Unicode, pattern modes, invalid expressions, and navigation
- verify SGR right-button release encoding
tooling:
- clarify the mandatory optimized build workflow for performance work
- require direct release test execution before falling back to Xvfb
- add Discard actions for conflicted files and conflict groups
- restore discarded conflicts from HEAD in both index and working tree
- restrict regular discard actions to changed tracked files
- preserve default editor commands when replacing an editor document
- enable copying from the read-only merge-view side panels
- cover conflict restoration and merge-side copying
- document build parallelism and function-spacing conventions
- preserve CSI subparameter separators for modern SGR color sequences
- fix synchronized updates and periodic presentation under sustained output
- support OSC palette queries, resets, and color scheme notifications
- implement alternate scroll, cursor style, and terminal version queries
- preserve the configured cursor shape for default blinking cursor requests
- recognize Kitty keyboard negotiation without falsely advertising support
- recognize OSC 8 hyperlink markers without emitting parser errors
- make release parser diagnostics opt-in through ETERM_LOG_ERRORS
- update the Kitty keyboard protocol implementation plan for worker ownership
- add regression coverage for rendering, colors, CSI modes, cursors, and OSC 8
- Add SmartGit-inspired context actions to Git History commits, including checkout, merge, fast-forward merge, cherry-pick, revert, branch creation, tag creation, and copying commit IDs or complete messages.
- Order commit actions into consistent operation, ref-creation, and clipboard groups. Hide the redundant Show in Git History action inside detached history tabs while retaining it in the source-control sidebar.
- Add a Working Tree / Index context menu with status-aware Commit and Stage actions. Track staged and unstaged availability in the history model and keep it synchronized as repository status changes.
- Extend the Git command wrapper with operations for creating branches at commits, creating and deleting tags, deleting remote branches, cherry-picking commits, and reverting commits.
- Support deleting tags and remote branches from the Branches view. When deleting a local branch with an upstream, optionally delete its tracked remote branch as part of the operation.
- Add confirmation and input dialogs for branch, tag, remote-deletion, and revert workflows. Disable history-changing commit actions while another Git operation is active.
Initialize SystemFontResolver when enabled and make its lifecycle and font-list
population thread-safe.
Use native codepoint fallback matching through Fontconfig on Linux, BSD, and
Haiku, DirectWrite on Windows, and Core Text on macOS and iOS. Preserve the
cached FreeType scan as a fallback when native matching is unavailable.
Enable system fonts by default for UIApplication and warm the font database in
the background. Allow applications to override the policy and disable the
automatic default in the unit-test runner.
Fix glyph fallback checks to respect the resolver's enabled state and add
coverage for concurrent warm-up and shaped symbol fallback.
Update efsw.
Introduce observable and computed values, typed widget bindings, validation groups, UI properties, commands, and UI-thread delivery.
Add observable vector and list model support for incrementally updated collections, with filtering and source-row mapping.
Modernize the Flight Booker and CRUD examples and add focused data handling and collection examples demonstrating the new APIs.
Organize the UI binding headers under ui/databinding, expand test coverage for notification and lifetime semantics, and document API selection, validation, ownership, threading, and performance behavior.
Implement spec-oriented paint phases for normal flow, floats, and
positioned descendants, including atomic stacking groups and applicable
z-index handling for flex and grid items.
Share cached ordering between drawing and hit testing, propagate
invalidation across stacking scopes, and preserve ancestor transforms
and clipping for promoted descendants.
Add regression coverage for paint order, hit testing, reparenting,
clipping, flex ordering, and the old Reddit layout. Document the
supported stacking model and remove the completed implementation plan.
- add a reusable right-side panel managed at the application level
- migrate debugger tabs to UITabWidgetSplitter instances
- support moving and splitting debugger tabs across bottom and right panels
- restrict debugger tab drops to debugger-owned panel targets
- serialize debugger tab layouts, panel state, and table column widths
- add pixel and percentage column-width modes to UIAbstractTableView
- support XML/CSS configuration and an optional width-mode context menu
- preserve percentage totals across resizing, fit-to-content, minimum widths,
scrollbar changes, and pixel-density rounding
- add splitter edge hiding while preserving splitter-always-show precedence
- use EventConnection ownership for safe widget and controller lifetimes
- validate serialized splitter layouts with structural limits
- display project-relative source paths in debugger stack frames
- add ecode localization strings, CSS documentation, tests, and agent rules
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.
