Handle construction tags

[tordans]

In TILDA we started rewriting construction tags. The idea being, that we want to handle them like the original object they are knowing that they are just temporary.

We could do the same in Speedwalk and it would IMO make sense for the same reason.

However, the difference with TILDA is, that we have to consider the export and upload case. The upload has to use the original OSM tags. So an easy overwrite like we do with TILDA is out and we would need to handle separate tag lists instead and decide which one to use where.

• For Uplaod we want the original tags of course
• But for Export I see reasons for both – depending on the data usage

This was too complex for a quick fix, so lets leave it here to hear what other think…

[tordans]

Here is a bit auf Cursor Code analysis on the topic…

Virtual construction tags and OSM-safe export

Goal

• Re-categorize highway=construction for display and analysis:
  • highway=construction + construction=foo → treat as highway=foo + lifecycle=construction (virtual).
  • highway=construction without construction=* → treat as highway=road + lifecycle=construction + fixme="Speedwalk: construction=* tag required" (virtual).
• Never commit these virtual tags to OSM. Export and the tags menu must use original OSM tags only.

Approach: two tag sets on Way

• **original_tags**: Real OSM tags (plus user edits). Used for OSM commit and for the tags menu in the UI.
• **tags** (effective): For classification, styling, routing, and all internal logic. Computed from original_tags via a single helper that applies the construction re-categorization (identity for non-construction).

Flow:

1. Scrape (scrape.rs): When creating a Way, set original_tags = tags (from OSM), then tags = effective_tags(original_tags), then kind = Kind::classify(&tags).
2. after_edit (edits.rs): When applying change_way_tags, apply to **original_tags**; then set way.tags = effective_tags(way.original_tags) and way.kind = Kind::classify(&way.tags).
3. Export to OSM (edits.rs): In to_osc and to_osmchange_json, use **way.original_tags** (not way.tags) for all ways from derived_ways and new_ways. New ways have no virtual mapping, so original_tags and tags can be the same for them.
4. Frontend: Expose original tags for the tags menu. In wasm.rs get_ways(), add a property (e.g. original_tags or tagsForOsm) with the tags to show in the sidebar and to commit. The UI continues to use tags for kind/style and for conditional logic (e.g. SidepathTagActions when effective highway is footway/path/cycleway).

Implementation outline

1. Backend: effective_tags and Way.original_tags

• New helper (e.g. in classify.rs or a small new module): fn effective_tags(original: &Tags) -> Tags.
  • If highway != construction, return original.clone().
  • If highway=construction and construction=* exists: new Tags with highway = construction_value, lifecycle = construction, and all other keys from original (excluding highway and construction).
  • If highway=construction and no construction: new Tags with highway=road, lifecycle=construction, fixme="Speedwalk: construction=* tag required", plus rest of original (excluding highway).
• Way (lib.rs): Add pub original_tags: Tags. Keep tags as the effective tags used everywhere for logic/display.

2. Scrape and new ways

• Scrape (scrape.rs): When building a Way, set original_tags = tags, then tags = effective_tags(&original_tags), then kind = Kind::classify(&tags).
• New ways (in edits.rs and anywhere Way is created): Set original_tags = tags.clone() (no construction virtualization for newly created ways).

3. after_edit and export

• after_edit (edits.rs): When applying change_way_tags, mutate way.original_tags (not way.tags). Then set way.tags = effective_tags(&way.original_tags) and way.kind = Kind::classify(&way.tags).
• to_osc / to_osmchange_json (edits.rs): Use way.original_tags instead of way.tags when emitting way tags for create/modify (so OSC/OSM change never contain virtual tags).

4. Routeable filter

• Export (export.rs): The routeable filter currently excludes highway=construction. After switching to effective tags, construction ways will have highway=footway (etc.) and lifecycle=construction. Exclude by **lifecycle=construction** (or equivalent check on effective tags) so construction ways still do not count as routeable, while remaining visible in the data for mapping.

5. Frontend: tags menu and types

• get_ways() (wasm.rs): Add a second property for ways, e.g. original_tags, set from way.original_tags, for the tags table and for “what gets committed.”
• WayProps (web/src/sidewalks/index.ts): Add originalTags?: Record<string, string> (or make it the source for the table when present).
• CurrentTagsTable and WayDetails (web/src/sidewalks/way-details/): Use original tags (e.g. pinnedWay.properties.originalTags ?? pinnedWay.properties.tags) for the tags table and for any “commit to OSM” semantics. Keep using tags for kind, styling, and actions (e.g. CenterlineTagActions / SidepathTagActions) so construction ways still get the right UI based on effective type.

6. Graph and other readers

• Graph (graph.rs): Continues to use way.tags (effective) for osm_tags so routing and analysis see the virtualized type. No change to call sites if Way always has effective tags and correct kind from classification.

Data flow (summary)

flowchart LR
  subgraph osm [OSM / Scrape]
    Raw[Raw OSM tags]
  end
  subgraph backend [Backend]
    Orig[original_tags]
    Eff[effective_tags]
    Tags[tags]
    Kind[Kind]
    Raw --> Orig
    Orig --> Eff
    Eff --> Tags
    Tags --> Kind
  end
  subgraph use [Usage]
    Class[Classification]
    Style[Map style]
    Export[OSC / OSM upload]
    Menu[Tags menu]
    Tags --> Class
    Tags --> Style
    Orig --> Export
    Orig --> Menu
  end

Loading

Edge cases

• AssumeTags and other commands that read way.tags: They keep using way.tags (effective). For construction ways, effective type is used (e.g. severance logic still sees highway=trunk if construction=trunk).
• normalizeSidewalkTags and get_side_locations: Keep using way.tags; construction footways will have effective highway=footway and existing logic stays valid.
• New ways: No virtualization; original_tags and tags are the same.

Testing

• Unit tests for effective_tags: (1) non-construction unchanged, (2) construction + construction=footway → highway=footway + lifecycle=construction, (3) construction without construction=* → highway=road + lifecycle=construction + fixme.
• Manually: load area with construction ways, confirm map shows them with correct kind/style, tags menu shows original OSM tags, and generated OSC/OSM change contains only original tags (no lifecycle/fixme from virtualization).

This keeps a single source of truth for “what goes to OSM” (original_tags + edits) and a consistent view for “what we show and analyze” (tags), without risking virtual tags being committed.