[Renderer] Build virtualized meshlet geometry with automatic LOD and streaming

Parent: #126
Depends on: #28, #27, #130, and #136

Problem

Traditional per-mesh LOD swaps and CPU submission cannot provide film-scale source geometry with stable frame cost. #28 and #27 establish GPU-visible geometry and visibility shading, but Bloom still needs an offline/runtime virtualized-geometry system to approach Nanite-class density.

Outcome

A Nanite-inspired, not Nanite-identical static-geometry path:

imported meshes are partitioned into meshlets/clusters with bounds and error metrics;
clusters form a hierarchical LOD DAG/tree produced by the cooker;
GPU culling selects clusters by frustum, backface cone, projected error, and Hi-Z occlusion;
indirect draws/visibility IDs render selected resident clusters;
required pages stream under a fixed memory/IO budget;
unsupported, skinned, deforming, translucent, and custom-vertex content stays on a documented compatibility path.

Offline format

The cooker must emit a versioned, endian-defined format containing:

cluster vertex/index payloads with bounded size (choose and document limits after GPU/cache experiments);
object-space AABB/sphere, normal cone, geometric error, parent/child links, and material ranges;
page grouping optimized for locality plus content hashes and dependency records;
a coarse always-resident fallback hierarchy;
source-to-cooked provenance for deterministic rebuilds.

Do not lock the public API to an internal cluster size.

Runtime architecture

Register virtual meshes and allocate stable mesh/page IDs.
Maintain residency/page table and request queue with per-frame upload/eviction budgets.
Cull instances, then traverse cluster hierarchy on GPU to projected-error targets.
Test selected clusters against previous-frame Hi-Z; preserve conservative behavior for newly revealed content.
Emit indirect commands/visibility IDs consumed by perf ticket 009: GPU-driven rendering — indirect multi-draw + GPU cull #28/perf ticket 008: visibility buffer (Nanite-style) replaces 4-MRT G-buffer #27.
Feed missing-page requests back asynchronously; render the nearest resident ancestor until data arrives.
Expose counters/debug views: selected LOD, rejected reason, page residency, requests, fallback clusters, triangles submitted/rasterized.

Quality behavior

LOD error is expressed in pixels and scaled by quality tier/render resolution.
Transitions must not crack. Prefer seamless hierarchy topology; use temporal/dither transitions only where necessary and test ghosting.
Camera cuts and fast motion may reduce occlusion efficiency but may not make geometry disappear.
Material boundaries and UV/tangent continuity must survive cluster construction.

Acceptance criteria

Import and render a static stress asset with at least 10 million source triangles under a configurable residency budget.
Camera motion produces no holes, cracks, missing-page flashes, or unbounded temporal trails in the fixed motion corpus.
Projected geometric error remains at or below the selected pixel threshold in an automated image/geometry test.
GPU culling and submission time scale primarily with candidate/visible clusters, not source triangle count; attach uncapped timings and counters.
Peak geometry residency respects its configured budget within one page plus explicitly measured staging overhead.
Skinned/translucent/deforming content is routed to the compatibility path with correct depth/composition and an inspectable reason.
Asset corruption/version mismatch fails with a useful message and never reads arbitrary offsets.
Existing immediate-mode and ordinary glTF models still render unchanged.

Likely files

tools/bloom-cook/
new cooked geometry modules under native/shared/src/
native/shared/src/renderer/scene_pass.rs, hiz.rs, graph.rs, shaders
native/shared/src/models*.rs and scene data ownership
src/models/ and world asset metadata as needed

Verification

Attach cooker determinism hashes, residency/culling statistics, fixed-camera stills, motion-sequence diffs, and before/after GPU captures on at least one discrete and one integrated GPU.

Non-goals

Skinned-mesh virtualization.
Runtime arbitrary topology editing.
Making mesh shaders mandatory; use them only as an optional backend after feature/correctness qualification.

Issue #131 cooked-geometry v1 evidence

This checkpoint establishes Bloom's opt-in offline meshlet/page artifact at
revision 59c8df7. It does not enable a virtualized runtime path or change
accepted pixels.

Static geometry proof

Two independent release cooks of
examples/renderer-test/assets/DamagedHelmet.glb are byte-identical:

source: 15,452 eligible triangles;
output: 258 leaf meshlets in 20 pages;
page budget: 65,536 bytes;
largest page: 63,216 bytes;
payload: 1,230,128 bytes;
complete artifact: 1,264,592 bytes;
artifact SHA-256:
df089b23324fe8a8e00842a80b44894fd27b276c9124b8ff81dd77f8cf7b2cd2;
payload SHA-256:
67b0352a54d3d669d76d688f94899bcb8a665c561587123ea85d5d6a2b1061b0.

The default 64-vertex/124-triangle leaf limits and 64 KiB page budget
therefore hold for a canonical textured glTF asset. Material identity and all
static shading vertex attributes remain in the artifact.

Compatibility proof

examples/test-gltf-watch/assets/Fox.glb produces a valid 176-byte
metadata-only artifact:

zero meshlets/pages/payload bytes;
mesh 0, primitive 0 records the stable skinned reason;
artifact SHA-256:
5e4125b6ba31649f5ebbd694d79242e19fdb0c561073beee08f490c12be063e2.

The cooker does not reinterpret skinned geometry as static or silently omit
the reason. Equivalent records exist for morph targets, BLEND materials, and
non-triangle topology.

Integrity and determinism gates

Thirteen release tests plus strict Clippy pass. They cover:

deterministic triangle-order partitioning and byte-exact serialization;
hard vertex/triangle/page limits and independently hashed pages;
conservative AABB/sphere/normal-cone construction;
deterministic missing-normal generation;
real GLB buffer import without image decoding;
metadata-only compatibility artifacts;
atomic replacement of an existing artifact;
rejection of bad magic/version/endian, non-canonical or overlapping ranges,
truncated data, payload corruption, invalid indices, invalid hierarchy
links, bad counts/stride/bounds, and NaN/Inf data.

The repository's quick quality-contract component runs format, Clippy, and
release tests for bloom-cook; it passed in one second from a warm build.
geometry-inspect validates the full file before reporting any records.

Runtime neutrality

This commit changes only tools/bloom-cook, documentation, and its CI gate:

zero production render passes or draws;
zero runtime buffers, images, allocations, bindings, or shader branches;
zero changes to ordinary glTF/immediate-mode dispatch;
zero engine/runtime dependencies.

The current artifact contains leaf clusters only. Runtime loading, hierarchical
LOD construction, coarse fallback clusters, residency, GPU traversal, and
streaming remain later #131 milestones and must be qualified before any
end-state acceptance box is checked.

The detailed format and compatibility contract is in
docs/virtualized-geometry.md.

Atomic hierarchy cooker checkpoint is now pushed in 845ff9c with qualification evidence in f8308d1 (PR #147).

What this adds:

atomic child/parent cluster-group relations in the existing 128-byte v1 record;
locality-aware 64v/124t leaves and multi-level attribute-aware simplification;
locked group borders, complete shading attributes, conservative group bounds, and accumulated absolute error;
strict reciprocal/range/level/error/root validation plus a corruption negative test;
explicit compatibility routing remains unchanged.

Damaged Helmet (--hierarchy-levels 8): 15,452 leaf triangles / 247 leaf clusters -> 4,510 triangles / 100 level-3 coarse roots (70.8% triangle and 60.2% raw-payload reductions). Two independent artifacts are byte-identical: 57f8cc200da84c7ab63cdcd7bf02cb0c8336a96777a2ccb7fc49beaa0af3fd10.

Regression controls:

the default leaf cook remains byte-identical to the prior qualified artifact (df089b23...);
Fox remains the exact 176-byte skinned compatibility artifact (5e4125b6...);
16 release tests, fmt, strict Clippy, and strict archive inspection pass;
shipping runtime delta remains zero passes/draws/buffers/branches/pixels.

I checked only the corruption/version-mismatch acceptance box. The unchanged-rendering box stays open until runtime integration is exercised end-to-end; stress asset, projected-pixel error, residency, GPU scaling, motion, and compatibility composition also remain open.

Evidence: docs/evidence/issue-131-atomic-hierarchy-v1.md and machine-readable JSON.

Coarse-page placement checkpoint is pushed in fe92915, with evidence in c22d89e.

The qualified hierarchy is now remapped coarse-first without breaking atomic parent/child ranges. Root/streamable classes and LOD levels cannot share a page, roots must be the page-table prefix, and the strict reader rejects violations.

Damaged Helmet: all 100 roots occupy the first 8 pages; 468,570 raw root bytes become 469,360 logical page bytes (790 bytes packing overhead; 524,288-byte upper bound if a runtime allocates fixed 64 KiB slots). Total geometry payload is unchanged; page separation adds one 64-byte page record. Two outputs are byte-identical (da0f68d7...), the default leaf artifact remains byte-identical, and 17 release tests plus strict Clippy pass.

No runtime acceptance box is checked: this makes the coarse upload boundary exact, but runtime allocation/staging, eviction, ancestor fallback, stress residency, and GPU traversal still require their own evidence.

Evidence: issue-131-coarse-page-prefix-v1.md and JSON.

Quantized static-vertex checkpoint is pushed in 2c51d09, with qualification evidence in a9f0135 (PR #147).

What this adds:

explicit --vertex-format quantized32 output as strict .bgeo version 2;
32-byte vertices: cluster-local UNORM16 positions, octahedral SNORM16 normals/tangents, finite binary16 UV0/UV1, UNORM8 color, SNORM16 handedness;
an explicit tangent-valid bit that preserves the all-zero missing-tangent sentinel;
fail-closed validation for unsafe source ranges, wrong stride/version, unknown flags, non-zero padding, non-finite half values, and malformed tangent sentinels;
exact reconstruction-error and float32 baseline byte metrics in the cook report.

Damaged Helmet with --hierarchy-levels 8: 2,937,040 -> 1,363,968 payload bytes (53.56% reduction), 48 -> 23 pages, and 469,360 -> 216,544 root-prefix bytes (53.86%). Position error is at most 0.00001532 object units, normal error 0.00342 degrees, and UV error 0.0004883. Two artifacts are byte-identical: 6c8f924e....

Sponza separately exercises real tangents: 0.00361 degrees maximum tangent error and 53.06% payload reduction. Its large tiled UVs expose a 0.01381 maximum binary16 error in the report; packed output remains explicit opt-in so asset policy can reject unsuitable error instead of silently changing pixels.

Regression controls:

default v1 leaf artifact remains byte-identical: df089b23...;
v1 hierarchy artifact remains byte-identical: da0f68d7...;
21 cooker tests, strict Clippy, formatting, strict inspection, and the complete local quick CI lane pass;
shipping runtime delta is zero passes/draws/buffers/branches/pixels.

No #131 acceptance box is checked: this is an offline storage/IO/residency prerequisite. Runtime loading, budget enforcement, traversal, fallback, image quality, and GPU timing remain open.

Evidence: Markdown and JSON.

Dependency progress from #136 / PR #147: 289ba31 and 16c58b0 now place the qualified .bgeo hierarchy behind a deterministic recipe key, immutable content-addressed chunk, and logical manifest. Hierarchy levels, meshlet/page limits, vertex format, source closure, and recipe revision all participate in the key; strict inspection validates the complete chunk before a cache hit.

This removes artifact-identity ambiguity for later #131 runtime lookup and proves a zero-write incremental hit, but it does not enable runtime loading, residency, traversal, missing-page fallback, or pixels. No #131 acceptance box changes.

Further #136 dependency progress in 2effe1e / 9ad5ca9: validated geometry manifests now compile into one deterministic bloom-asset-index-v1 table. A future #131 loader can resolve a logical virtual mesh without scanning the manifest tree, and asset-index-inspect fails if any manifest/chunk changed without rebuilding the index.

This remains offline-only and does not add residency, traversal, fallback, GPU work, or pixels. No #131 acceptance box changes.

Runtime archive/residency checkpoint is pushed in c2a0bd2 with evidence in 10ccfc2 on PR #147.\n\nWhat landed:\n- one bloom-geometry-format reader shared by the cooker and runtime, replacing the duplicated interpretation risk;\n- immutable runtime archive ownership with page slices exposed only after full structural, range, hash, vertex, hierarchy, and page-class validation;\n- indexed loading that additionally verifies complete-file length/hash, format version, payload hash, and source hash against the #136 identity;\n- a fixed-budget residency planner that pins the validated coarse-root page prefix;\n- atomic cluster-group transitions, deterministic LRU eviction with page-index tie-breaking, and nearest fully resident ancestor fallback;\n- telemetry for pinned/resident bytes and pages, uploads, evictions, exact/fallback resolutions, and unresolved requests.\n\nEnd-to-end runtime proof:\n- a valid encoded 3-level hierarchy is loaded through the production reader;\n- 448 root bytes stay pinned under a 1,120-byte budget;\n- fallback progresses deterministically from LOD 2 to 1 to exact LOD 0 as pages become resident;\n- the cache reaches exactly 1,120 bytes and never exceeds the budget;\n- a two-page 448-byte atomic group is rejected when only 224 streamable bytes are available, with state/counters unchanged;\n- corrupt magic and wrong index identity fail before an asset is exposed.\n\nDefault-path control:\n- no EngineState, Renderer, ModelManager, frame-graph, shader, or FFI owner was added;\n- the normal no-default-features renderer benchmark graph contains neither the new format crate nor SHA-256 code;\n- three interleaved detached-HEAD versus working-tree runs produced identical renderer-path telemetry in all six captures;\n- candidate medians were favorable on wall, CPU mean/p95, and GPU mean/p95. The magnitude is treated as machine noise, not a speedup, but rules out a regression.\n\nGates:\n- 382 shared unit tests passed, 1 existing ignore;\n- 59 golden tests passed, 2 hardware-only ignores;\n- 4 render-target tests and all visibility GPU parity/runtime tests passed;\n- 29 cooker tests and 39 quality-governance tests passed;\n- strict production lint, format, contracts, FFI parity, file ratchet, wasm, native models3d, and wasm models3d checks passed.\n\nEvidence:\n- https://github.com/Bloom-Engine/engine/blob/codex/rendering-wip-integrated-20260727/docs/evidence/issue-131-runtime-residency-v1.md\n- https://github.com/Bloom-Engine/engine/blob/codex/rendering-wip-integrated-20260727/docs/evidence/issue-131-runtime-residency-v1.json\n\nNo additional acceptance box is checked yet: this is logical CPU-side residency planning, not measured GPU allocation/staging. Next is stable runtime mesh/page IDs plus fixed GPU page allocation/upload, then projected-error traversal and visibility submission.

Fixed GPU page-residency checkpoint is pushed in 6dbbb02, with qualification evidence in 8368cdc on PR #147.

What landed:

a separate fixed-capacity raw cooked-page buffer rather than weakening perf ticket 009: GPU-driven rendering — indirect multi-draw + GPU cull #28's growable expanded Vertex3D/u32 compatibility arena;
stable 20-bit-slot/12-bit-generation VirtualMeshIds and generation-protected VirtualPageIds;
fixed 32-byte GPU mesh records and 16-byte logical page-table records;
validated coarse-root pages pinned before a mesh ID is returned;
all-or-nothing cluster-group uploads, deterministic global LRU, and protection for required, pinned, and GPU-retiring pages;
independent per-frame byte, page, and eviction limits;
queue-completion-delayed reuse of mesh IDs, page-table ranges, and physical slots;
telemetry separating fixed allocation, resident slot bytes, useful payload bytes, pinned/retiring slots, frame work, lifetime work, denials, and exact/ancestor resolutions.

Real Metal readback proof on the 32-core Apple M1 Max:

physical pool: exactly 3 × 4 KiB = 12,288 bytes;
page table: 16 × 16 = 256 bytes;
mesh table: 2 × 32 = 64 bytes;
total fixed GPU ownership: 12,608 bytes;
final useful validated payload: exactly 1,120 bytes in exactly 12,288 resident slot bytes;
one 448-byte root remains pinned;
a fresh frame uploads three pages / 896 bytes, performs one deterministic eviction, and resolves the leaf exactly at LOD 0;
physical payload, GPU page table, and GPU mesh table all read back byte-exact against their validated CPU sources/mirrors.

Negative proofs:

a two-page atomic group cannot partially load with only one replaceable slot; state/counters stay unchanged;
page and byte upload limits independently reject excess work without partial mappings;
a zero-eviction budget cannot disturb the resident set;
a retired ID cannot be reused before GPU completion and becomes stale after generation-safe slot reuse.

Regression gates:

complete quick lane passed in 57 seconds: 386 shared unit tests (1 existing ignore), device negotiation, 59 goldens (2 hardware ignores), 4 render-target tests, all visibility parity/runtime tests, strict production lint, formatting, FFI/contracts/file ratchet, 39 quality governance tests, 3 visual fault tests, 29 cooker tests, and example inventory;
native models3d and wasm web,models3d checks pass;
the no-default dependency graph still excludes both bloom-geometry-format and SHA-256;
no EngineState/Renderer/ModelManager/frame-graph/shader/FFI owner exists, so ordinary rendering gets zero new passes, draws, buffers, bindings, allocations, branches, or changed pixels.

Evidence:

No acceptance box changes yet. Driver-internal Queue::write_buffer staging overhead still needs discrete/integrated capture, and the pool is not yet consumed by GPU hierarchy traversal or visibility submission. Next is projected-pixel-error selection with conservative frustum/cone behavior, followed by Hi-Z and missing-page feedback.

GPU hierarchy traversal checkpoint is pushed in b863d12, with qualification evidence in 5010f3e on PR #147.

What landed:

a fixed 128-byte GPU cluster table containing validated bounds/error, cone, identity, page-local payload addresses, LOD/counts, and hierarchy relations;
fixed 128-byte instance, 32-byte selected-cluster, 16-byte page-request, and 48-byte counter ABIs;
bounded 2D GPU root/instance traversal using projected pixel error, conservative transformed spheres, frustum rejection, and sphere-aware normal-cone rejection;
cone rejection automatically disabled for non-uniform/sheared transforms while LOD and frustum selection remain active;
all-child-page residency required before refinement, with unique bounded page requests and nearest-resident-ancestor selection when detail is missing;
explicit overflow, invalid-record, fallback, refinement, culling, and depth-limit counters;
pool identity, generation, retirement, table-capacity, device-limit, group-width, and 32-level traversal protection.

Real Metal readback on the Apple M1 Max matches an independent CPU oracle exactly for selected records, page requests, and all counters. It covers LOD-0/middle/root thresholds, full frustum rejection, missing leaf pages, selected/request overflow, front/back cone behavior, non-uniform transforms, and a large camera cut plus opposing fast instance motion. The missing-page case keeps both resident middle clusters visible while requesting both leaf pages; missing-current-page and invalid-record counters remain zero.

The fixed pool readback now also proves the 4,096-byte cluster table byte-exact. The small fixture owns 12,288 physical bytes + 256 page-table bytes + 96 mesh-table bytes + 4,096 cluster-table bytes = exactly 16,736 bytes.

Regression boundary:

no Renderer, EngineState, ModelManager, frame-graph, scene, shader-library, or FFI owner was added;
ordinary rendering gets zero new constructions, buffers, bindings, passes, draws, branches, or changed pixels;
the governed quick lane passed in 52 seconds: 395 shared tests plus one existing ignore, 59 goldens plus two hardware ignores, render-target and visibility GPU suites, strict lint, contracts/FFI/file ratchet, wasm, 39 quality-governance tests, 3 visual fault tests, and 29 cooker tests;
native models3d and wasm web+models3d checks pass, and the no-default graph still excludes geometry-format and SHA-256.

Evidence:

No acceptance checkbox changes yet. Next is bounded indirect visibility emission and raw cooked-page decode. Any selected-output overflow must route the whole affected virtual batch through compatibility rather than render partial geometry. Conservative previous-frame Hi-Z and asynchronous request feedback follow that correctness checkpoint.

Virtual draw/decode checkpoint landed on PR #147.

Code: 92daf0e
Evidence: https://github.com/Bloom-Engine/engine/blob/74d114b/docs/evidence/issue-131-virtual-draw-emission-v1.md
Machine-readable evidence: https://github.com/Bloom-Engine/engine/blob/74d114b/docs/evidence/issue-131-virtual-draw-emission-v1.json

What this adds:

fixed-capacity GPU emission from selected resident clusters into 16-byte non-indexed indirect commands;
whole-batch zero-draw fallback for selected overflow, invalid records, missing current pages, or capacity mismatch;
resident ancestor draws remain valid when only the bounded request-feedback buffer overflows;
shared raw-page WGSL decoding for complete 72-byte Float32 and 32-byte quantized vertices, including local u8 indices;
real Metal decode parity for position, normal, tangent, UV0, UV1, color, and identity;
a real Metal render pass consuming the emitted commands and reading back exact first_instance values [1,2,3,4].

Qualification on the exact code tree: governed quick lane passed in 51 seconds; 401 shared tests passed / 1 existing ignore, 59 goldens passed / 2 hardware ignores, all render-target and visibility GPU tests passed, plus strict lint, FFI/schema parity, file governance, wasm, 39 quality-contract tests, 3 visual fault tests, and 29 cooker tests. Native models3d and wasm web,models3d checks also pass. The no-default dependency boundary remains clean.

No acceptance checkbox changes yet. This is still explicitly ownerless and cannot affect shipping pixels or frame cost. Remaining activation work includes current/previous transform and material-remap ABI, #27 visibility/PBR composition, a bounded non-indirect-count path, previous-frame Hi-Z, asynchronous request feedback/streaming, crack and temporal corpora, per-MRT parity, 10M-triangle stress/timing, and integrated/discrete qualification.

PR #147 now includes the qualified temporal/material ABI checkpoint for virtual geometry.

Code: 1b4d828
Evidence/docs: f2b71d6

What is now proven:

exact 208-byte instance ABI with an unchanged 128-byte traversal prefix plus previous model and tint;
selected records use dense dispatch indices while page requests retain sparse caller-stable IDs;
complete source-to-generation-safe material remapping is atomic and rejects duplicate, missing, unused, or zero mappings;
traversal fails before uploads/dispatch when a mesh has no complete material map;
real Metal decode covers 2 sparse-ID instances, 8 selected clusters, 24 indexed corners, current/previous world positions, inverse-transpose normals, tint, and material IDs 101/202;
default/off renderer path still allocates and records nothing for virtual geometry.

Qualification: focused virtual suite 24/24; governed quick lane passed in 72 s with 403 shared unit tests plus the negotiated-device test, 59 goldens, visibility parity/runtime, wasm, strict lint/contracts, quality governance, fault tests, and cooker tests. Native models3d and wasm web+models3d checks also passed; the no-default dependency boundary is unchanged.

Evidence: docs/evidence/issue-131-temporal-material-abi-v1.md

No acceptance box changes yet. The next slice is opt-in visibility-ID/raster/PBR integration with exact per-MRT parity and a separately qualified bounded path for adapters without indirect-count support.

Virtual visibility raster checkpoint is qualified and pushed.

Code: 6d1183d (collision-free compatibility/virtual ID namespaces), 688db93 (raw resident-page ID/depth raster), 0ab0629 (contract coverage). Evidence/docs: 1fce846, docs/evidence/issue-131-virtual-visibility-raster-v1.{md,json}.

The real Metal oracle selects/emits/rasterizes four fixture clusters into Rg32Uint; every covered pixel decodes as virtual draw 0..3 / primitive 0, background remains unambiguous, and both foreground/background are non-empty. The governed quick lane passed in 59s (406 shared tests plus the device, golden, visibility, cooker, governance, Clippy/format/contracts/wasm/native gates).

Safety boundary: this remains unattached to Renderer, adds zero default-path allocation/work/pixel change, routes masked content and unsupported devices to compatibility, and has no shipping fixed-count fallback that could execute stale commands. Production submission requires indirect-count today.

No acceptance checkbox changes yet. Next gated slice is virtual PBR reconstruction with exact current/previous clip, normal/tangent/tint/material/face state, and all established MRTs; then explicit compatibility composition and a bounded non-count path.

Virtual PBR reconstruction checkpoint is qualified and pushed.

Code: 9b3130f
Evidence: docs/evidence/issue-131-virtual-visibility-pbr-v1.{md,json}
Evidence commit: 311b6ff

What landed:

unchanged 32-byte selected records now carry render-ready absolute cluster/page addresses plus packed vertex encoding;
generation-safe cluster ownership rejects cross-mesh aliases;
raster/reconstruction dropped the redundant mesh-table fetch and storage binding;
exact perspective current/previous clip, inverse-transpose normal, mirrored tangent handedness, UV, tint/color, material ID, and face reconstruction;
virtual shading calls the authoritative specialized shade_main_scene and returns the production four MRTs;
compatibility and virtual ID consumers are disjoint;
full production renderer pipeline construction passes with exactly 8 fragment storage buffers;
real Metal raster/reconstruction and mixed Float32/quantized multi-mesh oracles pass.

Governed quick lane: PASS in 122 s, including 410 shared tests + negotiated device, 59 golden tests, visibility parity/runtime, wasm, strict Clippy/contracts, cooker and governance. Three hardware scenes built/captured; visual comparison is explicitly unqualified because approved portable baselines are absent.

No acceptance checkbox changes yet: this consumer remains explicit and unattached. Next is production ownership/routing and four-MRT composition, followed by a bounded no-indirect-count submission path.

Bounded no-indirect-count submission checkpoint implemented and pushed in 44d53ec (draft PR #147).

Problem closed by this slice: Apple M1/Metal exposes primitive index and indirect first instance but not MULTI_DRAW_INDIRECT_COUNT. The virtual visibility raster could be constructed there, yet production submission required an indirect count or a test-only exact draw count.

Fallback design:

compact selected cluster indices on GPU into 22 power-of-two triangle-count bins;
issue a constant 22 multi-draw-indirect commands, including zero-instance empty bins;
use first_instance as the compacted-bin offset and one selection-indirection buffer in the vertex shader;
round each cluster's submitted vertex count to the bin ceiling; amplification is strictly below 2x exact cluster vertices;
22 bins cover every validated cluster that fits the existing 4 MiB cooked-page bound;
whole-batch overflow/invalid/missing fallback remains authoritative because binning consumes the already-bounded emitted draw count.

Cost and capability behavior:

adapters with MULTI_DRAW_INDIRECT_COUNT retain the existing counted path unchanged;
fallback-only adapters allocate the bin state, compact index buffer, and 22-command buffer and run count/finalize/scatter compute passes;
unsupported devices no longer need CPU readback or per-cluster CPU submission;
ordinary/non-virtual rendering is unchanged.

Apple M1 Max / Metal verification:

real GPU visibility raster forced through the binned production draw API;
exact four selected clusters were counted, scattered, submitted, and reconstructed with correct namespaced visibility IDs;
command/index/state readbacks match the expected ABI;
full virtual_geometry filter: 29/29 tests pass, including hierarchy, residency, overflow, raw decode, temporal/material selection, raster, and four-MRT construction.

Stable checkpoint pushed: 660190b implements bounded asynchronous GPU missing-page feedback and in-memory page streaming; 1461545 records the qualification evidence.

Verified on the exact committed tree:

two fixed non-blocking readback slots (131,168 bytes total at the default 4,096-request cap);
newest-feedback canonicalization and bounded persistent pending queue;
pool byte/page/eviction budgets preserved, with blocked groups retained and resident ancestors visible;
real Metal oracle emitted two missing leaf groups, streamed one page per frame, then selected [4, 5, 6, 7] with zero requests/fallback;
shared suite 455 passed / 1 ignored;
GPU golden suite 77 passed / 2 ignored;
native no-default and wasm web+models3d checks passed;
no new scoped Clippy or file-ratchet findings.

Evidence: docs/evidence/issue-131-async-page-feedback-v1.md and .json.

No acceptance checkbox changed yet. Remaining work includes store/index IO behind this boundary, conservative previous-frame virtual Hi-Z, Bistro motion/parity, 10M-source-triangle stress, and cross-backend qualification.

Conservative previous-frame virtual Hi-Z is now implemented and qualified on branch codex/rendering-wip-integrated-20260727.

Code checkpoint: e930a5e
Evidence checkpoint: 9e0d2ad
Evidence: docs/evidence/issue-131-conservative-virtual-hiz-v1.md and .json

Verified contract:

private fixed 256x256 R32Float max-depth pyramid, 9 levels / 349,524 bytes;
whole atomic groups cull only when every in-frustum cluster is proven occluded over the union of previous/current expanded footprints;
camera cuts, resize, skipped frames, new instances, near-plane/off-screen bounds, and motion beyond one base cell fail open;
history becomes eligible only after queue submission;
ordinary rendering allocates and records none of this path; virtual-idle frames record no capture;
async feedback reports latest visible, frustum-culled, occlusion-culled, and uncertain group counts.

Metal oracle: stable captured instance selected 0 clusters and culled exactly 2 groups; camera motion and a new instance each stayed visible and selected all 4 fine clusters. Production four-MRT integration reported 2 submitted captures and 1 history instance without touching unrelated pixels.

Qualification: 458 shared tests passed / 1 existing ignore; full GPU golden corpus 77 passed / 2 hardware-specific ignores; 38 focused virtual tests; production renderer Metal integration; native no-default; wasm web+models3d; format and strict quick lint all passed. File-size failures remain limited to the same 3 pre-existing grandfathered files.

No acceptance checkbox changed yet. Remaining gates are async #136 store/index IO, approved Bistro motion/parity, 10M-source-triangle stress, and integrated/discrete Metal/Vulkan/D3D12 timing and quality evidence.

Detailed Bistro virtual-geometry parity and camera-return qualification is now verified and pushed.

Code checkpoint: 5c26c6a

Evidence checkpoint: d09d5e8

Evidence:

The real 1,176-placement Bistro exposed and now guards four independent faults: incomplete multi-level atomic replacement ranges, atomic groups falsely culled against different frustum planes, virtual opaque back-face ownership diverging from Bloom's ordinary scene path, and cooked vertex colors omitting the runtime material base-color factor.

Final 640x360 Metal gate after 180 streaming warmup frames:

ordinary vs virtual: mean RGB 7.135473, SSIM 0.81424849, clearly-lit missing geometry 0.001736%;
move away and return to the exact camera: mean RGB 0.000314, SSIM 0.99999140, missing geometry 0%;
1,074 virtual placements plus 102 compatibility placements;
1,957 resident pages in a fixed 128 MiB pool, zero pending/fallback/missing-current-page events and zero selected/request/invalid/depth-limit overflow at capture.

The gate is regression-sensitive: the original hierarchy failed at 10.7369 mean RGB / 0.76937 SSIM, and hierarchy/face fixes without the cooked color correction still failed at 9.3034 / 0.79258.

Qualification: 459 shared tests passed / 1 existing ignore, 39 focused virtual GPU tests, 77 GPU goldens passed / 2 hardware/manual ignores, 31 cooker tests, strict shared/cooker Clippy, wasm web, native no-default, formatting, and diff checks passed. The patch adds no file-size overage; the repository ratchet remains red only on the same three unrelated pre-existing files.

No acceptance checkbox is changed by this comment: the Bistro endpoint/motion gate is now closed, but the issue's broader 10M stress and full motion-corpus criteria remain. Next is the 10-million-source-triangle fixed-residency stress and uncapped timing/counter qualification, followed by asynchronous #136 store/index IO and cross-backend evidence.

10M-source-triangle fixed-residency stress is now qualified on codex/rendering-wip-integrated-20260727.

Checkpoints:

741cc5a — deterministic 10M source generator + runtime gate, source-bounded root dispatch, conservative group-union Hi-Z, production profiler coverage
19b77e8 — permanent evidence and roadmap update

Qualified Metal workload (Apple M1 Max, 640x360):

10,000,000 authored source triangles, 100 filtered placements
quantized v2 artifact: 245,500 clusters / 8,496 pages / 582,052,704 bytes
hard physical pool: 64 MiB; settled at 955 pages / 62,586,880 bytes
180 moving-camera warmup frames + 120 measured moving-camera frames
wall mean 8.2794 ms
GPU mean 4.7957 ms; GPU p95 7.9175 ms
hierarchy selection 1.7576 ms (down from 4.5010 ms diagnostic baseline)
bounded draw emission 0.1224 ms
zero fallback, missing-current pages, selected/request overflow, invalid records, depth-limit fallback, or pending groups

The gate enforces 16.67 ms wall mean, 8 ms GPU mean, 12 ms GPU p95, 3 ms selector mean, and 0.5 ms draw-emission mean.

Validation: shared 459 passed / 1 existing ignored; GPU golden 77 passed / 2 expected ignored; cooker 32 passed with strict Clippy; quality governance 41 passed; shared strict Clippy, wasm web, native no-default, formatting, and example inventory passed. The line ratchet remains red only for the same three unrelated pre-existing files; this checkpoint adds none.

Evidence: docs/evidence/issue-131-10m-stress-v1.{md,json}.

Remaining #131 work is asynchronous #136 store/index-backed archive I/O behind page feedback, then discrete/cross-backend timing and quality evidence. Runtime activation remains opt-in.

Native #136 store/index-backed archive I/O behind #131 GPU feedback is now qualified and pushed.

Checkpoints:

c601626 — strict bounded async store/index resolver
1cc6f1a — bounded file-page worker and atomic residency upload
c300880 — evidence

The same deterministic 10M-source-triangle artifact now runs without retaining its complete 582,052,704-byte archive. The runtime holds metadata + 50 coarse-root pages, then demand-read 76,226,352 bytes through 370 completed atomic requests with zero failures. It settled at 955 pages in the hard 64 MiB physical pool and ended with zero pending, reserved, ready, or in-flight I/O.

Moving-camera Metal gate (180 warmup + 120 measured at 640x360): 6.7390 ms wall mean, 4.4761 ms GPU mean, 7.8572 ms GPU p95, 1.6054 ms hierarchy selection, 0.1115 ms draw emission. Maximum caller-side request/poll duration was 0.1239 ms. There were zero fallback groups, missing-current pages, selected/request overflows, invalid records, or depth-limit fallbacks.

Qualification: focused virtual geometry 34/34; shared library 465 passed / 1 expected ignored; GPU goldens 77 passed / 2 expected ignored; strict shared Clippy; wasm web,models3d; format and diff checks. Evidence: Markdown and JSON.

I marked the independently verified 10M-under-configurable-residency acceptance item complete. The broader motion corpus, geometric-error oracle, scaling proof, staging-overhead accounting, complete compatibility proof, and discrete/cross-backend evidence remain open. The next #131 qualification slice is discrete-GPU and cross-backend timing/quality.

Projected-error geometry qualification is now verified and pushed.

Checkpoints:

6ea4c5b — independent source-vertex-to-parent-surface BVH bound, projected-pixel oracle, geometry recipe v2
428f8b6 — permanent evidence

The previous cooker could understate an accepted hierarchy edge: independently measured deviation was 0.00053679076, while the stored simplifier error was 0.00040672. Recipe v2 retains the simplifier metric but takes the maximum with an independent one-sided positional measurement and accumulates that conservative value through the hierarchy. The automated oracle walks every LOD0 descendant for every parent group and verifies both the stored object-space bound and the exact one-pixel projected threshold.

Two clean 10M cooks were byte-identical: 582,052,704 bytes, 245,500 clusters, 8,496 pages, artifact 13ab0d15..., index 5c69a9a6.... Cook wall times were 92.35 and 100.27 seconds versus the prior 121.41-second reference.

The corrected file-backed 10M Metal gate passed with the same 955 resident pages in the fixed 64 MiB pool and zero fallback/missing/overflow/invalid/depth-limit/pending events. Timings: 6.0585 ms wall mean, 4.3993 ms GPU mean, 7.7775 ms GPU p95, 1.6000 ms hierarchy selection, 0.1091 ms draw emission.

Evidence:

I marked only the projected-geometric-error acceptance item complete. Discrete/cross-backend qualification remains queued at https://github.com/Bloom-Engine/engine/actions/runs/33046639665 because the repository currently reports no online self-hosted runners; the remaining #131 acceptance items stay open.

Candidate/visible-cluster scaling is now qualified and pushed.

Checkpoints:

219344b — reusable 1/10/100-instance scaling sweep on one immutable 10M archive
dea1add — permanent evidence

All points retain the same 10,000,000-source-triangle, 245,500-cluster, 8,496-page artifact. Only the submitted placement set changes. Results on Apple M1 Max Metal:

Instances	Candidate groups	Selected clusters	Selector GPU	Draw emission GPU
1	4	71	0.9561 ms	0.0770 ms
10	40	710	1.0586 ms	0.0928 ms
100	440	10,220	1.4661 ms	0.1082 ms

Instances grew 100x, candidate groups 110x, and selected clusters 143.94x, while hierarchy-selection GPU mean grew only 1.53x. The one-instance point visits four groups despite the unchanged complete archive, guarding source-filtered root dispatch against archive-wide triangle/cluster scans. The full point remained at 955 pages in 64 MiB with zero fallback/missing/overflow/invalid/depth-limit/pending events; GPU mean/p95 were 4.1692/6.9526 ms and wall mean was 6.0774 ms.

The clean cross-backend driver now enforces this sweep for Metal, Vulkan, and DX12 after one cook. Strict renderer lint and all 58 quality-tool tests passed.

Evidence:

I marked only the GPU culling/submission scaling acceptance item complete. Hardware cross-backend, motion-corpus, staging-overhead, complete compatibility, and ordinary-model invariance work remains open.

Peak residency and streaming staging are now explicitly measured, regression-gated, and pushed.

Checkpoints:

2fabbaf — lifetime peak residency/I/O telemetry and exact 10M stress assertions
27731df — permanent evidence and runtime contract documentation

Apple M1 Max Metal, file-backed 10M archive, 100 placements, 180 warmup + 120 measured frames:

physical pool: 67,108,864 bytes configured
lifetime peak resident slots: 62,586,880 bytes / 955 pages (zero-byte overrun; 4,521,984 bytes headroom)
useful resident payload: 61,639,088 bytes
GPU page/mesh/cluster metadata: 31,559,984 bytes, reported separately
fixed double-buffered feedback readback: 131,184 bytes
CPU I/O budget / observed lifetime peak: 33,554,432 / 12,707,616 bytes
combined observed peak staging: 12,838,800 bytes
final CPU I/O reservation: zero
370 I/O requests completed with zero failures

The gate now requires exact page-stride arithmetic, lifetime peak residency within the pool, exact metadata sums, exact feedback allocation from public record sizes, CPU peak within its configured budget, and combined staging equal to GPU readback plus CPU peak. The run retained zero fallback/missing/overflow/invalid/depth-limit/pending events and all established timing limits passed.

Validation: 45 focused virtual-geometry release tests, enabled/disabled capability-report real-GPU tests, the file-backed 10M stress, strict renderer Clippy, formatting, and diff checks passed. No render pass, allocation, shader branch, budget, or accepted pixel changed.

Evidence:

I marked only the peak-residency/staging acceptance item complete. Motion-corpus, complete compatibility composition, ordinary-model invariance, and discrete cross-backend evidence remain open.

Branched hierarchy traversal and motion-residency stabilization are verified and pushed.

Checkpoints:

5b6c5c3 — bounded DFS traversal of every authored child replacement range, finite projected-error priority, priority-aware streaming admission, selected-group page-use feedback, and full ancestor-closure protection
371ba36 — expanded Bistro motion/path-return and exact clear-background leak gates plus the qualified 10M runtime gate

Root cause: the selector previously followed only the first cluster child range in an atomic group. Detailed Bistro groups can branch into several independent child ranges, so sibling branches disappeared as refinement progressed. The GPU and CPU selectors now visit every branch with a 32-entry bounded stack; overflow retains the complete resident parent. Uniform groups retain the cheap single-range fast path. Page-use feedback is emitted only for final selected groups, and CPU archive metadata reconstructs the complete atomic ancestor closure so asynchronous streaming cannot evict a live sibling branch between readbacks.

Clean-tree qualification on Apple M1 Max Metal:

focused virtual geometry: 47/47 passed
complete shared library: 471 passed / 1 existing ignored
detailed Bistro: 1,074 virtual + 102 compatibility placements, zero endpoint missing geometry, endpoint SSIM 0.99733651, motion SSIM minimum 0.95552893, path-return SSIM minimum 0.98604840, maximum clear-background leak 0.00023872
10M source-triangle stress: 100 placements, 955 resident pages in the fixed 64 MiB pool, 10.3058 ms wall mean, 5.3869 ms GPU mean, 8.5856 ms GPU p95, 2.2690 ms selector, 0.1280 ms draw emission
final stress frame: 10,220 selected clusters; zero fallback groups, missing-current pages, selected/request/page-use overflow, invalid records, depth-limit fallback, or pending groups

The selector cost is higher than the earlier incorrect single-branch path because it now renders the authored sibling branches, but the established 3 ms selector, 8 ms GPU mean, 12 ms GPU p95, 16.67 ms wall, and 0.5 ms draw gates all pass. The rejected linked-header experiment was removed because it did not improve timing.

I am leaving the broad motion acceptance checkbox open until this exact checkpoint also receives interactive Bistro confirmation and the remaining very subtle SSGI ground-line observation is handled separately.

Verified and pushed checkpoint 201b492 (fix(renderer): pack pinned virtual roots across lods).

Root cause: mesh-first coarse-root ordering can cross hierarchy levels, but the cooker still opened a new 64 KiB physical page for every root LOD transition. Detailed Bistro packed the unchanged 58,229,152 root payload bytes into 1,593 pinned slots, leaving only 455 of 2,048 slots for streamed detail and producing virtual-only fallback geometry.

Correction: root and streamable clusters remain strictly separated; streamable pages remain isolated by LOD; pinned roots may now share a page across LOD because they have the same lifetime/residency policy. Geometry recipe is bumped to v3; wire format remains v2. No runtime pass, allocation, shader branch, or per-frame work was added.

Detailed Bistro clean-cook result:

1,593 -> 905 pinned root pages (688 slots recovered)
4,516 -> 3,828 total pages
two independent cooks byte-identical (593a4b6b31da0498873986ae9f9488779dee4f7db5734533e12a0fd25eca1c29)
direct ordinary/virtual: mean RGB 0.930961, SSIM 0.96734683
moving corpus: max mean RGB 0.961510, min SSIM 0.96593132
zero missing-current-page, selected/request/page-use, invalid-record, or depth-limit overflow
the virtual-only blue sidewalk fragment is gone

Performance qualification also passed on Apple M1 Max/Metal with the fixed 64 MiB stress pool at 1/10/100 placements of the 10M-source-triangle corpus. The 100-placement run measured 5.265658 ms mean GPU, 8.426207 ms p95 GPU, 2.138291 ms hierarchy selection, and 0.116362 ms draw emission, with zero fallback/missing/overflow/IO-failure events.

Regression coverage now gates <=920 detailed-Bistro root pages and >=0.95 SSIM / <=3 mean RGB for direct and moving parity. Full shared/models3d tests, cooker 35/35, strict cooker/format Clippy, determinism, and diff/format checks passed.

Evidence: docs/evidence/issue-131-root-page-packing-v1.{md,json}.

Checkpoint 9a30270 adds a real-GPU mixed virtual/ordinary compatibility oracle.

Evidence:

Builds one exact source closure with two virtual placements and two cooker-routed alpha-blend compatibility placements.
Verifies the compatibility reason remains inspectable as alpha-blend.
Verifies compatibility geometry behind virtual coverage is depth-occluded exactly.
Verifies front translucent compatibility geometry keeps its authored alpha blend over virtual shading.
Retains the existing exact ordinary-pixel invariance check for an enabled but empty virtual batch.

Validation on native Metal / native-full:

cargo test --test visibility_buffer_shading_runtime -- --nocapture: 1 passed
cargo test --lib virtual_geometry:: -- --nocapture: 49 passed
cargo test --lib: 480 passed, 0 failed, 1 ignored

This advances the compatibility/depth/composition evidence, but I am leaving the acceptance checkbox open until the skinned/deforming compatibility path is exercised end-to-end as well. The fixed camera-motion criterion also remains open.

Skinned/deforming compatibility fix is pushed in checkpoint 2893929.

Root cause fixed:

the compact compatibility cache preserved skin weights, but draw_model_cached_compatibility always submitted the static cached draw, so staged joint palettes were ignored;
compact weighted caches now select the established cached-skinned renderer automatically;
non-compact subset and arbitrary-transform forms fail closed for weighted content because they cannot preserve the world-space palette contract without double-drawing virtual-owned primitives.

Real-GPU Metal/native-full oracle now proves:

the cooked route exposes the inspectable skinned reason;
arbitrary outer-transform submission is rejected;
a staged skin behind virtual geometry is depth-occluded exactly;
the same skin in front composes with its authored material;
changing one joint matrix changes more than 32 visible pixels, proving deformation is not silently frozen in bind pose.

Validation:

visibility_buffer_shading_runtime: 1 passed
cached_skinned_motion_sequence_bounds_animation_trails: passed; 0 trail frames, stable flicker 0.0360
full shared library: 480 passed, 0 failed, 1 ignored

Translucent and skeletal-deforming compatibility are now exercised end-to-end. I am leaving the broad acceptance checkbox open while I audit whether morph-target deformation needs a separate runtime contract; the cooker already reports morph-targets, but the ordinary importer currently has no morph animation owner.

Compatibility acceptance is now checked after the code and evidence checkpoints 9a30270, 2893929, and 5f732b9.

Permanent evidence:

Scope boundary: morph-targets remains a versioned inspectable cooker exclusion and is never virtualized as static geometry. Implementing ordinary glTF morph animation is a separate model/animation ownership feature; #131 now proves the virtual path preserves the established compatibility owner, shared depth/composition, live skin palettes, and explicit failure where the palette contract cannot be maintained.

The camera-motion and ordinary-glTF-invariance acceptance lines remain open.

Ordinary glTF / immediate-mode invariance is now qualified at 405d383bcb800ab0b1e819f70cfd1b4d339141de (evidence commit f4824e6).

Production load_model_with_textures_from_source_path loads the checked-in DamagedHelmet.glb, then the established cached-model path draws it.
The model contributes 328 visible pixels, preventing a vacuous off-screen/missing-model pass.
Enabling virtual geometry and submitting an empty virtual batch changes exactly 0/16,384 pixels; maximum channel delta is 0.
Real-GPU focused test: 1 passed. Shared library: 480 passed, 0 failed, 1 ignored.
Temporal/post effects are deliberately disabled for this registration/composition no-op oracle.

Permanent evidence: ordinary glTF invariance v1 (machine-readable JSON).

The ordinary-model acceptance box is checked. The fixed cross-backend camera-motion corpus remains open.

Complete bistrox.gltf integrated-GPU motion qualification is fixed, verified, and pushed.

Checkpoints:

60249af — source sanitation/material routing and exact single-sided virtual face ownership
b4e7c92 — permanent complete-scene evidence

The full source contains 2,909 placements (2,404 virtual + 505 compatibility) and 1,736,174 eligible source triangles. The cooker now maps 847 malformed optional tangent vertices to the established missing-tangent sentinel, routes 42 active-transmission plus three alpha-blend primitives to inspectable compatibility ownership, and reproduces the same eight-level payload hash across two cooks: e379cdb4...e5f.

Root cause of the late indoor failure: virtual visibility rendered back faces for single-sided opaque glTF materials even though the ordinary retained-scene pipeline culls them. At motion steps 25/30, the reverse side of an interior wall covered the view. Restoring exact glTF face ownership removes the occluder; this was not a streaming, Hi-Z, missing-page, history, or overflow failure.

Apple M1 Max / Metal, 640x360, 180-frame warmup + 30 outbound + 30 return + 30 settle:

start ordinary/virtual: mean RGB 1.170891, SSIM 0.96349717
moving corpus: maximum mean RGB 0.943374, minimum SSIM 0.97004718
maximum missing geometry 0.001736%, maximum background leak 0%
exact returned start: mean RGB 0, SSIM 1.0
matched path-return minimum SSIM 0.99999873
zero fallback/missing-current/selected/request/page-use/invalid/depth-limit events at the qualified start

Validation: complete release motion gate passed; shared library 481 passed / 1 existing ignored; cooker 48/48; geometry format 1/1; strict cooker/format Clippy; formatting and diff checks.

Evidence: Markdown and JSON.

I am leaving the camera-motion acceptance checkbox open. This completes the integrated-GPU half, while #131's verification contract still requires the same enforced corpus on a discrete GPU/backend; no threshold will be weakened for that run.

Navigation Menu

Repository navigation

[Renderer] Build virtualized meshlet geometry with automatic LOD and streaming #131

Problem

Outcome

Offline format

Runtime architecture

Quality behavior

Acceptance criteria

Likely files

Verification

Non-goals

Issue #131 cooked-geometry v1 evidence

Static geometry proof

Compatibility proof

Integrity and determinism gates

Runtime neutrality

3 remaining items

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

[Renderer] Build virtualized meshlet geometry with automatic LOD and streaming #131

Description

Problem

Outcome

Offline format

Runtime architecture

Quality behavior

Acceptance criteria

Likely files

Verification

Non-goals

Activity

proggeramlug commented on Jul 28, 2026

Issue #131 cooked-geometry v1 evidence

Static geometry proof

Compatibility proof

Integrity and determinism gates

Runtime neutrality

proggeramlug commented on Jul 28, 2026

proggeramlug commented on Jul 28, 2026

proggeramlug commented on Jul 29, 2026

proggeramlug commented on Jul 29, 2026

proggeramlug commented on Jul 29, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

proggeramlug commented on Aug 9, 2026

3 remaining items

proggeramlug commented on Aug 26, 2026

proggeramlug commented on Aug 26, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 27, 2026

proggeramlug commented on Aug 28, 2026

proggeramlug commented on Aug 28, 2026

proggeramlug commented on Aug 29, 2026

proggeramlug commented on Aug 29, 2026

proggeramlug commented on Aug 29, 2026

proggeramlug commented on Aug 29, 2026

proggeramlug commented on Aug 29, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions