burrito.space / bez
This repository has no description
Star
Fork 0
Watch
bez specs fixed-positioning.md
8.8 kB
Markdown
at track/scripted-e2e

enabled: true touches: [crates/layout/src/containing_block.rs, crates/layout/src/fragment.rs, crates/layout/src/boxtree.rs, crates/layout/src/lib.rs, crates/layout/src/stacking.rs, crates/layout/src/bin/fragment_check.rs, crates/layout/src/bin/held_out_check.rs, crates/layout/src/bin/paint.rs, crates/layout/src/generated/, crates/dom/src/computed.rs, crates/harness/src/containing_block_cases.rs, crates/harness/src/lib.rs, crates/generation/, docs/model-first-cost.md, roadmap.md, corpus/**, crates/provenance/src/css21_containing_block.rs, crates/provenance/src/lib.rs, docs/generated-functions.md] depends-on: [] #

fixed-positioning: position: fixed and a containing-block seam #

position: fixed does not exist in the engine. crates/dom/src/computed.rs position() maps Fixed (and Sticky) to Position::Static, so a fixed box is laid out in normal flow, and crates/layout/src/fragment.rs layout() takes only the viewport's width, so nothing could place a box against the viewport's height. The Web Features map (docs/web-features-map.json, feature fixed-positioning) lists it as unknown with 17 WPT test files in css/CSS2/positioning and css/css-position.

A fixed box's size and offsets follow the same CSS 2.1 §10.3.7/§10.6.4 equations an absolutely positioned box does, so the existing absolute seam (crates/layout/src/absolute.rs AbsoluteResolver, generated in crates/layout/src/generated/absolute.rs) solves them unchanged. What differs is which box is the containing block (§10.1). Today that choice is hand-written into fragment.rs (the is_containing_block test beside layout_absolute_box, where pending absolutes resolve against the nearest positioned ancestor or the tree root). This spec lifts that choice into a generated seam covering all four §10.1 rules and adds fixed as the one new input it has to get right. That keeps the model-generated part of the work real: a seam with its own corpus, drawn on the model pool, not only wiring.

Scope. In: position: fixed on block-level, non-replaced boxes with no text; the containing block of every box by CSS 2.1 §10.1 rules 1–4 (root → initial containing block; static/relative → the content edge of the nearest block-container ancestor; fixed → the viewport; absolute → the padding edge of the nearest ancestor whose position is not static, else the initial containing block); a fixed box escaping positioned ancestors, relative and absolute alike. The oracle never scrolls, so a fixed box and an absolute box against the initial containing block land in the same place at scroll 0. The corpus has to separate them by nesting fixed boxes inside positioned ancestors and by using bottom/percentage heights against the 600 px viewport height. Out: scrolling and scroll position, transform/filter/contain making an ancestor the containing block for fixed descendants (CSS Transforms, not CSS 2.1), position: sticky (stays mapped to Static), paged media. Say so in the seam's module doc.

Viewport height. Pass the viewport as (width, height) to layout(), layout_with_resolver and layout_with_resolvers, the same shape crates/layout/src/lib.rs scrollbars() already takes. That keeps it one argument changed at each call site rather than a new one appended. Callers pass 800×600, the oracle's VIEWPORT (oracle/oracle.mjs). Every caller listed in touches updates together, and the change is mechanical: no score may move because of it alone. Check this before building the seam: fragment_check --random stays 227/227 and bench/seam-floor.sh's four floors hold.

Build the same set the absolute seam has:

  • crates/dom/src/computed.rs: Position::Fixed, mapped from StyloPositionProperty::Fixed. Every existing == Position::Absolute test in boxtree.rs and fragment.rs that means "out of flow" becomes true for Fixed too. Keep those hunks small, since other seams edit these files.
  • crates/layout/src/containing_block.rs — ContainingBlockInputs (the box's own Position; its ancestors nearest-first, each with Position, whether it is a block container, and its content-box and padding-box rects in viewport coordinates; the viewport rect), ContainingBlockOutputs (the chosen rect, plus which rule chose it, for reporting), type ContainingBlockResolver, and a deliberately wrong resolve_baseline that reproduces today's behaviour (a fixed box treated as static).
  • fragment.rs: call the resolver where the containing block is chosen now. Pending fixed boxes bubble past every positioned ancestor to the root and resolve there against the viewport rect, not the root box's padding box. One more resolver argument on the three layout* entry points.
  • crates/harness/src/containing_block_cases.rs — own Category enum with pub const ALL, Case, enumerated(), random(seed, count), built on cases::{Elem, Source, px, RESET} like absolute_cases.rs. Categories at least: fixed at top level, fixed inside a relative ancestor, fixed inside an absolute ancestor, fixed with bottom/right only, fixed with a percentage height, absolute with no positioned ancestor, absolute inside nested positioned ancestors (nearest wins), static inside a padded block container. Never add to crates/harness/src/cases.rs RECIPES.
  • crates/generation/src/containing_block_runner.rs, a Seam::ContainingBlock variant (candidate_crate.rs), prompt::build_containing_block, admit::record_for_containing_block, and containing_block_ground_truth_cache, containing_block_generation_loop, containing_block_real_model_run under crates/generation/src/bin/, plus one baseline and two seeded-wrong fixtures under crates/generation/fixtures/containing-block-candidates/ (for example one that gives fixed boxes the nearest positioned ancestor, one that uses the content edge instead of the padding edge for absolutes).

The model endpoint and keys are read from the environment, and the binaries do not load .env themselves. Before every run: set -a; source .env; set +a in the worktree (.env is a symlink installed by tracks.json). Never print or commit any value from it.

Run, in order, each as cargo run --release -p generation --bin <name>:

  1. containing_block_ground_truth_cache — fills corpus/containing-block-ground-truth/ from the three browsers via oracle/oracle.mjs; record the case count and drops for engine disagreement.
  2. containing_block_generation_loop — the baseline seeds the regression set; both seeded-wrong fixtures must be rejected. If one is admitted, fix the loop or the corpus, not the fixture, and record what was wrong.
  3. containing_block_real_model_run against the folknet model gateway, with NEV_PROVIDER unset and NEV_MODELS=qwen3.8-flash-next:16:16,qwen3.8-27b-fast:32:32,qwen3.8-27b-fast-2:32:16,deepseek-v4.1-flash:2:2:1800 set after sourcing .env. Each entry is model:count:concurrency[:timeout_secs], and the concurrencies match what each alias serves (docs/infrastructure.md → "Rig change log"). It stops on its own after two flat batches or six, whichever comes first. Score each model's share as it arrives and print per-model counts the way absolute_real_model_run does (crate::orchestrate print_per_model_summary, best_per_model, and the model_of lookup at admission), so provenance records the winner's own model. Only if the gateway does not answer, fall back to NEV_PROVIDER=claude-code, and record that fallback and what the gateway returned as a Decision. Never set NEV_PROVIDER=anthropic.

When a candidate is admitted, commit it as crates/layout/src/generated/containing_block.rs byte for byte with the header line generated/width.rs uses, containing_block.provenance.json beside it, pub mod containing_block; in generated/mod.rs, and the three layout* entry points defaulting to it. Record every batch in docs/model-first-cost.md → "Batch scores and token totals", with per-model counts, and append the outcome to roadmap.md → "Phase 1 — Engine bootstrap" step 4 in the form the other seams use. A hand-written candidate is allowed only after every batch has failed to admit one, and is recorded as an escalation with the batch count that preceded it.

Gates. cargo test --workspace passes. fragment_check --random stays 227/227 with every category unchanged: no recipe in cases.rs uses position: fixed, and the generated seam must reproduce today's containing block for every non-fixed box. bench/seam-floor.sh's floors hold (floats 109, stacking 105, relative positioning 104, block height 105).