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
- 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.
