Milestones
List view
## Description Close out Borrowser’s no-JavaScript static HTML/CSS engine by freezing the supported scope, validating conformance coverage, auditing subsystem ownership, finalizing compatibility baselines, hardening release artifacts, documenting known limitations, and preparing the static engine for a release-quality milestone tag. Milestone AV introduced compositor architecture, display lists, advanced damage tracking, raster reuse, and backend-neutral presentation. Milestone AW builds on the complete static rendering stack from AD through AV and turns it into a defensible release closeout. This milestone should not add major new rendering features. It should not introduce JavaScript, dynamic DOM mutation, full navigation/history, browser UI, extensions, DevTools, service workers, full security sandboxing, or new advanced layout/paint systems. Those belong to later milestones. The goal is to prove that Borrowser’s documented static HTML/CSS renderer is: - architecturally coherent; - subsystem-owned correctly; - conformance-tested; - compatibility-tested; - reproducible; - documented; - bounded by production guardrails; - release-build safe; - and honest about what is still missing. After this milestone, Borrowser should be able to explain: - exactly what “static HTML/CSS engine complete” means; - which standards areas are supported, partially supported, unsupported, or deferred; - which WPT-style and AG fixtures define the conformance baseline; - which real-world pages define the compatibility baseline; - which known failures are accepted and why; - which release blockers remain open or are closed; - which debug snapshots are stable public maintenance surfaces; - which performance/memory budgets protect production behavior; - which security/network/storage hardening boundaries are in place; - which accessibility/forms/responsive/print/compositor foundations are included; - which claims can be made publicly; - and which future milestones must handle JavaScript, dynamic DOM, browser UI, navigation, process isolation, GPU acceleration, and broader platform behavior. This milestone intentionally favors release discipline, honest scope control, reproducibility, documentation, invariant audits, conformance baselines, and long-term maintainability over feature expansion. ## Requirements - Freeze the static no-JavaScript engine scope. - Define release claim language. - Define unsupported/deferred feature claim language. - Finalize the static engine support matrix. - Finalize subsystem ownership matrix. - Audit all milestone contracts from AD through AV. - Audit docs and feature tracker consistency. - Audit conformance fixture coverage. - Audit WPT-style imported/derived coverage. - Audit real-world compatibility corpus coverage. - Audit debug snapshot stability. - Audit production guardrails. - Audit performance/memory benchmarks. - Audit cache/cookie/network hardening state. - Audit accessibility tree and input modality state. - Audit forms/native interaction state. - Audit responsive/print foundations. - Audit compositor/display-list/damage state. - Finalize release candidate checklist. - Add release-blocker triage workflow. - Add known limitations document. - Add release notes. - Add reproducible release build instructions. - Add versioning/tagging policy. - Add static engine release packet. - Update `docs/engine-feature-gap-tracker.md` one final time for the static engine closeout. - Document explicit non-goals: JavaScript execution, dynamic DOM mutation, full DOM APIs, browser UI, full navigation/history, extensions, DevTools, service workers, full security sandbox, process isolation, full GPU compositor, full media playback, full storage APIs, full platform accessibility bridge, and complete web compatibility. ## Exit Criteria - Static no-JavaScript scope is frozen and documented. - Supported/partial/unsupported/deferred areas are listed honestly. - All AD through AV closeout docs are linked. - Conformance baseline exists and is reproducible. - Compatibility baseline exists and is reproducible. - Release-blocking failures are classified. - Known accepted failures are documented. - Debug snapshots are stable and documented. - Production guardrails are enabled and tested. - Performance/memory budgets are documented. - Release builds are reproducible. - Release notes and known limitations are complete. - The feature gap tracker reflects the static engine closeout accurately. - The milestone can be tagged without claiming JavaScript, full browser UI, complete web compatibility, or complete browser-platform behavior.
No due date•0/12 issues closed## Description Introduce Borrowser’s compositor-ready rendering architecture by separating semantic paint output from retained display lists, compositor surface/layer candidates, backend-neutral presentation, raster/damage tracking, scroll/viewport damage, and advanced retained visual artifact reuse. Milestone AP improved paint fidelity for backgrounds, borders, CSS images, visual effects, transforms, clipping, and visual regression surfaces. Milestone AU hardened the static rendering pipeline against real-world pages, malformed inputs, resource limits, compatibility quirks, and production failure modes. Milestone AV builds on those foundations by making Borrowser’s rendering pipeline ready for efficient incremental presentation. This milestone should not start with GPU-specific shortcuts. A serious browser engine needs a clean architecture first: - Layout owns geometry. - Paint owns semantic paint ordering and paint primitives. - Display-list construction owns stable paint operation recording. - Compositor owns grouping, surfaces, damage, retained visual artifacts, and presentation decisions. - Backend/GFX owns raster execution and platform/GPU/software details. - Browser/runtime owns lifecycle orchestration, retained state lifetime, invalidation, and debug coordination. The goal is to move from “we can repaint the page deterministically” toward “we can retain, diff, damage, raster, and present visual output through a compositor-shaped pipeline.” After this milestone, Borrowser should be able to explain: - how paint primitives become display list items; - which display items have stable identities; - which display items have visual bounds; - which items changed between frames; - which regions are damaged; - why a display item or surface was retained or rebuilt; - which boxes/effects became compositor surface candidates; - why a surface was created or not created; - how opacity, transforms, filters, clips, scroll containers, and fixed/sticky content affect compositor grouping; - how scroll and viewport changes produce damage; - how raster cache entries are keyed and invalidated; - how tiles or raster chunks are selected where supported; - how presentation is backend-neutral; - how software and future GPU backends share contracts; - and which compositor/GPU features remain intentionally deferred. This milestone intentionally favors explicit contracts, deterministic display lists, typed damage, retained artifact correctness, backend-neutral design, and measurable incremental behavior over premature GPU acceleration. ## Requirements - Define compositor/display-list/damage ownership boundaries. - Introduce a retained display list representation. - Introduce stable display item IDs distinct from DOM, layout, paint, stacking, accessibility, and retained render IDs. - Convert Paint-owned primitives into display list items. - Preserve deterministic display list ordering. - Add visual bounds for display items. - Add clips/effects/transforms to display-list item metadata. - Add display list snapshots and diffs. - Introduce compositor surface/layer candidate metadata. - Add compositor tree representation. - Add compositor commit lifecycle. - Add backend-neutral compositor output representation. - Support a software compositor/raster backend first. - Define future GPU backend boundary without requiring GPU support. - Add raster cache or retained raster artifact foundation. - Add tile/chunk representation where feasible. - Add damage tracking model. - Track damage from: - style changes; - layout changes; - paint-only changes; - transform changes; - opacity/effect changes; - clip changes; - image/resource changes; - viewport changes; - scroll changes where scoped; - focus/control/native interaction changes. - Add damage expansion for effects such as shadows, filters, and transforms. - Add damage clipping through clip chains where supported. - Add retained display-list reuse. - Add retained compositor surface reuse. - Add retained raster artifact reuse. - Add conservative invalidation fallback when damage cannot be proven narrow. - Add debug snapshots for display lists, compositor surfaces, damage regions, raster cache, commits, and presentation output. - Add performance/guardrail instrumentation for display-list size, surface count, damage region count, raster area, tile count, and commit cost. - Add AG-compatible fixtures for display lists, damage tracking, compositor grouping, retained reuse, scroll/viewport damage, and backend-neutral output. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AV scope and remaining compositor/rendering gaps. - Document explicit non-goals: GPU acceleration, platform compositor integration, hardware overlays, video compositor integration, WebGL/canvas compositing, animation engine, CSS transitions/animations, asynchronous scrolling, full occlusion culling, full dirty-region rasterization, browser process isolation, and pixel-perfect compositor parity with existing engines. ## Exit Criteria - Borrowser has a typed retained display list. - Display items have deterministic ordering, stable identities, and visual bounds. - Paint output can be converted into display lists without moving Paint semantics into the compositor. - Display-list diffs can identify changed visual items. - Damage regions are represented explicitly. - Damage can be derived for representative style/layout/paint/effect/viewport changes. - Conservative full-surface/full-viewport damage fallback exists when narrow damage is unsafe. - Compositor surface/layer candidates are represented with explicit reasons. - Compositor tree and commit lifecycle exist. - Software/backend-neutral presentation path exists. - Raster cache or retained raster artifact foundation exists. - Retained display-list/compositor/raster reuse is deterministic and debug-visible. - Debug snapshots expose display-list, compositor, damage, raster, and commit decisions. - AG-compatible fixtures cover representative compositor/damage behavior. - Performance and resource guardrails exist. - The feature gap tracker reflects AV completion honestly. - The milestone does not claim GPU acceleration, full compositor parity, animation, async scrolling, or complete dirty-region rendering.
No due date•0/12 issues closed## Description Harden Borrowser’s no-JavaScript static HTML/CSS engine against real-world pages by introducing a curated static-page compatibility corpus, deterministic real-world loading harnesses, scoped quirks-mode behavior, compatibility diagnostics, malformed-input resilience, progressive fallback rules, production guardrails, performance budgets, crash/panic hardening, and release-quality debug/reporting surfaces. Milestone AT introduced HTTP cache, cookies, storage boundaries, and networking hardening. Milestone AU builds on the completed static rendering stack from AE through AT by testing and hardening the whole engine against real static pages, legacy markup, malformed CSS, partial resources, unsupported features, heavy documents, compatibility modes, and production-like failure scenarios. This milestone should not become a JavaScript compatibility milestone, full browser navigation milestone, site-specific hack milestone, full web-compat parity milestone, browser UI milestone, extension system milestone, DevTools milestone, or complete security sandbox milestone. Those are later or separate concerns. The goal is to make Borrowser’s documented static HTML/CSS scope robust enough for real-world use: - real pages can be loaded through the normal pipeline; - malformed input does not crash the engine; - unsupported features degrade deterministically; - quirks are explicit and justified; - compatibility failures produce actionable diagnostics; - cross-engine differences are tracked; - resource limits are enforced; - performance regressions are visible; - production builds avoid debug-only assumptions; - and feature-gap tracker claims remain honest. After this milestone, Borrowser should be able to explain: - which real-world static pages are part of the compatibility corpus; - how each page is captured, minimized, replayed, and tested; - which compatibility mode each document uses; - which quirks were applied and why; - which unsupported features were encountered; - which unsupported features were safely ignored; - which resources failed and how rendering recovered; - whether a failure is parser, CSS, layout, paint, network, image, font, accessibility, or runtime-owned; - how Borrowser compares to reference engines for the supported no-JS subset; - which production guardrail prevented unbounded work; - which pages are compatibility blockers; - and which remaining gaps are intentionally deferred. This milestone intentionally favors disciplined compatibility engineering, deterministic reproduction, bounded resource usage, explicit quirks, and production reliability over broad unsupported web-compat claims. ## Requirements - Define real-world static-page compatibility ownership boundaries. - Add a curated real-world static page corpus. - Add capture/replay format for pages and subresources. - Add deterministic real-world loading harness. - Add cross-engine comparison workflow for the supported no-JS subset. - Add compatibility triage workflow. - Add compatibility result classification. - Add document mode and quirks-mode integration. - Add scoped quirks registry with rationale and tests. - Harden UA/default stylesheet behavior for real-world compatibility. - Harden malformed HTML recovery beyond parser unit fixtures. - Harden malformed CSS recovery beyond declaration parser fixtures. - Harden unsupported CSS feature handling. - Harden unsupported HTML element/attribute behavior. - Harden resource failure recovery for documents, stylesheets, images, fonts where scoped, media placeholders, and cached resources. - Harden progressive enhancement behavior for pages that expect unsupported JavaScript. - Add production panic/crash boundaries. - Add resource budgets for document size, stylesheet size, selector complexity, layout tree size, paint operation count, image dimensions, cache state, and total load work. - Add performance benchmark corpus for real-world static pages. - Add memory/allocation guardrails where feasible. - Add deterministic compatibility diagnostics. - Add reduced reproduction/minimization workflow. - Add release-readiness reports. - Add AG-compatible fixtures generated from compatibility regressions. - Update `docs/engine-feature-gap-tracker.md` honestly. - Document explicit non-goals: JavaScript execution, dynamic DOM mutation, Service Workers, full navigation/history, full browser UI, extensions, DevTools, complete web compatibility, complete quirks compatibility, full security sandbox, complete privacy model, and site-specific hacks without reusable compatibility rationale. ## Exit Criteria - Borrowser has a curated real-world static page compatibility corpus. - Real-world pages can be captured and replayed deterministically. - Compatibility results are classified by subsystem and failure type. - Document modes and scoped quirks are represented explicitly. - Quirks are tested, documented, and not implemented as untracked site hacks. - Malformed HTML/CSS/resource inputs do not crash the engine for the supported corpus. - Unsupported features produce deterministic fallback diagnostics. - Resource budgets and production guardrails are enforced. - Real-world performance and memory regressions are visible. - Cross-engine comparison reports exist for the supported no-JS subset. - Compatibility regressions can become minimized AG fixtures. - The feature gap tracker reflects AU completion honestly. - The milestone does not claim complete real-world browser compatibility, JavaScript compatibility, complete quirks behavior, or full production browser security.
No due date•0/12 issues closed## Description Strengthen Borrowser’s networking and platform foundations by introducing a browser-shaped HTTP cache, cookie jar, credential attachment model, storage boundary model, cache/cookie partitioning, request revalidation, storage quotas/eviction foundations, and hardened networking limits. Milestone AH introduced URL, origin, and resource-addressing foundations. Milestone AI introduced typed fetch requests/responses, redirects, response handling, and deterministic network fixtures. Milestone AJ introduced static document loading and stylesheet loading. Milestone AR introduced native form submission request construction. Milestone AT builds on those foundations by adding the stateful and hardened parts of browser networking. This milestone should not become a full browser security architecture, full storage API implementation, JavaScript storage API milestone, service worker milestone, CORS/CSP milestone, browser profile management UI, download manager, certificate UI, password manager, or privacy sandbox implementation. Those are later or separate concerns. The goal is to make Borrowser’s static no-JS renderer more realistic and safer when loading real pages: - reusable responses can come from an HTTP cache; - cacheability is decided through typed HTTP metadata; - stale responses can be revalidated; - cookies can be stored from responses; - cookies can be attached to eligible requests; - credentials behavior is explicit; - cache and cookie state are scoped by storage boundaries; - storage limits and eviction are deterministic; - network requests have clear resource limits; - unsafe or unsupported networking behavior is classified honestly. After this milestone, Borrowser should be able to explain: - which storage key a request belongs to; - whether the request can use the HTTP cache; - which cache key was used; - why a cached response was fresh, stale, revalidated, or bypassed; - which validators were used for conditional requests; - how a `304 Not Modified` response updated a cached response; - whether a response was stored or rejected from cache; - which cookies were accepted from a response; - which cookies were rejected and why; - which cookies were attached to a request; - how domain, path, Secure, HttpOnly, SameSite, expiration, and partition boundaries were applied; - how credentials mode affected cookie attachment/storage; - what storage quota or eviction decision was made; - which network limits protected the engine; - and which browser security/storage features remain intentionally deferred. This milestone intentionally favors typed state, deterministic cache/cookie behavior, explicit storage boundaries, conservative security defaults, strong fixtures, and hardened limits over broad platform completeness. ## Requirements - Define networking state ownership boundaries. - Introduce a typed storage key / network partition key model. - Introduce profile/session storage boundary concepts. - Introduce deterministic clock/time source for cache and cookie tests. - Add HTTP cache data model. - Add cache key construction. - Add cache lookup, freshness, and storage eligibility logic for the supported subset. - Add Cache-Control, Expires, Age, ETag, Last-Modified, Vary, and validator handling for the supported subset. - Add conditional request construction for revalidation. - Add `304 Not Modified` response merge/update behavior. - Add cache modes on fetch requests where scoped. - Add cookie jar data model. - Add Set-Cookie parsing for the supported subset. - Add cookie storage eligibility rules. - Add Cookie header construction for eligible requests. - Add domain/path matching. - Add Secure, HttpOnly, SameSite, expiration, Max-Age, host-only, and persistent/session cookie handling. - Add credential mode interaction with cookie attachment/storage. - Add cache and cookie partitioning through storage keys. - Add storage quota and deterministic eviction foundations. - Add clearing/reset APIs for tests and future browser UI. - Add networking hardening: - request/response header limits; - body-size limits; - redirect/cookie/cache entry limits; - decompression/encoding guardrails where scoped; - timeout/cancellation integration; - deterministic error taxonomy; - unsupported scheme/security behavior. - Integrate cache/cookie behavior with AI fetch orchestration. - Integrate document/subresource loading from AJ with cache/cookie-aware fetch. - Integrate form submission requests from AR with credential/cache policy where scoped. - Add deterministic debug snapshots for storage keys, cache decisions, cookie decisions, credential decisions, revalidation, eviction, and network hardening failures. - Add AG-compatible fixtures for cache, cookies, storage boundaries, credentials, and hardened networking behavior. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AT scope and remaining networking/storage/security gaps. - Document explicit non-goals: JavaScript storage APIs, `document.cookie`, Cache API, IndexedDB, localStorage/sessionStorage, service workers, full CORS, CSP, mixed-content blocking, HSTS preload behavior, certificate UI, password manager, browser profile UI, full privacy sandbox, complete browser storage partitioning, and complete HTTP cache/cookie compatibility. ## Exit Criteria - Borrowser has an explicit storage key / network partition model. - HTTP cache entries are typed, bounded, and partitioned. - Cache lookup, freshness, storage eligibility, and revalidation work for the supported subset. - `304 Not Modified` responses can update cached responses deterministically. - Cookie jar entries are typed, bounded, and partitioned. - Set-Cookie parsing and Cookie header construction work for the supported subset. - Cookie domain/path/Secure/HttpOnly/SameSite/expiration behavior is implemented for the supported subset. - Credentials mode affects cookie attachment/storage deterministically. - Cache and cookie state are scoped by storage boundaries. - Storage quota/eviction foundations exist. - Network hardening limits are explicit and tested. - Debug snapshots expose cache/cookie/storage/network decisions. - AG-compatible fixtures cover representative cache, cookie, credential, revalidation, partitioning, and hardening behavior. - The feature gap tracker reflects AT completion honestly. - The milestone does not claim complete browser security, complete storage APIs, service workers, full CORS/CSP, complete HTTP cache compatibility, or complete cookie/privacy behavior.
No due date•0/12 issues closed## Description Introduce Borrowser’s accessibility foundation by building a typed accessibility tree, mapping supported HTML semantics, supporting a scoped ARIA role/state/property model, computing accessible names and descriptions, exposing form/control/focus state, modeling input modality, and producing deterministic accessibility debug/conformance surfaces. Milestone AR introduced native no-JavaScript forms, inputs, focus, validation, form data, and native interaction. Milestone AS builds on that by exposing semantic meaning and interaction state through an accessibility-oriented representation. This milestone should not claim complete platform accessibility API support, full screen reader compatibility, complete ARIA implementation, full WCAG conformance, live regions, dynamic JavaScript-driven accessibility updates, complex widget authoring patterns, text selection accessibility, editing accessibility, OS-specific accessibility bridge completeness, or assistive-technology integration parity. Those are later platform and compatibility concerns. The goal is to make Borrowser able to construct and inspect a browser-shaped accessibility tree for static/no-JS documents and native controls. After this milestone, Borrowser should be able to explain: - which DOM/layout/control nodes appear in the accessibility tree; - which nodes are hidden or excluded; - which role each accessible node has; - whether a role came from native HTML semantics or ARIA; - which accessible name and description were computed; - which states and properties are exposed; - which form/control values are exposed; - which element is focused; - which input modality is active; - whether focus-visible styling should apply; - how keyboard and pointer modality affect focus presentation; - how accessibility tree updates are invalidated after control/focus/style changes; - how accessibility snapshots are tested; - and which accessibility/platform features remain intentionally deferred. This milestone intentionally favors typed accessibility contracts, deterministic semantic mapping, explicit unsupported behavior, debug visibility, and conformance fixtures over broad accessibility claims. ## Requirements - Define accessibility ownership boundaries across HTML/DOM, CSS, Browser/runtime, Layout, Paint, Controls, and future platform accessibility adapters. - Introduce a typed accessibility tree. - Introduce accessibility node IDs that are distinct from DOM IDs, layout IDs, paint IDs, and retained render IDs. - Map supported native HTML elements to accessibility roles. - Map supported ARIA roles, states, and properties. - Define precedence between native semantics and supported ARIA overrides. - Compute accessible names for the supported subset. - Compute accessible descriptions for the supported subset. - Support label integration from AR. - Support form/control accessibility state and value exposure from AR. - Support heading, landmark, list, table, image, link, button, and form-control semantics for the scoped subset. - Define accessibility tree inclusion/exclusion rules. - Support hidden/excluded state from `hidden`, `aria-hidden`, `display: none`, and other scoped mechanisms. - Preserve deterministic tree order. - Preserve source association for debug output. - Represent focus state in the accessibility tree. - Represent input modality state. - Support keyboard versus pointer modality tracking for focus-visible behavior. - Integrate supported accessibility-related CSS pseudo-class behavior where scoped. - Add accessibility invalidation integration with retained runtime state. - Add a platform accessibility adapter boundary without claiming complete OS API integration. - Add deterministic debug snapshots for accessibility tree, role mapping, name computation, description computation, states, values, relationships, focus, input modality, and invalidation. - Add AG-compatible fixtures for accessibility tree construction, HTML semantics, ARIA subset, accessible names/descriptions, control state, focus, and input modality. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AS scope and remaining accessibility gaps. - Document explicit non-goals: full platform accessibility API parity, full screen reader compatibility, full ARIA, full WCAG conformance, live regions, dynamic JS-driven updates, complex ARIA widgets, text selection accessibility, contenteditable accessibility, IME accessibility, full table accessibility, full SVG accessibility, and OS-specific accessibility bridge completeness. ## Exit Criteria - Borrowser has a typed accessibility tree for the supported static/no-JS document subset. - Supported native HTML elements map to accessibility roles. - Supported ARIA roles/states/properties are parsed and applied deterministically. - Accessible names and descriptions are computed for the supported subset. - Form/control state from AR is exposed through accessibility nodes. - Focus state is exposed through accessibility nodes. - Input modality is represented and can influence focus-visible behavior where scoped. - Accessibility tree inclusion/exclusion rules are deterministic and tested. - Accessibility tree updates integrate with retained runtime invalidation. - Debug snapshots expose role/name/state/value/focus/modality decisions. - AG-compatible fixtures cover representative accessibility behavior. - The feature gap tracker reflects AS completion honestly. - The milestone does not claim complete platform accessibility, full screen reader support, full ARIA, full WCAG conformance, or dynamic JavaScript accessibility behavior.
No due date•0/12 issues closed## Description Introduce Borrowser’s native no-JavaScript interaction foundation for HTML forms, form-associated elements, input controls, control state, focus navigation, labels, constraint validation, form data construction, and static form submission handoff. Milestone AQ introduced responsive rendering, media queries, viewport units, and print foundations. Milestone AR builds on the static HTML/CSS renderer by making documents interactable in the ways HTML supports natively without JavaScript. This milestone should not introduce JavaScript execution, DOM event dispatch, scriptable DOM bindings, custom elements, shadow DOM form participation, full browser navigation/history, autofill/password management, file picker UI, IME, accessibility platform APIs, advanced editing, payment/request APIs, or complete mobile input behavior. Those are later or out-of-scope concerns. The goal is to make supported HTML controls behave like real native controls inside Borrowser’s no-JS static renderer: - form controls have state; - labels associate with controls; - text controls can receive/edit values; - checkboxes/radios/selects/buttons can be activated; - focus can move predictably; - disabled/readonly controls behave differently from active controls; - constraint validation can classify supported invalid states; - form data can be constructed from successful controls; - form submission can produce a typed request/handoff; - rendering updates after native interaction flow through retained invalidation. After this milestone, Borrowser should be able to explain: - which elements are form-associated; - which form owns each control; - which controls are mutable; - which controls are disabled or readonly; - what each control’s current value is; - how value state differs from attributes; - which label is associated with which control; - which element is focused; - how sequential focus navigation is ordered; - how keyboard/pointer activation affects native controls; - which controls are successful for form submission; - how constraint validation is evaluated for the supported subset; - how a form data set is constructed; - how a native form submission request is built; - how native interaction invalidates style, layout, and paint; - and which interactive platform features remain intentionally deferred. This milestone intentionally favors typed control state, deterministic interaction state transitions, clear no-JS boundaries, form/focus debug surfaces, and recoverable unsupported behavior over broad platform interactivity. ## Requirements - Define native form/input/focus ownership boundaries. - Add or formalize form-associated element representation. - Resolve form ownership for supported controls. - Represent supported form controls and their current state. - Support initial value construction from parser-created DOM attributes. - Distinguish attributes, default values, current values, checkedness, selectedness, disabled state, readonly state, and dirty value flags where supported. - Support native state changes for representative input controls. - Support labels and label-control association. - Support `fieldset`, `legend`, disabled propagation, and basic grouping semantics where feasible. - Support focusable area representation. - Support sequential focus navigation for the no-JS static renderer. - Support `tabindex` for the scoped subset. - Support autofocus where feasible or explicitly defer it. - Support native activation behavior for buttons, checkboxes, radios, select options, and text controls where scoped. - Support basic keyboard/pointer interaction commands without introducing JS event dispatch. - Support constraint validation for a representative subset of controls and constraints. - Support construction of form data sets from successful controls. - Support typed form submission request construction using AH/AI/AJ foundations. - Support GET submission for the scoped subset. - Support POST submission where feasible or explicitly defer it. - Integrate native interaction updates with AC retained rendering invalidation. - Integrate form/control visual state with CSS selector/cascade support where available. - Add deterministic debug snapshots for form ownership, control state, focus state, validation state, form data, submission requests, and interaction-driven rendering invalidation. - Add AG-compatible fixtures for native forms, controls, focus, validation, and submission handoff. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AR scope and remaining forms/interaction gaps. - Document explicit non-goals: JavaScript, DOM events, scriptable form APIs, custom elements, shadow DOM, full navigation/history, file picker UI, autofill, password manager, IME, editing/contenteditable, drag and drop, selection APIs, accessibility platform integration, and complete mobile/native widget parity. ## Exit Criteria - Supported form controls have explicit typed state. - Form ownership is represented and tested. - Native control state changes work for the supported subset. - Focus state and sequential focus navigation are deterministic. - Labels associate with controls. - Disabled and readonly behavior are represented. - Constraint validation exists for the supported subset. - Form data construction works for successful supported controls. - Native form submission can build typed GET/POST handoff requests according to scoped support. - Interaction-driven rendering invalidation flows through retained runtime state. - Debug snapshots expose form, control, focus, validation, submission, and interaction state. - AG-compatible fixtures cover representative native no-JS interaction behavior. - The feature gap tracker reflects AR completion honestly. - The milestone does not claim JavaScript, DOM event dispatch, full DOM APIs, full navigation/history, autofill, file picker UI, IME, or complete browser form compatibility.
No due date•0/12 issues closed## Description Strengthen Borrowser’s static rendering engine by introducing responsive rendering foundations: media query parsing/evaluation, viewport-dependent units, viewport/environment style invalidation, responsive stylesheet selection, responsive image/layout integration, and print/page-target foundations. Milestone AP improved visual paint fidelity for backgrounds, borders, CSS images, shadows, opacity, transforms, effects, clipping, and visual regression surfaces. Milestone AQ builds on that by making the rendered result depend correctly and explicitly on the current rendering environment. This milestone should focus on environment-sensitive static rendering. It should not become a browser UI, device emulation, full paged-media engine, complete print engine, container queries, dynamic resize observer, JavaScript media APIs, scroll-driven animation, or full responsive browser automation milestone. The goal is to make Borrowser able to render the same static document differently and correctly under different viewport sizes, device pixel ratios, media types, and print/page contexts. After this milestone, Borrowser should be able to explain: - what the current rendering environment is; - what viewport size is used; - what device pixel ratio is used; - what media type is active; - which media features are supported; - which media queries matched; - which stylesheets or rules were active; - how viewport units resolved; - how responsive CSS affected computed style; - how viewport changes invalidated style, layout, and paint; - how responsive images or image candidates were selected where supported; - how print/page mode differs from screen mode; - how page size and page margins are represented; - how print fragmentation hooks into AN fragmentation foundations; - and which responsive/print features remain intentionally deferred. This milestone intentionally favors typed environment state, deterministic media evaluation, explicit viewport invalidation, supported responsive CSS behavior, and print foundations over broad device/browser simulation. ## Requirements - Define a rendering environment model. - Represent viewport size, device pixel ratio, media type, and supported media features. - Add CSS support for media query parsing and evaluation. - Support `@media` rules for the scoped subset. - Support media types such as `screen`, `print`, and `all`. - Support scoped media features such as width, height, orientation, aspect-ratio, resolution, and color where feasible. - Add deterministic behavior for unsupported media features. - Add viewport unit support for computed CSS values. - Support classic viewport units such as `vw`, `vh`, `vmin`, and `vmax`. - Support newer small/large/dynamic viewport units where feasible or explicitly defer. - Integrate viewport-unit resolution with CSS computed values. - Ensure viewport/environment changes trigger correct retained rendering invalidation. - Re-evaluate media queries when relevant environment inputs change. - Recompute style/layout/paint only where supported invalidation rules require it. - Integrate responsive image candidate selection with viewport/device pixel ratio where currently supported. - Define print media environment and page target foundations. - Add page size, page margins, and page fragment metadata where feasible. - Integrate print/page foundations with AN fragmentation structures. - Define screen versus print stylesheet behavior. - Add deterministic debug snapshots for rendering environment, media query evaluation, viewport unit resolution, responsive invalidation, and print/page state. - Add AG-compatible conformance fixtures for media queries, viewport units, responsive layout, responsive images, and print foundations. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AQ scope and remaining responsive/print gaps. - Document explicit non-goals: full browser device emulation, container queries, ResizeObserver, CSSOM media APIs, JavaScript media APIs, dynamic browser UI viewport changes, full paged media, complete print rendering, margin boxes/running headers, complete page floats, scroll-driven animations, and full responsive browser automation. ## Exit Criteria - Borrowser has a typed rendering environment model. - CSS media queries are parsed and evaluated for the supported subset. - `@media` rules affect stylesheet rule activation. - Viewport units resolve deterministically. - Environment changes invalidate style/layout/paint through explicit retained-runtime rules. - Responsive images use viewport/device-pixel-ratio inputs where currently supported. - Screen and print media contexts are represented. - Print/page foundations exist and integrate with fragmentation metadata. - Debug snapshots expose environment, media query, viewport unit, responsive invalidation, and print/page decisions. - AG-compatible fixtures cover representative responsive and print-foundation behavior. - The feature gap tracker reflects AQ completion honestly. - The milestone does not claim full media-query coverage, container queries, full print layout, complete paged media, JavaScript media APIs, or browser UI/device emulation.
No due date•0/10 issues closed## Description Strengthen Borrowser’s Paint/GFX subsystem by implementing higher-fidelity visual rendering for CSS backgrounds, borders, rounded corners, shadows, opacity, transforms, filters, clipping, masks where scoped, CSS image values, gradients, and deterministic visual regression surfaces. Milestone AO implemented advanced layout systems so Borrowser can produce richer geometry for modern static pages. Milestone AP builds on that geometry by improving how boxes, images, backgrounds, borders, effects, and visual layers are painted. This milestone should focus on paint fidelity and visual CSS output. It should not become a GPU compositor, retained scene graph, browser windowing, animation, transition, video playback, canvas, WebGL, SVG engine, or full pixel-perfect rendering milestone. Those are later or separate concerns. The goal is to make Borrowser’s supported visual output substantially more browser-like while preserving clear ownership boundaries: - CSS owns property parsing, computed values, and invalidation impact. - Layout owns geometry, fragments, clipping inputs, and box structure. - Paint owns paint ordering, paint primitives, visual effect application, semantic paint artifacts, and paint debug surfaces. - Browser/runtime owns retained artifact lifetime, invalidation, work planning, and repaint coordination. - GFX/backend owns raster/backend execution details. After this milestone, Borrowser should be able to explain: - how background layers are parsed, resolved, ordered, clipped, and painted; - how borders, border radius, and border joins are represented; - how rounded corners affect background, border, overflow, and image clipping; - how CSS images and gradients are turned into paint sources; - how decoded images from AK are painted as CSS images where supported; - how box shadows and text shadows are represented and painted; - how opacity affects paint grouping and stacking semantics; - how 2D transforms affect paint-space geometry and invalidation; - how filters are represented for the supported subset; - how visual effects interact with stacking contexts; - how clipping/masking behavior is represented for paint; - how layout fragments from AL/AN/AO are painted; - how visual regressions are tested structurally and, where feasible, through pixel/raster fixtures; - and which visual CSS features remain intentionally deferred. This milestone intentionally favors typed visual primitives, deterministic paint semantics, clear CSS/Layout/Paint boundaries, conservative effect support, and testable visual output over broad but shallow visual feature claims. ## Requirements - Define Paint/GFX ownership for visual fidelity features. - Add or harden CSS property support for backgrounds, borders, shadows, opacity, transforms, filters, clipping, and CSS images. - Implement layered background painting for the supported subset. - Implement background color, image, repeat, position, size, origin, clip, and attachment behavior where scoped. - Implement CSS image value support for supported URL images and gradients. - Integrate decoded image artifacts from AK as paint sources. - Implement rounded border geometry and border-radius clipping for supported boxes. - Implement higher-fidelity physical border painting. - Implement border shorthand and border-side visual behavior through CSS-owned values. - Implement box-shadow for the supported subset. - Implement text-shadow where feasible. - Implement opacity as Paint-owned grouping/semantic effect metadata for the supported subset. - Implement 2D transform representation and paint-space application for the supported subset. - Implement filter representation and scoped filter effects where feasible. - Implement clipping and mask foundations where scoped. - Integrate visual effects with existing stacking context and paint-order foundations. - Preserve deterministic paint operation ordering. - Preserve retained paint artifact reuse/invalidation correctness. - Add semantic paint snapshots for each new visual feature. - Add pixel/raster visual regression infrastructure where feasible, with structural snapshots remaining the CI-safe baseline if pixel tests are too backend-sensitive. - Add AG-compatible conformance fixtures for backgrounds, borders, CSS images, effects, clipping, and visual paint output. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AP scope and remaining paint gaps. - Document explicit non-goals: GPU compositor, retained display-list/scene graph architecture beyond existing retained paint artifacts, full dirty-region rasterization, animations, transitions, SVG rendering engine, canvas, WebGL, video rendering, complete CSS masking, full blend modes, advanced color management, and pixel-perfect cross-platform compatibility. ## Exit Criteria - Paint supports higher-fidelity CSS backgrounds for the supported subset. - Paint supports higher-fidelity CSS borders and rounded corners for the supported subset. - CSS image values and gradients are represented as paint sources where supported. - Decoded images from AK can be used by supported paint features. - Box shadows and text shadows are supported where scoped. - Opacity and supported visual effects are represented explicitly. - 2D transform paint metadata/application exists for the supported subset. - Clipping and rounded-corner interactions are deterministic and tested for the supported subset. - Paint output remains deterministic and snapshot-testable. - Retained paint invalidation handles AP visual changes correctly. - AG-compatible fixtures cover representative AP behavior. - Pixel/raster regression testing exists where feasible or is explicitly documented as deferred. - The feature gap tracker reflects AP completion honestly. - The milestone does not claim compositor/GPU layers, full dirty-region rendering, complete CSS effects, SVG/canvas/WebGL, animations/transitions, or complete browser visual fidelity.
No due date•0/12 issues closed## Description Strengthen Borrowser’s Layout subsystem by implementing browser-shaped foundations for the major advanced CSS layout systems: Flexbox, Grid, Tables, and Multi-Column layout. Milestone AL established stronger block formatting, inline formatting, and normal-flow correctness. Milestone AM improved text, fonts, line breaking, and typography fidelity. Milestone AN introduced positioning, floats, containing blocks, out-of-flow layout, and fragmentation foundations. Milestone AO builds on all of those by implementing the higher-level layout algorithms that modern static HTML/CSS pages depend on. This milestone should not treat advanced layout as a generic layout shortcut. Flexbox, Grid, Tables, and Multi-Column each have distinct formatting models, sizing algorithms, item participation rules, intrinsic sizing behavior, alignment behavior, fragmentation behavior, and paint handoff requirements. The goal is to make Borrowser capable of laying out modern static pages that use flex containers, grid containers, HTML/CSS tables, and multi-column content through explicit Layout-owned algorithms and deterministic debug surfaces. This milestone should not attempt to implement subgrid, masonry grid, full paged media, complete fragmentation, CSS regions, dynamic layout mutation, container queries, layout containment, scroll-driven layout, JavaScript layout APIs, or browser-specific quirks beyond documented static compatibility behavior. Those are later milestones. After this milestone, Borrowser should be able to explain: - how computed display values create flex, grid, table, and multi-column formatting contexts; - how flex items are collected, ordered, sized, flexed, wrapped, and aligned; - how grid tracks are defined, auto-generated, sized, and populated; - how grid items are placed explicitly or automatically; - how table wrappers, row groups, rows, columns, cells, captions, and anonymous table boxes are generated; - how fixed and auto table layout are handled for the supported subset; - how multi-column containers create column fragments; - how content is balanced or flowed across columns; - how advanced layout systems interact with intrinsic sizing, replaced elements, text layout, fragmentation, overflow, and paint; - how layout changes invalidate retained layout and paint artifacts; - and which advanced layout features remain intentionally deferred. This milestone intentionally favors correctness, algorithm boundaries, deterministic geometry, conformance fixtures, and conservative unsupported-feature handling over broad but shallow compatibility. ## Requirements - Define Layout ownership for Flexbox, Grid, Tables, and Multi-Column algorithms. - Add or harden CSS property support for advanced layout systems. - Expand current Flexbox support beyond the existing narrow row-only subset. - Implement Flexbox main-axis sizing, flexing, wrapping, alignment, ordering, gaps, and cross-axis behavior for the supported subset. - Implement Grid container/item models, explicit grids, implicit grids, track sizing, auto-placement, grid gaps, and alignment for the supported subset. - Implement Table formatting tree construction, anonymous table box fix-up, fixed table layout, and supported auto table layout behavior. - Implement Multi-Column container layout, column box generation, column gaps/rules, and integration with AN fragmentation foundations. - Integrate advanced layout systems with intrinsic sizing from AK and typography from AM. - Integrate advanced layout systems with containing block, positioning, float, and fragmentation foundations from AN. - Ensure Paint consumes final layout geometry and metadata without owning advanced layout algorithms. - Ensure Browser/runtime retained layout invalidation accounts for advanced layout property changes. - Add deterministic debug snapshots for each advanced layout system. - Add AG-compatible conformance fixtures for representative flex, grid, table, and multi-column cases. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AO scope and remaining advanced layout gaps. - Document explicit non-goals: subgrid, masonry, complete table compatibility, complete fragmentation, complete paged media, container queries, CSS containment, scroll-driven layout, dynamic JS-driven layout mutation, layout worklets, and browser-specific quirks beyond documented static behavior. ## Exit Criteria - Flexbox has a browser-shaped Layout-owned algorithm for the supported subset. - Grid has a browser-shaped Layout-owned algorithm for the supported subset. - Tables have a browser-shaped Layout-owned formatting tree and layout algorithm for the supported subset. - Multi-Column has a browser-shaped Layout-owned column/fragments foundation for the supported subset. - CSS owns advanced layout property parsing, computed values, and invalidation impact. - Layout owns advanced layout algorithms and final geometry. - Paint consumes advanced layout output without reinterpreting layout semantics. - Browser/runtime retained rendering responds correctly to advanced layout invalidation. - Deterministic debug snapshots expose flex, grid, table, and multi-column decisions. - AG-compatible fixtures cover representative advanced layout behavior. - The feature gap tracker reflects AO completion honestly. - The milestone does not claim complete advanced CSS layout compatibility, subgrid, masonry, complete table layout, full fragmentation, paged media, or dynamic layout APIs.
No due date•0/12 issues closed## Description Strengthen Borrowser’s Layout subsystem by implementing browser-shaped foundations for CSS positioning, containing block resolution, floats, clear behavior, out-of-flow layout, sticky/fixed positioning boundaries, and fragmentation-aware layout data. Milestone AL made normal-flow block and inline layout significantly more correct. Milestone AM strengthened text, fonts, line breaking, and typography fidelity. Milestone AN builds on those foundations by adding layout behavior that deliberately escapes or modifies normal flow. This milestone should focus on layout correctness and subsystem boundaries. It should not become a full compositor, scroll container, paged printing, multi-column, regions, top layer, transforms, anchor positioning, or complete sticky scrolling milestone. Those are later concerns. The goal is to make Borrowser able to represent and lay out positioned and floated boxes through explicit containing-block, formatting-context, and fragment contracts. After this milestone, Borrowser should be able to explain: - which boxes are in normal flow; - which boxes are relatively offset; - which boxes are out-of-flow; - which containing block is used for each positioned box; - how inset offsets are resolved; - how absolute and fixed positioned boxes are sized and placed; - how sticky positioning is represented for the static/no-JS renderer scope; - which floats participate in a block formatting context; - how normal-flow content avoids floats; - how `clear` affects block placement; - where fragmentation boundaries exist; - how boxes produce fragments; - how Layout exposes positioned, floated, and fragmented geometry to Paint; - and which advanced layout behaviors remain deferred. This milestone intentionally favors explicit layout contracts, conservative support subsets, deterministic geometry, debug visibility, and conformance fixtures over pretending to complete all advanced CSS layout behavior. ## Requirements - Define Layout ownership for positioning, floats, containing blocks, and fragmentation. - Add or formalize computed CSS support for relevant properties: - `position`; - `top`; - `right`; - `bottom`; - `left`; - logical inset aliases if supported or explicitly deferred; - `float`; - `clear`; - `z-index` integration with existing paint/stacking foundations; - `break-before`; - `break-after`; - `break-inside`; - page/column fragmentation properties where feasible. - Introduce explicit containing block resolution. - Define the initial containing block. - Define containing blocks for normal-flow, relative, absolute, fixed, and sticky boxes. - Implement relative positioning offsets for supported boxes. - Implement absolute positioning layout for supported boxes. - Implement fixed positioning representation for the viewport/static page context. - Implement sticky positioning representation conservatively or explicitly defer dynamic sticking behavior. - Ensure positioned boxes integrate with existing stacking and paint-order semantics. - Introduce out-of-flow layout participation metadata. - Implement float placement for the supported subset. - Implement normal-flow avoidance of floats for supported block/inline content. - Implement `clear` behavior for supported block cases. - Introduce fragmentation data structures and fragment-aware layout output. - Implement a conservative fragmentation foundation for future page/column/multicol work. - Ensure Paint consumes final positioned/floated/fragmented geometry without owning layout decisions. - Ensure Browser/runtime retained layout invalidation handles positioning/float/fragmentation-affecting property changes. - Add deterministic debug snapshots for containing blocks, positioned layout, float placement, clear behavior, and fragments. - Add AG-compatible conformance fixtures. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AN scope and remaining layout gaps. - Document explicit non-goals: transforms, CSS anchor positioning, top layer, complete sticky scrolling behavior, full scroll container behavior, complete paged printing, complete fragmentation, multi-column layout, CSS regions, compositor layers, GPU positioning, and complete positioned-layout compatibility. ## Exit Criteria - Containing blocks are represented explicitly. - Positioned layout consumes containing block data rather than ad-hoc parent geometry. - Relative positioning offsets are implemented for the supported subset. - Absolute positioning is implemented for the supported subset. - Fixed positioning is represented relative to the viewport/static page context. - Sticky positioning is either implemented for a conservative static subset or explicitly deferred. - Out-of-flow boxes are distinguishable from normal-flow boxes. - Floats are represented and placed deterministically for the supported subset. - Normal-flow content avoids floats where supported. - `clear` behavior is implemented for supported block cases. - Fragmentation data structures exist and layout output can represent box fragments. - Paint consumes final positioned/floated/fragmented geometry without owning layout semantics. - Retained rendering invalidation accounts for positioning, float, and fragmentation-affecting properties. - AG-compatible fixtures cover representative positioning, float, containing-block, and fragmentation cases. - The feature gap tracker reflects AN completion honestly. - The milestone does not claim complete positioning, complete sticky scrolling, complete fragmentation, multi-column, paged media, transforms, top layer, or compositor behavior.
No due date•0/10 issues closed## Description Strengthen Borrowser’s text and typography pipeline by introducing a browser-shaped foundation for font selection, font metrics, text measurement, whitespace processing, Unicode-aware line breaking, inline text layout, text alignment, text decorations, and deterministic text paint handoff. Milestone AL introduced stronger block formatting, inline formatting, line boxes, and normal-flow correctness. Milestone AM builds on that by making the text inside those inline formatting contexts significantly more correct, measurable, and extensible. This milestone should focus on the text and font systems needed for high-quality static HTML/CSS rendering. It should not attempt to complete all international typography, all OpenType shaping behavior, full bidi, vertical writing modes, ruby, MathML text layout, font loading from the network, variable fonts, color fonts, advanced font fallback, editing/text selection, or platform accessibility text navigation. Those are later milestones. The goal is to make Borrowser able to measure, break, align, decorate, and paint text through explicit text/font contracts instead of ad-hoc string measurement. After this milestone, Borrowser should be able to explain: - how computed font properties become a font selection request; - which font face was selected; - which fallback behavior was used; - which font metrics were exposed to Layout; - how text was segmented into runs; - how whitespace was collapsed or preserved; - where line-break opportunities were found; - why a line broke where it did; - how text alignment affected inline fragments; - how line-height and baselines were resolved; - how text decorations were propagated and painted; - which text shaping features are supported, partial, or deferred; - and which typography behaviors remain intentionally unsupported. This milestone intentionally favors typed text/font contracts, deterministic metrics, explicit fallback behavior, Unicode-aware line-breaking foundations, correct Layout/Paint ownership boundaries, and strong regression surfaces over broad advanced typography coverage. ## Requirements - Define Text/Fonts ownership boundaries across CSS, Layout, Paint, Browser/runtime, and future resource loading. - Introduce or formalize a font selection model. - Consume computed CSS font properties from CSS. - Add support for representative font-related properties. - Add support for representative text-related properties. - Introduce a font database or font provider abstraction. - Define deterministic fallback behavior for missing fonts. - Expose font metrics through typed Layout-owned inputs. - Introduce text measurement through a dedicated text/font subsystem. - Introduce text run segmentation for supported scripts. - Implement supported whitespace processing behavior. - Implement supported Unicode-aware line-break opportunity detection. - Integrate line-break opportunities with AL line box construction. - Implement supported `line-height` behavior more precisely. - Implement supported baseline/ascent/descent handling. - Implement supported text alignment behavior. - Implement supported text transform behavior if feasible. - Implement supported text decoration behavior beyond the existing narrow underline subset where feasible. - Integrate text fragments with Paint through deterministic text paint commands. - Add deterministic debug snapshots for font selection, metrics, text runs, whitespace processing, line breaks, line boxes, alignment, decorations, and text paint output. - Add AG-compatible conformance fixtures for text/font/typography behavior. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AM scope and remaining typography gaps. - Document explicit non-goals: full bidi, vertical writing modes, ruby, full Unicode shaping, full font fallback, web font loading, variable fonts, color fonts, editing, selection, IME, accessibility text navigation, and complete international typography. ## Exit Criteria - Font selection is represented through explicit typed contracts. - Layout receives font metrics from a text/font subsystem instead of guessing metrics ad hoc. - Text measurement is deterministic and regression-testable. - Whitespace processing is implemented for the supported subset. - Line-break opportunities are represented explicitly. - AL line box construction consumes improved text measurement and line-break data. - Supported text alignment behavior is implemented and tested. - Supported text-decoration behavior is owned by CSS/Layout/Paint through clear contracts. - Paint consumes positioned text fragments and decoration metadata without owning text layout. - Debug snapshots expose text/font/line-breaking decisions. - AG-compatible fixtures cover representative typography behavior. - The feature gap tracker reflects AM completion honestly. - The milestone does not claim full international typography, full font fallback, web fonts, bidi, vertical writing modes, or complete text rendering compatibility.
No due date•0/10 issues closed## Description Strengthen Borrowser’s Layout subsystem by implementing a browser-shaped foundation for normal-flow block formatting, inline formatting, block containers, anonymous box fix-up, margin behavior, line box construction, inline box placement, and deterministic layout geometry. Milestone AK introduced image/resource decoding and intrinsic sizing so replaced elements can provide real layout inputs. Milestone AL builds on that by making normal flow itself significantly more correct. This milestone should focus on block and inline layout behavior that most static HTML/CSS pages depend on before moving to positioning, floats, fragmentation, grid, tables, advanced typography, or compositor-level rendering. This milestone should not implement CSS Grid, table layout, floats, full positioning, sticky/fixed positioning, fragmentation, pagination, writing modes, bidi, advanced shaping, full font fallback, multi-column layout, or flexbox expansion. Those are later milestones. The goal is to make Borrowser’s normal-flow layout engine structurally correct, deterministic, and ready for deeper text, positioning, and advanced layout milestones. After this milestone, Borrowser should be able to explain: - how computed `display` values generate layout boxes; - which boxes participate in block formatting contexts; - which boxes establish inline formatting contexts; - how block containers normalize mixed block/inline children; - where anonymous block boxes are generated; - how block widths and heights are resolved in normal flow; - how vertical margins collapse; - how inline content is split into line boxes; - how inline boxes, text runs, and replaced elements are placed inside lines; - how overflow/clip metadata is produced for normal-flow boxes; - how layout geometry is exposed to Paint; - and which advanced layout behaviors are intentionally deferred. This milestone intentionally favors correctness, typed layout contracts, deterministic geometry, conservative unsupported-feature handling, and strong debug/test coverage over broad layout feature expansion. ## Requirements - Define Layout ownership for normal-flow block and inline formatting. - Introduce or formalize block formatting context representation. - Introduce or formalize inline formatting context representation. - Build layout boxes from computed display values without CSS parsing inside Layout. - Normalize mixed block-level and inline-level content through anonymous box generation. - Implement block container layout for supported normal-flow children. - Implement deterministic vertical block flow. - Implement supported width/height resolution for normal-flow block boxes. - Implement supported margin, border, padding, and content-box geometry. - Implement vertical margin collapsing for supported normal-flow cases. - Implement inline formatting context construction for supported inline content. - Implement line box construction and line breaking for the current text model. - Integrate replaced elements from AK into inline and block normal flow. - Preserve Layout ownership of geometry and formatting behavior. - Ensure Paint consumes final layout rectangles and metadata without owning layout decisions. - Expose deterministic layout debug snapshots for block formatting, inline formatting, anonymous boxes, margins, line boxes, and replaced-element placement. - Add AG-compatible conformance fixtures for block/inline/normal-flow layout. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AL scope and remaining layout gaps. - Document explicit non-goals: floats, positioning, fragmentation, pagination, tables, grid, broader flexbox, multi-column layout, writing modes, bidi, advanced typography, and full browser layout compatibility. ## Exit Criteria - Normal-flow block layout is represented through explicit Layout-owned contracts. - Inline formatting contexts and line boxes exist for the supported inline subset. - Anonymous block box generation is deterministic and tested. - Mixed block/inline children are normalized before layout execution. - Supported block widths, heights, margins, borders, and padding resolve deterministically. - Supported vertical margin collapsing behavior is implemented and tested. - Inline text and inline replaced elements participate in line boxes where supported. - Layout emits deterministic geometry snapshots suitable for regression testing. - Paint consumes Layout output without owning normal-flow layout semantics. - AG-compatible fixtures cover representative normal-flow block and inline cases. - The feature gap tracker reflects AL completion honestly. - The milestone does not claim floats, full positioning, fragmentation, writing modes, advanced typography, grid, tables, or full CSS layout completeness.
No due date•0/10 issues closed## Description Introduce Borrowser’s static image and media-resource foundation: discovering image/media resource references, selecting image candidates, fetching image resources, decoding supported image formats, extracting intrinsic dimensions and aspect ratios, and exposing replaced-element metadata to Layout and Paint. Milestone AJ introduced static document loading, stylesheet loading, and static page assembly. Milestone AK builds on that page assembly lifecycle by adding the next major class of subresources: images and static media-related resources. This milestone should make Borrowser capable of loading and sizing basic images in static HTML/CSS documents. It should not implement full audio/video playback, media controls, streaming media, adaptive media, JavaScript media APIs, animated image playback timelines, full responsive image/media-query behavior, lazy-loading scheduling, preloading, decoding prioritization, or GPU texture upload. Those are later platform/rendering concerns. The goal is to give the rendering pipeline correct image availability and intrinsic sizing data so replaced elements can participate in layout and paint in a browser-shaped way. After this milestone, Borrowser should be able to explain: - which image/media references were discovered; - which image candidate was selected; - which resource address was fetched; - which response was received; - which image decoder was used; - whether decoding succeeded or failed; - what intrinsic width, height, aspect ratio, and density were produced; - how failed images are represented; - how replaced-element intrinsic data flows into layout; - how decoded image data flows into paint or a paint-ready image artifact; - how CSS image resources are discovered and loaded where supported; - how video/audio/media elements are represented without playback; - and which image/media behaviors remain intentionally deferred. This milestone intentionally favors typed image resource contracts, deterministic candidate selection, recoverable decode failures, intrinsic sizing correctness, debug visibility, and static renderer integration over full media-platform completeness. ## Requirements - Introduce image/media resource discovery in the static page assembly lifecycle. - Discover supported HTML image references. - Discover supported responsive image candidates where feasible. - Discover supported CSS image references where currently parsed. - Discover static media-related references such as video poster images where feasible. - Define unsupported/deferred media references deterministically. - Convert discovered references into AH resource addresses. - Fetch image resources through AI. - Preserve request URL, final URL, response metadata, redirect chain, and failure state. - Introduce an image decoder abstraction. - Implement a minimal supported image format set. - Decode supported image formats into typed image artifacts or metadata. - Extract intrinsic width, intrinsic height, intrinsic aspect ratio, and density where supported. - Define behavior for unsupported image formats. - Define behavior for malformed/corrupt image data. - Define behavior for failed image fetches. - Define behavior for missing image resources. - Define static replaced-element metadata for images. - Integrate image intrinsic sizing with Layout. - Integrate decoded image artifacts or paint-ready image references with Paint. - Preserve deterministic behavior when images load successfully, fail, or are unsupported. - Add deterministic debug snapshots for image discovery, candidate selection, fetch, decode, intrinsic sizing, and layout/paint handoff. - Add AG-compatible conformance/integration fixtures. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AK scope and remaining image/media gaps. - Document explicit non-goals: audio/video playback, streaming media, media controls, JavaScript media APIs, full responsive image media-query behavior, preload scanner, lazy-loading scheduling, image cache, animated image timelines, GPU texture upload, and full CSS image painting. ## Exit Criteria - Borrowser discovers supported image/media resource references from static documents. - Image references resolve through AH resource addresses. - Image resources fetch through AI. - Supported image formats decode through a typed decoder abstraction. - Intrinsic width, height, aspect ratio, and density are represented explicitly. - Failed image fetches and decode failures are recoverable and debug-visible. - Layout can consume image intrinsic sizing data for replaced elements. - Paint can consume decoded image artifacts or paint-ready image references for supported image rendering. - CSS image references are discovered/loaded where currently supported without claiming full CSS image painting. - Static media elements can be represented without implementing playback. - AG-compatible fixtures cover representative image discovery, fetching, decoding, sizing, and failure scenarios. - The feature gap tracker reflects AK completion honestly. - The milestone does not claim full responsive images, full CSS images, audio/video playback, media controls, image caching, or GPU/compositor image handling.
No due date•0/10 issues closed## Description Introduce Borrowser’s static document loading lifecycle: fetching the main document, decoding response bytes into HTML input, parsing the document, discovering stylesheet dependencies, fetching and parsing stylesheets, assembling the final static document style set, and handing the assembled page into the retained rendering pipeline. Milestone AH introduced URL, origin, base URL, and resource-addressing foundations. Milestone AI introduced typed fetch requests, typed fetch responses, redirect handling, response metadata, and deterministic networking fixtures. Milestone AJ connects those pieces with AE’s HTML parser, AD/AF’s CSS foundations, AG’s conformance harness, and AC’s retained rendering runtime. This milestone should make Borrowser capable of loading a static HTML document and all supported stylesheet resources needed to style it. This milestone should not implement JavaScript execution, parser-blocking scripts, `document.write`, full navigation history, browser tabs, HTTP cache, cookies, CORS enforcement, CSP, mixed-content blocking, image decoding, font loading, media loading, preloads, service workers, or dynamic DOM mutation. Those are later platform concerns. The goal is to build the first complete no-JS page assembly pipeline: 1. receive a document URL; 2. construct a document fetch request; 3. fetch the main document; 4. interpret response metadata; 5. convert body bytes into parser input; 6. parse HTML into a document tree; 7. determine document URL, final URL, origin, and base URL; 8. discover supported stylesheet links; 9. fetch external stylesheets; 10. parse inline and external CSS; 11. assemble stylesheet order; 12. build computed style; 13. hand the page into retained rendering; 14. expose deterministic loading/debug/conformance output. After this milestone, Borrowser should be able to explain: - how a document load starts; - which URL was requested; - which final URL was reached after redirects; - which response metadata was used; - how document bytes became HTML parser input; - which base URL was selected; - which stylesheet links were discovered; - which stylesheets were fetched; - which stylesheets failed; - which stylesheet order was used; - how inline and external styles were combined; - when the static document is considered assembled; - how failed subresources affect rendering; - and how the assembled static page enters the retained rendering pipeline. This milestone intentionally favors explicit lifecycle state, deterministic resource ordering, recoverable stylesheet failures, clear debug output, and conformance-testable behavior over broad browser loading completeness. ## Requirements - Introduce a document loading lifecycle model. - Introduce typed document load states. - Start document loads from AH resource addresses and AI fetch requests. - Fetch the main document using AI’s fetch layer. - Preserve original URL, final URL, redirect chain, document URL, origin, and base URL. - Interpret AI response metadata for document loading. - Define response body decoding behavior for HTML input. - Integrate with AE HTML tokenization, tree construction, and parser-created DOM. - Apply AH document base URL and `<base href>` behavior. - Discover supported stylesheet references from parser-created HTML. - Construct stylesheet fetch requests from discovered resource addresses. - Fetch external stylesheets through AI. - Parse external stylesheets through the CSS subsystem. - Parse inline `<style>` contents through the CSS subsystem. - Define stylesheet ordering across UA/default, external author, inline `<style>`, and inline `style` attributes where supported. - Define behavior for failed stylesheet fetches. - Define behavior for unsupported stylesheet MIME/content type where currently known. - Define behavior for disabled/alternate/media-dependent stylesheets where supported or deferred. - Build a static stylesheet set for the document. - Run selector matching, cascade, inheritance, and computed-style construction through AF. - Hand the assembled static page into AC’s retained rendering pipeline. - Add deterministic debug snapshots for document loading, stylesheet discovery, stylesheet fetch results, stylesheet ordering, and static page assembly. - Add AG-compatible conformance/integration fixtures. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AJ scope and remaining document/resource loading gaps. - Document explicit non-goals: JavaScript execution, parser-blocking scripts, `document.write`, full navigation/history lifecycle, HTTP cache, cookies, CORS, CSP, mixed content, image decoding, font loading, service workers, preload/prefetch, dynamic DOM mutation, and full browser event loop behavior. ## Exit Criteria - Borrowser has a typed static document loading lifecycle. - Main document fetching uses AI’s fetch layer. - Document URL, final URL, origin, and base URL are explicit. - HTML response bytes can be parsed into AE’s parser-created DOM. - Supported stylesheet links are discovered from the parsed document. - External stylesheets are fetched through AI. - Inline and external stylesheets are parsed by CSS. - Stylesheet ordering is deterministic and documented. - Failed stylesheet loads are recoverable and debug-visible. - The static stylesheet set feeds AF selector/cascade/computed-style construction. - The assembled static page feeds AC retained rendering. - Loading/debug snapshots are deterministic and regression-testable. - AG-compatible fixtures cover representative static page assembly scenarios. - The milestone does not claim image loading, font loading, HTTP cache, cookies, JS, navigation history, or full browser loading behavior.
No due date•0/10 issues closed## Description Introduce Borrowser’s no-JS fetch and HTTP networking foundation for retrieving static document and subresource bytes through typed requests, typed responses, deterministic redirect handling, response metadata, body handling, network errors, and conformance-testable networking behavior. Milestone AH introduced URL, origin, base URL, and resource-addressing foundations. Milestone AI builds on AH by turning typed resource addresses into fetch requests and fetch responses. This milestone should provide the networking substrate that later document loading, stylesheet loading, image loading, font loading, and static page assembly milestones can consume. This milestone should not implement the JavaScript `fetch()` API, XMLHttpRequest, service workers, full CORS enforcement, HTTP cache, cookies, storage, navigation history, CSP, mixed-content policy, authentication UI, browser download UI, HTTP/2, HTTP/3, or full security policy behavior. Those are later platform concerns. The goal is to make Borrowser able to fetch static resources in a browser-shaped, deterministic, testable, and future-proof way. After this milestone, Borrowser should be able to explain: - how a resource address becomes a fetch request; - what request metadata is attached; - which network backend executes the request; - how HTTP status, headers, and body bytes are represented; - how redirects are followed or rejected; - how redirect limits and redirect loops are handled; - how final response URLs are tracked; - how response body limits and errors are handled; - how MIME/content-type metadata is exposed; - how network errors differ from HTTP error responses; - how deterministic mocked/network fixtures validate behavior; - and which browser networking features remain intentionally deferred. This milestone intentionally favors typed request/response contracts, deterministic behavior, bounded resource handling, explicit errors, and testability over broad browser networking completeness. ## Requirements - Introduce a typed fetch request model. - Introduce a typed fetch response model. - Introduce a typed HTTP header model. - Introduce a response body representation suitable for static resource loading. - Introduce a network error taxonomy. - Introduce a fetch client/backend abstraction. - Support deterministic mock/fake network backends for tests. - Support real HTTP/HTTPS fetching behind a controlled backend where feasible. - Support GET requests for static document/subresource loading. - Support HEAD requests only if useful and correctly modeled. - Define current behavior for unsupported methods. - Build fetch requests from AH resource addresses. - Preserve request URL, current URL, final URL, and redirect chain where relevant. - Implement redirect handling for supported 3xx status codes. - Enforce redirect limits. - Resolve redirect `Location` headers using AH URL resolution. - Define deterministic behavior for malformed redirect locations. - Represent HTTP status codes and reason metadata. - Represent response headers deterministically. - Represent response body bytes with explicit size/resource guardrails. - Expose content type / MIME metadata without doing full MIME sniffing unless explicitly supported. - Distinguish network failures from successful HTTP responses with error status codes. - Add conformance and integration fixtures using AG harness patterns. - Add local HTTP test-server or fake-network fixtures for deterministic networking tests. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AI scope and remaining networking gaps. - Document explicit non-goals: JavaScript `fetch()`, XHR, service workers, HTTP cache, cookies, full CORS enforcement, CSP, mixed-content policy, authentication UI, full navigation lifecycle, HTTP/2, HTTP/3, WebSockets, and full browser security-policy enforcement. ## Exit Criteria - Borrowser has typed fetch requests and typed fetch responses. - Resource addresses from AH can be converted into fetch requests. - HTTP status, headers, body bytes, final URL, and redirect chain are represented explicitly. - Redirect handling is deterministic and tested. - Redirect loops and redirect limits are handled safely. - Network errors are represented separately from HTTP error responses. - Response body handling has explicit resource guardrails. - Deterministic fake-network fixtures exist. - Real HTTP/HTTPS fetching exists where feasible or is cleanly abstracted behind a backend contract. - AG-compatible conformance/integration tests cover representative fetch, HTTP, redirect, response, and error scenarios. - Future document loading, stylesheet loading, and image loading milestones can consume typed responses without owning networking semantics. - The milestone does not claim HTTP cache, cookies, CORS, CSP, service workers, JavaScript networking APIs, or complete browser navigation behavior.
No due date•0/10 issues closed## Description Introduce Borrowser’s browser-platform foundation for URL parsing, base URL resolution, origin computation, same-origin classification, resource addressing, and deterministic resource identity. Milestone AG introduced conformance-test infrastructure so parser, CSS, layout, paint, and future platform behavior can be tested and compared in a disciplined way. The next step is to introduce the addressing layer that all document loading, stylesheet loading, image loading, networking, caching, security boundaries, and navigation work will depend on. This milestone should not perform real HTTP fetching yet. It should not implement redirects, HTTP caching, cookies, storage, navigation history, service workers, CORS enforcement, CSP, mixed-content blocking, or JavaScript-facing URL APIs. Those are later milestones. The goal is to make Borrowser understand what a resource address is before it attempts to fetch resources from that address. After this milestone, Borrowser should be able to explain: - how a URL string is parsed; - how parse errors are represented; - how relative URLs resolve against a base URL; - what the active document base URL is; - how document URLs differ from resource URLs; - how origins are computed; - when two origins are same-origin; - when an origin is opaque; - how resource references from HTML/CSS are normalized; - how resource identities are keyed for future loading/cache behavior; - how unsupported schemes are handled; - how URL/origin behavior is exposed in deterministic debug and conformance surfaces. This milestone intentionally favors correctness, deterministic parsing, typed data structures, conformance fixtures, and security-boundary clarity over real networking behavior. ## Requirements - Introduce a typed browser URL representation or explicitly wrap an existing standards-oriented URL parser behind Borrowser-owned types. - Define URL parsing behavior for supported schemes. - Define deterministic URL parse-error handling. - Define base URL resolution for relative URLs. - Define document URL and document base URL concepts. - Define resource URL concepts for HTML and CSS references. - Define supported and unsupported schemes. - Define origin representation. - Define tuple origins and opaque origins. - Define same-origin comparison. - Define origin serialization for debug/test output. - Define resource addressing keys for future fetch/cache integration. - Normalize and resolve resource references from parser-created HTML where currently available. - Normalize and resolve resource references from CSS values where currently available. - Add deterministic debug snapshots for parsed URLs, base URL resolution, origins, and resource addresses. - Add conformance-oriented tests for URL parsing, URL resolution, origin computation, same-origin checks, and resource-address extraction. - Integrate with AG conformance infrastructure where useful. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AH scope and remaining platform/networking gaps. - Document explicit non-goals: real HTTP fetching, redirects, CORS, cookies, storage, HTTP cache, CSP, mixed content, navigation history, service workers, JavaScript URL APIs, and full browser security policy enforcement. ## Exit Criteria - Borrowser has an explicit URL/addressing foundation. - URL parsing is typed, deterministic, and testable. - Relative URL resolution works against explicit base URLs. - Documents have explicit URL and base URL state. - Origins are represented explicitly. - Same-origin comparison is deterministic and tested. - Opaque origins are represented or explicitly documented where deferred. - HTML/CSS resource references can resolve to normalized resource addresses where supported. - Unsupported schemes are handled deterministically. - Resource identity keys exist for future fetch/cache work. - Debug snapshots expose URL, base URL, origin, and resource-address behavior. - AG conformance fixtures cover representative URL/origin/addressing cases. - The milestone does not perform real network fetches or claim full browser security policy support.
No due date•0/10 issues closed## Description Introduce Borrowser’s conformance-testing infrastructure for static HTML/CSS rendering, parser behavior, CSS behavior, layout behavior, paint behavior, and cross-engine comparison. Milestones AD and AF strengthen Borrowser’s CSS value, property, selector, cascade, and computed-style foundations. Milestone AE strengthens HTML tokenization, tree construction, and parser-created DOM output. Milestone AG makes those foundations measurable against web-platform-style tests and real browser behavior. This milestone should not attempt to import or pass the entire Web Platform Tests suite. It should create a professional, deterministic, maintainable test harness that can gradually import, classify, run, snapshot, compare, and track relevant tests. Because Borrowser is intentionally keeping JavaScript out of scope for now, this milestone must distinguish between: - tests Borrowser can run now; - tests Borrowser can parse but not execute; - tests that require JavaScript, DOM APIs, events, timers, browser automation, or platform APIs; - tests that are relevant later but must be marked unsupported for the current static HTML/CSS scope. The goal is to make conformance visible and honest. Borrowser should be able to say which tests it supports, which tests it passes, which tests fail, which tests are expected to fail, which tests are out of scope, and why. After this milestone, Borrowser should be able to explain: - where conformance fixtures live; - which WPT-style test types are recognized; - which tests are selected for the current no-JS static renderer scope; - how expected failures are recorded; - how unsupported tests are classified; - how parser/style/layout/paint outputs are compared; - how reftest-style comparisons are represented before full pixel infrastructure exists; - how Borrowser results can be compared with other browser engines; - how conformance progress is tracked over time; - and how future milestones can expand coverage without rewriting the harness. This milestone intentionally favors deterministic infrastructure, explicit scope classification, metadata, stable outputs, and conformance bookkeeping over broad test volume. ## Requirements - Introduce a dedicated conformance test harness structure. - Define supported test categories for the current no-JS static renderer scope. - Define unsupported/deferred test categories for JS, DOM APIs, events, timers, WebDriver, CSSOM, and dynamic browser behavior. - Add test discovery for in-repo conformance fixtures. - Add a path for importing or referencing WPT-style tests without committing to full WPT execution. - Add metadata for expected pass, expected fail, unsupported, skipped, flaky, and not-yet-classified tests. - Add deterministic result reporting. - Add deterministic parser output comparison. - Add deterministic DOM tree comparison. - Add deterministic CSS selector/cascade/computed-style comparison. - Add deterministic layout tree/geometry comparison where currently supported. - Add deterministic paint operation/semantic paint comparison where currently supported. - Add reftest-style comparison infrastructure appropriate to Borrowser’s current renderer. - Add a cross-engine comparison workflow for selected tests where feasible. - Add CI-safe test subsets. - Add local extended test subsets. - Add documentation for adding, classifying, and updating conformance tests. - Update `docs/engine-feature-gap-tracker.md` to reflect AG completion and remaining conformance gaps. - Explicitly document that AG does not mean broad WPT compliance or full browser compatibility. ## Exit Criteria - Borrowser has a dedicated conformance test harness. - Test discovery, classification, execution, and reporting are deterministic. - The harness can distinguish runnable, expected-failing, unsupported, skipped, and unclassified tests. - The no-JS static HTML/CSS scope is encoded in metadata rather than tribal knowledge. - Parser, DOM, CSS, layout, and paint outputs can be compared through stable fixtures. - Reftest-style infrastructure exists, even if initially structural or semantic instead of pixel-perfect. - Cross-engine comparison has a documented workflow. - CI-safe and local-extended test sets are separated. - Expected failures are tracked explicitly. - Unsupported JS/platform tests are classified honestly. - Feature gap tracker updates reflect AG completion without overstating conformance. - Future milestones can add WPT coverage without reinventing test infrastructure.
No due date•0/10 issues closed## Description Strengthen Borrowser’s CSS engine by implementing a browser-shaped selector matching, specificity, cascade, inheritance, and computed-style resolution foundation. Milestone AD introduced the CSS-owned value model, property registry, shorthand foundation, specified/computed value boundaries, and invalidation impact classifications. Milestone AE strengthened parser-created HTML/DOM construction. This milestone connects those foundations: CSS rules should be matched against the parser-created document tree, declarations should be ordered through a deterministic cascade, inherited and initial values should be resolved correctly, and computed style should become the authoritative style input for Layout, Paint, and Browser/runtime retained rendering. This milestone should not attempt to implement every selector, every pseudo-class, every pseudo-element, every at-rule, every media-query feature, custom properties, animations, transitions, CSSOM, or JavaScript-facing style APIs. Those are later milestones. The goal is to make the supported selector/cascade/computed-style pipeline correct, deterministic, inspectable, and extensible. After this milestone, Borrowser should be able to explain: - which CSS rules matched each element; - why a selector matched or did not match; - what specificity each selector has; - how declarations were ordered by origin, importance, specificity, and source order; - which declaration won for each property; - how inheritance was applied; - how CSS-wide keywords were resolved; - how specified values became computed values; - which computed values were exposed to Layout and Paint; - which selector/cascade/style invalidation dependencies were recorded for Browser/runtime; - and which selector/cascade features remain unsupported or intentionally conservative. This milestone keeps CSS selector, cascade, and computed-style semantics inside the CSS subsystem. Browser/runtime may consume CSS-owned style invalidation information and computed-style artifact lifecycle results, but Browser/runtime must not own selector semantics, cascade ordering, specificity calculation, or property meaning. ## Requirements - Introduce or formalize a CSS-owned selector AST for supported selectors. - Implement deterministic selector parsing for the supported subset. - Implement deterministic selector matching against parser-created DOM elements. - Implement specificity calculation for supported selectors. - Implement cascade ordering for supported origins, importance, specificity, and source order. - Integrate stylesheet rules, inline style declarations, and UA/default style rules where currently supported. - Resolve declared values into cascaded, specified, inherited, initial, and computed values using AD’s property registry. - Resolve CSS-wide keywords consistently with AD’s supported behavior. - Build a computed style tree or equivalent computed style artifact for the document. - Ensure Layout and Paint consume computed values, not raw declarations. - Add a supported subset of pseudo-classes only where static, deterministic, and no-JS compatible. - Add a clear policy for unsupported dynamic pseudo-classes and pseudo-elements. - Add deterministic debug snapshots for selector parsing, selector matching, specificity, cascade winners, inheritance, computed style, and unsupported selector behavior. - Add conformance-oriented tests for selectors, specificity, cascade, inheritance, and computed style. - Integrate CSS-owned selector/style invalidation dependency information with Browser/runtime retained dirty-state planning where feasible. - Update `docs/engine-feature-gap-tracker.md` to reflect completed AF scope and remaining CSS gaps. - Document explicit non-goals: full selector coverage, full media queries, custom properties, animations, transitions, CSSOM, `getComputedStyle()`, JS-driven style mutation, and broad CSS property completion. ## Exit Criteria - Supported selectors parse into typed CSS-owned selector structures. - Supported selectors match parser-created DOM elements deterministically. - Specificity is calculated through a typed model. - Cascade ordering is deterministic and documented. - Cascaded, specified, inherited, initial, and computed values have clear responsibilities. - Computed style is the authoritative input for Layout and Paint. - UA/default styles, author styles, and inline styles are integrated where supported. - Unsupported selectors and unsupported pseudo behavior fail safely and deterministically. - Selector/cascade/computed-style debug snapshots are stable and regression-testable. - Browser/runtime consumes CSS-owned invalidation/dependency information without owning CSS semantics. - The feature gap tracker reflects AF completion honestly. - The milestone does not claim complete CSS selector, cascade, media-query, custom-property, animation, CSSOM, or JavaScript-facing style API support.
No due date•1/10 issues closed