Skip to content

Snow: one date-free snow layer for TrailView and the planner, and small per-year tiles for routes #3125

Closed
3 of 3 issues completed

Description

@timohueser

Status: done
Part of workstream 2 of #3000.

TL;DR

Goal: A release has three snow layers instead of 47. TrailView and the planner map read one shared tile that holds the snow of every date. The route features read at most 25 small tiles per route.

Problem: TrailView reads one of 46 layers for each band of 8 days. So each date change reads the whole view again (35 to 77 requests), and the bands are 64 % of the files of a release. The planner reads per-year data of 18 bytes per pixel: about 11 to 13 MB for one screen of the map, and about 140 MB along a 2,000 km route (estimated).

Decision: The step planner/snow makes three archives from the per-year tiles that it joins from the prepared source snow (#2937):

  • snow: for each pixel, the first and the last band of the longest run of bands in which at least half of the years with data had snow. Tiles of 512 × 512 pixels in lossless WebP, at zoom 0 to 11. TrailView and the planner map read it. The client compares the band of the date with the run, so a date change reads nothing.
  • snow-levels: the same runs for four more levels: any year, at least 1/4 of the years, at least 3/4 of the years, and every year. Only the planner map reads it. With snow, it gives the map 6 classes and a hatch for no data.
  • snow-seasons: the per-year onset and melt-out of today, in tiles of 64 × 64 pixels at zoom 2 to 14. A coarser pixel keeps, for each year, the earliest onset and the latest melt-out of the pixels under it, so a long route never gets a snow-free date that is too early. The route strip, the route year chart and the year calendar at a point read it. A route reads the finest zoom at which it needs at most 25 tiles.

The step planner/trailview-snow, its 46 layers and the TrailView ruleset value snow_share go.

Rejected:

  • TrailView reads the per-year tiles: one view downloads about 53 bands of today. The best lossless encoding is only 11 % smaller, because the 20 m data is noisy.
  • Lossy WebP for the runs: q90 is only 3 % smaller than lossless with 8-day steps (3.5 bands against 3.6), with a mean error of 3 days and 8 days at the 95th percentile, against 2 and 3. Smaller lossy settings move the days by 5 to 9 days on average and by 16 to 26 days at the 95th percentile.
  • Bands of 16 days: 2.5 bands of today for the first TrailView view instead of 3.6, but errors of up to a week. The owner chose 8 days.
  • Group the bands, for example one tile per month: fewer files, but each date change still reads the view again.
  • A snowline model from the terrain: small, but a model and not the measured data. It loses aspect, wind drift and glaciers.
  • snow-levels at half resolution: the planner reads tiles at the zoom of the view, so it saves bytes only at the closest zoom.
  • Continuous colouring, one level for each number of years: about 7.6 MB for one screen, only 35 % below today. The owner chose 6 classes.
  • A smooth colour ramp from the levels: not more accurate than the classes. The mean error of the fraction is 0.052 against 0.053.
  • A planner level tile without the shared level, with today's class lines at 1/3 and 2/3: about the same planner bytes, but the release stores one more run, and the classes of the planner do not match the edge of the snow in TrailView.
  • A server endpoint for the route features: one request at full detail, but the work goes to the VPS, which is the bottleneck of EPIC — Scale readiness: 100 concurrent users, long routes, from one region to the world #3000. That is about 0.3 to 0.5 s of CPU for a 2,000 km route and 30 to 50 GB of disk for Europe (estimated). It saves almost no R2 cost.
  • Small route tiles at full detail without a limit: 60 to 100 requests for a 100 km route instead of about 20.
  • A limit of 50 tiles per route: about 850 m pixels at 2,000 km instead of 1.7 km, but up to 50 requests for a 100 km route.
  • The mean of today in the coarse snow-seasons tiles: a small snowy pass in a pixel that is mostly valley disappears, so a long route gets a snow-free date that is too early. The worst case fills the same tiles, so it costs no data, only a few minutes of bake CPU (estimated). The owner chose the worst case.

Systems: planner-map-baking, trailview, route-planning, data-engine, data-registry, device-map-builder (it owns the TrailView browser test files)
Contracts: specs/planner-snow-tiles.md, specs/trailview-tiles.md, specs/obc-data.md, specs/planner-release.md
Size: L (6 systems, a breaking change of the snow formats)

Facts

  • TrailView opens one band at a time. GroundSource in builder/web/src/lib/trailview/stream/ground.ts maps the day step of the date to a band (snowBand) and opens the archive trailview-snow-NN of that band (snowDays). A date in another band opens another archive and reads its tiles again.
  • TrailView uses two values of the snow. snowState in ground-pages.ts writes, for each pixel, the snow by the region's snow_share, whether the data has the pixel, and the share of years. ground.wgsl reads the first two values and the satellite's snow mark, not the share.
  • snow_share has no other use. Only data/trailview/regions/world.json sets it, at 0.5, and every region inherits it. rules.ts also writes it into SLOT.terrain, but no shader reads that value: ground.wgsl and rocks.wgsl read only the first two values of that slot.
  • The planner reads the per-year tiles three ways. In snow-layer.svelte.ts, draw colours each map tile from the per-year tile of its zoom (paintTile in snow.ts). sample reads the tiles of the archive's max zoom under the route (eachTile). The strip (snowClass), the route year chart (snowYear) and the year calendar at a point (snowChart) use those samples. snowYear colours its cells with shareClass and snowClasses, the 4 classes of today.
  • The year calendar reads samples, not tiles. chart(samples, i, view) of DataLayer in data-layer.ts is synchronous. For a point on the route, it uses the route samples. For a pin on the map, PlannerApp.svelte samples that one point.
  • Both clients can read an opaque lossless WebP byte for byte. The planner has imagePixels in terrain.ts. TrailView has straightPixels in ground-worker.ts.
  • obc data: the prepared source snow (format 1), and planner/snow bakes from it #2937 joins the per-year tiles of a region. On its branch, join in tools/planner_snow.py builds the per-year tiles of zoom 0 to 12 from the season files of the blocks. season_tile fills a tile of zoom 9 to 12 that a season lacks from its nearest ancestor of zoom 8 or more. Tiles of zoom 9 to 12 exist only where HR-WSI has data. MODIS stops at zoom 8. Below its max zoom, a pixel takes the majority class and the mean day of the pixels under it (parent, blend).
  • The bands are a step of their own. PLANNER_TRAILVIEW_SNOW in host/obc-data-steps/src/planner.rs runs tools/trailview/snow.py and one grid step for each band. Two lists name the data layers of a release: DATA_LAYERS in catalog.rs, where pointer adds the 46 band names, and DATA_LAYERS in tools/planner_runtime.py, which lists the bands. trailview-colour already has several archives from one step: each of its grid steps names the step in its step option, which step of tools/planner_grid_maps.py reads.
  • The tile Worker serves zoom 14. The tile Worker is the Cloudflare Worker that serves the tiles of a release from its packs. MAX_ZOOM is 16 in planner/tiles/src/worker.mjs. The pack rule puts the tiles of zoom 9 and deeper into packs of base level 9 (LEVELS, base_level in tools/planner_runtime.py). The basemap and the overlays already reach zoom 14.
  • Snow is in no offline area. tools/planner_downloads.py lists the basemap, the places, the overlays and the terrain only.
  • The site deploys each push to develop. .github/workflows/deploy-site.yml publishes the planner and TrailView, which read the active release at page load.

Plan

This is an epic. Each sub-issue below is one pull request.

The formats

These rules are the contract of the three archives. Sub-issue A writes them into specs/planner-snow-tiles.md.

Words.

  • A season runs from 1 September to 31 August. A day step is 2 days, counted from 1 September: 0 to 182.
  • The onset and the melt-out of a season are the first and the last day step of its longest snow period at a pixel. Byte 253 is no snow in the season, 254 is snow on every day, 255 is no data.
  • A per-year tile is a tile of 256 × 256 pixels with the onset plane and the melt-out plane of each season: the tile of today's snow.pmtiles. The join of obc data: the prepared source snow (format 1), and planner/snow bakes from it #2937 makes these tiles at zoom 0 to 12.
  • HR-WSI is the 20 m snow data of Copernicus, stored to zoom 12. MODIS is the 500 m daily snow data of NASA, stored to zoom 8.

Bands. Band b, from 0 to 45, holds the day steps 4b to 4b + 3. The day of band b is the day step min(4b + 2, 182). A date reads the band ⌊day step ÷ 4⌋. These are the bands of TrailView today. Example: 1 March is day step 90, so band 22, whose day is day step 90.

Levels. For a pixel, k is the number of seasons with data, and c(b) is the number of seasons with snow on the day of band b: onset ≤ day ≤ melt-out, or 254. A level holds band b when k ≥ 1 and:

Level Holds band b when Archive
any c(b) ≥ 1 snow-levels, image 1
quarter c(b) ≥ 1 and 4 c(b) ≥ k snow-levels, image 2
half c(b) ≥ 1 and 2 c(b) ≥ k snow
three quarters 4 c(b) ≥ 3 k snow-levels, image 3
every c(b) = k snow-levels, image 4

Runs. The run of a level is its longest run of consecutive bands that it holds, the earliest on a tie. A run stores its first and its last band. A level that holds no band stores 253 in both bytes. A pixel with k = 0 stores 255 in both bytes. Each level keeps its own run. So in a pixel with more than one run, a higher level can hold a band that a lower level does not. The planner map takes its class from the lowest level up (Readers), so its classes stay in order. This is accepted: at the half level, 9 % of the pixels of the measured sample (Prototype below) have more than one run, and the longest run keeps 99 % of their bands.

snow and snow-levels. PMTiles v3, tile type webp, no compression, tiles of 512 × 512 pixels at zoom 0 to 11. Tile z/x/y covers the four per-year tiles of zoom z + 1, as the bands do today. Example: snow tile 11/1072/722 covers the per-year tiles 12/2144/1444, 12/2145/1444, 12/2144/1445 and 12/2145/1445, each as a quarter of its pixels. Where the join lacks one of these per-year tiles of zoom 9 to 12, that quarter takes its part of the per-year tile z/x/y, each pixel twice in each direction. A run image is a lossless WebP: red is the first band, green is the last band, blue is 0. A snow tile is one run image. A snow-levels tile is four run images one after the other, in the order of the table. The length of each image is 8 + the RIFF size in bytes 4 to 7, as in the colour tile of specs/trailview-tiles.md. A tile where no pixel has data is not in the archive.

snow-seasons. PMTiles v3, tile type unknown, gzip, tiles of 64 × 64 pixels at zoom 2 to 14. The body is the planar body of the per-year tile with 4,096 pixels per plane: for each season, the onset plane and then the melt-out plane. A tile where no season has data is not in the archive.

  • A tile of zoom 14 holds the pixels of its part of the per-year tile of zoom 12. Example: tile 14/8576/5776 holds the north-west 64 × 64 pixels of the per-year tile 12/2144/1444.
  • Below zoom 14, a pixel takes, for each season, the worst case of its 2 × 2 pixels one zoom deeper: the earliest onset and the latest melt-out of those that are dated; 254 when one of them is 254; 253 when all of them with data are 253; 255 when all are 255. A quarter whose tile one zoom deeper is not in the archive (only MODIS has data there) takes its part of the per-year tile of zoom z − 2. So a tile at the edge of HR-WSI keeps the MODIS data of its other quarters.
  • snow and snow-levels come from the per-year tiles, which keep the mean. So at a coarse zoom, the map can show a pass with less snow than the route chart. This is the safe way round for the chart.
  • The strip, the route year chart and the year calendar of a point on the route use the route samples. On a long route, they show the worst case of coarse pixels: a valley road next to a pass can show the snow of the pass. A pin at the same point reads zoom 14 and can show less snow. When a route grows past 25 tiles at its zoom, it reads one zoom coarser, so the classes of a part that did not change can change too. This is accepted.

Metadata. Each of the three archives has snow_format 1, first_season, seasons, source, resolution_m and attribution. snow-seasons also has step_days 2. A reader reads only snow_format 1.

Readers.

  • A reader of snow or snow-levels that lacks a tile of zoom 8 to 11 reads the nearest ancestor that the archive has, down to zoom 7. This is the rule that obc data: the prepared source snow (format 1), and planner/snow bakes from it #2937 gives the bands.
  • A route has samples: the points that the planner samples along the route for its profile today. Before any read, the planner picks the finest zoom, at most the archive's max zoom, at which the samples fall in at most 25 tiles; else zoom 2. A tile of zoom 11 to 14 that the archive lacks then reads its ancestor of zoom 10. So a route makes at most 25 requests, and at most 25 more where only MODIS has data in a release that also has HR-WSI.
  • A pin on the map samples one point, so it reads one tile at the archive's max zoom. A point on the route uses the route samples.
  • The planner map draws 6 classes and a hatch for no data, on the band of the date. The hatch is where snow has 255. Else the class is the highest level that holds the band while each lower level holds it too, in the order any, quarter, half, three quarters, every; none when any does not hold it.

Sub-issues

A. Bake (planner-map-baking, trailview, data-engine, device-map-builder)

  1. tools/planner_snow.py: join writes snow-seasons.pmtiles with the rules above. It makes snow.pmtiles and snow-levels.pmtiles from the four children of each tile of zoom 0 to 11. New functions runs(planes, level), run_image(first, last) and worst(children). step writes the three archives and records the tiles and the bytes of each.
  2. Delete tools/trailview/snow.py and tools/trailview/tests/test_snow.py.
  3. host/obc-data-steps/src/planner.rs: snow writes the three archives, and each has a grid step with the step option planner/snow, as trailview-colour does. Delete PLANNER_TRAILVIEW_SNOW, SNOW_BANDS, the layer name trailview-snow and its check. Raise the format of PLANNER_SNOW to 2: its readers need the new data, so the update review shows the warning of the web planner.
  4. host/obc-data-steps/src/planner/catalog.rs: DATA_LAYERS gets snow-levels and snow-seasons. pointer adds no band names.
  5. tools/planner_runtime.py: DATA_LAYERS maps snow, snow-levels and snow-seasons to snow_format, without the bands.
  6. tools/planner_verify.py: check the tile type, the size and the image count of each of the three kinds, instead of the bands.
  7. builder/web/src/lib/data/contents.ts: the snow card loses with: { trailview: ["trailview-snow"] }.
  8. builder/web/tests/browser/trailview/box.sh: the test box lists the three snow archives, not the bands.
  9. Specs: specs/planner-snow-tiles.md gets the formats above. specs/trailview-tiles.md loses "Snow days" and says that TrailView reads snow. specs/obc-data.md gives planner/snow its three outputs and grids, and loses planner/trailview-snow and the layer trailview-snow. specs/planner-release.md names the three archives.
  10. Tests: tools/tests/test_planner_snow.py: the run of a pixel, the earliest of two equal runs, 253 and 255, the four images of a snow-levels tile, a zoom 14 tile with the bytes of its part of the per-year tile, the worst case of four pixels, and a tile at the edge of HR-WSI whose quarters come from both rules. tools/tests/test_planner_grid_maps.py: a snow kind instead of trailview-snow-04. planner.rs: the snow step has three grids.

B. TrailView (trailview, data-registry, device-map-builder)

  1. builder/web/src/lib/trailview/stream/ground.ts: open the layer snow once, at the start, and check snow_format. Delete SNOW_BANDS, snowBand, snowName and snowDays. pages reads the snow tile of the ground tile with the reader rule above.
  2. ground-worker.ts decode: a snow tile gives two bytes per pixel, the first and the last band.
  3. ground-pages.ts: GroundDate carries the band instead of snowIndex and shares. snowState(snow, band) gives snow where the run holds the band, and data where the byte is not 255. The fourth byte of the snow page, the share of years today, is 0.
  4. builder/web/src/lib/trailview/ground/pages.ts: the date key holds the band instead of the day step. A date change still builds the pages again from the cached tiles, because the colour weight in the key changes each day, but it reads no new snow tile.
  5. Delete snow_share from rules/regions.ts, ground/rules.ts (SLOT.terrain takes 0), ground/ground.ts, data/trailview/regions/world.json and the schema in tools/trailview/rules.py.
  6. builder/web/tests/browser/trailview/harness.js and link.mjs: the layer snow, not the bands; no snow_share.
  7. Tests: ground.test.ts, ground-pages.test.ts, rules.test.ts.

C. Planner (route-planning)

  1. builder/web/src/lib/planner/layers/snow.ts:
    • snowClasses gives 6 classes by the fraction f = c(b) ÷ k: no year (f = 0), below 1/4, 1/4 to below 1/2, 1/2 to below 3/4, 3/4 to below 1, and every year (f = 1). The map leaves "no year" clear, as today. The labels and the light and dark colours are proposals; the owner approves them with the gallery.
    • paintTile colours from the runs of snow and snow-levels. Above the data zoom, a level holds the band at a screen pixel when the nearest data pixels whose run holds it have at least half of the bilinear weight of the four nearest. The hatch is where pixels with 255 have more than half. This replaces blendSeason and steady.
    • snowClass gives the class of a sample from c(b) and k on the band of the date, as the map does. The strip and snowYear colour with the 6 classes. snowYear keeps its columns of day steps. snowChart keeps its cells of one season each: snow, clear or no data. snowBand is the one home of the band rule; B imports it.
  2. snow-layer.svelte.ts: snowMeta checks snow_format 1 instead of step_days. draw reads the tiles of zoom min(max(z − 1, 0), the archive's max zoom) of snow and snow-levels, decoded with imagePixels, with the reader rule above for a missing tile. At map zoom 0, it draws that tile at half size. Above the archive's max zoom, it draws the part of the tile that covers the map tile, as draw does today. sample reads snow-seasons with the reader rules above.
  3. registry.ts: the snow layer gets the URLs of its three archives.
  4. Tests: snow.test.ts: the class of a pixel from its runs, also when the runs do not nest; a class border above the data zoom; the zoom of a long line at 25 tiles, and one zoom coarser when the line grows past 25 tiles; and the zoom 10 ancestor of a missing tile.

Order

  1. A merges after obc data: the prepared source snow (format 1), and planner/snow bakes from it #2937. After A merges, no release is published until B and C merge: a release from A has a snow archive that today's clients cannot read, and no bands.
  2. B and C merge after A, together (B imports snowBand from C), just before the one re-bake of workstreams 1, 2 and 3 of EPIC — Scale readiness: 100 concurrent users, long routes, from one region to the world #3000 is published. The site deploys each push to develop, and B and C read only the new formats. So between their merge and the publish, the deployed TrailView shows no snow, and the planner shows that snow data could not load. The same is true after a rollback to a release from before this change.

Files

  • tools/planner_snow.py: change: the three archives from the join.
  • tools/trailview/snow.py, tools/trailview/tests/test_snow.py: delete.
  • host/obc-data-steps/src/planner.rs, host/obc-data-steps/src/planner/catalog.rs: change: the snow step and its grids, no bands.
  • tools/planner_runtime.py, tools/planner_verify.py: change: the three snow kinds.
  • tools/trailview/rules.py, data/trailview/regions/world.json: change: no snow_share.
  • builder/web/src/lib/data/contents.ts, builder/web/src/lib/data/contents.test.ts: change: no trailview-snow.
  • builder/web/src/lib/trailview/stream/ground.ts, ground-worker.ts, ground-pages.ts, builder/web/src/lib/trailview/ground/pages.ts, ground.ts, rules.ts, ground.wgsl (comment), builder/web/src/lib/trailview/rules/regions.ts: change: the snow run, no bands, no snow_share.
  • builder/web/src/lib/planner/layers/snow.ts, snow-layer.svelte.ts, registry.ts: change: the 6 classes and the small route tiles.
  • builder/web/tests/browser/trailview/box.sh, harness.js, link.mjs: change: the layer snow.
  • specs/planner-snow-tiles.md, specs/trailview-tiles.md, specs/obc-data.md, specs/planner-release.md: change: the formats.
  • tools/tests/test_planner_snow.py, tools/tests/test_planner_grid_maps.py, builder/web/src/lib/trailview/stream/ground.test.ts, ground-pages.test.ts, builder/web/src/lib/trailview/ground/rules.test.ts, builder/web/src/lib/planner/layers/snow.test.ts: change.

Done when

  • Each pull request passes the suites that obc test affected --base origin/develop selects, and obc exec cargo clippy -p obc-data-steps --all-targets -- -D warnings for A.
  • A re-bake of Central Switzerland to the local target, with workstreams 1 and 3, records against the production release:
    • the objects and the bytes of each snow layer;
    • TrailView: the requests and the bytes of the first view, of a date change and of the date slider over one year;
    • the planner map: the requests and the bytes of one screen at zoom 10 and at zoom 12;
    • the route features: the requests and the bytes of a 100 km route and of the longest route in the bake;
    • the route year chart: for the routes of the bake, the snow-free dates at the zoom of the 25-tile rule against zoom 14, with the worst case and with the mean;
    • the tile Worker: the reads of a cold snow-seasons tile, with the size of its pack directories.
  • The owner approves a before and after gallery: TrailView and the planner map at zoom 10 and 12, on 1 December, 1 March, 1 May and 1 July, in the Alps and in the lowland.
  • The owner opens the planner and TrailView on the re-bake.

Limits

Out of scope

Prototype: How small is a date-free snow tile, and what does it cost the planner?

Answer: A tile that holds the snow period of most years, in lossless WebP with 8-day steps, is 3.6 times one band of today, and gives the look of the bands of today. The planner map gets 6 classes from it and one extra tile for about a third of today's bytes. The per-year data does not compress much in any encoding.

Evidence. The production release bf0927b0cd57 (Central Switzerland). Three zoom 11 squares: 1072/722 and 1069/721 in the Alps, and 1070/719 around Lucerne. For each square: the 46 band tiles, and the four zoom 12 per-year tiles under it, read through the tile Worker. Encoded with Pillow 12.3 WebP, method 4. "One band" is the mean size of one band tile of the square, 31 KB.

Encoding for the area of one band tile Size, in bands Mean error 95th percentile error
All 46 bands, as served 46
Per-year tiles, gzip (today) 53
Per-year tiles, lossless WebP of each plane 47
Most-years period, lossless, 2-day steps 6.2 0 0
Most-years period, lossless, 8-day steps 3.6 2 days 3 days
Most-years period, lossless, 16-day steps 2.5 4 days 7 days
Most-years period, 3 × 3 median, lossless, 8-day steps 2.5 5 days 21 days
Most-years period, lossy WebP q90, two gray images 3.5 3 days 8 days
Most-years period, lossy WebP q75, two gray images 2.0 5 days 16 days
Most-years period, lossy WebP q75, red and green of one image 1.2 9 days 26 days

Planner map, per screen tile of 256 × 256 pixels at zoom 12 (the shared tile is 28 KB of it):

Planner map Per screen tile One screen of about 30 tiles
Today, per-year tile (zoom 12: 361 KB, zoom 11: 429 KB) 361–429 KB 11–13 MB
4 classes: shared tile and 2 levels about 80 KB about 2.4 MB
6 classes: shared tile and 4 levels (estimated, about 26 KB per level) about 130 KB about 4 MB
Continuous: shared tile and every level about 260 KB about 7.6 MB
  • 4 classes (lines at any year, 1/2 and 2/3) from the lossless 8-day periods differ from the exact classes of the per-year data on 4.8 % of the pixel-days, nearly all on days near a class line.
  • Per-year tiles cut into 64 × 64 pixels are 23 KB each: 370 KB for the area of one 256 × 256 tile, against 361 KB.

The scripts were not committed. Run again from a branch prototype/snow-periods if the design needs more numbers.


Generated by Claude Code

Activity

  1. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    The owner approved the before and after gallery of the Central Switzerland re-bake: the planner map with the 6 classes, the labels and the colours (sure snow pale, the classes of fewer years in blue), and the TrailView views. The near-equal light colours of 1/4 to 1/2 and of 3/4 to below 1 stay as they are.


    Generated by Claude Code

  2. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    State after the build:

    Open, in order:

    1. Wait for workstream 1 (Larger map packs: one pack rule with a 15 MiB limit #3069) and for the Europe terrain prepare (the prepared terrain source is now format 4; without it a bake has only the Copernicus 30 m terrain).
    2. Merge develop into snow-formats, check Snow: one date-free snow layer for TrailView and the planner, and small per-year tiles for routes #3175 is green, and run the one re-bake of workstreams 1, 2 and 3 of EPIC — Scale readiness: 100 concurrent users, long routes, from one region to the world #3000.
    3. Merge Snow: one date-free snow layer for TrailView and the planner, and small per-year tiles for routes #3175 into develop just before that release is published, then close Snow A. Bake: planner/snow writes snow, snow-levels and snow-seasons, and the TrailView snow bake goes #3129, Snow B. TrailView: the snow of a date from the run of snow #3127, Snow C. Planner: 6 classes from snow and snow-levels, and the route features from snow-seasons #3128 and set Status: done on this epic.
    4. Before the merge: check the Requirements: line with obc req (needs the verification agent token), and run builder/web/tests/browser/trailview/box.sh with the CDSE keys (one bulk download at a time).
    5. Not measured yet: the reads of a cold snow-seasons tile through the tile Worker. Measure it on the published release.

    Generated by Claude Code

  3. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    Done. #3175 merged snow-formats into develop (3469850). #3129, #3127 and #3128 are closed.

    The owner chose to merge without a publish. The deployed site shows no snow until the next Swiss re-bake (the road work of #3096) is published, because the production release still has the old snow layers.

    These move to that publish:

    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