Skip to content

TrailView ground plan GP7: the mesh, its strip, pieces and floors, and the cell build times #3101

Closed

Description

@timohueser

Rewritten to option C (GP7-C) after the owner's direction of 2026-11-05 (#3096, comments 6668537331 and 6670626340). The previous body (CPU heights, refinement, floors, pieces per node) is in this issue's edit history.

Status: approved
Part of #3096. One pull request into ground-plan: #3160.
Depends on: GP3 and GP3R (faces and the near records of a cell), GP6 (height_at on the GPU, merged in #3140).

TL;DR

Goal: Each cell gives the GPU the 2D topology of the ground that the terrain grid cannot draw: the sharp faces, one ring of ground about them, and a strip that meets the terrain grid. The GPU gives each corner its height, look fields and normal from the one height function, once per cell. The CPU builds no height.
Problem: GP7 as first built (CDT, Ruppert at 20°, CPU heights and normals over the whole owned region) took 5–6 s per town cell and about 22 s per jump.
Decision: R = the level-17 cells of the sharp faces, grown by two rings; the outer ring is the strip. One bulk-loaded CDT of D = R ∖ S with the faces' edges and the level-18 grid, no refinement. Corners are (point, label). One step slot per face-edge piece between two labels, always drawn. The terrain sinks its vertices strictly inside R, so no floors are necessary. One mesh range (level-18 grid); the far look B (GP8) draws past it.
Rejected:

  • Ruppert refinement and a least angle: thin triangles of correct geometry are valid (owner); the rosettes at cm-short edges go.
  • CPU heights and normals: seconds per town cell; the GPU computes them once per cell (GP9).
  • Floors (CPU or GPU pass): the sunk vertices and the strip of the terrain's own triangles keep the terrain under the mesh by construction.
  • A second mesh range at level 17: B draws past the near range.
  • Grid points only outside paved faces: the interpolation error inside a road is about 2× higher (spike, p99 20–28 mm against 8–13 mm).

Design (the code is the reference: host/obc-ground-plan/src/mesh/)

  1. Sharp face: a face whose height rule is not slope or terrain.
  2. R: the level-17 cells whose open square meets the inside of a sharp face, grown by FACE_RING = 2 rings (Chebyshev). R is a union of 5 × 5 squares. S (the strip): the cells of R with an 8-neighbour outside R; one cell wide. D = (R ∖ S) ∩ cell.
  3. Rim: each cell gives its neighbours its sharp marks (one bit per level-17 cell) and its plan vertices on its four lines. R about a cell reads the rims of the cell and its 8 neighbours, so two cells agree on R.
  4. Points and constraints of D: every face edge with a sharp face on a side, split into equal pieces of at most l_max (4 m paved, 3 m shoulder and verge, 2 m blend, 2.4 m ground); D's border, locked: each side of a D cell toward a non-D cell, with its middle point (a level-18 grid point); a span on the cell line also holds the plan vertices of both cells on it, and its middle only where it lies more than 0.4 m from them; the level-18 grid points inside D, 0.4 m or more from every face edge, in every face. Edges between two ground faces are no constraints: the ground is one continuous field.
  5. Triangulation: one try_bulk_load_cdt of all points and constraints. A crossing of two constraints returns MeshError::InvalidPlan. A flood fill from the face edges, then from D's border, gives each triangle its face.
  6. Strip: each strip cell is the terrain's own 8 triangles over its 3 × 3 level-18 points. A point on ∂R is a terrain vertex: the GPU draws it with the terrain's vertex code (it slides, morphs and takes the page's height). Every other point is a fixed ground corner. A unit test shows that no strip triangle turns over, for all 255 neighbour patterns and every morph.
  7. Corners: a sharp face's triangles take the face's label (face_labels, the records' label). A ground triangle takes at each point the point's one ground corner, labelled by the ground face that holds the point: the ground side of a face edge at the point, else the face raster at a grid point, else records::find (points on the cell lines).
  8. Step slots: one per face-edge piece p → q between two labels: the corners of the left face at p and q, then those of the right face. Always drawn as two triangles that meet at the zero point of the step. No threshold, no counter, no indirect draw.
  9. Sunk points: the level-18 grid points of the cell strictly inside R. The terrain draws such a vertex far below the mesh. Every terrain triangle inside R then has a sunk corner, or all three corners on ∂R and is the strip's own triangle.
  10. Bytes: CellMesh::to_bytes (module doc of mesh/mod.rs): a head, corners (2 words: x, y in 19 bits each, a 25-bit label, the terrain-vertex flag), triangles (3 × u32), step slots (4 × u32), sunk bits (257 × 257). One piece per cell.
  11. Bridge and worker: the cell build makes the faces and the near records in one pass. CellPlan.rim(), CellPlan.mesh_input(), MeshInput.mesh(rims), MeshInput.records(). The plan worker keeps the rims and meshes a cell when the rims of its 8 neighbours are there (at most 12 cells wait; the oldest then meshes with the rims that are there). Built.meshes carries each mesh with its near records.

Checks

  • obc test -p obc-ground-plan --lib mesh: region marks, the strip's morph test.
  • obc test -p obc-ground-plan --test mesh: all 256 fixture cells: every triangle turns as gridIndices, every edge has two triangles or lies on a cell line or ∂R; ground corners carry the records' label; two neighbour cells have the same corners and height bits (CPU twin of height_at) on their shared line. About 35 s.
  • Dropped by the owner: the angle gate, the CPU floor twin, the native = WASM hash.

Measurements

All 256 fixture cells, timosPC, one thread, release, load 14–17 (other agents and the terrain run). Median / p95 / max per cell, ms. Evidence: /media/timo/OSM1/tmp/ground-plan/gp7c/ (native/, wasm/, INDEX.md).

Per cell Native WASM (Node 24, the bridge) Reference
Mesh stage 6.1 / 47 / 90 8.1 / 72 / 200 GP7 first build: 6,000 (v12 town cell); spike C: 12.5 / 133 / 270
of it: region, points, triangulation, corners 0.3 / 0.9 / 3.5 / 1.4 (p95 0.4 / 4.4 / 37 / 6.0) –
Faces and near records 7.9 / 104 / 254 –
Whole cell (decode, graph, faces and records, rim, mesh) 17 / 155 / 359 32 / 260 / 447 develop's road job: 72–84 median
Jump: all cells within 600 m of a view (52 views whose cells all have their tiles) Native WASM, one worker
Whole build, median / p95 / max (s) 1.17 / 2.56 / 2.63 1.95 / 3.27 / 3.27
Of it the mesh (s) 0.33 / 0.69 / 0.71 0.57 / 1.01 / 1.03

With two workers the WASM jump is about 1.0 / 1.6 s (half; not measured). GP3's faces and records are about 70 % of it.

Per view (cells within 600 m, median / max) GP7-C Develop
Triangles drawn: D + strip + 2 per step slot 587k / 1,060k (D 360k / 667k, strip 120k / 173k, slots 106k / 223k) 156k / 409k road triangles
Corners 311k / 555k –
Bytes to the GPU (corners 8 B, triangles 12 B, slots 16 B, sunk bits 8 kB per cell) 9.2 / 16.4 MB –

Per cell: corners 4,705 / 36,262 / 67,537; triangles 7,252 / 56,163 / 98,663 (strip 2,136 / 12,832 / 17,456); slots 593 / 6,750 / 15,536. R covers 5 % / 37 % / 60 % of a cell. The 600 m disc is an upper bound: the mesh draws only over level-18 nodes. A slot of no step covers no pixel, but its vertices run.

WASM size: 1,676,975 B raw, 643,415 B gzipped (the faces alone: 1,410,161 / 537,529); the budget is now the head build rounded up to 16 KiB.

Checks over the fixture (tests/mesh.rs): 0 validity faults; on 480 shared cell lines no difference in corners or height bits over 1 mm, 2 points with a sub-mm step (0.18 and 0.35 mm) between two labels that one cell holds and the other does not; 0 ground corners with a label other than the records'; 69 sharp triangles in GP3R's known patch class (a crossing over a rail bed) carry the face plan's label; 631 ground corners on an edge between two ground faces carry the other ground label (equal heights).

Out of scope

  • GP9: the GPU passes (corners: heights, look fields, normals; the step slots' vertex shader), the sinking of terrain vertices, the draw, the range, the crack count.
  • GP11: the looks. GP12: decks. GP14: water surfaces.

Deviations from the option C proposal and its review

  1. No floors: sunk vertices. The terrain draws each level-18 vertex strictly inside R far below the mesh (the sunk bits). The strip is the terrain's own triangles, so every terrain triangle inside R has a sunk corner or is the strip's own triangle. This replaces the floors pass of the proposal (step 10) and review change 3 (floors from the page heights): there is no floor value, no atomic and no recompute after a stamp. It was the owner's idea to try first; it holds in the 2D tests (morph test, validity), not yet on the GPU.
  2. The strip: the terrain's own 8 triangles per strip cell, with fixed ground corners where the terrain has no ∂R vertex. GP7's first body filled holes by a search over triangulations and kept level-18 points off the inner border. Here the inner border holds the level-18 middle point of each side as a fixed vertex (it never slides), so no search, no pattern table and no strip growth are necessary. 8 triangles per strip cell.
  3. Neighbour data: a cell reads its neighbours' rims (sharp marks and plan vertices on the shared lines), not their whole plans. The border spans hold their ends, both cells' plan vertices on them and the middle point; no feet, no halving (they served the angle bound).
  4. Ground labels come from the face plan: the ground side of a face edge at the point, else a scan-line raster of the faces at the grid points, else records::find on the cell lines. Against find over the fixture: 0 wrong ground corners. 69 sharp triangles (one level crossing over a rail bed, cell 34296/23098) take the face plan's rail-bed label where the records give the crossing: GP3R's known "patch" class.
  5. One piece per cell, u32 indices. No pieces per level-18 node and no 16-bit parts: GP9 draws per cell today. A town cell has about 60k corners, so 16-bit indices would need pieces.
  6. The step's material is not in the slot: the GPU takes the look from the two labels and the step's height (review finding 10).
  7. Border steps: a face edge on the cell line has no slot (a plan holds its own cell's faces). Over the fixture's 480 shared lines, 2 points have a sub-mm step (0.18 and 0.35 mm) between two labels that one cell holds and the other does not; no other difference in corners or height bits.
  8. The cell build makes the faces and the near records in one pass in the bridge (the mesh's labels index that block).

Generated by Claude Code

Activity

  1. timohueser commented on Nov 3, 2026

    @timohueser
    OwnerAuthor

    Deviation from GP1 (PR #3117), for this sub-issue: Terrain::new(key, pages) takes the cell key and keeps only the pages that Terrain::wanted(key) lists, so heights depend on the cell alone. Terrain::height is defined only inside the cell grown by its margin and answers None past level 13; handle None, do not query outside that square.

  2. timohueser commented on Nov 3, 2026

    @timohueser
    OwnerAuthor

    Note from GP0's review (PR #3118): the road worker's build times in the baseline are approximate: roads/road-worker.ts handles messages async and awaits tile and ground decodes, so a later job can answer first. GP7 times its cell build inside the worker (the build itself, decode apart).

  3. timohueser commented on Nov 3, 2026

    @timohueser
    OwnerAuthor

    Deviations from GP5 phase A (draft PR #3124), for this sub-issue: a build request holds a tile list, because a cell reads 1–4 zoom-13 tiles (feature_tiles); the bridge has add_tile(column, row, bytes) and feature_tiles(x, y), and a cell is empty only when none of its tiles exists. cell::build_cell(bytes, rules, now) takes the request bytes, runs STAGES and times each stage (the clock changes no output); later stages add themselves to STAGES. The plan digest (FNV-1a over the canonical bytes) is computed only for the debug draw, so build timings exclude it. Stats JSON is written by hand (no serde): add new stats to Flat::of. The timing page is builder/web/plan-timing.html (native vs WASM in Chrome; the iPhone steps are in builder/ground-plan-wasm/README.md).

  4. timohueser commented on Nov 3, 2026

    @timohueser
    OwnerAuthor

    More from GP5's review round (draft PR #3124): the timing page reports first (only row 1 runs on a cold instance) and mean (elapsed time of all later runs ÷ their count; Safari clamps performance.now() to about 1 ms, so per-run times of a few ms are coarse there). PlanStats.build.prepare holds the worker's gunzip and WebP decode time per cell (median 2.1 ms in Chrome; the first cell about 107 ms for the decoder's first use). The requests index lists each cell's fixture input files as sources. The bridge's digest() throws on a NaN in the plan. The viewer's ready of 4.7–6.7 s on top views is mostly the wait for the pages to go idle, not build time: the 2 s jump gate needs its own measurement.

  5. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    DRAFT for review: a new body of GP7 for the one road model. This comment does not change the issue body. An independent reviewer reads it before the owner does.

    Sources: the round's proposal (#3096 (comment)), its review (#3096 (comment)), the owner's decisions of 2026-11-05 (#3096 (comment)), the GP6 draft on #3113, and on timosPC /media/timo/OSM1/tmp/ground-plan/one-model/ (PROPOSAL-heights.md, heights/cost/, q4w/, shapes/far/).

    How to read it. GP7's mesh stays as approved. What changes is where its heights, normals, look frames and owned region come from. A section marked unchanged keeps the approved text word for word; the body edit copies it. Every other section is new text.


    TrailView ground plan GP7: the mesh of GP3's faces on height_at, its strip, pieces and floors, and the cell build times

    Status: draft (one road model)
    Part of #3096. One pull request into ground-plan.
    Depends on: #3100 (GP5), #3113 (GP6: height_at, height_at_sides), GP3R ("the records of a cell", being filed: the near records), #3134 (GP3 follow-ups).

    TL;DR

    Goal: Each cell's faces become a valid triangle mesh in two ranges (near and far), with locked cell borders, vertical faces only on face edges and only by a named rule, a strip that meets the terrain at every morph, pieces per level-18 node and floors that keep the terrain under the mesh. Every vertex takes its height from GP6's height_at with its face's label, so the mesh draws the same function as the far pages. The build time, the triangles, the bytes and the WASM size of every fixture cell are known, native, in Chrome and on the iPhone.

    Problem: The approved body meshes GP6's heights per face (Heights::z, z_grad, frame) and takes the owned region from GP6's bit grid. In the one road model GP6 gives one point function over the records, with no gradient, no frame and no owned region. The far range draws the same function on its pages (GP8), so near and far agree only if the mesh reads it at its vertices.

    Decision: The triangulation, the locked lines, the strip, the floors, the vertex and the pieces stay as approved. Changes: (1) every vertex calls height_at with its face's label; an edge vertex calls height_at_sides with the labels of both sides (0.52× the time of two calls); (2) a vertical face stands only where the two sides differ by more than 1 mm and Height.step names a rule; (3) the normal comes from central differences of height_at with the vertex's label; (4) the look's across, along and half come from the label's host line by the same rule as the far look's fields; (5) the owned region comes from GP3's faces (every non-terrain face, slope bands included) and the footprints of the stamp's kept water and structure terms; (6) the WASM budget rises at GP7 (owner, 2026-11-05).

    Rejected:

    • Heights per face with a gradient from GP6: two functions for one ground; the far pages could not draw it.
    • Normals from the facets: the epic asks for the height function's normal, and facets would make the triangulation part of the look on smooth faces.
    • An analytic gradient in height_at now: about as much code again in Rust and WGSL. Central differences cost four calls per vertex; the bench decides (Measurements). If the cost is too high, GP6 adds the gradient.
    • The owned region from GP6's bit grid: GP6 has none; the shapes give it.
    • A frame per face from GP6's wedge.rs for the look: the far look takes its fields from the label's host lines, so the mesh does the same.
    • The approved body's rejected items (spade's own refine, a two-row strip, pieces cut at node lines, 32-bit indices, floors as f32, a height-error refinement in slope faces): unchanged.

    Systems: trailview
    Contracts: none
    Size: L (a mesh module of about 2,000 lines, a new dependency, the bridge and the timing page, the debug tool's layers, fixture-wide checks)

    Facts

    Unchanged (approved Facts 1 to 13 on the terrain grid, vertex_place, the corridor vertex, pieces, spade, Cargo.lock, the fixture), with these lines replaced:

    • GP6 gives height_at(block, q, label, t) -> Height { h, kind, owner, step } and height_at_sides(block, q, [label_a, label_b], t) -> [Height; 2]. q is in frame units (about 1.6 mm) from the cell origin; t is the plain terrain at q. A face's label is the label of the records at every point of the face (GP3R's invariant: one set of candidates, one decide).
    • GP6's cost on its vertex proxy (one thread, 166 cells, under load, before round 5): 5.3 / 51 / 89 ms per cell (median, p95, max), 695 ns per paved call. The proxy has no face vertices and no edge vertices.
    • GP3's faces stage per cell, four threads: 43–59 ms (town) and 2.8–2.9 ms (rural) median. Near records: 2.79 / 28.8 / 52.8 ms native, 3.34 / 33.6 / 62.0 ms WASM. A request's decode: about 2.7 ms per cell. WASM ÷ native: 1.24–1.30 (shapes/far/).
    • Estimate before the mesh: about 0.1 s per town cell (faces, records, heights, decode); about 12 cells in the mesh range give 1.2–1.4 s native and 1.6–1.8 s in WASM, against the epic's 2 s jump gate.
    • The bridge with GP3's faces stage is 515 KiB gzip against a budget of 272 KiB (builder/wasm/wasm_size_guard.py on ground-plan). Owner, 2026-11-05: raise the budget at GP7.
    • GP3 keeps arcs as 10° polygons. The far range evaluates the true circle; the difference is at most 0.55 % of the radius (6.6 cm at r = 12 m).
    • The prototype's near mesh (q4w/mesh/, heights/round6/mesh/) clipped GP3's faces to a 0.5 m grid, took height_at with each face's label, and filled the steps on face edges with walls. It shows a smooth road where the pages show a texel stair. It is not GP7's triangulation.

    Design

    1. What GP7 takes and gives

    Takes:

    • GP1: CellKey, the frame, Terrain::height, the debug tool.
    • GP3 and GP4: the planar map of the cell plus margin (Face with its label index, Edge, overlay priority), every face edge split at the cell lines. GP7 meshes faces of level 0.
    • GP3R: the cell's near block, built in the same cell build; find for a point's label where GP7 needs it.
    • GP6: height_at, height_at_sides, Height.step.
    • GP5: the bridge, the plan worker, the timing page.

    Gives: unchanged (mesh_cell, MeshOptions { near }, CellMesh, triangulate, morph::place), with mesh_cell(cell, plan, block, terrain, options) in place of mesh_cell(cell, plan, heights, terrain, owned, options).

    2. Regions

    • R, the owned region: the level-17 cells of the window whose open square meets the inside of a level-0 face whose label's rule is not terrain (slope band faces included), or a footprint of the stamp's kept water and structure terms (below). Then the growths of the approved section 2, in their order.
    • Why the faces suffice for the ways: outside every non-terrain face, height_at returns T (the slope field fades into T within band_fade_m of the band's edge, GP6 section 4), and the far pages hold the same function (GP8). So at the strip the page's height is the plain terrain.
    • Kept footprints (until GP12 and GP14 make them records; GP8 keeps these stamps as today): a river's half-width plus waterways.json's reach; a lake's or the sea's shore ramp, SHORE_REACH_M (15 m) past the shore; a deck's trough, a bore's cover and a gallery's fill, the reaches of stamp-core.wgsl (about 16 m past the way's edge). They come from GP1's feature lines. The footprints keep the strip on terrain that no kept stamp changes, so the strip's outer vertices take the plain terrain (the approved reason). Inside a footprint the mesh draws height_at, which knows no kept stamp, while the hidden page holds it (GP8 bounds the pages' heights by the kept water and structure terms). So until GP12 and GP14 the mesh draws plain ground over today's river banks, deck troughs and bore covers inside the owned region, as in the approved design.
    • S, D, spans, the growths, REGION_RING: unchanged.

    3. Locked lines

    Unchanged. The split rule reads height_at_sides along the line in place of GP6's z for "every point where a step along the line changes sign".

    4. Triangulation

    Unchanged, with "a face whose height rule is slope or terrain" read from the face's label.

    5. Vertices, heights and vertical faces

    • Heights: a point p inside one face takes height_at(block, p, label, T(p)) with that face's label. A point on a face edge takes height_at_sides with the labels of the two faces. A point where more than two faces meet takes height_at_sides for each pair of neighbours in cyclic order; each face's height is computed once.
    • Groups: unchanged: two faces next to each other across an edge at p join when their heights differ by at most JOIN_M (1 mm). The rule reads heights, not edge kinds, so the mesh is closed whatever GP6 gives.
    • Vertical faces: unchanged geometry. A vertical face stands only on a face edge (a constraint segment between two faces). Its material comes from the named step: Kerb gives MAT.KERB; NoRoom, CutWins, RailRoad, Unrelated and StructureEnd give MAT.WALL (GP11 gives RailRoad its retaining-wall look). A vertical face where neither side names a step counts in unnamed_steps (target 0; a GP6 fault, reported with its place).
    • No step inside a face: a point inside one face has one height, so no vertical face can stand there. GP6's scan counts the jumps of the function inside faces. GP7 counts their trace in the mesh: an interior edge of one face whose grade exceeds 3 (the steepest cut_max), by surface (steep_inside). Reported; the target is 0 on paved faces.
    • Normal: n = normalize(−g_e, g_s, 1) in east, north, up, with g_e and g_s the central differences of height_at with the vertex's own label at ±NORMAL_STEP_M along east and south (four calls; they do not need a label at the offset points, because the label is fixed). A vertex on a step edge takes the normal of its own side. Stored octahedral, as approved.
    • A face edge on the cell border: the cell that holds the lower face builds the vertical face (unchanged). Both cells compute the same heights there only if GP6's border invariant holds (equal bits, GP6 section 7); M3 proves it.

    6. The strip

    Unchanged.

    7. Floors

    Unchanged.

    8. The vertex

    Unchanged (20 bytes, five words). Word 4 holds the normal of section 5.

    9. Pieces

    Unchanged, with the contract with GP9.

    10. Look attributes

    One function, look::vertex_look(block, face, p) -> VertexLook { word, across, along }. GP11 owns what the fields mean and replaces the body; GP7 writes the first version:

    • Material and code: the face's label (surface, material line) by a Rust port of lookOf, drawnCode and marked, as approved. Sidewalk, kerb top and ground faces as approved.
    • Frame: across, along and half come from the label's host line: the nearest segment of the material line (a junction region: its host lines, label words 4–11), by the rule that model_at uses for its fields in the far look (GP3R). So the near mesh and the far look read one frame, and the lines run on through junctions by the same rule. Where the label has no host line, across, along and half are 0.
    • along = the count at the frame's metres along, less a base: stroke metres, or along / 0.6 m on a rail bed. base = 720 × floor(the lowest count of that way in the piece / 720), as approved.
    • At a zoom-13 line the metres along of one point can differ by up to 0.1 m between two cells; a look's phase jumps by up to 0.1 m there (unchanged).

    11. Constants

    Unchanged (mesh/params.rs), with two rows added and one changed:

    Name Near Far Why
    NORMAL_STEP_M 0.1 0.2 small against the least ℓ_max (2 m near, 4 m far), so the normal is the function's at the vertex; under the 0.41 m texel of a level-18 page
    STEEP_INSIDE 3.0 3.0 the steepest cut_max: an interior edge steeper than it is a jump of the function
    JOIN_M 0.001 0.001 GP6's heights.step_m (read from the table, not a copy)

    12. Edge cases

    Unchanged, with these lines changed:

    • Hairpins and close junctions: many faces and walls in one node; walls come from height groups and carry GP6's step names. With W and GP3's leg split, the legs' wall stands on the medial face edge.
    • A step that changes side along an edge (unrelated owners): split at the zero point of height_at_sides (approved section 4, step 1).
    • Unknown terrain: height_at is unknown where T is unknown; only those triangles and their vertical faces go (unchanged).

    13. Fallbacks

    Unchanged, plus unnamed_steps and steep_inside as counts.

    14. Checks in the crate

    M1 to M6: unchanged. M3 compares height bits; it holds only with GP6's border invariant. Added:

    • M7, steps by rule: every vertical face lies on a face edge, and its side names a step (unnamed_steps 0).
    • M8, deviation from the function: at every triangle's centroid and edge midpoints, the mesh height against height_at with the triangle's label (the approved deviation gate, now against the function): paved labels (owner, blend, kerb offset) p99 ≤ 1 cm and max ≤ 3 cm near, p99 ≤ 3 cm far; slope and terrain reported.

    Plan

    Unchanged (steps 1 to 20), with these steps changed:

    • Step 4 (mesh/region.rs): R from the faces' labels and the kept footprints (section 2).
    • Step 7 (mesh/vertices.rs): heights by height_at and height_at_sides, groups, normals by central differences, vertical faces with the step's material, unnamed_steps, steep_inside.
    • Step 10 (mesh/look.rs): vertex_look from the label's host line.
    • Step 15 (the bridge and the size guard): the ground-plan budget = the head build with faces, records, heights and mesh, rounded up to 16 KiB; the PR states raw and gzip with and without each stage (faces, records, heights, mesh) as the reason.
    • Step 16 (the timing page): the stages decode, graph, faces, records, heights, near, far, strip, floors, pieces.

    Files

    Unchanged, plus host/obc-ground-plan/src/mesh/ reads faces::heights (no Heights type).

    Verification

    • Checks: unchanged (mesh_fixture with M1 to M8, the look vectors, clippy, check-bytes.sh, the size guard with the raised budget, fmt, obc suites check).
    • Measurements (the PR's head build):
      • Native time per cell and stage (decode, graph, faces, records, heights, near, far, strip, floors, pieces), release, one thread, all fixture cells: median, p95, max, sum. Heights apart: calls per cell by kind (inside, height_at_sides, normals) and ns per call.
      • Chrome on the GTX box: the same table from the timing page, for both options; the jump time (all cells within 600 m, LOD metric) for each of v01 to v17, with 1, 2 and 3 workers. Gate: the largest jump time ≤ 2 s (the epic). Over it, the PR reports to the owner with the options: smaller cells, fewer grid points in slope faces, cells built farther ahead, the analytic gradient in place of the normals' four calls.
      • iPhone: the timing page link and the steps for the owner (near: false); the owner posts the table and sets the gates.
      • Triangles and bytes per cell; sums within 600 m of v01 to v17 and along the walk and valley-drive flights, against today's pools and GP0's corridor counts (unchanged).
      • WASM memory after a jump against the 55 MiB worker heap; the WASM size with and without each stage.
      • Angles: the histogram (unchanged). Deviation: M8's table.
    • Pictures: unchanged (the debug tool's near and far wireframes, strip, angles, walls, floors; glTF of v17 and i07), plus the near mesh of v17, i07 and d-hairpin with heights.legs = ramp and = wall (the owner's question 4 needs both; with wall only once GP3 splits legs). The owner looks for: walls on face edges only, a flat road, no torn or slanted triangles inside a face.

    Done when

    • M1 to M8 pass with every count 0 over the fixture, in CI.
    • The size guard holds the raised budget, and WORKERS is set from the jump times.
    • Every MeshStats fallback count is 0; unnamed_steps is 0.
    • The jump gate holds, or the owner accepts the measured times.
    • The PR has the tables, the histogram, the deviation table and the pictures, and the implementer looked at each.
    • The PR has merged into ground-plan.

    Out of scope

    Unchanged, with: heights and step names: GP6; the records: GP3R; the far look: GP8.

    Questions for the owner

    1. The WASM budget: the owner said to raise it at GP7. Recommendation: the head build rounded up to 16 KiB, with each stage's share in the PR; the epic's section 15 keeps "GP5 sets the size budget" and gets this line.
    2. Normals by four extra calls of height_at per vertex, or an analytic gradient in GP6. Recommendation: central differences; GP6 adds the gradient only if the jump gate fails on its cost.

    What changed from the approved body, and why

    • Heights: from height_at and height_at_sides with the face's label, not from Heights::z. Reason: one function near and far (owner: one road model).
    • Vertical faces: only by a named rule from GP6 (Height.step); unnamed_steps and steep_inside count the faults. Reason: the owner rule that a step stands only where a rule asks for it.
    • Normals: central differences of the function; GP6 gives no gradient.
    • Look frame: from the label's host line, as the far look; GP6 gives no frame.
    • Owned region: from GP3's faces and the stamp's kept footprints; GP6 gives no grid. Reason: outside non-terrain faces the function is T.
    • Deviation gate: against the function at the triangle's label.
    • WASM budget: raised at GP7 (owner).
    • Timing: the records stage is part of the cell build.
    • Kept: triangulation, locked lines, strip, floors, vertex, pieces, range per cell, checks M1 to M6.

    Generated by Claude Code

  6. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Deviation from GP5 (PR #3136), for this sub-issue: the size budget of ground-plan in builder/wasm/wasm_size_guard.py already holds the bridge with the faces stage: 1,376 KiB raw and 528 KiB gzip (measured 1,400,602 B and 535,120 B, rounded up to the next 16 KiB). The old budget (672 / 272 KiB) failed CI. GP7 sets the budget again when it adds spade, with the reason in its pull request.


    Generated by Claude Code

  7. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Update to the deviation from GP5 (PR #3136): after the merge of GP3R's records, the bridge is 1,410,161 B raw and 537,529 B gzip. The budget of ground-plan is now this size plus 5 %, rounded up to the next 16 KiB: 1,456 KiB raw and 560 KiB gzip. The 5 % is headroom for the stages that land before GP7, which sets the budget.


    Generated by Claude Code

  8. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Interface note from GP6 (draft PR #3140), for this sub-issue:

    • height_at_sides(block, q, [label_a, label_b], t) -> [Height; 2] gives both sides the same Height.step: the rule of the step between them (NoRoom, CutWins, RailRoad, Unrelated, StructureEnd), or Step::None under heights.step_m or with no rule. A name holds where the step lies within its rule's size and step_m (not equal to it). height_at alone always gives Step::None.
    • heights.wall_m (and wall_face_m, wall_min_m) are not in the block: GP6 has no reader. GP7 adds wall_m with its reader.
    • Cost, one thread: 1.1 / 27.5 / 80.9 ms of heights per fixture cell (median, p95, max) on GP6's vertex proxy with the faces' vertices; height_at_sides is 0.59 times two calls.
    • Border vertices: on the fixture, every point on a cell line that both cells read has bit-equal heights and terrain, so M3 can compare bits.

    Generated by Claude Code

  9. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Status of GP7 after plan step 7 (first part): the jump gate fails. Work stops before step 8 for an owner decision. Draft PR #3159 (branch claude/gp7-mesh, head 683e0e0, stacked on claude/gp6-heights).

    Done

    • Steps 1 to 6 and the heights and normals of step 7: spade = "=2.15.1", mesh/params.rs, morph.rs, region.rs, lines.rs, cdt.rs, vertices.rs. 8 unit tests pass, clippy clean, fmt clean. Not done: groups' vertices as output, vertical faces, steps 8 to 20.
    • The debug tool's command mesh (one thread, release): stage times, counts, the jump estimate, and wireframes per range.
    • Deviations 1 to 6 are in this issue's body (new section).

    Measurements (release, one thread, timosPC under load 3.5 to 4.5; ms per cell)

    Cell Near triangles 20° / 0° Far triangles 20° / 0° Mesh build 20° / 0° (all stages)
    34296/23099 (v12, town) 178,638 / 107,024 137,182 / 44,688 6,025 / 1,315
    34298/23098 (v17) 175,767 / 109,327 126,933 / 45,579 5,060 / 1,300
    34299/23097 74,399 / 47,665 51,259 / 20,523 1,565 / 461
    34298/23097 70,465 / 43,855 50,233 / 18,473 1,538 / 432
    34293/23098 57,403 / 39,819 38,041 / 14,521 1,093 / 341
    34294/23104 (lake-shore) 50,616 / 27,812 37,864 / 9,978 1,161 / 214
    • Stage medians at 20°: faces and records 52, region 12, far 519, far heights 200, near 567, near heights 237. At 0°: far 67, far heights 66, near 134, near heights 125.
    • Heights: 1.6 µs per call at 20° (1.2 µs at 0°), the face walks of the normals included. Calls over the 6 cells at 20°: inside 350,498, sides 199,574, normals 2,094,632 (79 % of all calls).
    • Jump estimate: 14 cells lie within 600 m of a view. 14 × the median cell = 22 s native, 29 s WASM (×1.3) at 20°; 6.4 s native, 8.4 s WASM at 0°. Town views are higher. With 3 workers: about 10 s and 2.8 s in WASM. The 2 s gate fails by about 10× at 20° and 1.5× to 4× at 0°.
    • The cause is the triangle count. (1) The level-18 grid in the slope and terrain faces of D: about 32,000 grid points in a town cell (D is most of the cell). (2) The 20° bound in narrow bands and at short face edges: the faces of a v17 cell have 12,514 edges, 128 under 1 cm, 710 under 5 cm, 3,004 under 20 cm (median 0.63 m). Ruppert grades down to them (the rosettes in the picture), and the shoulders split into many small triangles. At 0° the shoulders become long slivers instead.

    Pictures

    /media/timo/OSM1/tmp/ground-plan/gp7/step7/ with INDEX.md. Best: angle20/v17-sharp-corners-near.png (20°: every triangle in its face, the grid in slopes, no red, rosettes at tiny edges) and angle0/v17-sharp-corners-near.png (no bound: slivers along the shoulders, fans at the island tip).

    Options for the owner (each measured or estimated)

    1. Tune the implementation first (no design change): the triangulation rescans all triangles after each queue drain and uses ordered maps in hot loops. I expect 2× to 3× on the far and near stages, not 10×.
    2. Cheaper normals (the issue's lever): one stencil call for the five points of a vertex, or the analytic gradient. The normals are 79 % of the height calls: about 2× to 3× on the heights stages.
    3. Fewer grid points: terrain faces inside R take the level-17 grid in the near range (they draw plain T); FACE_RING 2 → 1. Estimate: a third fewer near triangles in towns.
    4. A lower angle bound where faces are narrow (a general rule: 20° only in faces at least l_max wide, else for example 10°): 10° everywhere gives near 126,109 to 147,652 triangles on the v17 cells (20°: 175,767 to 221,538). M2 changes. Slivers are valid geometry, and the normals come from the function, so the shading does not show them.
    5. GP3: a least edge length in the faces' output (no edge under a few cm): fewer rosettes at 20°.
    6. 3 workers and cells built ahead (plan step 17).

    Recommendation: do 1 and 2 now (no design change), measure again, then the owner chooses from 3, 4 and 5 with that table. 1 and 2 alone do not pass the gate in towns.

    Next step

    The owner's decision on the gate. Then plan step 7's rest (per-face vertices, vertical faces, unnamed_steps), then step 8 (the strip; Region::new takes the strip's solvable already).

    Tools

    obc exec env CARGO_TARGET_DIR=/media/timo/OSM1/cache/cargo-target-gp7 cargo run --release -p obc-ground-plan --example debug -- mesh --places v17,v12 --size-m 48 [--min-angle DEG] [--far-only] --out DIR (under systemd-run --user --scope -p MemoryMax=3G -p MemorySwapMax=0 timeout 900); --cells all times every fixture cell without pictures (about 1 h at 20°: not run). MESH_PLAN_STATS=1 prints the plan's edge lengths.


    Generated by Claude Code

  10. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Deviations of GP7-C (draft PR #3160) from the option C proposal and its review. The body of this issue now holds the GP7-C design; the first GP7 design is in its edit history.

    1. No floors: sunk vertices. The terrain draws each level-18 vertex strictly inside R far below the mesh (the sunk bits). The strip is the terrain's own triangles, so every terrain triangle inside R has a sunk corner or is the strip's own triangle. This replaces the floors pass of the proposal (step 10) and review change 3 (floors from the page heights): there is no floor value, no atomic and no recompute after a stamp. It was the owner's idea to try first; it holds in the 2D tests (morph test, validity), not yet on the GPU.
    2. The strip: the terrain's own 8 triangles per strip cell, with fixed ground corners where the terrain has no ∂R vertex. GP7's first body filled holes by a search over triangulations and kept level-18 points off the inner border. Here the inner border holds the level-18 middle point of each side as a fixed vertex (it never slides), so no search, no pattern table and no strip growth are necessary. 8 triangles per strip cell.
    3. Neighbour data: a cell reads its neighbours' rims (sharp marks and plan vertices on the shared lines), not their whole plans. The border spans hold their ends, both cells' plan vertices on them and the middle point; no feet, no halving (they served the angle bound).
    4. Ground labels come from the face plan: the ground side of a face edge at the point, else a scan-line raster of the faces at the grid points, else records::find on the cell lines. Against find over the fixture: 0 wrong ground corners. 69 sharp triangles (one level crossing over a rail bed, cell 34296/23098) take the face plan's rail-bed label where the records give the crossing: GP3R's known "patch" class.
    5. One piece per cell, u32 indices. No pieces per level-18 node and no 16-bit parts: GP9 draws per cell today. A town cell has about 60k corners, so 16-bit indices would need pieces.
    6. The step's material is not in the slot: the GPU takes the look from the two labels and the step's height (review finding 10).
    7. Border steps: a face edge on the cell line has no slot (a plan holds its own cell's faces). Over the fixture's 480 shared lines, 2 points have a sub-mm step (0.18 and 0.35 mm) between two labels that one cell holds and the other does not; no other difference in corners or height bits.
    8. The cell build makes the faces and the near records in one pass in the bridge (the mesh's labels index that block).

    Generated by Claude Code

  11. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    GP7-C landed in ground-plan with PR #3160. The CPU builds the 2D near mesh only (sharp faces, one ring, the strip). Heights, look fields and normals come from the GPU in GP9. The first review, the delta review and their fixes are on the PR. The old CPU mesh draft #3159 is superseded.


    Generated by Claude Code

  12. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    This is the GP7-C design as merged with PR #3160 (the agent could not edit the body; posted as a comment). Numbers are from the first round; the delta fixes are on the PR.

    Rewritten to option C (GP7-C) after the owner's direction of 2026-11-05 (#3096, comments 6668537331 and 6670626340). The previous body (CPU heights, refinement, floors, pieces per node) is in this issue's edit history.

    Status: approved
    Part of #3096. One pull request into ground-plan: #3160.
    Depends on: GP3 and GP3R (faces and the near records of a cell), GP6 (height_at on the GPU, merged in #3140).

    TL;DR

    Goal: Each cell gives the GPU the 2D topology of the ground that the terrain grid cannot draw: the sharp faces, one ring of ground about them, and a strip that meets the terrain grid. The GPU gives each corner its height, look fields and normal from the one height function, once per cell. The CPU builds no height.
    Problem: GP7 as first built (CDT, Ruppert at 20°, CPU heights and normals over the whole owned region) took 5–6 s per town cell and about 22 s per jump.
    Decision: R = the level-17 cells of the sharp faces, grown by two rings; the outer ring is the strip. One bulk-loaded CDT of D = R ∖ S with the faces' edges and the level-18 grid, no refinement. Corners are (point, label). One step slot per face-edge piece between two labels, always drawn. The terrain sinks its vertices strictly inside R, so no floors are necessary. One mesh range (level-18 grid); the far look B (GP8) draws past it.
    Rejected:

    • Ruppert refinement and a least angle: thin triangles of correct geometry are valid (owner); the rosettes at cm-short edges go.
    • CPU heights and normals: seconds per town cell; the GPU computes them once per cell (GP9).
    • Floors (CPU or GPU pass): the sunk vertices and the strip of the terrain's own triangles keep the terrain under the mesh by construction.
    • A second mesh range at level 17: B draws past the near range.
    • Grid points only outside paved faces: the interpolation error inside a road is about 2× higher (spike, p99 20–28 mm against 8–13 mm).

    Design (the code is the reference: host/obc-ground-plan/src/mesh/)

    1. Sharp face: a face whose height rule is not slope or terrain.
    2. R: the level-17 cells whose open square meets the inside of a sharp face, grown by FACE_RING = 2 rings (Chebyshev). R is a union of 5 × 5 squares. S (the strip): the cells of R with an 8-neighbour outside R; one cell wide. D = (R ∖ S) ∩ cell.
    3. Rim: each cell gives its neighbours its sharp marks (one bit per level-17 cell) and its plan vertices on its four lines. R about a cell reads the rims of the cell and its 8 neighbours, so two cells agree on R.
    4. Points and constraints of D: every face edge with a sharp face on a side, split into equal pieces of at most l_max (4 m paved, 3 m shoulder and verge, 2 m blend, 2.4 m ground); D's border, locked: each side of a D cell toward a non-D cell, with its middle point (a level-18 grid point); a span on the cell line also holds the plan vertices of both cells on it, and its middle only where it lies more than 0.4 m from them; the level-18 grid points inside D, 0.4 m or more from every face edge, in every face. Edges between two ground faces are no constraints: the ground is one continuous field.
    5. Triangulation: one try_bulk_load_cdt of all points and constraints. A crossing of two constraints returns MeshError::InvalidPlan. A flood fill from the face edges, then from D's border, gives each triangle its face.
    6. Strip: each strip cell is a fixed fan of 6 triangles over its 8 border points (its middle point is always sunk and goes): four corner ears and two triangles in the diamond of the side middles. The NW and SE ears are the terrain's own triangles; such an ear is left out when all three of its corners are on ∂R, because the terrain draws it. The NE and SW ears are always drawn. A point on ∂R is a terrain vertex: the GPU draws it with the terrain's vertex code (it slides, morphs and takes the page's height). Every other point is a fixed ground corner. A unit test shows that no strip triangle turns over, for all 255 neighbour patterns and every morph.
    7. Corners: a sharp face's triangles take the face's label (face_labels, the records' label). A ground triangle takes at each point the point's one ground corner, labelled by the ground face that holds the point: the ground side of a face edge at the point, else the face raster at a grid point, else records::find (points on the cell lines).
    8. Step slots: one per face-edge piece p → q between two labels: the corners of the left face at p and q, then those of the right face. Always drawn as two triangles that meet at the zero point of the step. No threshold, no counter, no indirect draw.
    9. Sunk points: the grid points of the cell strictly inside R; the GPU derives them from the R bits (every region cell that touches the point is in R). The terrain draws such a vertex far below the mesh. Every terrain triangle inside R then has a sunk corner, or all three corners on ∂R (a NW or SE ear that the terrain draws). This holds only on terrain nodes of the mesh level (params::MESH_LEVEL = 18) and without the snap of terrain vertices to road edges; the mesh draws only there.
    10. Bytes: CellMesh::to_bytes (module doc of mesh/mod.rs): a head, corners sorted by point (2 words: x, y in 19 bits each, a 25-bit label, the terrain-vertex flag), triangle runs (count, base corner), triangles (3 × u16 less the run's base), step runs, step slots (4 × u16 less the run's base), R on the cell and one ring (130 × 130 bits). GP9 draws a run with baseVertex.
    11. Bridge and worker: the cell build makes the faces and the near records in one pass. CellPlan.rim(), CellPlan.mesh_input(), MeshInput.mesh(rims) (nothing when the mesh reads the same of the rims as the last call), MeshInput.records(). The plan sends the worker the wanted, coming and kept cells. The worker meshes a cell when each of its 8 neighbours has a rim or does not come (a failed build or mesh leaves an empty rim), and again when what it reads of a changed rim changes; so the meshes do not depend on the build order. A meshes message carries each mesh with its near records, or gone for an unwanted cell whose mesh no longer fits (the plan drops its record).

    Checks

    • obc test -p obc-ground-plan --lib mesh: region marks, the strip's morph test.
    • obc test -p obc-ground-plan --test mesh: all 256 fixture cells: every triangle turns as gridIndices, every edge has two triangles or lies on a cell line or ∂R; ground corners carry the records' label; two neighbour cells have the same corners and height bits (CPU twin of height_at) on their shared line. About 35 s.
    • Dropped by the owner: the angle gate, the CPU floor twin, the native = WASM hash.

    Measurements

    All 256 fixture cells, timosPC, one thread, release, load 14–17 (other agents and the terrain run). Median / p95 / max per cell, ms. Evidence: /media/timo/OSM1/tmp/ground-plan/gp7c/ (native/, wasm/, INDEX.md).

    Per cell Native WASM (Node 24, the bridge) Reference
    Mesh stage 6.1 / 47 / 90 8.1 / 72 / 200 GP7 first build: 6,000 (v12 town cell); spike C: 12.5 / 133 / 270
    of it: region, points, triangulation, corners 0.3 / 0.9 / 3.5 / 1.4 (p95 0.4 / 4.4 / 37 / 6.0) –
    Faces and near records 7.9 / 104 / 254 –
    Whole cell (decode, graph, faces and records, rim, mesh) 17 / 155 / 359 32 / 260 / 447 develop's road job: 72–84 median
    Jump: all cells within 600 m of a view (52 views whose cells all have their tiles) Native WASM, one worker
    Whole build, median / p95 / max (s) 1.17 / 2.56 / 2.63 1.95 / 3.27 / 3.27
    Of it the mesh (s) 0.33 / 0.69 / 0.71 0.57 / 1.01 / 1.03

    With two workers the WASM jump is about 1.0 / 1.6 s (half; not measured). GP3's faces and records are about 70 % of it.

    Per view (cells within 600 m, median / max) GP7-C Develop
    Triangles drawn: D + strip + 2 per step slot 587k / 1,060k (D 360k / 667k, strip 120k / 173k, slots 106k / 223k) 156k / 409k road triangles
    Corners 311k / 555k –
    Bytes to the GPU (corners 8 B, triangles 12 B, slots 16 B, sunk bits 8 kB per cell) 9.2 / 16.4 MB –

    Per cell: corners 4,705 / 36,262 / 67,537; triangles 7,252 / 56,163 / 98,663 (strip 2,136 / 12,832 / 17,456); slots 593 / 6,750 / 15,536. R covers 5 % / 37 % / 60 % of a cell. The 600 m disc is an upper bound: the mesh draws only over level-18 nodes. A slot of no step covers no pixel, but its vertices run.

    WASM size: 1,676,975 B raw, 643,415 B gzipped (the faces alone: 1,410,161 / 537,529); the budget is now the head build rounded up to 16 KiB.

    Checks over the fixture (tests/mesh.rs): 0 validity faults; on 480 shared cell lines no difference in corners or height bits over 1 mm, 2 points with a sub-mm step (0.18 and 0.35 mm) between two labels that one cell holds and the other does not; 0 ground corners with a label other than the records'; 69 sharp triangles in GP3R's known patch class (a crossing over a rail bed) carry the face plan's label; 631 ground corners on an edge between two ground faces carry the other ground label (equal heights).

    Out of scope

    • GP9: the GPU passes (corners: heights, look fields, normals; the step slots' vertex shader), the sinking of terrain vertices, the draw, the range, the crack count.
    • GP11: the looks. GP12: decks. GP14: water surfaces.

    Deviations from the option C proposal and its review

    1. No floors: sunk vertices. The terrain draws each level-18 vertex strictly inside R far below the mesh (the sunk bits). The strip is the terrain's own triangles, so every terrain triangle inside R has a sunk corner or is the strip's own triangle. This replaces the floors pass of the proposal (step 10) and review change 3 (floors from the page heights): there is no floor value, no atomic and no recompute after a stamp. It holds in the 2D tests (morph test, validity), not yet on the GPU.
    2. The strip: one fixed fan of 6 triangles per strip cell over its border points, with fixed ground corners where the terrain has no ∂R vertex; a NW or SE ear of three ∂R corners is left out (the terrain draws it); NE and SW ears are always drawn. GP7's first body filled holes by a search over triangulations and kept level-18 points off the inner border. Here the inner border holds the middle point of each side as a fixed vertex (it never slides), so no search, no pattern table and no strip growth are necessary.
    3. Neighbour data: a cell reads its neighbours' rims (sharp marks and plan vertices on the shared lines), not their whole plans. The border spans hold their ends, both cells' plan vertices on them and the middle point; no feet, no halving (they served the angle bound).
    4. Ground labels come from the face plan: the ground side of a face edge at the point, else a scan-line raster of the faces at the grid points, else records::find on the cell lines. Against find over the fixture: 0 wrong ground corners. 69 sharp triangles (one level crossing over a rail bed, cell 34296/23098) take the face plan's rail-bed label where the records give the crossing: GP3R's known "patch" class.
    5. One piece per cell, 16-bit indices in runs. No pieces per level-18 node. The corners are sorted by point; triangles and slots are cut into runs whose corners lie within 65,536 of a base (one run per cell over the fixture).
    6. The step's material is not in the slot: the GPU takes the look from the two labels and the step's height (review finding 10).
    7. Border steps: a face edge on the cell line has no slot (a plan holds its own cell's faces). Over the fixture's 480 shared lines, 2 points have a sub-mm step (0.18 and 0.35 mm) between two labels that one cell holds and the other does not; no other difference in corners or height bits.
    8. The cell build makes the faces and the near records in one pass in the bridge (the mesh's labels index that block).

    Generated by Claude Code

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions