Fetch and cache the models.dev catalog asynchronously, replacing bundled model lists when catalog data is available while preserving local and user-configured providers.
Update live AI Assistant instances after refresh, defer startup requests until the UI is ready, and cancel in-flight catalog requests during shutdown. Prioritize providers with configured credentials and infer each provider's cheapest title-generation model from catalog pricing.
Add model reasoning metadata, effort controls, request serialization, chat persistence, and localized UI labels. Refresh the bundled fallback models and support API keys for arbitrary catalog providers.
Fix ACP Agent mode message chunks enqueue ordering issue (ACP thought chunks were enqueued twice while answer chunks were enqueued once).
Fix UIDropDownList WrapContent sizing so dropdown width follows its text, skin, and padding, and tighten UIDropDown automatic height sizing.
Add FileSystem::dirRemoveAll() to normalize trailing separators and use the non-throwing std::filesystem::remove_all overload.
Migrate ecode and unit-test cleanup call sites to the centralized helper, preventing Haiku from crashing when removing directories with trailing slashes during shutdown.
getNodeFromPath() now translates paths under the configured root—such as /var/...—to the canonical root—such as /private/var/.. before calling realpath(). This keeps moved/deleted paths resolvable after the original leaf disappears.
- enable efsw cross-directory move reporting in ecode
- transfer FileSystemModel nodes between materialized parents
- preserve selections, descendant paths, and lazy destination branches
- update open document paths when parent directories move
- fix persistent indexes across insert, delete, and move operations
- clear stale tree-view metadata before model nodes are deleted
- safely handle getRealPath() failures for stale paths
- add model operation and filesystem move regression tests
- update efsw and SOIL2 submodules
Require the requested family when matching CoreText descriptors to prevent
substitutions such as Verdana resolving to Helvetica.
Validate the matched descriptor family and derive TTC face indices by matching
CoreText PostScript names against the font's FreeType faces instead of using
the descriptor array position.
Add macOS regression coverage for resolving and loading Verdana styles.
Support explicit liga, calt, clig, and dlig shaping features and include
text hints in layout caching, measurement, drawing, and character
position calculations.
Propagate scene-wide font feature defaults through UI text producers,
with granular widget overrides and recursive cache invalidation. Update
UICodeEditor and UIConsole to use shaped positioning when font features
are enabled, including with monospaced fonts.
Add separate UI and editor font feature settings to ecode, persist them
as comma-separated OpenType tags, and apply changes immediately. Add
localized menu labels, reusable Text feature conversion helpers, and
regression coverage for shaping, positioning, propagation, and parsing.
Preserve explicitly selected font styles and correctly reconcile external fonts with the asynchronously loaded system font list.
Group same-family external fonts under the Style column when styles are visible, and expose them as distinct family entries when styles are hidden. Include filenames in localized external-font labels to distinguish alternate
font versions.
Ensure system-listed regular faces remain available after asynchronous loading and add regression coverage for collisions, selection, and hidden style 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
Refactor IniFile storage to keep keys and values in unified SmallVector-backed
records, avoiding parallel vector growth and allocations for common small
configurations.
Use std::string_view by value throughout the IniFile input API to prevent
temporary std::string allocations for keys, value names, paths, and comments.
Write serialized components directly to streams instead of constructing a
temporary string for every line.
Return ProjectBuildConfiguration by const reference to avoid copying it during
project saves, and use inline storage for DocumentView visual lines to avoid
heap allocations while rendering the code editor minimap.
Add IniFile tests covering parsing, mutation, ordered serialization, and a
byte-for-byte ecode project-state round trip.
Enable multiple selection in the Git status tree and apply stage, unstage, discard, open, and diff actions to all applicable files.
Open selected diffs in a single multi-file diff view, including portable handling for untracked files, and group mutating operations by repository.
Make the commit dialog resizable, allow its text editor to grow with the window, and wrap commit messages by word.
Add an unlocked take-screenshot command and expose it under Settings -> Window with a default Print Screen binding.
Allow configuring the screenshot destination, filename pattern, and output format. Save screenshots under the ecode configuration directory by default, notify users after capture, and provide an action to open the result in the integrated image viewer.
Addresses a request in SpartanJ/ecode#950.
Allow UIFontPickerDialog sections to be hidden and make ecode's UI, editor, and terminal font dialogs select both the font and its size.
Keep external fonts selectable across asynchronous font enumeration, including when they share a family name with a system font, and label them as external. Also normalize UILinearLayout weights across visible children so hidden picker columns release their space correctly.
Update font picker previews, size units, menu labels, translations, and lifetime handling.
Addresses SpartanJ/ecode#944.
SDL2 prevents the default action for Ctrl/Cmd key events on Emscripten,
which stops browsers from emitting the native paste event.
Intercept Ctrl/Cmd+V before SDL2 consumes it, allow the browser paste
event to update the internal clipboard, and replay the keydown so the
application executes its normal paste command.
Also refresh the clipboard through the asynchronous Clipboard API when
opening a context menu, enabling paste actions triggered without a
keyboard shortcut.
Export Emscripten's ccall runtime method so the browser clipboard helper
can reliably invoke its C++ callbacks in optimized builds, and disable
clang-format for the header containing embedded JavaScript.
- migrate TextRanges to SmallVector with capacity for two selections
- preserve vector, initializer-list, and single-range construction
- add coverage for inline storage, copying, and heap fallback
- export UIStyle::PropertyResolution for Windows shared builds
- reuse formatting, document text, property resolution, and layout storage
- use inline containers for interpolations, callbacks, wrapping, and matcher state
- optimize single-line insertion by mutating document lines without splitting
- iterate PATH entries directly in Sys::which and reuse candidate buffers
- avoid temporary clocks and string copies in frequent ecode plugin updates
- retain documents during autocomplete cache jobs and prevent duplicate scheduling
- fix PatternMatcher copy assignment and MSVC move-only container compilation
- expand coverage for matching, text insertion, reusable strings, and Sys::which
- reuse reentrant property-resolution storage during variable substitution
- skip redundant resolution-slot copies using structural source comparison
- retain variable cache capacity and resolve variables in place
- avoid copying canonical names for definition-backed properties
- propagate resolved inherited properties by reference through widget trees
- parse animation and transition declarations with allocation-light string views
- share declaration tokenization between animation and transition parsers
- avoid empty animation-map and action-query allocations
- parse border radii without temporary split vectors
- accept string views when converting UI lengths
- format color hex values directly without string streams
- use inline storage for small polygon point collections
- preserve animation parsing semantics and fix longhand direction handling
- save eeiv configuration when closing through keyboard shortcuts
- extend animation, variable-resolution, property-name, and color tests
Probable reproduction:
1. Open global search.
2. Enter a search term.
3. Start “replace in files” with Mod+R.
4. Before the asynchronous search finishes, switch to document search.
5. Immediately reopen normal global search.
The replace tree becomes active as soon as the search starts, but its model is only assigned when the asynchronous result arrives. Reopening normal global search tried to reuse that still-null model and called rowCount() on it. The loader is also closed during this transition, explaining the SceneNode::checkClose() trace from another timing of the same sequence.
The fix:
- Only transfers replace results when the replace model exists.
- Adds a defensive null check to updateGlobalSearchBarResults().
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.
Introduce EventConnection and EventConnectionList for scoped Node event listeners that safely handle either emitter or observer destruction order.
Add ObservableValue and UIValueBinding for UI-independent observable state, along with a shared UIValueConverter policy used by both observable and raw data bindings.
Harden UIDataBind and UIProperty lifetime behavior, documentation, conversion, operators, and multi-widget handling. Preserve UIProperty as the lightweight option for UI-local owned values and UIDataBind for explicitly managed external values.
Use inline ordered callback storage to preserve registration-order dispatch without per-listener tree allocations.
Migrate submenu observation to scoped connections, safely clear ecode run configuration bindings before model erasure, and simplify the 7GUIs Counter example with UIProperty.
Add lifecycle, ordering, conversion, binding, and mutation regression tests.
Introduce contiguous PropertyId and ShorthandId enums backed by name-to-ID maps, replacing hash-valued property identifiers throughout the style system.
Replace PropertyIdSet's unordered set with a fixed-size bitset, eliminating heap allocations during style state changes while providing deterministic ascending iteration.
Keep name hashes for stylesheet storage and unknown or custom properties, while using dense typed IDs for registered-property lookup and dispatch.
Preserve property aliases and the public Checked compatibility identifier.
Add transaction-end reconciliation for interdependent image sizing properties, deferring percentage-based calculations until their containing block is resolved.
Keep formatting-context-owned sizes intact for table cells and inline content.
Add validation and tests for dense built-in registration, custom IDs, aliases, bitset operations, allocation-free storage, unknown properties, property application order, and image sizing regressions.
- 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.
- intercept global new/delete operations in debug memory-manager builds
- distinguish anonymous global allocations from source-tracked leaks
- modernize eeNew to support constructor-expression syntax
- improve memory reports with tabulated leaks and separate largest allocations
- cache autocomplete shortcuts instead of hashing string keys on key events
- reuse UIStyle property sets across state changes
- reuse Text shadow colors and avoid temporary outline-color copies
- use inline storage for temporary linear-gradient rendering data
- make unit tests resolve assets from the executable directory
- add memory-manager and PropertyIdSet regression coverage
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).
- stop statement at-rules such as @charset at their semicolon
- preserve the following selector and declaration block
- support feature-level not() expressions in media queries
- add regression coverage for @charset and negated media features
Fixes Lobsters theme variables being discarded, which caused mixed light and dark colors when loading its stylesheets.
- 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.
Snap dotted and dashed border geometry to physical pixels so centered
patterns cannot begin on ambiguous half-pixel coordinates. This makes
rectangular dot placement deterministic across llvmpipe and macOS GPU
drivers.
Update the old Reddit golden image to use the snapped dot phase.
Optimize compile-time header dependencies
- Extract lightweight singleton declarations.
- Remove unnecessary core.hpp, stream, pack, and container includes.
- Add explicit direct dependencies across system, network, graphics, and syntax headers.
- Forward-declare stream and pack types where possible.
- Normalize selected network headers to LF.
- 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
Blockify floated inline elements and use wrap-content sizing for width-auto
floats so vote columns do not stretch across their containing block.
Recompute right-aligned text using the float's final shrink-to-fit width,
preventing overflow clipping from hiding rank text.
Handle bottom-edge fallback baselines in middle-aligned atomic boxes so
fixed-height inline parents do not vertically displace and clip elements
such as Reddit flair emoji.
Add a regression test covering the Reddit rank, vote arrows, rendered text,
and flair emoji alignment.
- Added UISceneNode::getVisibleWorldBounds() with an optional bounds-node binding.
- UIWebView binds its document scene to the scroll container’s clipped viewport.
- UINode::nodeDraw() now culls against visible scene bounds instead of the full document extent.
- Existing top-level scenes retain their previous behavior.
- Added a regression test confirming offscreen document widgets are skipped and visible widgets render.
eeiv: Add drag & drop of images and folders. Added small welcome screen.
eterm: Detect windows below the default width and height and resize the window to fix the screen.
ecode image viewing will not auto-scale images to the pixel density.
eeiv: Modernizing eeiv to use eepp GUI, already working just like before, there are probably a few things to fix.
- require propagated float placement to make forward progress
- avoid zero-displacement loops when float edges touch
- recompute collisions after each vertical adjustment
- add regression coverage for touching propagated and active floats
The float-aware rich-text layout was resetting curX for every block formatting context, including inline-blocks. That made consecutive action buttons overlap. The reset is now limited to block-level BFCs;
inline-blocks retain normal cursor advancement.
Added:
- An always-on deferred CSS regression covering inline anchors, inline-block siblings, and float exclusions.
- Strict action-row and title/domain ordering checks in the opt-in Reddit visual smoke test.
- A small CSS fixture reproducing Reddit’s layout rules.
Track percentage-based margins in UIHTMLWidget and re-resolve them when
the containing parent acquires its final size. This prevents margins
computed against an initial zero-width container from remaining stale
until the viewport is resized.
Add regressions covering percentage margin recomputation and the SS64
footer layout after a deferred stylesheet is loaded.
Reserve stylesheet source positions when link elements are encountered
instead of assigning them when asynchronous loading completes.
Track the stylesheet and rule ordinals explicitly so deferred external
styles retain their document order relative to later inline styles.
Preserve this ordering when extracting marked stylesheet rules.
Add an SS64 regression test covering heading and button styles after a
deferred stylesheet finishes loading.
Activate retained CSS cursors when the event dispatcher resolves a new
hover target instead of applying them at the end of UIWidget mouse-over
handling.
Resolve cursors through the nearest widget ancestor for non-widget hit
targets while allowing text inputs, editors, splitters, resize handles,
and plugins to override the default cursor contextually.
This restores ecode and Breeze cursor behavior without changing their
existing styles.
Map the standard CSS pointer value to the hand cursor and retain the
computed cursor in each UIWidget instead of mutating the scene during
style application.
Apply the retained cursor when a widget becomes the hover target, restore
the arrow when leaving the UI, and make cursor inheritance available to
descendants such as inline SVG elements.
Store cursor state in an existing UIWidget padding gap and centralize
cursor serialization in Cursor::toName().
Add regressions for pointer parsing, cursor serialization, inheritance,
and the SS64 search button SVG.
Propagate descendant float exclusions through non-BFC HTML containers so
floats participate in their nearest block formatting context.
Finalize line geometry before translating propagated exclusions, track
finalized lines incrementally, and search successive float bands when a
fixed-width inline-block does not fit beside active floats.
Recognize inline-block elements as block formatting contexts while
preserving their fixed width. Reuse persistent float-exclusion storage
across relayouts to avoid repeated allocations.
Add SS64 regressions covering narrow viewports, HiDPI rendering, stacked
floats, anchor sizing, SVG sizing, and footer overlap.
Fixed `cursor: pointer`, `pointer` was not registered.
Use border-box sizing for HTML buttons to match browser user-agent styles and
prevent padding from increasing explicitly declared button heights.
Keep inline SVG textures rasterized at full physical resolution while assigning
density-independent sprite destination sizes, avoiding double scaling on HiDPI
displays.
Add SS64 and pixel-density regressions for button alignment, percentage-sized
SVG layout, and drawable dimensions.
Resolve percentage dimensions for HTML-backed widgets after their containing
block has a definite size. Apply the resolution during rich-text, flex, and
grid layout without triggering broad layout invalidation.
Rasterize SVGs using their resolved dimensions when intrinsic width or height
attributes are missing or percentage-based.
Add regression coverage for percentage-sized SVGs and the SS64 navigation
buttons and search icon.
Preserve the final cross-axis size assigned to auto-sized stretched flex
items when their block layout runs. Keep intrinsic flex measurement
separate so content changes can still update item sizing correctly.
Add an HTML regression test covering a short sidebar stretched alongside
taller content.
- 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
Treat UIHTMLInput as the stable HTML/CSS host while keeping its native
control as an anonymous implementation detail.
Prevent author CSS from matching internal control widgets, avoiding
duplicated backgrounds and other styles. Keep valid input types such as
email intact for attribute selectors while falling back to compatible
native implementations.
Synchronize the internal control with the host content box after layout,
including flex sizing, and preserve intrinsic measurement for size and
font changes. Preserve input state across dynamic type changes and make
hidden transitions reversible.
Also fix border-radius calculations and add regressions for CSS ownership,
anonymous widget isolation, dynamic type changes, input sizing, and the
Causality newsletter form.
- 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
- Empty vector: every quad is Mask; use the existing single draw call.
- Non-empty vector: the text contains subpixel glyphs; entries correspond to every quad.
addGlyphQuad() therefore delays allocation until the first subpixel glyph. At that point it backfills earlier quads as Mask, records the current subpixel glyph, and tracks every subsequent quad.
addLine() only appends Mask after tracking has started. A line before the first subpixel glyph will be included by the later backfill; a line after it must be appended to preserve the one-entry-per-quad mapping.
This protects the common grayscale path from subpixel-related overhead while correctly handling mixed mask/subpixel text. It introduces no allocations until subpixel rendering is actually encountered.
The critical fix versus the earlier broken version is that the first subpixel glyph is appended unconditionally. The old code accidentally skipped it when it was the first quad, causing the first character to be
classified as Mask.
Fix:
- User fallback now uses "user-fallback-font".
- Built-in CJK and custom fallback fonts remain registered together.
- Added and passed a regression test verifying both fallback resources remain in the chain.
Fixes in premake5.lua:
- Removed obsolete PRECISE_F32=1; Wasm already provides precise float behavior.
- Moved ENVIRONMENT=worker,web to final application link options.
Fixed MarkdownView not getting the correct CSS style from the base theme.
Document that a FontTrueType can be locally associated with only one
ResourceScope and that catalog imports should be used to share fonts
between scopes.
Note the current single FontService pointer limitation and the possible
future direction of moving fallback resolution out of shared fonts.
Introduce ResourceNameHash using wyhash for fast drawable and font
secondary indexes without changing the global String::HashType.
Replace the 32-bit resource indexes with direct 64-bit weak-handle
lookups while keeping complete ResourceKey lookup authoritative.
Preserve legacy persisted drawable hash support through a documented
compatibility scan and migrate internal font operations to semantic
name lookup.
Add regression coverage proving names that collide under the legacy
hash remain independently addressable.
Identify asynchronous loads by cache epoch and operation ID so stale
completions cannot modify replacement entries or corrupt in-flight
accounting after clear().
Move decoding, GPU texture mutation, notifications, callback destruction,
and final resource releases outside the cache mutex. Revalidate operation
identity between completion phases to preserve correctness across decode
delays and notification reentrancy.
Add regression coverage for stale same-key completions after cache reset.
- 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
Martín Lucas Golini