Thanks for elaborating on how you are using this data. It's always difficult to know what the reasons, motivations or intentions of changes are without some more communication.

Yes, as I said, the signage here is really stupid and practically covers pretty much all cases, but that's not what it legally means. And OSM tags have specific well-defined meanings.

To elaborate on terminology. "General traffic" on OSM means "everyone", same as it means for all other similar tags, like access, weight/height restrictions, parking rules, etc. It means - everyone unless there is an exception via a sign, some rule or otherwise.

"Maximum" does not refer to the maximum between different signs/modes, it refers only to the maximum for that specific target. It can lowered, it can be raised, it can be cancelled, it can be an exception or the default. It all depends on the actual signage and traffic laws. This is true for all restrictions for all sorts of things - maximums, minimums, advisory, etc.

To explain this even more. Let's say every road in Riga is tagged with `maxspeed=50`. That is the default and applies to everyone. Then some roads have a 30 sign - for everyone. This cancels and lowers the normal limit for everyone and sets a different one. So it becomes `maxspeed=30`. It could also be a 70 sign. Then it raises the limit to `maxspeed=70` for everyone. Then some roads have a 30 sign but for HGVs only. This does not cancel the normal limit for everyone. This only changes the limit for HGVs. So it becomes `maxspeed=50` + `maxspeed:hgv=30`. And in very rare cases, you might even have something like a 70 sign for cars. So it raises the limit for cars only. So it would be `maxspeed=50` + `maxspeed:motorcar=70`. This is the case on this road, just taken to a (silly) extreme.

I would like to help you with your issue, sure. So I understand your app/service is having trouble with this exception. But be aware that it would also have issues with any other locations where the signs reduce or increase the speed for the specific modes of transport. These are infrequent in Latvia and generally in the world, but also there are plenty of such examples. And that's just scratching the surface of the real-world complexity. And these are the same rules used for access restrictions and many other rules.

Whatever routing or speed detection software you are using, you need to tell the developers to actually parse/implement the correct OSM tags. These tags have existed for a long time, so these are not new or obscure. They are also designed to be logical and machine-readable and parsable. This just takes a little more care in implementation than reading a single `maxspeed` value and assuming it's always valid.

If your ride-sharing is using cars, then it should be using the value hierarchy `maxspeed:motorcar` -> `maxspeed:motor_vehicle` -> `maxspeed:vehicle` -> `maxspeed` in that order of priority. This is the same hierarchy as used by access and you can see the full list here https://wiki.openstreetmap.org/wiki/Key:access#Land-based_transportation . So if there is a `maxspeed:motorcar`, then it does not matter what `maxspeed` or `maxspeed:vehicle` is - it's the `maxspeed:motorcar` that matters, like in this example. More specific mode of transport overrides the less specific one. This is why `maxspeed=50` + `maxspeed:hgv=30` means 30 for HGVs not 50 - the `:hgv` overrides the broader limit. And same is true for `maxspeed=50` + `maxspeed:motorcar=90` - the `:motorcar` overrides the default limit, even if it's in the "other direction".

When in real-life there are differences between modes of transport like this, the software will indeed have to actually consider which mode of transport it's for. `maxspeed` only describes the most broad legal value. Then additional subtags describe differences and exceptions. And I should mention there are also many incomplete, inaccurate and plain wrong values in the map data. As we slowly improve previously-inaccurately tagged roads like this one, it's inevitable that some software will break if it hasn't actually implemented tag parsing correctly.

The road like https://www.openstreetmap.org/way/1117665582 in your last example is set to `maxspeed=70` because it has a single general traffic speed limit sign that applies to everyone - https://www.mapillary.com/app/?pKey=1240676136946087&focus=photo . It's not an exception for cars or something like, it's for everyone. This is what almost all speed limit signs are like in Latvia, yes. Luckily, this also means software that only parses one value gets the right value. But that's just due to the tags are designed to have sensible hierarchy and traffic signs are usually logical.

I know this is already a lot of information for a complex topic. But just for your consideration, take this road as an example: https://www.openstreetmap.org/way/826601696 - it has `maxspeed=50` + `maxspeed:conditional=30 @ (Mo-Fr 07:00-19:00)`. Does your software think this road is always 50? Because for practical purposes, most of the time it's actually 30. I realise that most software does not implement every rule (especially complex conditions) like this and mostly responds only when users complain. But as I mentioned the real-world is messy.

Let me know if you have questions, I'm happy to answer them and direct you to whatever resources I am aware of.