@drawtonomy/sdk 0.8.0 → 0.9.0

package/dist/exporter/odrToShapes.js

@@ -0,0 +1,1370 @@
+// Convert a parsed OpenDRIVE model (`OdrMap`) into the shape primitives that
+// the drawtonomy editor consumes (points, linestrings, lanes, traffic lights).
+//
+// Mirrors the Lanelet2 OSM import path (`osmToShapes`): the output is the
+// same intermediate `ImportedShapes` structure, extended with a sidecar (the
+// original XML plus the derived geographic origin) and a list of warnings for
+// features that were parsed but flattened or ignored.
+//
+// Geometry pipeline per road:
+//   1. Adaptively sample the reference line (line/arc/spiral/paramPoly3).
+//   2. At each station, shift by the laneOffset polynomial along the normal
+//      to obtain the lane reference ("center") polyline.
+//   3. Accumulate lane widths outward (left lanes +t, right lanes -t) to get
+//      every lane boundary polyline in meters.
+//   4. Convert meters -> pixels and ENU (y up) -> canvas (y down), the exact
+//      inverse of the OpenDRIVE exporter's conversion, so that
+//      import -> export is near-identity.
+//
+// Boundary sharing: adjacent lanes within one road/section share a single
+// boundary linestring (lane -1's outer boundary IS lane -2's inner boundary),
+// and the center boundary is shared between lane +1 and lane -1.
+//
+// Direction semantics: in OpenDRIVE, left lanes (positive ids) run opposite
+// to the reference line. Boundary polylines are stored in reference-line
+// order, so left lanes set invertLeft/invertRight = true — the editor then
+// reads the boundaries reversed, consistent with how `osmToShapes` encodes
+// direction via boundary inversion.
+import { evalPoly3, sampleReferenceLine } from './odrGeometry';
+import { sampleAtParam } from './laneCenterline';
+import { createShapeIdAllocator, } from './osmToShapes';
+import { PIXELS_PER_METER } from './units';
+/** Lanes narrower than this (m) carry no usable area and are skipped. */
+const WIDTH_EPS = 1e-3;
+const S_EPS = 1e-6;
+/**
+ * Lane sections shorter than this (m) are skipped as transition slivers.
+ * Generated maps (e.g. CARLA towns) often encode lane-count transitions as
+ * chains of centimeter-scale lane sections; materializing those as lanes
+ * produces degenerate slivers that no exporter can represent. A lane section
+ * below vehicle scale carries no usable lane area, so connectivity is
+ * bridged across skipped sections via their lane-level links instead.
+ */
+const MIN_SECTION_LEN_M = 0.3;
+/**
+ * Derive a WGS84 origin from an OpenDRIVE <geoReference> PROJ string.
+ *
+ * Supports `+proj=tmerc +lat_0=.. +lon_0=..` (exact: the projection origin is
+ * the local (0, 0)) and `+proj=utm +zone=..` (approximate: the zone's central
+ * meridian on the equator; UTM's false easting/northing is not compensated).
+ * Returns null when the origin cannot be derived.
+ */
+export function parseGeoReferenceOrigin(geoReference) {
+    if (!geoReference)
+        return null;
+    if (/\+proj=tmerc\b/.test(geoReference)) {
+        const latMatch = geoReference.match(/\+lat_0=(-?[\d.]+(?:[eE][-+]?\d+)?)/);
+        const lonMatch = geoReference.match(/\+lon_0=(-?[\d.]+(?:[eE][-+]?\d+)?)/);
+        if (latMatch && lonMatch) {
+            const lat = parseFloat(latMatch[1]);
+            const lon = parseFloat(lonMatch[1]);
+            if (Number.isFinite(lat) && Number.isFinite(lon)) {
+                return { lat, lon, approximate: false };
+            }
+        }
+        return null;
+    }
+    if (/\+proj=utm\b/.test(geoReference)) {
+        const zoneMatch = geoReference.match(/\+zone=(\d+)/);
+        if (zoneMatch) {
+            const zone = parseInt(zoneMatch[1], 10);
+            if (zone >= 1 && zone <= 60) {
+                return { lat: 0, lon: zone * 6 - 183, approximate: true };
+            }
+        }
+        return null;
+    }
+    return null;
+}
+/** ENU meters -> canvas pixels (inverse of the exporter's pxToEnuX). */
+function enuToCanvasX(m) {
+    return m * PIXELS_PER_METER;
+}
+/** ENU meters -> canvas pixels with the y-axis flip (inverse of pxToEnuY). */
+function enuToCanvasY(m) {
+    return -m * PIXELS_PER_METER;
+}
+function laneOffsetAt(road, s) {
+    let active = null;
+    for (const rec of road.laneOffsets) {
+        if (rec.s <= s + S_EPS)
+            active = rec;
+        else
+            break;
+    }
+    return active ? evalPoly3(active, s - active.s) : 0;
+}
+/** Lane width at `ds` meters past the lane-section start. */
+function laneWidthAt(lane, ds) {
+    let active = null;
+    for (const rec of lane.widths) {
+        if (rec.sOffset <= ds + S_EPS)
+            active = rec;
+        else
+            break;
+    }
+    if (!active)
+        return 0;
+    const w = evalPoly3(active, ds - active.sOffset);
+    return w > 0 ? w : 0;
+}
+function roadMarkToSubtype(rm) {
+    if (!rm)
+        return 'solid';
+    if (rm.type.includes('broken'))
+        return 'dashed';
+    return 'solid';
+}
+/**
+ * OpenDRIVE lane type -> lanelet-style lane subtype. Lane shapes follow the
+ * lanelet vocabulary (`attributes.type = 'lanelet'`, kind in `subtype`) so
+ * that the Lanelet2 exporter emits valid `type=lanelet` relations; the exact
+ * OpenDRIVE type is preserved separately in `odr_type` for re-export.
+ */
+const ODR_TYPE_TO_LANELET_SUBTYPE = {
+    driving: 'road',
+    sidewalk: 'walkway',
+    walking: 'walkway',
+    biking: 'bicycle_lane',
+    exit: 'exit',
+    entry: 'road',
+    onRamp: 'road',
+    offRamp: 'road',
+    bus: 'bus_lane',
+    taxi: 'bus_lane',
+    crosswalk: 'crosswalk',
+};
+function laneletSubtypeFor(odrType) {
+    return ODR_TYPE_TO_LANELET_SUBTYPE[odrType] ?? odrType;
+}
+function shouldKeepLane(lane, maxWidth) {
+    if (lane.type === 'none')
+        return false;
+    return maxWidth > WIDTH_EPS;
+}
+function emptyBounds() {
+    return {
+        minX: Infinity,
+        maxX: -Infinity,
+        minY: Infinity,
+        maxY: -Infinity,
+        centerX: 0,
+        centerY: 0,
+        width: 0,
+        height: 0,
+    };
+}
+/**
+ * Classify a junction lane's turning direction from the accumulated signed
+ * heading change along its reference samples (left lanes travel against the
+ * reference direction, flipping the sign). Consumers such as Autoware require
+ * a turn_direction tag on every lanelet inside an intersection.
+ */
+function turnDirectionFor(stations, isLeftLane) {
+    let total = 0;
+    for (let i = 1; i < stations.length; i++) {
+        let d = stations[i].hdg - stations[i - 1].hdg;
+        while (d > Math.PI)
+            d -= 2 * Math.PI;
+        while (d < -Math.PI)
+            d += 2 * Math.PI;
+        total += d;
+    }
+    if (isLeftLane)
+        total = -total;
+    const TURN_THRESHOLD = (20 * Math.PI) / 180;
+    if (total > TURN_THRESHOLD)
+        return 'left';
+    if (total < -TURN_THRESHOLD)
+        return 'right';
+    return 'straight';
+}
+/** OpenDRIVE signal types converted to traffic light shapes (vehicle / pedestrian). */
+const TRAFFIC_LIGHT_SIGNAL_TYPES = new Set(['1000001', '1000002']);
+/** Interpolated pose on the sampled reference line at station `s` (clamped). */
+function poseAt(samples, s) {
+    const first = samples[0];
+    if (s <= first.s)
+        return first;
+    const last = samples[samples.length - 1];
+    if (s >= last.s)
+        return last;
+    for (let i = 0; i < samples.length - 1; i++) {
+        const a = samples[i];
+        const b = samples[i + 1];
+        if (s > b.s)
+            continue;
+        const span = b.s - a.s;
+        const f = span > S_EPS ? (s - a.s) / span : 0;
+        return { x: a.x + (b.x - a.x) * f, y: a.y + (b.y - a.y) * f, hdg: a.hdg };
+    }
+    return last;
+}
+/**
+ * Convert a parsed OpenDRIVE map into editor-ready point/linestring/lane
+ * records plus a sidecar for round-trip export.
+ *
+ * Pass `selectedRoadIds` to restrict the conversion to a subset of roads
+ * (selective import); leave it `undefined` to import every road.
+ */
+export function odrToShapes(map, options = {}) {
+    const idAllocator = options.idAllocator ?? createShapeIdAllocator();
+    const warnings = [];
+    const origin = parseGeoReferenceOrigin(map.header.geoReference);
+    if (origin?.approximate) {
+        warnings.push('geoReference uses a UTM projection; the derived origin is the zone central meridian on the equator (false easting/northing not compensated).');
+    }
+    const result = {
+        points: [],
+        linestrings: [],
+        lanes: [],
+        trafficLights: [],
+        crosswalks: [],
+        bounds: emptyBounds(),
+        sidecar: {
+            rawXml: map.rawXml,
+            originLat: origin ? origin.lat : null,
+            originLon: origin ? origin.lon : null,
+        },
+        warnings,
+    };
+    if (origin) {
+        result.originLatLon = { lat: origin.lat, lon: origin.lon };
+    }
+    let roads = map.roads;
+    if (options.selectedRoadIds) {
+        const selected = new Set(options.selectedRoadIds);
+        roads = roads.filter(r => selected.has(r.id));
+    }
+    // ---- Statistics for aggregated warnings ----
+    let elevationRoads = 0;
+    let superelevationRoads = 0;
+    let poly3Roads = 0;
+    let signalCount = 0;
+    let convertedSignalCount = 0;
+    let objectCount = 0;
+    let convertedObjectCount = 0;
+    let microSectionRoads = 0;
+    // ---- Shape materialization ----
+    const laneRegistry = new Map();
+    const lanesByRoad = new Map();
+    const laneShapeById = new Map();
+    const sectionCount = new Map();
+    /** Section indices skipped per road (micro sections / unsampleable). */
+    const skippedSections = new Map();
+    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;
+                    }
+                    if (Object.keys(parsed).length === 0)
+                        parsed = null;
+                }
+            }
+            catch {
+                // Malformed userData JSON is ignored (third-party files).
+            }
+        }
+        restoredAttrCache.set(road.id, parsed);
+        return parsed;
+    };
+    const registryKey = (roadId, sectionIdx, odrLaneId) => `${roadId}|${sectionIdx}|${odrLaneId}`;
+    for (const road of roads) {
+        roadById.set(road.id, road);
+        sectionCount.set(road.id, road.laneSections.length);
+        if (road.hasElevation)
+            elevationRoads++;
+        if (road.hasSuperelevation)
+            superelevationRoads++;
+        if (road.planView.some(g => g.kind === 'poly3'))
+            poly3Roads++;
+        signalCount += road.signals.length;
+        objectCount += road.objects.length;
+        if (road.planView.length === 0 || road.laneSections.length === 0) {
+            warnings.push(`Road ${road.id}: no plan view geometry or lane sections; skipped.`);
+            continue;
+        }
+        // Stations that must be present: laneSection starts, laneOffset
+        // breakpoints, and lane width record breakpoints.
+        const extraStations = [];
+        for (const sec of road.laneSections) {
+            extraStations.push(sec.s);
+            for (const lane of [...sec.left, ...sec.right]) {
+                for (const w of lane.widths)
+                    extraStations.push(sec.s + w.sOffset);
+            }
+        }
+        for (const lo of road.laneOffsets)
+            extraStations.push(lo.s);
+        const samples = sampleReferenceLine(road, {
+            maxChordErrorMeters: options.maxChordErrorMeters,
+            maxStepMeters: options.maxStepMeters,
+            extraStations,
+        });
+        if (samples.length < 2) {
+            warnings.push(`Road ${road.id}: reference line could not be sampled; skipped.`);
+            continue;
+        }
+        const skipped = new Set();
+        let microSections = 0;
+        for (let secIdx = 0; secIdx < road.laneSections.length; secIdx++) {
+            const sec = road.laneSections[secIdx];
+            const secEnd = secIdx + 1 < road.laneSections.length ? road.laneSections[secIdx + 1].s : road.length;
+            // Micro sections (a few centimeters or less — common in generated maps
+            // as lane-count transition slivers) carry no usable lane area; they are
+            // skipped and lane-level connectivity is bridged across them below.
+            if (secEnd - sec.s < MIN_SECTION_LEN_M) {
+                skipped.add(secIdx);
+                microSections++;
+                continue;
+            }
+            const stations = samples.filter(st => st.s >= sec.s - S_EPS && st.s <= secEnd + S_EPS);
+            if (stations.length < 2) {
+                skipped.add(secIdx);
+                continue;
+            }
+            materializeSection(road, sec, secIdx, stations);
+        }
+        skippedSections.set(road.id, skipped);
+        if (microSections > 0)
+            microSectionRoads++;
+        // Signals are materialized after every road's lanes exist, because a
+        // <signalReference> may point at lanes of a road processed later.
+        signalRoads.push({ road, samples });
+    }
+    /**
+     * Resolve lane references that point into skipped (micro) sections to the
+     * nearest materialized section, following lane-level links in `dir`
+     * (+1 = toward larger section indices, -1 = toward smaller). Returns the
+     * (sectionIdx, laneId) pairs in the first materialized section reached.
+     */
+    function resolveThroughSkipped(road, secIdx, laneIds, dir) {
+        const out = [];
+        const skipped = skippedSections.get(road.id);
+        const visit = (si, ids, depth) => {
+            if (si < 0 || si >= road.laneSections.length || ids.length === 0 || depth > road.laneSections.length) {
+                return;
+            }
+            if (!skipped?.has(si)) {
+                for (const id of ids)
+                    out.push({ secIdx: si, laneId: id });
+                return;
+            }
+            const sec = road.laneSections[si];
+            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);
+                }
+            }
+            visit(si + dir, nextIds, depth + 1);
+        };
+        visit(secIdx, laneIds, 0);
+        return out;
+    }
+    /**
+     * Resolve the lane shapes a <validity> lane range applies to on `road` at
+     * station `s`, falling back to every driving lane of the road when the
+     * validity list is empty. Resolved shape ids are appended to `into`.
+     */
+    function resolveAffectedLanes(road, s, validity, into) {
+        let secIdx = 0;
+        for (let i = 0; i < road.laneSections.length; i++) {
+            if (road.laneSections[i].s <= s + S_EPS)
+                secIdx = i;
+            else
+                break;
+        }
+        if (validity.length > 0) {
+            for (const v of validity) {
+                const lo = Math.min(v.fromLane, v.toLane);
+                const hi = Math.max(v.fromLane, v.toLane);
+                for (let odrLaneId = lo; odrLaneId <= hi; odrLaneId++) {
+                    if (odrLaneId === 0)
+                        continue;
+                    const reg = laneRegistry.get(registryKey(road.id, secIdx, odrLaneId));
+                    if (reg && !into.includes(reg.shapeId))
+                        into.push(reg.shapeId);
+                }
+            }
+        }
+        else {
+            for (const reg of lanesByRoad.get(road.id) ?? []) {
+                if (reg.laneType === 'driving' && !into.includes(reg.shapeId)) {
+                    into.push(reg.shapeId);
+                }
+            }
+        }
+    }
+    /**
+     * Rebuild a stop-line linestring from a signal's
+     * <userData code="stopLine" value="[[x,y],...]"> record (ENU meters).
+     * Returns the linestring shape id, or null when the record is absent or
+     * malformed.
+     */
+    function materializeStopLine(stopLineJson) {
+        if (!stopLineJson)
+            return null;
+        let coords;
+        try {
+            coords = JSON.parse(stopLineJson);
+        }
+        catch {
+            return null;
+        }
+        if (!Array.isArray(coords) || coords.length < 2)
+            return null;
+        const pts = [];
+        for (const entry of coords) {
+            if (!Array.isArray(entry) || entry.length < 2)
+                return null;
+            const [x, y] = entry;
+            if (typeof x !== 'number' || typeof y !== 'number')
+                return null;
+            pts.push({ x, y });
+        }
+        const pointIds = [];
+        let firstX = 0;
+        let firstY = 0;
+        pts.forEach((p, i) => {
+            const x = enuToCanvasX(p.x);
+            const y = enuToCanvasY(p.y);
+            if (i === 0) {
+                firstX = x;
+                firstY = y;
+            }
+            const pointId = idAllocator.next('point');
+            result.points.push({ id: pointId, x, y, osmId: '' });
+            pointIds.push(pointId);
+        });
+        const ls = {
+            id: idAllocator.next('linestring'),
+            x: firstX,
+            y: firstY,
+            pointIds,
+            osmId: '',
+            attributes: { type: 'stop_line', subtype: 'solid', width: '0.2' },
+        };
+        result.linestrings.push(ls);
+        return ls.id;
+    }
+    // <signalReference> records grouped by the referenced signal id, so a
+    // signal controlling several roads recovers its full validity set.
+    const referencesBySignalId = new Map();
+    for (const road of roads) {
+        for (const ref of road.signalReferences) {
+            if (!ref.id)
+                continue;
+            const list = referencesBySignalId.get(ref.id) ?? [];
+            list.push({ road, s: ref.s, validity: ref.validity });
+            referencesBySignalId.set(ref.id, list);
+        }
+    }
+    /**
+     * 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
+     * <signalReference>. A <userData code="stopLine"> record is rebuilt into a
+     * stop-line linestring and linked through `stopLineId`.
+     */
+    function materializeSignals(road, samples) {
+        for (const sig of road.signals) {
+            if (!TRAFFIC_LIGHT_SIGNAL_TYPES.has(sig.type))
+                continue;
+            const pose = poseAt(samples, sig.s);
+            // Unit normal toward +t (left of the reference direction in ENU).
+            const ex = pose.x - Math.sin(pose.hdg) * sig.t;
+            const ey = pose.y + Math.cos(pose.hdg) * sig.t;
+            const affected = [];
+            resolveAffectedLanes(road, sig.s, sig.validity, affected);
+            for (const ref of referencesBySignalId.get(sig.id) ?? []) {
+                if (ref.road.id === road.id)
+                    continue;
+                resolveAffectedLanes(ref.road, ref.s, ref.validity, affected);
+            }
+            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++;
+        }
+    }
+    for (const { road, samples } of signalRoads) {
+        materializeSignals(road, samples);
+    }
+    /** Driving-lane shape ids of a road (regulatory link resolution). */
+    const drivingLanesOf = (roadId) => {
+        const out = [];
+        for (const reg of lanesByRoad.get(roadId) ?? []) {
+            if (reg.laneType === 'driving' && !out.includes(reg.shapeId))
+                out.push(reg.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
+     * object's heading (relative to the road direction), spanning `length`
+     * with band width `width`. Regulatory links stashed by the exporter in
+     * <userData code="crosswalkLinks"> (affected roads + stop line polyline)
+     * are resolved back to lane shape ids / a stop-line linestring.
+     */
+    function materializeCrosswalks(road, samples) {
+        for (const obj of road.objects) {
+            if (obj.type !== 'crosswalk')
+                continue;
+            if (!(obj.length > 0) || !(obj.width > 0))
+                continue;
+            const pose = poseAt(samples, obj.s);
+            // Unit normal toward +t (left of the reference direction in ENU).
+            const cx = pose.x - Math.sin(pose.hdg) * obj.t;
+            const cy = pose.y + Math.cos(pose.hdg) * obj.t;
+            const axisHdg = pose.hdg + obj.hdg;
+            const hx = (Math.cos(axisHdg) * obj.length) / 2;
+            const hy = (Math.sin(axisHdg) * obj.length) / 2;
+            const startX = enuToCanvasX(cx - hx);
+            const startY = enuToCanvasY(cy - hy);
+            const endX = enuToCanvasX(cx + hx);
+            const endY = enuToCanvasY(cy + hy);
+            const shapeX = (startX + endX) / 2;
+            const shapeY = (startY + endY) / 2;
+            const affected = [];
+            let stopLineId = null;
+            const rawLinks = obj.userData['crosswalkLinks'];
+            if (rawLinks) {
+                try {
+                    const links = JSON.parse(rawLinks);
+                    if (Array.isArray(links.affectedRoads)) {
+                        for (const rid of links.affectedRoads) {
+                            if (typeof rid !== 'string')
+                                continue;
+                            for (const shapeId of drivingLanesOf(rid)) {
+                                if (!affected.includes(shapeId))
+                                    affected.push(shapeId);
+                            }
+                        }
+                    }
+                    if (Array.isArray(links.stopLine)) {
+                        stopLineId = materializeStopLine(JSON.stringify(links.stopLine));
+                    }
+                }
+                catch {
+                    // Malformed userData JSON is ignored (third-party files).
+                }
+            }
+            const data = {
+                id: idAllocator.next('crosswalk'),
+                x: shapeX,
+                y: shapeY,
+                startX: startX - shapeX,
+                startY: startY - shapeY,
+                endX: endX - shapeX,
+                endY: endY - shapeY,
+                crosswalkWidth: obj.width * PIXELS_PER_METER,
+                osmId: '',
+                affectedLaneIds: affected,
+                stopLineId,
+                attributes: {
+                    type: 'crosswalk',
+                    odr_road_id: road.id,
+                    odr_object_id: obj.id,
+                },
+            };
+            result.crosswalks.push(data);
+            convertedObjectCount++;
+        }
+    }
+    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.
+    for (const road of roads) {
+        const rawYield = road.userData['yieldRoads'];
+        if (!rawYield)
+            continue;
+        let yieldRoadIds;
+        try {
+            yieldRoadIds = JSON.parse(rawYield);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(yieldRoadIds))
+            continue;
+        const yieldLaneIds = [];
+        for (const rid of yieldRoadIds) {
+            if (typeof rid !== 'string')
+                continue;
+            for (const shapeId of drivingLanesOf(rid)) {
+                if (!yieldLaneIds.includes(shapeId))
+                    yieldLaneIds.push(shapeId);
+            }
+        }
+        if (yieldLaneIds.length === 0)
+            continue;
+        for (const shapeId of drivingLanesOf(road.id)) {
+            const lane = laneShapeById.get(shapeId);
+            if (lane)
+                lane.yieldLaneIds = [...yieldLaneIds];
+        }
+    }
+    function materializeSection(road, sec, secIdx, stations) {
+        // Unit normals pointing toward +t (left of the reference direction in ENU).
+        const normals = stations.map(st => ({ x: -Math.sin(st.hdg), y: Math.cos(st.hdg) }));
+        // Lane reference polyline: reference line shifted by the laneOffset.
+        const centerPts = stations.map((st, j) => {
+            const off = laneOffsetAt(road, st.s);
+            return { x: st.x + normals[j].x * off, y: st.y + normals[j].y * off };
+        });
+        // Accumulate boundary polylines from the center outward. Index 0 is the
+        // center; index i is the outer boundary of the i-th lane (inner-to-outer
+        // order). Widths of skipped lanes still shift the outer boundaries.
+        const accumulate = (lanes, sign) => {
+            const boundaries = [centerPts];
+            let prev = centerPts;
+            for (const lane of lanes) {
+                const next = prev.map((p, j) => {
+                    const w = laneWidthAt(lane, stations[j].s - sec.s);
+                    return { x: p.x + sign * normals[j].x * w, y: p.y + sign * normals[j].y * w };
+                });
+                boundaries.push(next);
+                prev = next;
+            }
+            return boundaries;
+        };
+        const leftBoundaries = accumulate(sec.left, 1);
+        const rightBoundaries = accumulate(sec.right, -1);
+        // Lazily materialize boundary linestrings so adjacent lanes share them.
+        // The center boundary (index 0) is shared across both sides.
+        const lsCache = new Map();
+        const getLinestring = (side, index, pts, rm) => {
+            const key = index === 0 ? 'C' : `${side}${index}`;
+            const cached = lsCache.get(key);
+            if (cached)
+                return cached;
+            const pointIds = [];
+            let firstX = 0;
+            let firstY = 0;
+            pts.forEach((p, j) => {
+                const x = enuToCanvasX(p.x);
+                const y = enuToCanvasY(p.y);
+                if (j === 0) {
+                    firstX = x;
+                    firstY = y;
+                }
+                const pointId = idAllocator.next('point');
+                const data = { id: pointId, x, y, osmId: '' };
+                result.points.push(data);
+                pointIds.push(pointId);
+            });
+            const data = {
+                id: idAllocator.next('linestring'),
+                x: firstX,
+                y: firstY,
+                pointIds,
+                osmId: '',
+                attributes: {
+                    type: 'line_thin',
+                    subtype: roadMarkToSubtype(rm),
+                    width: '0.2',
+                },
+            };
+            result.linestrings.push(data);
+            lsCache.set(key, data);
+            return data;
+        };
+        const centerRoadMark = sec.center.find(l => l.id === 0)?.roadMarks[0];
+        const boundaryRoadMark = (lanes, index) => index === 0 ? centerRoadMark : lanes[index - 1]?.roadMarks[0];
+        const materializeSide = (lanes, boundaries, side) => {
+            for (let i = 0; i < lanes.length; i++) {
+                const lane = lanes[i];
+                let maxWidth = 0;
+                for (const st of stations) {
+                    const w = laneWidthAt(lane, st.s - sec.s);
+                    if (w > maxWidth)
+                        maxWidth = w;
+                }
+                if (!shouldKeepLane(lane, maxWidth))
+                    continue;
+                const innerLs = getLinestring(side, i, boundaries[i], boundaryRoadMark(lanes, i));
+                const outerLs = getLinestring(side, i + 1, boundaries[i + 1], boundaryRoadMark(lanes, i + 1));
+                // Left lanes (positive ids) travel opposite to the reference line, so
+                // their boundaries (stored in reference-line order) are read reversed.
+                // For both sides the inner boundary is the lane's left edge in travel
+                // direction (verified against screen coordinates with y pointing down).
+                const isLeftLane = lane.id > 0;
+                const laneShapeId = idAllocator.next('lane');
+                const attributes = {
+                    type: 'lanelet',
+                    subtype: laneletSubtypeFor(lane.type),
+                    one_way: 'yes',
+                    // 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),
+                    odr_type: lane.type,
+                    odr_road_id: road.id,
+                    odr_lane_id: String(lane.id),
+                    odr_section_s: String(sec.s),
+                };
+                attributes.type = 'lanelet';
+                if (road.junction !== '-1') {
+                    attributes.odr_junction_id = road.junction;
+                    if (!attributes.turn_direction) {
+                        attributes.turn_direction = turnDirectionFor(stations, isLeftLane);
+                    }
+                }
+                const data = {
+                    id: laneShapeId,
+                    x: innerLs.x,
+                    y: innerLs.y,
+                    leftBoundaryId: innerLs.id,
+                    rightBoundaryId: outerLs.id,
+                    invertLeft: isLeftLane,
+                    invertRight: isLeftLane,
+                    osmId: '',
+                    attributes,
+                    next: [],
+                    prev: [],
+                };
+                result.lanes.push(data);
+                laneShapeById.set(laneShapeId, data);
+                const registered = {
+                    shapeId: laneShapeId,
+                    roadId: road.id,
+                    sectionIdx: secIdx,
+                    odrLaneId: lane.id,
+                    laneType: lane.type,
+                };
+                laneRegistry.set(registryKey(road.id, secIdx, lane.id), registered);
+                const roadLanes = lanesByRoad.get(road.id) ?? [];
+                roadLanes.push(registered);
+                lanesByRoad.set(road.id, roadLanes);
+            }
+        };
+        materializeSide(sec.left, leftBoundaries, 'L');
+        materializeSide(sec.right, rightBoundaries, 'R');
+    }
+    // ---- Connectivity ----
+    const connect = (fromShapeId, toShapeId) => {
+        const from = laneShapeById.get(fromShapeId);
+        const to = laneShapeById.get(toShapeId);
+        if (!from || !to)
+            return;
+        if (!from.next.includes(toShapeId))
+            from.next.push(toShapeId);
+        if (!to.prev.includes(fromShapeId))
+            to.prev.push(fromShapeId);
+    };
+    /**
+     * Registered lanes at a road's start (first section) or end (last
+     * section). When the outermost section is a skipped micro section, the
+     * lane reference is resolved through it along the lane-level links to the
+     * first materialized section.
+     */
+    const lanesAt = (roadId, contact, odrLaneId) => {
+        const road = roadById.get(roadId);
+        const count = sectionCount.get(roadId) ?? 0;
+        if (!road || count === 0)
+            return [];
+        const secIdx = contact === 'start' ? 0 : count - 1;
+        const direct = laneRegistry.get(registryKey(roadId, secIdx, odrLaneId));
+        if (direct)
+            return [direct];
+        const out = [];
+        for (const t of resolveThroughSkipped(road, secIdx, [odrLaneId], contact === 'start' ? 1 : -1)) {
+            const reg = laneRegistry.get(registryKey(roadId, t.secIdx, t.laneId));
+            if (reg && !out.includes(reg))
+                out.push(reg);
+        }
+        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)
+     * toward its start. A connection is `a -> b` when a's travel exits at the
+     * contact and b's travel enters there (and vice versa); when both exit or
+     * both enter, the directions are inconsistent and the pair is skipped.
+     */
+    const linkLanes = (a, aOdrId, cpA, b, bOdrId, cpB) => {
+        const aExits = (aOdrId < 0) === (cpA === 'end');
+        const bEnters = (bOdrId < 0) === (cpB === 'start');
+        if (aExits && bEnters)
+            connect(a.shapeId, b.shapeId);
+        else if (!aExits && !bEnters)
+            connect(b.shapeId, a.shapeId);
+    };
+    // Chain consecutive lane sections within each road via lane-level links.
+    // References into skipped micro sections are resolved through them to the
+    // nearest materialized section.
+    for (const road of roads) {
+        for (let secIdx = 0; secIdx < road.laneSections.length; secIdx++) {
+            const sec = road.laneSections[secIdx];
+            for (const lane of [...sec.left, ...sec.right]) {
+                const cur = laneRegistry.get(registryKey(road.id, secIdx, lane.id));
+                if (!cur)
+                    continue;
+                if (secIdx + 1 < road.laneSections.length) {
+                    for (const succId of lane.successorIds) {
+                        for (const t of resolveThroughSkipped(road, secIdx + 1, [succId], 1)) {
+                            const nxt = laneRegistry.get(registryKey(road.id, t.secIdx, t.laneId));
+                            if (!nxt)
+                                continue;
+                            if (lane.id < 0 && t.laneId < 0)
+                                connect(cur.shapeId, nxt.shapeId);
+                            else if (lane.id > 0 && t.laneId > 0)
+                                connect(nxt.shapeId, cur.shapeId);
+                        }
+                    }
+                }
+                if (secIdx > 0) {
+                    for (const predId of lane.predecessorIds) {
+                        for (const t of resolveThroughSkipped(road, secIdx - 1, [predId], -1)) {
+                            const prv = laneRegistry.get(registryKey(road.id, t.secIdx, t.laneId));
+                            if (!prv)
+                                continue;
+                            if (lane.id < 0 && t.laneId < 0)
+                                connect(prv.shapeId, cur.shapeId);
+                            else if (lane.id > 0 && t.laneId > 0)
+                                connect(cur.shapeId, prv.shapeId);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Road-level links (road <-> road). Junction links are resolved separately
+    // through the junction connection table.
+    const processRoadLink = (roadA, link, cpA) => {
+        if (!link || link.elementType !== 'road')
+            return;
+        const roadB = roadById.get(link.elementId);
+        if (!roadB)
+            return;
+        const cpB = link.contactPoint ?? (cpA === 'end' ? 'start' : 'end');
+        const sec = roadA.laneSections[cpA === 'start' ? 0 : roadA.laneSections.length - 1];
+        if (!sec)
+            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 toId of targetIds) {
+                    for (const b of lanesAt(roadB.id, cpB, toId)) {
+                        linkLanes(a, lane.id, cpA, b, toId, cpB);
+                    }
+                }
+            }
+        }
+    };
+    for (const road of roads) {
+        processRoadLink(road, road.predecessor, 'start');
+        processRoadLink(road, road.successor, 'end');
+    }
+    // Junction connections: incomingRoad -> connectingRoad laneLinks.
+    for (const junction of map.junctions) {
+        for (const conn of junction.connections) {
+            const roadA = roadById.get(conn.incomingRoad);
+            const roadC = roadById.get(conn.connectingRoad);
+            if (!roadA || !roadC)
+                continue;
+            // Which end of the incoming road faces this junction?
+            const contacts = [];
+            if (roadA.successor?.elementType === 'junction' && roadA.successor.elementId === junction.id) {
+                contacts.push('end');
+            }
+            if (roadA.predecessor?.elementType === 'junction' && roadA.predecessor.elementId === junction.id) {
+                contacts.push('start');
+            }
+            if (contacts.length === 0)
+                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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // ---- 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
+    //    single linestring so left/right adjacency is expressed by sharing.
+    // 2. Boundary endpoints of connected lanes are welded into shared Point
+    //    shapes so a Lanelet2 export emits shared nodes (Autoware routing and
+    //    shared-node connection detection both depend on this).
+    dedupeSharedBoundaries(result);
+    weldConnectedLaneContacts(result);
+    removeOrphanPoints(result);
+    // ---- Aggregated warnings ----
+    if (elevationRoads > 0) {
+        warnings.push(`Elevation profiles on ${elevationRoads} road(s) were flattened to 2D.`);
+    }
+    if (superelevationRoads > 0) {
+        warnings.push(`Superelevation/lateral profiles on ${superelevationRoads} road(s) were ignored (2D import).`);
+    }
+    if (poly3Roads > 0) {
+        warnings.push(`Deprecated <poly3> geometry on ${poly3Roads} road(s) was approximated (local abscissa taken as arc length).`);
+    }
+    const unconvertedSignals = signalCount - convertedSignalCount;
+    const unconvertedObjects = objectCount - convertedObjectCount;
+    if (unconvertedSignals > 0 || unconvertedObjects > 0) {
+        warnings.push(`${unconvertedSignals} signal(s) and ${unconvertedObjects} object(s) were parsed but not converted to shapes.`);
+    }
+    if (microSectionRoads > 0) {
+        warnings.push(`Micro lane sections (< ${MIN_SECTION_LEN_M} m) on ${microSectionRoads} road(s) were skipped; lane connectivity was bridged across them.`);
+    }
+    // ---- Bounds ----
+    for (const point of result.points) {
+        if (point.x < result.bounds.minX)
+            result.bounds.minX = point.x;
+        if (point.x > result.bounds.maxX)
+            result.bounds.maxX = point.x;
+        if (point.y < result.bounds.minY)
+            result.bounds.minY = point.y;
+        if (point.y > result.bounds.maxY)
+            result.bounds.maxY = point.y;
+    }
+    if (result.points.length > 0) {
+        result.bounds.width = result.bounds.maxX - result.bounds.minX;
+        result.bounds.height = result.bounds.maxY - result.bounds.minY;
+        result.bounds.centerX = result.bounds.minX + result.bounds.width / 2;
+        result.bounds.centerY = result.bounds.minY + result.bounds.height / 2;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Round-trip fidelity post-processing
+// ---------------------------------------------------------------------------
+/**
+ * Max pointwise deviation (m) for two boundaries to count as one line, in
+ * the interior of the polyline. Two genuinely distinct parallel boundaries
+ * are at least a lane width apart in their interior, so this can stay tight.
+ */
+const BOUNDARY_DEDUPE_INTERIOR_TOL_M = 0.3;
+/**
+ * Max pointwise deviation (m) near the polyline ends. Contact-point welding
+ * (see weldConnectedLaneContacts) moves junction corners by up to a couple
+ * of meters, and the per-road reconstruction of a shared boundary diverges
+ * around such a kink, so the comparison is more permissive there. A false
+ * match would require two boundaries that pinch below this at both ends AND
+ * run within the interior tolerance in between — i.e. a degenerate sliver.
+ */
+const BOUNDARY_DEDUPE_END_TOL_M = 1.5;
+/**
+ * Max contact gap (m) tolerated when welding the boundary endpoints of two
+ * lanes joined by a next/prev edge. At junction entries/exits the corner on
+ * the outer side of a turning connecting lane legitimately sits up to about
+ * `laneWidth * 2 * sin(turnAngle / 2)` away from the incoming lane's corner,
+ * so this is generous; the weld is only ever applied across declared edges,
+ * never discovered by proximity.
+ */
+const CONTACT_WELD_MAX_GAP_M = 10;
+/**
+ * Merge boundary linestrings that trace the same geometry (all resampled
+ * points within tolerance), so adjacent lanes reference one shared
+ * linestring. Reversed duplicates merge too, flipping the lane's invert flag.
+ *
+ * The OpenDRIVE exporter emits one road per lane with its own reference
+ * line, so a boundary shared between two adjacent lanes comes back as two
+ * near-identical linestrings; this pass restores the sharing (and with it
+ * the left/right adjacency information).
+ */
+function dedupeSharedBoundaries(result) {
+    const pointById = new Map(result.points.map(p => [p.id, p]));
+    const boundaryIds = new Set();
+    for (const lane of result.lanes) {
+        boundaryIds.add(lane.leftBoundaryId);
+        boundaryIds.add(lane.rightBoundaryId);
+    }
+    const entries = [];
+    for (const ls of result.linestrings) {
+        if (!boundaryIds.has(ls.id))
+            continue;
+        const pts = [];
+        for (const pid of ls.pointIds) {
+            const p = pointById.get(pid);
+            if (p)
+                pts.push({ x: p.x, y: p.y });
+        }
+        if (pts.length >= 2)
+            entries.push({ ls, pts });
+    }
+    const candidates = [];
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            const m = boundaryMatchScore(entries[i].pts, entries[j].pts);
+            if (m === null)
+                continue;
+            candidates.push({
+                a: entries[i].ls.id,
+                b: entries[j].ls.id,
+                reversed: m.reversed,
+                score: m.score,
+            });
+        }
+    }
+    if (candidates.length === 0)
+        return;
+    // Best (lowest-deviation) matches merge first, so the true duplicate of a
+    // boundary wins over a nearby copy across a very narrow lane; the
+    // left!=right constraint below then blocks the false match.
+    candidates.sort((x, y) => x.score - y.score);
+    // 2. Union-find with orientation parity (0 = same order as parent, 1 =
+    //    reversed), constrained so no lane ends up with left === right.
+    const parent = new Map();
+    const parity = new Map();
+    const findWithParity = (x) => {
+        let root = x;
+        let p = 0;
+        while (true) {
+            const up = parent.get(root);
+            if (up === undefined || up === root)
+                break;
+            p ^= parity.get(root) ?? 0;
+            root = up;
+        }
+        // Path compression (re-walk, pointing every node at the root).
+        let cur = x;
+        let curP = p;
+        while (cur !== root) {
+            const up = parent.get(cur);
+            const upP = parity.get(cur) ?? 0;
+            parent.set(cur, root);
+            parity.set(cur, curP);
+            cur = up;
+            curP ^= upP;
+        }
+        return { root, parity: p };
+    };
+    const pairKey = (x, y) => (x < y ? `${x}|${y}` : `${y}|${x}`);
+    /** Current root pairs (left|right) of every lane; merges may not collapse one. */
+    const lanePairs = new Set();
+    const lanesByRoot = new Map();
+    for (const lane of result.lanes) {
+        lanePairs.add(pairKey(lane.leftBoundaryId, lane.rightBoundaryId));
+        for (const b of [lane.leftBoundaryId, lane.rightBoundaryId]) {
+            const list = lanesByRoot.get(b) ?? [];
+            list.push(lane);
+            lanesByRoot.set(b, list);
+        }
+    }
+    let merges = 0;
+    for (const c of candidates) {
+        const fa = findWithParity(c.a);
+        const fb = findWithParity(c.b);
+        if (fa.root === fb.root)
+            continue;
+        if (lanePairs.has(pairKey(fa.root, fb.root)))
+            continue; // would collapse a lane
+        // Attach b's tree under a's root, composing orientation parities.
+        parent.set(fb.root, fa.root);
+        parity.set(fb.root, fa.parity ^ (c.reversed ? 1 : 0) ^ fb.parity);
+        merges++;
+        // Re-key the root pairs of the lanes that referenced b's old root.
+        const moved = lanesByRoot.get(fb.root) ?? [];
+        const target = lanesByRoot.get(fa.root) ?? [];
+        for (const lane of moved) {
+            target.push(lane);
+            lanePairs.add(pairKey(findWithParity(lane.leftBoundaryId).root, findWithParity(lane.rightBoundaryId).root));
+        }
+        lanesByRoot.set(fa.root, target);
+        lanesByRoot.delete(fb.root);
+    }
+    if (merges === 0)
+        return;
+    // 3. Apply: every boundary resolves to its root linestring; a reversed
+    //    parity flips the lane's invert flag for that boundary.
+    const replaced = new Map();
+    for (const entry of entries) {
+        const id = entry.ls.id;
+        const f = findWithParity(id);
+        if (f.root !== id)
+            replaced.set(id, { keepId: f.root, reversed: f.parity === 1 });
+    }
+    for (const lane of result.lanes) {
+        const left = replaced.get(lane.leftBoundaryId);
+        if (left) {
+            lane.leftBoundaryId = left.keepId;
+            if (left.reversed)
+                lane.invertLeft = !lane.invertLeft;
+        }
+        const right = replaced.get(lane.rightBoundaryId);
+        if (right) {
+            lane.rightBoundaryId = right.keepId;
+            if (right.reversed)
+                lane.invertRight = !lane.invertRight;
+        }
+    }
+    result.linestrings = result.linestrings.filter(ls => !replaced.has(ls.id));
+}
+/**
+ * Position-dependent dedupe tolerance (px): the interior tolerance over the
+ * middle half of the polyline, tapering up to the end tolerance at t=0 / t=1.
+ */
+function dedupeTolAt(t) {
+    const interior = BOUNDARY_DEDUPE_INTERIOR_TOL_M * PIXELS_PER_METER;
+    const end = BOUNDARY_DEDUPE_END_TOL_M * PIXELS_PER_METER;
+    // 0 for t in [0.25, 0.75], rising linearly to 1 at t = 0 / t = 1.
+    const edge = Math.max(0, Math.abs(t - 0.5) * 2 - 0.5) / 0.5;
+    return interior + (end - interior) * edge;
+}
+/**
+ * Score how well two boundary polylines trace the same line. Each polyline
+ * is resampled by normalized arc length and the distance from every sample
+ * to the OTHER polyline (nearest point on any segment) is taken, normalized
+ * by the graded tolerance; the worst ratio over both directions is the score
+ * (<= 1 means a match). Nearest-point distance is used instead of comparing
+ * param-matched samples because differing vertex distributions of the same
+ * curve cause longitudinal slip that is not a geometric deviation.
+ * The relative orientation is decided by the endpoint pairing, which also
+ * acts as a cheap pre-filter. Returns null for no match.
+ */
+function boundaryMatchScore(a, b) {
+    const d = (p, q) => Math.hypot(p.x - q.x, p.y - q.y);
+    const endTolPx = BOUNDARY_DEDUPE_END_TOL_M * PIXELS_PER_METER;
+    const a0 = a[0];
+    const a1 = a[a.length - 1];
+    const b0 = b[0];
+    const b1 = b[b.length - 1];
+    const forwardEnds = Math.max(d(a0, b0), d(a1, b1));
+    const reversedEnds = Math.max(d(a0, b1), d(a1, b0));
+    if (Math.min(forwardEnds, reversedEnds) > endTolPx)
+        return null;
+    const score = Math.max(polylineDeviationScore(a, b), polylineDeviationScore(b, a));
+    if (score > 1)
+        return null;
+    return { reversed: reversedEnds < forwardEnds, score };
+}
+/**
+ * Worst nearest-point distance from arc-length resampled points of `a` to
+ * the polyline `b`, normalized by the graded tolerance (1 = at tolerance).
+ */
+function polylineDeviationScore(a, b) {
+    const n = Math.max(a.length, 8);
+    let worst = 0;
+    for (let i = 0; i < n; i++) {
+        const t = i / (n - 1);
+        const pa = sampleAtParam(a, t);
+        const score = distanceToPolyline(pa, b) / dedupeTolAt(t);
+        if (score > worst) {
+            worst = score;
+            if (worst > 1)
+                return worst;
+        }
+    }
+    return worst;
+}
+/** Distance from a point to the nearest segment of a polyline. */
+function distanceToPolyline(q, poly) {
+    let best = Infinity;
+    for (let i = 0; i < poly.length - 1; i++) {
+        const ax = poly[i].x;
+        const ay = poly[i].y;
+        const dx = poly[i + 1].x - ax;
+        const dy = poly[i + 1].y - ay;
+        const len2 = dx * dx + dy * dy;
+        let t = len2 > 0 ? ((q.x - ax) * dx + (q.y - ay) * dy) / len2 : 0;
+        if (t < 0)
+            t = 0;
+        else if (t > 1)
+            t = 1;
+        const px = ax + dx * t;
+        const py = ay + dy * t;
+        const dist = Math.hypot(q.x - px, q.y - py);
+        if (dist < best)
+            best = dist;
+    }
+    return best;
+}
+/**
+ * Weld the boundary endpoint Points of lanes joined by a next/prev edge into
+ * shared Point shapes (union-find; the cluster centroid is the welded
+ * position). Lane-section chains and road links meet exactly; junction
+ * connections can differ on the outer corner of a turn, which is exactly the
+ * corner a Lanelet2-style map shares between consecutive lanelets.
+ *
+ * Welds are derived ONLY from declared edges, and each weld joins a lane's
+ * end to its successor's start; a lane's own start and end are never merged,
+ * so short connecting lanes survive unchanged.
+ */
+function weldConnectedLaneContacts(result) {
+    const maxGapPx = CONTACT_WELD_MAX_GAP_M * PIXELS_PER_METER;
+    const pointById = new Map(result.points.map(p => [p.id, p]));
+    const lsById = new Map(result.linestrings.map(l => [l.id, l]));
+    const laneById = new Map(result.lanes.map(l => [l.id, l]));
+    const parent = new Map();
+    const find = (x) => {
+        let root = x;
+        while (true) {
+            const p = parent.get(root);
+            if (p === undefined || p === root)
+                break;
+            root = p;
+        }
+        let cur = x;
+        while (cur !== root) {
+            const next = parent.get(cur);
+            parent.set(cur, root);
+            cur = next;
+        }
+        return root;
+    };
+    const union = (a, b) => {
+        if (!parent.has(a))
+            parent.set(a, a);
+        if (!parent.has(b))
+            parent.set(b, b);
+        const ra = find(a);
+        const rb = find(b);
+        if (ra !== rb)
+            parent.set(rb, ra);
+    };
+    /** Boundary endpoint Point id at the lane's travel start/end. */
+    const corner = (lane, boundary, side) => {
+        const ls = lsById.get(boundary === 'left' ? lane.leftBoundaryId : lane.rightBoundaryId);
+        if (!ls || ls.pointIds.length === 0)
+            return null;
+        const invert = boundary === 'left' ? lane.invertLeft : lane.invertRight;
+        const ids = ls.pointIds;
+        const atStoredStart = side === 'start' ? !invert : invert;
+        return atStoredStart ? ids[0] : ids[ids.length - 1];
+    };
+    const gap = (aId, bId) => {
+        const a = pointById.get(aId);
+        const b = pointById.get(bId);
+        if (!a || !b)
+            return Infinity;
+        return Math.hypot(a.x - b.x, a.y - b.y);
+    };
+    let welds = 0;
+    for (const lane of result.lanes) {
+        for (const nextId of lane.next) {
+            const next = laneById.get(nextId);
+            if (!next)
+                continue;
+            const aL = corner(lane, 'left', 'end');
+            const aR = corner(lane, 'right', 'end');
+            const bL = corner(next, 'left', 'start');
+            const bR = corner(next, 'right', 'start');
+            if (!aL || !aR || !bL || !bR)
+                continue;
+            if (gap(aL, bL) > maxGapPx || gap(aR, bR) > maxGapPx)
+                continue;
+            union(aL, bL);
+            union(aR, bR);
+            welds++;
+        }
+    }
+    if (welds === 0)
+        return;
+    // Cluster centroid becomes the welded position (representative value).
+    const clusters = new Map();
+    for (const id of parent.keys()) {
+        const root = find(id);
+        const list = clusters.get(root) ?? [];
+        list.push(id);
+        clusters.set(root, list);
+    }
+    for (const [root, members] of clusters) {
+        if (members.length < 2)
+            continue;
+        let sx = 0;
+        let sy = 0;
+        let n = 0;
+        for (const m of members) {
+            const p = pointById.get(m);
+            if (!p)
+                continue;
+            sx += p.x;
+            sy += p.y;
+            n++;
+        }
+        const rp = pointById.get(root);
+        if (!rp || n === 0)
+            continue;
+        rp.x = sx / n;
+        rp.y = sy / n;
+    }
+    // Rewrite linestring point references to the cluster roots and refresh the
+    // anchor coordinates (linestrings anchor on their first point).
+    for (const ls of result.linestrings) {
+        let changed = false;
+        const ids = ls.pointIds.map(id => {
+            if (!parent.has(id))
+                return id;
+            const root = find(id);
+            if (root !== id)
+                changed = true;
+            return root;
+        });
+        if (changed)
+            ls.pointIds = ids;
+        const first = pointById.get(ls.pointIds[0]);
+        if (first) {
+            ls.x = first.x;
+            ls.y = first.y;
+        }
+    }
+    for (const lane of result.lanes) {
+        const ls = lsById.get(lane.leftBoundaryId);
+        if (ls) {
+            lane.x = ls.x;
+            lane.y = ls.y;
+        }
+    }
+}
+/** Drop Point records no longer referenced by any linestring. */
+function removeOrphanPoints(result) {
+    const used = new Set();
+    for (const ls of result.linestrings) {
+        for (const pid of ls.pointIds)
+            used.add(pid);
+    }
+    if (used.size === result.points.length)
+        return;
+    result.points = result.points.filter(p => used.has(p.id));
+}
+//# sourceMappingURL=odrToShapes.js.map