@drawtonomy/sdk 0.9.0 → 0.11.0

package/dist/exporter/odrToShapes.js

@@ -1,5 +1,6 @@
 // Convert a parsed OpenDRIVE model (`OdrMap`) into the shape primitives that
-// the drawtonomy editor consumes (points, linestrings, lanes, traffic lights).
+// the drawtonomy editor consumes (points, linestrings, lanes, traffic lights,
+// traffic signs, crosswalks).
 //
 // Mirrors the Lanelet2 OSM import path (`osmToShapes`): the output is the
 // same intermediate `ImportedShapes` structure, extended with a sidecar (the
@@ -29,6 +30,7 @@ import { evalPoly3, sampleReferenceLine } from './odrGeometry';
 import { sampleAtParam } from './laneCenterline';
 import { createShapeIdAllocator, } from './osmToShapes';
 import { PIXELS_PER_METER } from './units';
+import { hashRoadState, } from './odrCarryThrough';
 /** Lanes narrower than this (m) carry no usable area and are skipped. */
 const WIDTH_EPS = 1e-3;
 const S_EPS = 1e-6;
@@ -219,6 +221,7 @@ export function odrToShapes(map, options = {}) {
         linestrings: [],
         lanes: [],
         trafficLights: [],
+        trafficSigns: [],
         crosswalks: [],
         bounds: emptyBounds(),
         sidecar: {
@@ -255,35 +258,52 @@ export function odrToShapes(map, options = {}) {
     const roadById = new Map();
     /** Roads (with their reference samples) whose signals are converted after all lanes exist. */
     const signalRoads = [];
-    /** Lane attributes restored from <userData code="laneAttributes"> per road. */
     const restoredAttrCache = new Map();
-    const restoredLaneAttributes = (road) => {
-        const cached = restoredAttrCache.get(road.id);
-        if (cached !== undefined)
-            return cached;
-        let parsed = null;
-        const raw = road.userData['laneAttributes'];
-        if (raw) {
-            try {
-                const obj = JSON.parse(raw);
-                if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
-                    parsed = {};
-                    for (const [k, v] of Object.entries(obj)) {
-                        // `type` is fixed to 'lanelet' and odr_* meta is regenerated.
-                        if (typeof v !== 'string' || k === 'type' || k.startsWith('odr_'))
-                            continue;
-                        parsed[k] = v;
+    const pickStringAttrs = (obj) => {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            // `type` is fixed to 'lanelet' and odr_* meta is regenerated.
+            if (typeof v !== 'string' || k === 'type' || k.startsWith('odr_'))
+                continue;
+            out[k] = v;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+    };
+    const restoredLaneAttributes = (road, odrLaneId) => {
+        let entry = restoredAttrCache.get(road.id);
+        if (entry === undefined) {
+            entry = { flat: null, perLane: null };
+            const raw = road.userData['laneAttributes'];
+            if (raw) {
+                try {
+                    const obj = JSON.parse(raw);
+                    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                        const flat = {};
+                        for (const [k, v] of Object.entries(obj)) {
+                            if (v && typeof v === 'object' && !Array.isArray(v) && /^-?\d+$/.test(k)) {
+                                const laneAttrs = pickStringAttrs(v);
+                                if (laneAttrs) {
+                                    entry.perLane = entry.perLane ?? new Map();
+                                    entry.perLane.set(parseInt(k, 10), laneAttrs);
+                                }
+                            }
+                            else {
+                                flat[k] = v;
+                            }
+                        }
+                        entry.flat = pickStringAttrs(flat);
                     }
-                    if (Object.keys(parsed).length === 0)
-                        parsed = null;
+                }
+                catch {
+                    // Malformed userData JSON is ignored (third-party files).
                 }
             }
-            catch {
-                // Malformed userData JSON is ignored (third-party files).
-            }
+            restoredAttrCache.set(road.id, entry);
         }
-        restoredAttrCache.set(road.id, parsed);
-        return parsed;
+        const perLane = entry.perLane?.get(odrLaneId) ?? null;
+        if (!entry.flat && !perLane)
+            return null;
+        return { ...(entry.flat ?? {}), ...(perLane ?? {}) };
     };
     const registryKey = (roadId, sectionIdx, odrLaneId) => `${roadId}|${sectionIdx}|${odrLaneId}`;
     for (const road of roads) {
@@ -482,17 +502,22 @@ export function odrToShapes(map, options = {}) {
         }
     }
     /**
-     * Convert traffic light signals (type 1000001/1000002) into traffic light
-     * shapes. The position is the (s, t) station evaluated on the reference
-     * line; `affectedLaneIds` resolves the <validity> lane range against the
-     * lane section containing s (falling back to every driving lane of the
-     * road), merged with the lanes of any road that re-applies the signal via
+     * Convert signals into shapes: type 1000001/1000002 become traffic lights,
+     * any other type with dynamic != "yes" becomes a static traffic sign. The
+     * position is the (s, t) station evaluated on the reference line;
+     * `affectedLaneIds` resolves the <validity> lane range against the lane
+     * section containing s (falling back to every driving lane of the road),
+     * merged with the lanes of any road that re-applies the signal via
      * <signalReference>. A <userData code="stopLine"> record is rebuilt into a
-     * stop-line linestring and linked through `stopLineId`.
+     * stop-line linestring and linked through `stopLineId`; sign attributes
+     * stashed in <userData code="signAttributes"> (sign_code etc.) are restored.
      */
     function materializeSignals(road, samples) {
         for (const sig of road.signals) {
-            if (!TRAFFIC_LIGHT_SIGNAL_TYPES.has(sig.type))
+            const isTrafficLight = TRAFFIC_LIGHT_SIGNAL_TYPES.has(sig.type);
+            // Dynamic signals of unknown type cannot be represented as static
+            // signs; they stay sidecar-only (counted in the warnings).
+            if (!isTrafficLight && sig.dynamic === 'yes')
                 continue;
             const pose = poseAt(samples, sig.s);
             // Unit normal toward +t (left of the reference direction in ENU).
@@ -505,25 +530,71 @@ export function odrToShapes(map, options = {}) {
                     continue;
                 resolveAffectedLanes(ref.road, ref.s, ref.validity, affected);
             }
+            if (isTrafficLight) {
+                const data = {
+                    id: idAllocator.next('traffic_light'),
+                    x: enuToCanvasX(ex),
+                    y: enuToCanvasY(ey),
+                    // Default editor proportions (30x60 px) when the signal carries no size.
+                    w: sig.width > 0 ? sig.width * PIXELS_PER_METER : 30,
+                    h: sig.height > 0 ? sig.height * PIXELS_PER_METER : 60,
+                    osmId: '',
+                    affectedLaneIds: affected,
+                    stopLineId: materializeStopLine(sig.userData['stopLine']),
+                    attributes: {
+                        type: 'traffic_light',
+                        odr_signal_id: sig.id,
+                        odr_road_id: road.id,
+                        odr_signal_type: sig.type,
+                        odr_signal_subtype: sig.subtype,
+                    },
+                };
+                result.trafficLights.push(data);
+                convertedSignalCount++;
+                continue;
+            }
+            // Static traffic sign. Attributes stashed by the exporter in
+            // <userData code="signAttributes"> (sign_code, sign_type, regulatory
+            // element subtype, custom tags) are restored verbatim; third-party
+            // signs fall back to the signal name as the sign code.
+            const attributes = { type: 'traffic_sign' };
+            const rawSignAttrs = sig.userData['signAttributes'];
+            if (rawSignAttrs) {
+                try {
+                    const obj = JSON.parse(rawSignAttrs);
+                    if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                        for (const [k, v] of Object.entries(obj)) {
+                            if (typeof v !== 'string' || k === 'type' || k.startsWith('odr_'))
+                                continue;
+                            attributes[k] = v;
+                        }
+                    }
+                }
+                catch {
+                    // Malformed userData JSON is ignored (third-party files).
+                }
+            }
+            if (!attributes.sign_code && sig.name)
+                attributes.sign_code = sig.name;
+            attributes.odr_signal_id = sig.id;
+            attributes.odr_road_id = road.id;
+            attributes.odr_signal_type = sig.type;
+            attributes.odr_signal_subtype = sig.subtype;
+            if (sig.country)
+                attributes.odr_country = sig.country;
             const data = {
-                id: idAllocator.next('traffic_light'),
+                id: idAllocator.next('traffic_sign'),
                 x: enuToCanvasX(ex),
                 y: enuToCanvasY(ey),
-                // Default editor proportions (30x60 px) when the signal carries no size.
+                // Default editor proportions (30x30 px) when the signal carries no size.
                 w: sig.width > 0 ? sig.width * PIXELS_PER_METER : 30,
-                h: sig.height > 0 ? sig.height * PIXELS_PER_METER : 60,
+                h: sig.height > 0 ? sig.height * PIXELS_PER_METER : 30,
                 osmId: '',
                 affectedLaneIds: affected,
                 stopLineId: materializeStopLine(sig.userData['stopLine']),
-                attributes: {
-                    type: 'traffic_light',
-                    odr_signal_id: sig.id,
-                    odr_road_id: road.id,
-                    odr_signal_type: sig.type,
-                    odr_signal_subtype: sig.subtype,
-                },
+                attributes,
             };
-            result.trafficLights.push(data);
+            result.trafficSigns.push(data);
             convertedSignalCount++;
         }
     }
@@ -539,6 +610,36 @@ export function odrToShapes(map, options = {}) {
         }
         return out;
     };
+    /** Shape ids of a specific (road, ODR lane id) pair, across all sections. */
+    const lanesOfRoadLane = (roadId, odrLaneId) => {
+        const out = [];
+        for (const reg of lanesByRoad.get(roadId) ?? []) {
+            if (reg.odrLaneId === odrLaneId && !out.includes(reg.shapeId))
+                out.push(reg.shapeId);
+        }
+        return out;
+    };
+    /** Resolve a [[roadId, laneId], ...] JSON record to lane shape ids. */
+    const resolveLanePairs = (pairs) => {
+        const out = [];
+        if (!Array.isArray(pairs))
+            return out;
+        for (const entry of pairs) {
+            if (!Array.isArray(entry) || entry.length < 2)
+                continue;
+            const [rid, lid] = entry;
+            if (typeof rid !== 'string' || typeof lid !== 'string')
+                continue;
+            const odrLaneId = parseInt(lid, 10);
+            if (!Number.isFinite(odrLaneId))
+                continue;
+            for (const shapeId of lanesOfRoadLane(rid, odrLaneId)) {
+                if (!out.includes(shapeId))
+                    out.push(shapeId);
+            }
+        }
+        return out;
+    };
     /**
      * Convert crosswalk objects into crosswalk shapes. The band center is the
      * (s, t) station on the reference line; the walking axis follows the
@@ -572,7 +673,15 @@ export function odrToShapes(map, options = {}) {
             if (rawLinks) {
                 try {
                     const links = JSON.parse(rawLinks);
-                    if (Array.isArray(links.affectedRoads)) {
+                    // Current exports carry lane-precise [[roadId, laneId], ...] pairs;
+                    // legacy files only listed road ids (=> every driving lane).
+                    if (Array.isArray(links.affectedLanes)) {
+                        for (const shapeId of resolveLanePairs(links.affectedLanes)) {
+                            if (!affected.includes(shapeId))
+                                affected.push(shapeId);
+                        }
+                    }
+                    else if (Array.isArray(links.affectedRoads)) {
                         for (const rid of links.affectedRoads) {
                             if (typeof rid !== 'string')
                                 continue;
@@ -615,10 +724,38 @@ export function odrToShapes(map, options = {}) {
     for (const { road, samples } of signalRoads) {
         materializeCrosswalks(road, samples);
     }
-    // Restore right-of-way links stashed by the exporter in
-    // <userData code="yieldRoads">: every driving lane of the carrying road
-    // yields priority over the driving lanes of the listed roads.
+    // Restore right-of-way links stashed by the exporter.
+    // Current exports carry <userData code="yieldLanes"> with per-lane
+    // { ownLaneId: [[roadId, laneId], ...] } records; legacy files carried
+    // <userData code="yieldRoads"> (every driving lane of the carrying road
+    // yields over the driving lanes of the listed roads).
     for (const road of roads) {
+        const rawYieldLanes = road.userData['yieldLanes'];
+        if (rawYieldLanes) {
+            let byLane;
+            try {
+                byLane = JSON.parse(rawYieldLanes);
+            }
+            catch {
+                continue;
+            }
+            if (!byLane || typeof byLane !== 'object' || Array.isArray(byLane))
+                continue;
+            for (const [laneIdStr, pairs] of Object.entries(byLane)) {
+                const odrLaneId = parseInt(laneIdStr, 10);
+                if (!Number.isFinite(odrLaneId))
+                    continue;
+                const yieldLaneIds = resolveLanePairs(pairs);
+                if (yieldLaneIds.length === 0)
+                    continue;
+                for (const shapeId of lanesOfRoadLane(road.id, odrLaneId)) {
+                    const lane = laneShapeById.get(shapeId);
+                    if (lane)
+                        lane.yieldLaneIds = [...yieldLaneIds];
+                }
+            }
+            continue;
+        }
         const rawYield = road.userData['yieldRoads'];
         if (!rawYield)
             continue;
@@ -741,7 +878,7 @@ export function odrToShapes(map, options = {}) {
                     // Lanelet tags stashed by the exporter in <userData
                     // code="laneAttributes"> (speed_limit, turn_direction, location,
                     // one_way=no, exact subtype, custom tags) override the defaults.
-                    ...restoredLaneAttributes(road),
+                    ...restoredLaneAttributes(road, lane.id),
                     odr_type: lane.type,
                     odr_road_id: road.id,
                     odr_lane_id: String(lane.id),
@@ -819,6 +956,72 @@ export function odrToShapes(map, options = {}) {
         }
         return out;
     };
+    /**
+     * Resolve a (road, contact, lane id) endpoint to materialized lanes.
+     *
+     * Within a road this is `lanesAt` (which already bridges skipped micro
+     * sections). When the whole road was skipped — e.g. the short synthesized
+     * junction connecting roads this exporter emits, or any sub-threshold road
+     * in third-party files — the resolution continues across the road: lane
+     * links are walked through its (skipped) sections to the far end, and the
+     * road-level link there is followed into the neighbouring road, recursively,
+     * so connectivity is bridged across skipped roads instead of being lost.
+     */
+    const resolveLaneEndpoints = (roadId, contact, odrLaneId, depth = 0) => {
+        const direct = lanesAt(roadId, contact, odrLaneId);
+        if (direct.length > 0)
+            return direct.map(reg => ({ reg, odrLaneId, contact }));
+        const road = roadById.get(roadId);
+        if (!road || depth > 4)
+            return [];
+        // Only bridge across roads with no materialized lanes at all; partially
+        // materialized roads are fully handled by the in-road resolution above.
+        if ((lanesByRoad.get(roadId) ?? []).length > 0)
+            return [];
+        const n = road.laneSections.length;
+        if (n === 0)
+            return [];
+        // Walk lane-level links through the skipped sections to the far end.
+        const farContact = contact === 'start' ? 'end' : 'start';
+        const dir = contact === 'start' ? 1 : -1;
+        let idx = contact === 'start' ? 0 : n - 1;
+        let ids = [odrLaneId];
+        for (let step = 0; step < n - 1 && ids.length > 0; step++) {
+            const sec = road.laneSections[idx];
+            const nextIds = [];
+            for (const id of ids) {
+                const lane = [...sec.left, ...sec.right].find(l => l.id === id);
+                if (!lane)
+                    continue;
+                for (const linked of dir === 1 ? lane.successorIds : lane.predecessorIds) {
+                    if (!nextIds.includes(linked))
+                        nextIds.push(linked);
+                }
+            }
+            ids = nextIds;
+            idx += dir;
+        }
+        const farSec = road.laneSections[farContact === 'start' ? 0 : n - 1];
+        const link = farContact === 'end' ? road.successor : road.predecessor;
+        if (!farSec || !link || link.elementType !== 'road')
+            return [];
+        const cpB = link.contactPoint ?? (farContact === 'end' ? 'start' : 'end');
+        const out = [];
+        for (const id of ids) {
+            const lane = [...farSec.left, ...farSec.right].find(l => l.id === id);
+            if (!lane)
+                continue;
+            const targetIds = farContact === 'end' ? lane.successorIds : lane.predecessorIds;
+            for (const tid of targetIds) {
+                for (const ep of resolveLaneEndpoints(link.elementId, cpB, tid, depth + 1)) {
+                    if (!out.some(o => o.reg === ep.reg && o.odrLaneId === ep.odrLaneId && o.contact === ep.contact)) {
+                        out.push(ep);
+                    }
+                }
+            }
+        }
+        return out;
+    };
     /**
      * Link two lanes meeting at a shared contact, respecting travel direction:
      * right lanes (id < 0) travel toward the road's end, left lanes (id > 0)
@@ -887,10 +1090,10 @@ export function odrToShapes(map, options = {}) {
             return;
         for (const lane of [...sec.left, ...sec.right]) {
             const targetIds = cpA === 'end' ? lane.successorIds : lane.predecessorIds;
-            for (const a of lanesAt(roadA.id, cpA, lane.id)) {
+            for (const a of resolveLaneEndpoints(roadA.id, cpA, lane.id)) {
                 for (const toId of targetIds) {
-                    for (const b of lanesAt(roadB.id, cpB, toId)) {
-                        linkLanes(a, lane.id, cpA, b, toId, cpB);
+                    for (const b of resolveLaneEndpoints(roadB.id, cpB, toId)) {
+                        linkLanes(a.reg, a.odrLaneId, a.contact, b.reg, b.odrLaneId, b.contact);
                     }
                 }
             }
@@ -919,15 +1122,101 @@ export function odrToShapes(map, options = {}) {
                 contacts.push('end'); // Tolerant default.
             for (const cpA of contacts) {
                 for (const ll of conn.laneLinks) {
-                    for (const a of lanesAt(roadA.id, cpA, ll.from)) {
-                        for (const b of lanesAt(roadC.id, conn.contactPoint, ll.to)) {
-                            linkLanes(a, ll.from, cpA, b, ll.to, conn.contactPoint);
+                    for (const a of resolveLaneEndpoints(roadA.id, cpA, ll.from)) {
+                        for (const b of resolveLaneEndpoints(roadC.id, conn.contactPoint, ll.to)) {
+                            linkLanes(a.reg, a.odrLaneId, a.contact, b.reg, b.odrLaneId, b.contact);
                         }
                     }
                 }
             }
         }
     }
+    // Hidden lane links: edges the exporter could not express as standard
+    // <link>/<laneLink> records because a contact width is zero (the OpenDRIVE
+    // zero-width / appearing-lane link rules), stashed per road as
+    // <userData code="hiddenLaneLinks" value="[{fr,fl,tr,tl},...]"> with
+    // from-road / from-lane / to-road / to-lane ids (from end -> to start in
+    // travel direction). Restored here into next/prev like any other link.
+    for (const road of roads) {
+        const raw = road.userData['hiddenLaneLinks'];
+        if (!raw)
+            continue;
+        let recs;
+        try {
+            recs = JSON.parse(raw);
+        }
+        catch {
+            continue; // Malformed userData JSON is ignored (third-party files).
+        }
+        if (!Array.isArray(recs))
+            continue;
+        for (const rec of recs) {
+            if (!rec || typeof rec !== 'object')
+                continue;
+            const { fr, fl, tr, tl } = rec;
+            if (typeof fl !== 'number' || typeof tl !== 'number')
+                continue;
+            const fromRoad = fr === undefined ? road.id : String(fr);
+            const toRoad = tr === undefined ? road.id : String(tr);
+            for (const a of resolveLaneEndpoints(fromRoad, 'end', fl)) {
+                for (const b of resolveLaneEndpoints(toRoad, 'start', tl)) {
+                    linkLanes(a.reg, a.odrLaneId, a.contact, b.reg, b.odrLaneId, b.contact);
+                }
+            }
+        }
+    }
+    // Junction <priority high low> records restore right-of-way links: the
+    // lanes standing in for the prioritized connecting road gain yieldLaneIds
+    // over the lanes standing in for the yielding one. A materialized
+    // connecting road is represented by its own lanes; a skipped (short
+    // synthesized) one resolves through its predecessor link to the incoming
+    // lanes the maneuver started from — the lanes the exporter originally read
+    // the yieldLaneIds off. Merged with any userData-restored links above.
+    const priorityRoadLanes = (roadId) => {
+        const own = lanesByRoad.get(roadId) ?? [];
+        if (own.length > 0) {
+            const out = [];
+            for (const reg of own) {
+                if (!out.includes(reg.shapeId))
+                    out.push(reg.shapeId);
+            }
+            return out;
+        }
+        const road = roadById.get(roadId);
+        if (!road)
+            return [];
+        const lastSec = road.laneSections[road.laneSections.length - 1];
+        if (!lastSec)
+            return [];
+        const out = [];
+        for (const lane of [...lastSec.left, ...lastSec.right]) {
+            for (const ep of resolveLaneEndpoints(roadId, 'end', lane.id)) {
+                if (!out.includes(ep.reg.shapeId))
+                    out.push(ep.reg.shapeId);
+            }
+        }
+        return out;
+    };
+    for (const junction of map.junctions) {
+        for (const pr of junction.priorities) {
+            const highLanes = priorityRoadLanes(pr.high);
+            const lowLanes = priorityRoadLanes(pr.low);
+            if (highLanes.length === 0 || lowLanes.length === 0)
+                continue;
+            for (const shapeId of highLanes) {
+                const lane = laneShapeById.get(shapeId);
+                if (!lane)
+                    continue;
+                const merged = lane.yieldLaneIds ?? [];
+                for (const lowId of lowLanes) {
+                    if (lowId !== shapeId && !merged.includes(lowId))
+                        merged.push(lowId);
+                }
+                if (merged.length > 0)
+                    lane.yieldLaneIds = merged;
+            }
+        }
+    }
     // ---- Round-trip fidelity post-processing ----
     // 1. Boundaries that are geometrically one line (each exported road carries
     //    its own copy of a boundary shared with its neighbour) collapse into a
@@ -938,6 +1227,107 @@ export function odrToShapes(map, options = {}) {
     dedupeSharedBoundaries(result);
     weldConnectedLaneContacts(result);
     removeOrphanPoints(result);
+    // ---- Carry-through records ----
+    // Per-road state hashes for `exportToOpenDrive({ sidecar })`: a road whose
+    // hash still matches at export time was not edited and is re-emitted
+    // verbatim from the sidecar XML. Hashes are taken AFTER all post-processing
+    // (dedupe / weld / orphan removal) so they describe exactly the shapes the
+    // editor will hold; the exporter recomputes them from the live shapes.
+    {
+        const recPointById = new Map(result.points.map(p => [p.id, p]));
+        const recLsById = new Map(result.linestrings.map(l => [l.id, l]));
+        const boundaryPts = (lsId, invert) => {
+            if (!lsId)
+                return null;
+            const ls = recLsById.get(lsId);
+            if (!ls)
+                return null;
+            const ids = invert ? [...ls.pointIds].reverse() : ls.pointIds;
+            const pts = [];
+            for (const pid of ids) {
+                const p = recPointById.get(pid);
+                if (p)
+                    pts.push({ x: p.x, y: p.y });
+            }
+            return pts.length >= 2 ? pts : null;
+        };
+        const laneRoadOf = new Map();
+        for (const [roadId, regs] of lanesByRoad) {
+            for (const reg of regs)
+                laneRoadOf.set(reg.shapeId, roadId);
+        }
+        // Regulatory shapes touching a road: attached to it (odr_road_id) or
+        // affecting any of its lanes. Mirrored by the exporter's hash builder.
+        const regStatesByRoad = new Map();
+        const addRegState = (state, affected, own) => {
+            const touching = new Set();
+            if (own && roadById.has(own))
+                touching.add(own);
+            for (const lid of affected) {
+                const rid = laneRoadOf.get(lid);
+                if (rid)
+                    touching.add(rid);
+            }
+            for (const rid of touching) {
+                const list = regStatesByRoad.get(rid) ?? [];
+                list.push(state);
+                regStatesByRoad.set(rid, list);
+            }
+        };
+        for (const tl of result.trafficLights) {
+            addRegState({
+                kind: 'traffic_light',
+                shapeId: tl.id,
+                numbers: [tl.x, tl.y, tl.w, tl.h, 0],
+                attributes: tl.attributes,
+                affectedLaneIds: tl.affectedLaneIds,
+                stopLinePts: boundaryPts(tl.stopLineId, false),
+                controllerId: '',
+            }, tl.affectedLaneIds, tl.attributes['odr_road_id']);
+        }
+        for (const ts of result.trafficSigns) {
+            addRegState({
+                kind: 'traffic_sign',
+                shapeId: ts.id,
+                numbers: [ts.x, ts.y, ts.w, ts.h, 0],
+                attributes: ts.attributes,
+                affectedLaneIds: ts.affectedLaneIds,
+                stopLinePts: boundaryPts(ts.stopLineId, false),
+                controllerId: '',
+            }, ts.affectedLaneIds, ts.attributes['odr_road_id']);
+        }
+        for (const cw of result.crosswalks) {
+            addRegState({
+                kind: 'crosswalk',
+                shapeId: cw.id,
+                numbers: [cw.x, cw.y, cw.startX, cw.startY, cw.endX, cw.endY, cw.crosswalkWidth, 0],
+                attributes: cw.attributes,
+                affectedLaneIds: cw.affectedLaneIds,
+                stopLinePts: boundaryPts(cw.stopLineId, false),
+                controllerId: '',
+            }, cw.affectedLaneIds, cw.attributes['odr_road_id']);
+        }
+        const roadRecords = {};
+        for (const road of roads) {
+            const regLanes = lanesByRoad.get(road.id) ?? [];
+            const laneStates = regLanes.map(reg => {
+                const lane = laneShapeById.get(reg.shapeId);
+                return {
+                    leftPts: boundaryPts(lane.leftBoundaryId, lane.invertLeft),
+                    rightPts: boundaryPts(lane.rightBoundaryId, lane.invertRight),
+                    attributes: lane.attributes,
+                    next: lane.next,
+                    prev: lane.prev,
+                    yieldLaneIds: lane.yieldLaneIds ?? [],
+                };
+            });
+            roadRecords[road.id] = {
+                laneShapeIds: regLanes.map(r => r.shapeId),
+                stateHash: hashRoadState(laneStates, regStatesByRoad.get(road.id) ?? []),
+            };
+        }
+        result.sidecar.roadRecords = roadRecords;
+    }
     // ---- Aggregated warnings ----
     if (elevationRoads > 0) {
         warnings.push(`Elevation profiles on ${elevationRoads} road(s) were flattened to 2D.`);