roadgraph-router-v2 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,8 +1,12 @@
 import {
+  ConditionKind,
+  MAX_STORED_VALUES,
   ProfileId,
   RouterError,
   VarintReader,
   VarintWriter,
+  accessAtTime,
+  accessAvoiding,
   accessForVehicle,
   accessMaskFor,
   allowsEverything,
@@ -12,7 +16,14 @@ import {
   combineProfiledGraph,
   componentSizes,
   componentsFor,
+  conditionHolds,
+  conditionalDurations,
+  conditionalValue,
+  conditionsOf,
+  conditionsOnEdge,
+  countAvoided,
   countBlocked,
+  countClosedAt,
   createEdgeSpatialIndex,
   createSpatialIndex,
   decodeGraph,
@@ -36,9 +47,12 @@ import {
   maxSpeedMpsFor,
   motorcycleRoutingProfile,
   nearbyEdgeIds,
+  packEdgeConditions,
   packEdgeLimits,
   packTurnRestrictions,
   packTurnSequences,
+  parseConditional,
+  parseEdgeConditions,
   parseLengthMeters,
   parseMaxSpeedKph,
   parseWeightTonnes,
@@ -50,11 +64,14 @@ import {
   straightLineAtMost,
   toDecimetres,
   toHalfTonnes,
+  touchesArea,
+  travelTimeFrom,
   truckRoutingProfile,
+  unreadableConditions,
   unzigzag,
   withSpatialIndex,
   zigzag
-} from "./chunk-PXL65P3L.js";
+} from "./chunk-QSIKDM4A.js";
 
 // src/compact.ts
 function scaleFor(values, maximum) {
@@ -107,6 +124,104 @@ function compactGraph(graph, options = {}) {
   };
 }
 
+// src/alternatives.ts
+var DEFAULT_MAX_STRETCH = 1.4;
+var DEFAULTS = { count: 3, maxStretch: DEFAULT_MAX_STRETCH, maxSharing: 0.75, penaltyFactor: 2 };
+var MOST_ROUTES = 10;
+function checkAlternativeOptions(options) {
+  const whole = (name, value) => {
+    if (!Number.isInteger(value)) throw new RangeError(`routeAlternatives: ${name} must be a whole number, not ${value}.`);
+  };
+  const finite = (name, value, least, most) => {
+    if (!Number.isFinite(value) || value < least || value > most) {
+      throw new RangeError(`routeAlternatives: ${name} must be between ${least} and ${most}, not ${value}.`);
+    }
+  };
+  if (options.count !== void 0) {
+    whole("count", options.count);
+    finite("count", options.count, 1, MOST_ROUTES);
+  }
+  if (options.maxStretch !== void 0) finite("maxStretch", options.maxStretch, 1, Number.MAX_SAFE_INTEGER);
+  if (options.maxSharing !== void 0) finite("maxSharing", options.maxSharing, 0, 1);
+  if (options.penaltyFactor !== void 0) finite("penaltyFactor", options.penaltyFactor, 1, Number.MAX_SAFE_INTEGER);
+}
+var costOfRoute = (result, preference) => preference === "fastest" ? result.durationSeconds : result.distanceMeters;
+function roadOf(graph, edge) {
+  const source = edgeSource(graph, edge);
+  const target = graph.edgeTargets[edge];
+  const ends = source < target ? `${source}:${target}` : `${target}:${source}`;
+  const polyline = edgePolyline(graph, edge, source);
+  const points = source < target ? polyline : [...polyline].reverse();
+  const scale = graph.coordinateScale ?? 1e7;
+  let first = 2166136261;
+  let second = 16777619;
+  for (const point of points) {
+    for (const value of [Math.round(point.lat * scale), Math.round(point.lng * scale)]) {
+      first = Math.imul(first ^ value & 65535, 16777619) >>> 0;
+      first = Math.imul(first ^ value >>> 16, 16777619) >>> 0;
+      second = Math.imul(second ^ value & 65535, 2246822507) >>> 0;
+      second = Math.imul(second ^ value >>> 16, 3266489909) >>> 0;
+    }
+  }
+  return `${ends}:${first.toString(36)}${second.toString(36)}`;
+}
+function roadsOf(graph, route2) {
+  const roads = /* @__PURE__ */ new Set();
+  for (const edge of route2.edgeIds) roads.add(roadOf(graph, edge));
+  for (const snap of [route2.originSnap, route2.destinationSnap]) {
+    if (snap.edge >= 0) roads.add(roadOf(graph, snap.edge));
+  }
+  return roads;
+}
+function sharedFraction(graph, candidate, used) {
+  const scale = graph.edgeDistanceScale ?? 1;
+  let shared = 0;
+  let total = 0;
+  for (const edge of candidate.edgeIds) {
+    const length = graph.edgeDistancesMeters[edge] * scale;
+    total += length;
+    if (used.has(roadOf(graph, edge))) shared += length;
+  }
+  for (const snap of [candidate.originSnap, candidate.destinationSnap]) {
+    if (snap.edge < 0) continue;
+    const travelled = snap.travelledMeters ?? 0;
+    total += travelled;
+    if (used.has(roadOf(graph, snap.edge))) shared += travelled;
+  }
+  return total > 0 ? shared / total : 1;
+}
+function routeAlternatives(graph, from, to, preference = "fastest", options = {}) {
+  checkAlternativeOptions(options);
+  const { count, maxStretch, maxSharing, penaltyFactor } = { ...DEFAULTS, ...options };
+  const best = route(graph, from, to, preference, options);
+  if (count <= 1) return [best];
+  const chosen = [best];
+  const ceiling = costOfRoute(best, preference) * maxStretch;
+  const used = roadsOf(graph, best);
+  const penalties = /* @__PURE__ */ new Map();
+  const penalise = (edges) => {
+    for (const edge of edges) penalties.set(edge, (penalties.get(edge) ?? 1) * penaltyFactor);
+  };
+  penalise(best.edgeIds);
+  const attempts = (count - 1) * 3;
+  for (let attempt = 0; attempt < attempts && chosen.length < count; attempt += 1) {
+    let candidate;
+    try {
+      candidate = route(graph, from, to, preference, { ...options, costPenalties: penalties });
+    } catch (error) {
+      if (error instanceof RouterError && error.code === "NO_ROUTE") break;
+      throw error;
+    }
+    penalise(candidate.edgeIds);
+    if (costOfRoute(candidate, preference) > ceiling) continue;
+    if (sharedFraction(graph, candidate, used) > maxSharing) continue;
+    chosen.push(candidate);
+    for (const road of roadsOf(graph, candidate)) used.add(road);
+  }
+  const rest = chosen.slice(1).sort((left, right) => costOfRoute(left, preference) - costOfRoute(right, preference));
+  return [best, ...rest];
+}
+
 // src/merge.ts
 var COORDINATE_SCALE = 1e7;
 var LENGTH_EPSILON_METERS = 0.01;
@@ -261,6 +376,8 @@ function mergeRoadGraphs(graphs) {
   const hasAccess = graphs.some((graph) => graph.edgeAccess);
   const mergedAccess = hasAccess ? accessMaskFor(edgeCount, () => true) : void 0;
   const limitRows = /* @__PURE__ */ new Map();
+  const conditionRows = [];
+  const seenConditions = /* @__PURE__ */ new Set();
   for (let index = 0; index < graphs.length; index += 1) {
     const graph = graphs[index];
     const edgeMap = edgeMaps[index];
@@ -286,6 +403,18 @@ function mergeRoadGraphs(graphs) {
         limitRows.set(merged, existing);
       }
     }
+    const conditions = graph.edgeConditions;
+    if (conditions) {
+      for (let row = 0; row < conditions.edges.length; row += 1) {
+        const merged = rebase(conditions.edges[row]);
+        if (merged < 0) continue;
+        const value = conditions.values[conditions.rules[row]];
+        const key = `${merged}:${conditions.kinds[row]}:${value}`;
+        if (seenConditions.has(key)) continue;
+        seenConditions.add(key);
+        conditionRows.push({ edge: merged, kind: conditions.kinds[row], value });
+      }
+    }
     const { turnRestrictionFromEdges: fromEdges, turnRestrictionToEdges: toEdges } = graph;
     if (fromEdges && toEdges) {
       for (let pair = 0; pair < fromEdges.length; pair += 1) {
@@ -307,6 +436,7 @@ function mergeRoadGraphs(graphs) {
     }
   }
   const mergedLimits = packEdgeLimits([...limitRows].map(([edge, limits]) => ({ edge, limits })));
+  const mergedConditions = packEdgeConditions(conditionRows);
   return withSpatialIndex({
     nodeLatitudes: mergedLatitudes.slice(0, nodeCount),
     nodeLongitudes: mergedLongitudes.slice(0, nodeCount),
@@ -319,6 +449,7 @@ function mergeRoadGraphs(graphs) {
     ...graphs[0].maxSpeedKph ? { maxSpeedKph: graphs[0].maxSpeedKph } : {},
     ...mergedAccess ? { edgeAccess: mergedAccess } : {},
     ...mergedLimits ? { edgeLimits: mergedLimits } : {},
+    ...mergedConditions ? { edgeConditions: mergedConditions } : {},
     ...pointCount ? { edgeShapeOffsets, edgeShapeLatitudes, edgeShapeLongitudes } : {},
     ...bannedPairs.length ? packTurnRestrictions(bannedPairs) : {},
     ...bannedSequences.length ? packTurnSequences(bannedSequences) : {}
@@ -830,10 +961,15 @@ var RoadRouter = class _RoadRouter {
     }
     return new _RoadRouter(void 0, this.loader, this.options, wanted.id, this.bundleVehicle);
   }
-  async route(from, to, preference = "fastest") {
-    if (this.graph) return route(this.graph, from, to, preference, { vehicle: this.vehicle });
-    if (isBundle(this.loader)) return this.routeOverBundle(this.loader, from, to, preference);
-    return this.routeOverLoader(this.loader, from, to, preference);
+  /**
+   * `when` says when the journey starts, so conditional restrictions apply.
+   * Leaving it out ignores them, which is how this library behaved before it
+   * could read them.
+   */
+  async route(from, to, preference = "fastest", when = {}) {
+    if (this.graph) return route(this.graph, from, to, preference, { vehicle: this.vehicle, ...when });
+    if (isBundle(this.loader)) return this.routeOverBundle(this.loader, from, to, preference, when);
+    return this.routeOverLoader(this.loader, from, to, preference, when);
   }
   /**
    * Downloads a corridor, routes, then asks whether any tile left out could
@@ -844,7 +980,39 @@ var RoadRouter = class _RoadRouter {
    * graph contains. Because the test measures ground distance rather than
    * counting neighbours, the answer does not depend on the tile size.
    */
-  async routeOverBundle(bundle, from, to, preference) {
+  /**
+   * Several ways there, best first, with up to `count - 1` alternatives after
+   * it. Fewer than asked for means the network held nothing else worth
+   * offering, which is the usual answer where there is one obvious way.
+   *
+   * Over a bundle this downloads a wider corridor than a single route needs:
+   * an alternative may be worse than the best by as much as `maxStretch`, and
+   * the tiles holding it lie outside the corridor that proved the best route.
+   */
+  async routeAlternatives(from, to, preference = "fastest", options = {}) {
+    checkAlternativeOptions(options);
+    const withVehicle = { vehicle: this.vehicle, ...options };
+    if (this.graph) return routeAlternatives(this.graph, from, to, preference, withVehicle);
+    if (isBundle(this.loader)) {
+      const { best, graphNow, widen, reachFor } = await this.bestOverBundle(this.loader, from, to, preference, options);
+      if (options.count !== void 0 && options.count <= 1) return [best];
+      if (options.searchWiderCorridor === false) return routeAlternatives(graphNow(), from, to, preference, withVehicle);
+      await widen(reachFor(best) * (options.maxStretch ?? DEFAULT_MAX_STRETCH));
+      return routeAlternatives(graphNow(), from, to, preference, withVehicle);
+    }
+    const loader = this.loader;
+    return routeAlternatives(await loader.loadForRoute(from, to), from, to, preference, withVehicle);
+  }
+  async routeOverBundle(bundle, from, to, preference, when = {}) {
+    return (await this.bestOverBundle(bundle, from, to, preference, when)).best;
+  }
+  /**
+   * The same corridor walk, stopping with the graph it settled on as well as
+   * the route. Alternatives need the graph, and need to be able to widen it
+   * once more: a second route may be worse than the best by more than the
+   * corridor was ever sized to hold.
+   */
+  async bestOverBundle(bundle, from, to, preference, when = {}) {
     const straightLine = haversineMeters2(from, to);
     const ceiling = straightLine * (this.options.maxDetourFactor ?? Infinity);
     const selected = this.profileId ?? bundle.profileId;
@@ -867,7 +1035,7 @@ var RoadRouter = class _RoadRouter {
     for (const factor of [1, ...SEARCH_WIDENING_FACTORS]) {
       if (factor !== 1 && !await widen(factor === Infinity ? Infinity : budget * factor)) break;
       try {
-        best = route(graph, from, to, preference, { vehicle: this.vehicle });
+        best = route(graph, from, to, preference, { vehicle: this.vehicle, ...when });
         break;
       } catch (error) {
         failure = error;
@@ -876,29 +1044,31 @@ var RoadRouter = class _RoadRouter {
     }
     if (!best) throw failure ?? new RouterError("NO_ROUTE", "No route connects the selected points.");
     for (let pass = 0; pass < MAX_CONFIRMATION_PASSES; pass += 1) {
-      if (!await widen(reachFor(best))) return best;
+      if (!await widen(reachFor(best))) return { best, graphNow: () => graph, widen, reachFor };
       try {
-        best = route(graph, from, to, preference, { costBound: preference === "fastest" ? best.durationSeconds : best.distanceMeters, vehicle: this.vehicle });
+        best = route(graph, from, to, preference, { costBound: preference === "fastest" ? best.durationSeconds : best.distanceMeters, vehicle: this.vehicle, ...when });
       } catch (error) {
         if (error.code !== "NO_ROUTE") throw error;
-        return best;
+        return { best, graphNow: () => graph, widen, reachFor };
       }
     }
-    return best;
+    return { best, graphNow: () => graph, widen, reachFor };
   }
-  async routeOverLoader(loader, from, to, preference) {
+  async routeOverLoader(loader, from, to, preference, when = {}) {
     const graph = await loader.loadForRoute(from, to);
     try {
-      return route(graph, from, to, preference, { vehicle: this.vehicle });
+      return route(graph, from, to, preference, { vehicle: this.vehicle, ...when });
     } catch (error) {
       if (!(error instanceof Error) || error.code !== "NO_ROUTE" || !loader.loadExpandedForRoute) throw error;
-      return route(await loader.loadExpandedForRoute(from, to), from, to, preference, { vehicle: this.vehicle });
+      return route(await loader.loadExpandedForRoute(from, to), from, to, preference, { vehicle: this.vehicle, ...when });
     }
   }
 };
 export {
   BundleCompression,
+  ConditionKind,
   DEFAULT_VEHICLE_PRESET,
+  MAX_STORED_VALUES,
   ProfileId,
   RoadRouter,
   RouterError,
@@ -906,17 +1076,27 @@ export {
   VarintReader,
   VarintWriter,
   VehiclePresetId,
+  accessAtTime,
+  accessAvoiding,
   accessForVehicle,
   accessMaskFor,
   allowsEverything,
   buildTurnRestrictionIndex,
   buildTurnSequenceIndex,
   carRoutingProfile,
+  checkAlternativeOptions,
   combineProfiledGraph,
   compactGraph,
   componentSizes,
   componentsFor,
+  conditionHolds,
+  conditionalDurations,
+  conditionalValue,
+  conditionsOf,
+  conditionsOnEdge,
+  countAvoided,
   countBlocked,
+  countClosedAt,
   createEdgeSpatialIndex,
   createRouteGraphLoader,
   createSpatialIndex,
@@ -947,22 +1127,29 @@ export {
   motorcycleRoutingProfile,
   nearbyEdgeIds,
   openRoadGraphBundle,
+  packEdgeConditions,
   packEdgeLimits,
   packTurnRestrictions,
   packTurnSequences,
+  parseConditional,
+  parseEdgeConditions,
   parseLengthMeters,
   parseMaxSpeedKph,
   parseWeightTonnes,
   profileOf,
   resolveVehicle,
   route,
+  routeAlternatives,
   routingProfiles,
   searchBoundsFor,
   snapToGraph,
   straightLineAtMost,
   toDecimetres,
   toHalfTonnes,
+  touchesArea,
+  travelTimeFrom,
   truckRoutingProfile,
+  unreadableConditions,
   unzigzag,
   vehiclePreset,
   vehiclePresetName,

package/dist/worker.js

@@ -1,7 +1,7 @@
 import {
   decodeGraph,
   route
-} from "./chunk-PXL65P3L.js";
+} from "./chunk-QSIKDM4A.js";
 
 // src/worker.ts
 var graph = null;
@@ -13,7 +13,7 @@ self.onmessage = ({ data }) => {
       return;
     }
     if (!graph) throw new Error("Load a routing graph before requesting a route.");
-    self.postMessage({ id: data.id, ok: true, route: route(graph, data.from, data.to, data.preference) });
+    self.postMessage({ id: data.id, ok: true, route: route(graph, data.from, data.to, data.preference, { departAt: data.departAt, publicHoliday: data.publicHoliday }) });
   } catch (error) {
     self.postMessage({ id: data.id, ok: false, error: error instanceof Error ? error.message : "Routing failed" });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roadgraph-router-v2",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Compile any OpenStreetMap PBF extract into compact, range-addressable routing bundles and route over them with A* in Node.js or the browser.",
   "private": false,
   "type": "module",

package/scripts/roadgraph-compile.mjs

@@ -87,6 +87,7 @@ function createTileGraph(tile, profileCount) {
     edgeUsable: perProfile(() => new Column(Uint8Array)),
     // Sparse: almost no road states a height or a weight.
     edgeLimits: perProfile(() => new Map()),
+    edgeConditions: perProfile(() => []),
     restrictions: perProfile(() => []),
     runs: perProfile(() => []),
   };
@@ -218,10 +219,20 @@ function encodeEfr2(graph, library, profiles) {
   };
 
   const split = profiles.length > 1 || profiles.some((entry) => entry.usesPhysicalLimits);
-  if (!split) return { shared: library.encodeCompactGraph(assembled), profiles: [], limitedEdges: 0 };
+  if (!split) {
+    // One vehicle writes one chunk, and that chunk is its whole graph, so the
+    // conditional restrictions belong in it. Without this a bundle compiled
+    // for a single vehicle would read as though no road were ever shut.
+    const onlyConditions = library.packEdgeConditions(
+      graph.edgeConditions[0].map((row) => ({ ...row, edge: placement[row.edge] })),
+    );
+    const encoded = library.encodeCompactGraph(onlyConditions ? { ...assembled, edgeConditions: onlyConditions } : assembled);
+    return { shared: encoded, profiles: [], limitedEdges: 0, conditionalEdges: onlyConditions?.edges.length ?? 0 };
+  }
 
   const restrictionCount = banned.length + runs.length;
   let limitedEdges = 0;
+  let conditionalEdges = 0;
   const chunks = profiles.map((entry, profileIndex) => {
     const usable = graph.edgeUsable[profileIndex].view();
     // `placement` maps a built edge to its stored position, so the mask is
@@ -233,6 +244,10 @@ function encodeEfr2(graph, library, profiles) {
     for (const [edge, limits] of graph.edgeLimits[profileIndex]) entries.push({ edge: placement[edge], limits });
     const edgeLimits = library.packEdgeLimits(entries);
     limitedEdges += edgeLimits?.edges.length ?? 0;
+    const edgeConditions = library.packEdgeConditions(
+      graph.edgeConditions[profileIndex].map((row) => ({ ...row, edge: placement[row.edge] })),
+    );
+    conditionalEdges += edgeConditions?.edges.length ?? 0;
     const restrictionMask = library.accessMaskFor(restrictionCount, (index) => index < banned.length
       ? pairOwners[pairOrder[index]].has(profileIndex)
       : runOwners[runOrder[index - banned.length]].has(profileIndex));
@@ -242,11 +257,12 @@ function encodeEfr2(graph, library, profiles) {
       edgeDurationScale: durationScales[profileIndex],
       edgeDurationsSeconds: durationColumns[profileIndex],
       edgeAccess,
+      ...(edgeConditions ? { edgeConditions } : {}),
       ...(edgeLimits ? { edgeLimits } : {}),
       ...(restrictionCount ? { restrictionCount, restrictionMask } : {}),
     });
   });
-  return { shared: library.encodeSharedGraph(assembled), profiles: chunks, limitedEdges };
+  return { shared: library.encodeSharedGraph(assembled), profiles: chunks, limitedEdges, conditionalEdges };
 }
 
 /** Writes the fixed-size directory, then streams each chunk straight from the
@@ -314,7 +330,7 @@ function memoryGuard(limitBytes, label, count) { if (count % 1_000 !== 0) return
 async function firstPass(file, roadFile, limitBytes, profiles) {
   const required = approximateIds(), keeperNodes = approximateIds(), stream = createWriteStream(roadFile), bounds = { minLat: Infinity, minLon: Infinity, maxLat: -Infinity, maxLon: -Infinity };
   const restrictions = [], restrictionWays = new Set(), barriers = [];
-  let ways = 0, entities = 0, skippedRestrictions = 0, barrierCount = 0;
+  let ways = 0, entities = 0, skippedRestrictions = 0, barrierCount = 0, conditionalRestrictions = 0;
   // One pass serves every vehicle: the reader is asked for the union of the
   // tags they read, and each way is offered to all of them.
   const wayTags = [...new Set(profiles.flatMap((entry) => entry.wayTagKeys))];
@@ -347,6 +363,10 @@ async function firstPass(file, roadFile, limitBytes, profiles) {
       const perProfile = profiles.map((entry) => entry.evaluateTurnRestriction(entity.tags ?? {}));
       const parsed = perProfile.find(Boolean) ?? null;
       if (!parsed) continue;
+      // A turn banned only at certain hours is banned at every hour here.
+      // Counting them says how much of a region that costs rather than
+      // leaving it to be discovered: in Portugal it is 1 relation in 26,599.
+      if (Object.keys(entity.tags ?? {}).some((key) => key.endsWith(":conditional"))) conditionalRestrictions += 1;
       const members = entity.members ?? [];
       const from = members.find((member) => member.role === "from" && member.type === "way");
       const to = members.find((member) => member.role === "to" && member.type === "way");
@@ -378,8 +398,8 @@ async function firstPass(file, roadFile, limitBytes, profiles) {
     keeperNodes.add(refs[0]); keeperNodes.add(refs[refs.length - 1]);
     await write(stream, {
       id: entity.id, refs,
-      forward: lanes.map((lane) => lane?.forward ? { speed: lane.forwardSpeedKph, limits: lane.forwardLimits ?? null } : null),
-      reverse: lanes.map((lane) => lane?.backward ? { speed: lane.backwardSpeedKph, limits: lane.backwardLimits ?? null } : null),
+      forward: lanes.map((lane) => lane?.forward ? { speed: lane.forwardSpeedKph, limits: lane.forwardLimits ?? null, conditions: lane.conditions ?? null } : null),
+      reverse: lanes.map((lane) => lane?.backward ? { speed: lane.backwardSpeedKph, limits: lane.backwardLimits ?? null, conditions: lane.conditions ?? null } : null),
     });
   }
   await new Promise((resolve, reject) => stream.end((error) => error ? reject(error) : resolve()));
@@ -390,7 +410,7 @@ async function firstPass(file, roadFile, limitBytes, profiles) {
   // A barrier can only matter where a road passes through it, and the node
   // has to survive simplification for the ban to have edges to name.
   for (const blocked of barriers) { if (blocked) for (const id of blocked) if (required.has(id)) keeperNodes.add(id); }
-  return { required, keeperNodes, bounds, ways, restrictions: usable, restrictionWays, skippedRestrictions, barriers, barrierCount };
+  return { required, keeperNodes, bounds, ways, restrictions: usable, restrictionWays, skippedRestrictions, conditionalRestrictions, barriers, barrierCount };
 }
 
 async function secondPass(file, required, limitBytes, databasePath) {
@@ -522,6 +542,7 @@ async function build(roadFile, coordinates, topology, layout, bounds, tolerance,
         graph.edgeDurations[profileIndex].push(distance / (speed * (1000 / 3600)));
         graph.edgeUsable[profileIndex].push(lane ? 1 : 0);
         if (lane?.limits) graph.edgeLimits[profileIndex].set(index, lane.limits);
+        if (lane?.conditions) for (const condition of lane.conditions) graph.edgeConditions[profileIndex].push({ edge: index, ...condition });
       }
       graph.edgeWay.push(tracked ? wayId : 0);
       graph.edgeShapeStart.push(graph.shapeLat.length);
@@ -638,12 +659,14 @@ else {
     // so peak memory tracks the largest single tile rather than the region.
     const spillPath = resolve(workspace, "chunks.bin"), spill = createWriteStream(spillPath), chunks = [];
     let limitedEdges = 0;
+    let conditionalEdges = 0;
     for (let index = 0; index < built.graphs.length; index += 1) {
       const graph = built.graphs[index];
       const encoded = encodeEfr2(graph, library, profiles);
       // The shared half first, then each vehicle's: the reader needs a tile's
       // shared row before the rows that depend on it.
       limitedEdges += encoded.limitedEdges ?? 0;
+      conditionalEdges += encoded.conditionalEdges ?? 0;
       for (const [profileId, buffer] of [[0, encoded.shared], ...encoded.profiles.map((chunk, at) => [profiles[at].id, chunk])]) {
         const raw = new Uint8Array(buffer);
         const data = compression === "gzip" ? gzipSync(raw, { level: constants.Z_BEST_COMPRESSION }) : raw;
@@ -658,7 +681,7 @@ else {
     const bundleBytes = await writeBundle(output, chunks, compression, spillPath, profiles, split, defaultVehicle, library.VehiclePresetId);
     await verifyBundle(output, built.graphs.length);
     const nodesBefore = storedNodes, nodesAfter = built.routingNodes, edges = built.routingEdges, rawBytes = chunks.reduce((sum, chunk) => sum + chunk.rawBytes, 0);
-    const report = { formatVersion: 1, input: file, inputBytes: source.size, profile: profiles.map((entry) => entry.name).join(","), compression: `${compression}-per-tile`, tileSizeKm, paddingKm, pbfPasses: 2, tiles: built.graphs.length, relevantOsmWays: first.ways, relevantOsmNodes, relevantOsmNodesExact: false, routingNodesBeforeSimplification: nodesBefore, routingNodesAfterSimplification: nodesAfter, reductionPercent: Number((100 * (1 - nodesAfter / Math.max(1, nodesBefore))).toFixed(2)), routingEdges: edges, turnRestrictionsRead: first.restrictions.length, turnRestrictionsSkipped: first.skippedRestrictions, barriersRead: first.barrierCount, barrierBans: built.barrierBans, bannedTurnPairs: built.bannedTurns, bannedTurnRuns: built.bannedRuns, layout: split ? "shared-plus-profile" : "single-chunk", profiles: profiles.map((entry) => entry.name), defaultVehicle: defaultVehicle ?? null, edgesWithPhysicalLimits: limitedEdges, uncompressedGraphBytes: rawBytes, bundleBytes, compressionRatio: Number((bundleBytes / Math.max(1, rawBytes)).toFixed(4)), peakRssBytes: Math.max(observedPeakRss, process.memoryUsage().rss), elapsedMilliseconds: Math.round(performance.now() - started) };
+    const report = { formatVersion: 1, input: file, inputBytes: source.size, profile: profiles.map((entry) => entry.name).join(","), compression: `${compression}-per-tile`, tileSizeKm, paddingKm, pbfPasses: 2, tiles: built.graphs.length, relevantOsmWays: first.ways, relevantOsmNodes, relevantOsmNodesExact: false, routingNodesBeforeSimplification: nodesBefore, routingNodesAfterSimplification: nodesAfter, reductionPercent: Number((100 * (1 - nodesAfter / Math.max(1, nodesBefore))).toFixed(2)), routingEdges: edges, turnRestrictionsRead: first.restrictions.length, turnRestrictionsSkipped: first.skippedRestrictions, conditionalTurnRestrictionsIgnored: first.conditionalRestrictions, barriersRead: first.barrierCount, barrierBans: built.barrierBans, bannedTurnPairs: built.bannedTurns, bannedTurnRuns: built.bannedRuns, layout: split ? "shared-plus-profile" : "single-chunk", profiles: profiles.map((entry) => entry.name), defaultVehicle: defaultVehicle ?? null, edgesWithPhysicalLimits: limitedEdges, edgesWithConditionalRestrictions: conditionalEdges, uncompressedGraphBytes: rawBytes, bundleBytes, compressionRatio: Number((bundleBytes / Math.max(1, rawBytes)).toFixed(4)), peakRssBytes: Math.max(observedPeakRss, process.memoryUsage().rss), elapsedMilliseconds: Math.round(performance.now() - started) };
     await writeFile(`${output}.json`, `${JSON.stringify(report, null, 2)}\n`);
     console.table({ input_mb: (source.size / 1e6).toFixed(1), pbf_passes: report.pbfPasses, relevant_ways: first.ways.toLocaleString(), relevant_nodes: relevantOsmNodes.toLocaleString(), nodes_before: nodesBefore.toLocaleString(), nodes_after: nodesAfter.toLocaleString(), reduction_percent: report.reductionPercent, routing_edges: edges.toLocaleString(), turn_restrictions: first.restrictions.length.toLocaleString(), barriers: first.barrierCount.toLocaleString(), banned_turn_pairs: built.bannedTurns.toLocaleString(), banned_turn_runs: built.bannedRuns.toLocaleString(), tiles: built.graphs.length, raw_mb: (rawBytes / 1e6).toFixed(1), efrb_mb: (bundleBytes / 1e6).toFixed(1), compression_ratio: report.compressionRatio, peak_rss_mb: (report.peakRssBytes / 1e6).toFixed(1), elapsed_seconds: (report.elapsedMilliseconds / 1000).toFixed(1) });
   } catch (error) {