roadgraph-router-v2 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,32 +1,77 @@
 import {
+  ConditionKind,
+  MAX_STORED_VALUES,
+  ProfileId,
   RouterError,
   VarintReader,
   VarintWriter,
+  accessAtTime,
+  accessAvoiding,
+  accessForVehicle,
+  accessMaskFor,
+  allowsEverything,
   buildTurnRestrictionIndex,
   buildTurnSequenceIndex,
   carRoutingProfile,
+  combineProfiledGraph,
+  componentSizes,
+  componentsFor,
+  conditionHolds,
+  conditionalDurations,
+  conditionalValue,
+  conditionsOf,
+  conditionsOnEdge,
+  countAvoided,
+  countBlocked,
+  countClosedAt,
   createEdgeSpatialIndex,
   createSpatialIndex,
   decodeGraph,
+  decodeProfileChunk,
+  decodeSharedGraph,
+  edgeAllowed,
   edgePolyline,
   edgeSource,
   edgeSpatialIndexFor,
   encodeCompactGraph,
   encodeGraph,
+  encodeProfileChunk,
+  encodeSharedGraph,
   findNearestNode,
+  fromDecimetres,
+  fromHalfTonnes,
   getRoutingProfile,
+  getRoutingProfileById,
+  guardedJunctionsFor,
   isTurnBanned,
+  maxSpeedMpsFor,
+  motorcycleRoutingProfile,
   nearbyEdgeIds,
+  packEdgeConditions,
+  packEdgeLimits,
   packTurnRestrictions,
   packTurnSequences,
+  parseConditional,
+  parseEdgeConditions,
+  parseLengthMeters,
   parseMaxSpeedKph,
+  parseWeightTonnes,
+  profileOf,
   route,
   routingProfiles,
+  searchBoundsFor,
   snapToGraph,
+  straightLineAtMost,
+  toDecimetres,
+  toHalfTonnes,
+  touchesArea,
+  travelTimeFrom,
+  truckRoutingProfile,
+  unreadableConditions,
   unzigzag,
   withSpatialIndex,
   zigzag
-} from "./chunk-4FIOQAFG.js";
+} from "./chunk-QSIKDM4A.js";
 
 // src/compact.ts
 function scaleFor(values, maximum) {
@@ -54,7 +99,8 @@ function compactGraph(graph, options = {}) {
   const edgeDurationsSeconds = new Uint16Array(durations.length);
   for (let index = 0; index < distances.length; index += 1) {
     edgeDistancesMeters[index] = Math.round(distances[index] / edgeDistanceScale);
-    edgeDurationsSeconds[index] = Math.round(durations[index] / edgeDurationScale);
+    const quantised = Math.round(durations[index] / edgeDurationScale);
+    edgeDurationsSeconds[index] = quantised || (durations[index] > 0 || distances[index] > 0 ? 1 : 0);
   }
   const edgeShapeOffsets = graph.edgeShapeOffsets?.slice();
   const edgeShapeLatitudes = graph.edgeShapeLatitudes && Int32Array.from(graph.edgeShapeLatitudes, (value) => Math.round(value / inputCoordinateScale * coordinateScale));
@@ -69,12 +115,113 @@ function compactGraph(graph, options = {}) {
     coordinateScale,
     edgeDistanceScale,
     edgeDurationScale,
+    // Quantising the weights does not change which vehicle the graph is for.
+    ...graph.profileId ? { profileId: graph.profileId } : {},
+    ...graph.maxSpeedKph ? { maxSpeedKph: graph.maxSpeedKph } : {},
     ...edgeShapeOffsets && edgeShapeLatitudes && edgeShapeLongitudes ? { edgeShapeOffsets, edgeShapeLatitudes, edgeShapeLongitudes } : {},
     ...graph.turnRestrictionFromEdges && graph.turnRestrictionToEdges ? { turnRestrictionFromEdges: graph.turnRestrictionFromEdges.slice(), turnRestrictionToEdges: graph.turnRestrictionToEdges.slice() } : {},
     ...graph.turnRestrictionSequenceOffsets && graph.turnRestrictionSequenceEdges ? { turnRestrictionSequenceOffsets: graph.turnRestrictionSequenceOffsets.slice(), turnRestrictionSequenceEdges: graph.turnRestrictionSequenceEdges.slice() } : {}
   };
 }
 
+// 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;
@@ -84,24 +231,52 @@ function nodeKey(latitude, longitude) {
 function mergeRoadGraphs(graphs) {
   if (!graphs.length) throw new Error("At least one road graph is required.");
   if (graphs.length === 1) return graphs[0];
+  const profileId = graphs[0].profileId;
+  for (const graph of graphs) {
+    if (graph.profileId !== profileId) throw new Error("Cannot merge road graphs compiled for different routing profiles.");
+  }
+  const scale = graphs[0].coordinateScale ?? 1;
+  const uniformScale = graphs.every((graph) => (graph.coordinateScale ?? 1) === scale);
+  let minLatitude = Infinity;
+  let minLongitude = Infinity;
+  let span = Infinity;
+  if (uniformScale) {
+    let maxLatitude = -Infinity;
+    let maxLongitude = -Infinity;
+    for (const graph of graphs) {
+      for (let index = 0; index < graph.nodeLatitudes.length; index += 1) {
+        const latitude = graph.nodeLatitudes[index];
+        const longitude = graph.nodeLongitudes[index];
+        if (latitude < minLatitude) minLatitude = latitude;
+        if (latitude > maxLatitude) maxLatitude = latitude;
+        if (longitude < minLongitude) minLongitude = longitude;
+        if (longitude > maxLongitude) maxLongitude = longitude;
+      }
+    }
+    span = maxLongitude - minLongitude + 1;
+    if ((maxLatitude - minLatitude + 1) * span > Number.MAX_SAFE_INTEGER) span = Infinity;
+  }
+  const packed = Number.isFinite(span);
+  const totalNodes = graphs.reduce((sum, graph) => sum + graph.nodeLatitudes.length, 0);
+  const mergedLatitudes = new Int32Array(totalNodes);
+  const mergedLongitudes = new Int32Array(totalNodes);
+  let nodeCount = 0;
   const nodeIds = /* @__PURE__ */ new Map();
-  const latitudes = [];
-  const longitudes = [];
   const nodeMaps = [];
   let candidateEdges = 0;
   for (const graph of graphs) {
-    const coordinateScale = graph.coordinateScale ?? 1;
+    const graphScale = graph.coordinateScale ?? 1;
     const nodeMap = new Uint32Array(graph.nodeLatitudes.length);
     for (let index = 0; index < graph.nodeLatitudes.length; index += 1) {
-      const lat = graph.nodeLatitudes[index] / coordinateScale;
-      const lng = graph.nodeLongitudes[index] / coordinateScale;
-      const key = nodeKey(lat, lng);
+      const rawLatitude = graph.nodeLatitudes[index];
+      const rawLongitude = graph.nodeLongitudes[index];
+      const key = packed ? (rawLatitude - minLatitude) * span + (rawLongitude - minLongitude) : nodeKey(rawLatitude / graphScale, rawLongitude / graphScale);
       let mergedIndex = nodeIds.get(key);
       if (mergedIndex === void 0) {
-        mergedIndex = latitudes.length;
+        mergedIndex = nodeCount++;
         nodeIds.set(key, mergedIndex);
-        latitudes.push(lat);
-        longitudes.push(lng);
+        mergedLatitudes[mergedIndex] = graphScale === COORDINATE_SCALE ? rawLatitude : Math.round(rawLatitude / graphScale * COORDINATE_SCALE);
+        mergedLongitudes[mergedIndex] = graphScale === COORDINATE_SCALE ? rawLongitude : Math.round(rawLongitude / graphScale * COORDINATE_SCALE);
       }
       nodeMap[index] = mergedIndex;
     }
@@ -109,7 +284,6 @@ function mergeRoadGraphs(graphs) {
     candidateEdges += graph.edgeTargets.length;
   }
   nodeIds.clear();
-  const nodeCount = latitudes.length;
   const slotStart = new Uint32Array(nodeCount + 1);
   for (let index = 0; index < graphs.length; index += 1) {
     const graph = graphs[index];
@@ -190,22 +364,61 @@ function mergeRoadGraphs(graphs) {
   for (let edge = 0; edge < edgeCount; edge += 1) {
     const graph = graphs[sourceGraph[edge]];
     if (!graph.edgeShapeOffsets || !graph.edgeShapeLatitudes || !graph.edgeShapeLongitudes) continue;
-    const scale = graph.coordinateScale ?? 1;
+    const scale2 = graph.coordinateScale ?? 1;
     let target = edgeShapeOffsets[edge];
     for (let point = graph.edgeShapeOffsets[sourceEdge[edge]]; point < graph.edgeShapeOffsets[sourceEdge[edge] + 1]; point += 1, target += 1) {
-      edgeShapeLatitudes[target] = Math.round(graph.edgeShapeLatitudes[point] / scale * COORDINATE_SCALE);
-      edgeShapeLongitudes[target] = Math.round(graph.edgeShapeLongitudes[point] / scale * COORDINATE_SCALE);
+      edgeShapeLatitudes[target] = Math.round(graph.edgeShapeLatitudes[point] / scale2 * COORDINATE_SCALE);
+      edgeShapeLongitudes[target] = Math.round(graph.edgeShapeLongitudes[point] / scale2 * COORDINATE_SCALE);
     }
   }
   const bannedPairs = [];
   const bannedSequences = [];
+  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];
     const rebase = (edge) => slotToEdge[edgeMap[edge]];
+    if (mergedAccess) {
+      for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+        if (edgeAllowed(graph.edgeAccess, edge)) continue;
+        const merged = rebase(edge);
+        if (merged >= 0) mergedAccess[merged >> 3] &= ~(1 << (merged & 7));
+      }
+    }
+    const limits = graph.edgeLimits;
+    if (limits) {
+      for (let row = 0; row < limits.edges.length; row += 1) {
+        const merged = rebase(limits.edges[row]);
+        if (merged < 0) continue;
+        const existing = limitRows.get(merged) ?? {};
+        const stricter = (left, right) => left === void 0 ? right : Math.min(left, right);
+        if (limits.heightDecimetres[row]) existing.heightMeters = stricter(existing.heightMeters, fromDecimetres(limits.heightDecimetres[row]));
+        if (limits.widthDecimetres[row]) existing.widthMeters = stricter(existing.widthMeters, fromDecimetres(limits.widthDecimetres[row]));
+        if (limits.lengthDecimetres[row]) existing.lengthMeters = stricter(existing.lengthMeters, fromDecimetres(limits.lengthDecimetres[row]));
+        if (limits.weightHalfTonnes[row]) existing.weightTonnes = stricter(existing.weightTonnes, fromHalfTonnes(limits.weightHalfTonnes[row]));
+        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) {
+        if (!edgeAllowed(graph.restrictionMask, pair)) continue;
         const fromEdge = rebase(fromEdges[pair]);
         const toEdge = rebase(toEdges[pair]);
         if (fromEdge >= 0 && toEdge >= 0) bannedPairs.push([fromEdge, toEdge]);
@@ -214,20 +427,29 @@ function mergeRoadGraphs(graphs) {
     const offsets = graph.turnRestrictionSequenceOffsets;
     const sequenceEdges = graph.turnRestrictionSequenceEdges;
     if (!offsets || !sequenceEdges) continue;
+    const pairCount = fromEdges?.length ?? 0;
     for (let sequence = 0; sequence + 1 < offsets.length; sequence += 1) {
+      if (!edgeAllowed(graph.restrictionMask, pairCount + sequence)) continue;
       const rebased = [];
       for (let at = offsets[sequence]; at < offsets[sequence + 1]; at += 1) rebased.push(rebase(sequenceEdges[at]));
       if (rebased.every((edge) => edge >= 0)) bannedSequences.push(rebased);
     }
   }
+  const mergedLimits = packEdgeLimits([...limitRows].map(([edge, limits]) => ({ edge, limits })));
+  const mergedConditions = packEdgeConditions(conditionRows);
   return withSpatialIndex({
-    nodeLatitudes: Int32Array.from(latitudes, (value) => Math.round(value * COORDINATE_SCALE)),
-    nodeLongitudes: Int32Array.from(longitudes, (value) => Math.round(value * COORDINATE_SCALE)),
+    nodeLatitudes: mergedLatitudes.slice(0, nodeCount),
+    nodeLongitudes: mergedLongitudes.slice(0, nodeCount),
     coordinateScale: COORDINATE_SCALE,
     edgeOffsets,
     edgeTargets,
     edgeDistancesMeters,
     edgeDurationsSeconds,
+    ...profileId ? { profileId } : {},
+    ...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) : {}
@@ -289,12 +511,55 @@ async function createRouteGraphLoader(manifestUrl, fetcher = fetch) {
   };
 }
 
+// src/vehicle.ts
+var VehiclePresetId = {
+  van: 1,
+  rigid: 2,
+  articulated: 3,
+  "road-train": 4,
+  "us-semi": 5
+};
+function vehiclePresetName(id) {
+  return Object.keys(VehiclePresetId).find((name) => VehiclePresetId[name] === id) ?? null;
+}
+var VEHICLE_PRESETS = {
+  van: { heightMeters: 2.6, widthMeters: 2.1, lengthMeters: 6, weightTonnes: 3.5 },
+  rigid: { heightMeters: 3.8, widthMeters: 2.55, lengthMeters: 10, weightTonnes: 18 },
+  articulated: { heightMeters: 4, widthMeters: 2.55, lengthMeters: 16.5, weightTonnes: 40 },
+  "road-train": { heightMeters: 4, widthMeters: 2.55, lengthMeters: 18.75, weightTonnes: 44 },
+  "us-semi": { heightMeters: 4.11, widthMeters: 2.59, lengthMeters: 22, weightTonnes: 36.3 }
+};
+var DEFAULT_VEHICLE_PRESET = "articulated";
+function vehiclePreset(name) {
+  const preset = VEHICLE_PRESETS[name];
+  if (!preset) throw new Error(`Unknown vehicle preset "${name}". Available: ${Object.keys(VEHICLE_PRESETS).join(", ")}.`);
+  return { ...preset };
+}
+function resolveVehicle(input, fallbackPreset = DEFAULT_VEHICLE_PRESET) {
+  if (typeof input === "string") return vehiclePreset(input);
+  const base = vehiclePreset(input?.preset ?? fallbackPreset);
+  if (!input) return base;
+  const resolved = {
+    heightMeters: input.heightMeters ?? base.heightMeters,
+    widthMeters: input.widthMeters ?? base.widthMeters,
+    lengthMeters: input.lengthMeters ?? base.lengthMeters,
+    weightTonnes: input.weightTonnes ?? base.weightTonnes
+  };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isFinite(value) || value <= 0) throw new Error(`Vehicle ${name} must be a positive number.`);
+  }
+  return resolved;
+}
+
 // src/bundle.ts
 var MAGIC = 1112688197;
 var VERSION = 1;
+var PROFILED_VERSION = 2;
+var SHARED_CHUNK = 0;
 var HEADER_BYTES = 32;
 var DIRECTORY_ENTRY_BYTES = 40;
 var COORDINATE_SCALE2 = 1e7;
+var DEFAULT_MERGED_CACHE_SIZE = 2;
 var BundleCompression = {
   none: 0,
   gzip: 1
@@ -334,56 +599,75 @@ async function fetchRange(url, start, end, fetcher) {
   if (response.status === 200 && buffer.byteLength >= end + 1) return buffer.slice(start, end + 1);
   throw new Error("Routing bundle server returned an invalid byte range.");
 }
-async function decodeChunk(buffer, compression) {
-  if (compression === BundleCompression.none) return withSpatialIndex(decodeGraph(buffer));
+async function decompressChunk(buffer, compression) {
+  if (compression === BundleCompression.none) return buffer;
   if (compression !== BundleCompression.gzip || !("DecompressionStream" in globalThis)) {
     throw new Error("This browser cannot decompress the routing bundle chunk.");
   }
   const stream = new Blob([buffer]).stream().pipeThrough(new DecompressionStream("gzip"));
-  return withSpatialIndex(decodeGraph(await new Response(stream).arrayBuffer()));
+  return new Response(stream).arrayBuffer();
+}
+async function decodeChunk(buffer, compression) {
+  return withSpatialIndex(decodeGraph(await decompressChunk(buffer, compression)));
 }
 async function gzipChunk(buffer) {
   if (!("CompressionStream" in globalThis)) throw new Error("This runtime cannot create gzip-compressed routing bundles.");
   const stream = new Blob([buffer]).stream().pipeThrough(new CompressionStream("gzip"));
   return new Response(stream).arrayBuffer();
 }
-function createBundle(tiles, chunks) {
-  const directoryBytes = tiles.length * DIRECTORY_ENTRY_BYTES;
+function profileOfTiles(tiles) {
+  const profileId = tiles[0].graph.profileId ?? 0;
+  const maxSpeedKph = tiles[0].graph.maxSpeedKph ?? 0;
+  for (const tile of tiles) {
+    if ((tile.graph.profileId ?? 0) !== profileId) throw new Error("A routing bundle cannot mix tiles compiled for different profiles.");
+  }
+  return { profileId, maxSpeedKph };
+}
+function createBundle(rows, version, header) {
+  const directoryBytes = rows.length * DIRECTORY_ENTRY_BYTES;
   let offset = HEADER_BYTES + directoryBytes;
-  const byteLength = offset + chunks.reduce((sum, chunk) => sum + chunk.data.byteLength, 0);
+  const byteLength = offset + rows.reduce((sum, row) => sum + row.chunk.data.byteLength, 0);
   const buffer = new ArrayBuffer(byteLength);
   const view = new DataView(buffer);
   view.setUint32(0, MAGIC, true);
-  view.setUint16(4, VERSION, true);
+  view.setUint16(4, version, true);
   view.setUint16(6, HEADER_BYTES, true);
-  view.setUint32(8, tiles.length, true);
+  view.setUint32(8, rows.length, true);
   view.setUint32(12, HEADER_BYTES, true);
   view.setUint32(16, directoryBytes, true);
-  for (let index = 0; index < tiles.length; index += 1) {
-    const tile = tiles[index];
-    const chunk = chunks[index];
+  view.setUint8(20, header.defaultProfileId);
+  view.setUint16(22, Math.round(header.maxSpeedKph), true);
+  view.setUint32(24, header.profileMask, true);
+  view.setUint32(28, header.tileCount, true);
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
     const entry = HEADER_BYTES + index * DIRECTORY_ENTRY_BYTES;
-    view.setUint32(entry, tile.id, true);
-    view.setInt32(entry + 4, toFixed(tile.bounds.minLat), true);
-    view.setInt32(entry + 8, toFixed(tile.bounds.minLng), true);
-    view.setInt32(entry + 12, toFixed(tile.bounds.maxLat), true);
-    view.setInt32(entry + 16, toFixed(tile.bounds.maxLng), true);
+    view.setUint32(entry, row.tileId, true);
+    view.setInt32(entry + 4, toFixed(row.bounds.minLat), true);
+    view.setInt32(entry + 8, toFixed(row.bounds.minLng), true);
+    view.setInt32(entry + 12, toFixed(row.bounds.maxLat), true);
+    view.setInt32(entry + 16, toFixed(row.bounds.maxLng), true);
     view.setUint32(entry + 20, offset, true);
-    view.setUint32(entry + 24, chunk.data.byteLength, true);
-    view.setUint32(entry + 28, chunk.rawByteLength, true);
-    view.setUint16(entry + 32, chunk.compression, true);
-    new Uint8Array(buffer, offset, chunk.data.byteLength).set(new Uint8Array(chunk.data));
-    offset += chunk.data.byteLength;
+    view.setUint32(entry + 24, row.chunk.data.byteLength, true);
+    view.setUint32(entry + 28, row.chunk.rawByteLength, true);
+    view.setUint16(entry + 32, row.chunk.compression, true);
+    view.setUint8(entry + 34, row.profileId);
+    new Uint8Array(buffer, offset, row.chunk.data.byteLength).set(new Uint8Array(row.chunk.data));
+    offset += row.chunk.data.byteLength;
   }
   return buffer;
 }
+function singleProfileRows(tiles, chunks) {
+  return tiles.map((tile, index) => ({ tileId: tile.id, bounds: tile.bounds, profileId: SHARED_CHUNK, chunk: chunks[index] }));
+}
 function encodeRoadGraphBundle(tiles) {
   if (!tiles.length) throw new Error("A routing bundle requires at least one tile.");
   const chunks = tiles.map((tile) => {
     const data = encodeCompactGraph(compactGraph(tile.graph));
     return { data, rawByteLength: data.byteLength, compression: BundleCompression.none };
   });
-  return createBundle(tiles, chunks);
+  const profile = profileOfTiles(tiles);
+  return createBundle(singleProfileRows(tiles, chunks), VERSION, { ...profile, defaultProfileId: profile.profileId, profileMask: maskFor([profile.profileId]), tileCount: tiles.length });
 }
 async function encodeCompressedRoadGraphBundle(tiles, options = {}) {
   if (!tiles.length) throw new Error("A routing bundle requires at least one tile.");
@@ -392,46 +676,136 @@ async function encodeCompressedRoadGraphBundle(tiles, options = {}) {
     const raw = encodeCompactGraph(compactGraph(tile.graph));
     return { data: await gzipChunk(raw), rawByteLength: raw.byteLength, compression: BundleCompression.gzip };
   }));
-  return createBundle(tiles, chunks);
+  const profile = profileOfTiles(tiles);
+  return createBundle(singleProfileRows(tiles, chunks), VERSION, { ...profile, defaultProfileId: profile.profileId, profileMask: maskFor([profile.profileId]), tileCount: tiles.length });
+}
+function maskFor(profileIds) {
+  let mask = 0;
+  for (const id of profileIds) if (id > 0 && id <= 32) mask |= 1 << id - 1;
+  return mask >>> 0;
+}
+function profilesIn(mask) {
+  const ids = [];
+  for (let bit = 0; bit < 32; bit += 1) if (mask & 1 << bit) ids.push(bit + 1);
+  return ids;
+}
+async function encodeProfiledRoadGraphBundle(tiles, options = {}) {
+  if (!tiles.length) throw new Error("A routing bundle requires at least one tile.");
+  const wanted = tiles[0].profiles.map((profile) => profile.profileId);
+  if (!wanted.length) throw new Error("A multi-profile bundle requires at least one profile.");
+  if (new Set(wanted).size !== wanted.length) throw new Error("A multi-profile bundle cannot list the same profile twice.");
+  const gzip = (options.compression ?? "gzip") !== "none";
+  const rows = [];
+  for (const tile of tiles) {
+    const present = tile.profiles.map((profile) => profile.profileId);
+    if (present.length !== wanted.length || present.some((id, index) => id !== wanted[index])) {
+      throw new Error("Every tile in a multi-profile bundle must carry the same profiles, in the same order.");
+    }
+    const pack = async (raw) => gzip ? { data: await gzipChunk(raw), rawByteLength: raw.byteLength, compression: BundleCompression.gzip } : { data: raw, rawByteLength: raw.byteLength, compression: BundleCompression.none };
+    const shared = compactGraph(tile.graph);
+    rows.push({ tileId: tile.id, bounds: tile.bounds, profileId: SHARED_CHUNK, chunk: await pack(encodeSharedGraph(shared)) });
+    for (const profile of tile.profiles) {
+      rows.push({ tileId: tile.id, bounds: tile.bounds, profileId: profile.profileId, chunk: await pack(encodeProfileChunk(profile)) });
+    }
+  }
+  const fastest = Math.max(...tiles[0].profiles.map((profile) => profile.maxSpeedKph));
+  return createBundle(rows, PROFILED_VERSION, { defaultProfileId: wanted[0], maxSpeedKph: fastest, profileMask: maskFor(wanted), tileCount: tiles.length });
 }
-async function openRoadGraphBundle(url, fetcher = fetch) {
+async function openRoadGraphBundle(url, fetcher = fetch, options = {}) {
   const header = await fetchRange(url, 0, HEADER_BYTES - 1, fetcher);
   const headerView = new DataView(header);
-  if (headerView.getUint32(0, true) !== MAGIC || headerView.getUint16(4, true) !== VERSION || headerView.getUint16(6, true) !== HEADER_BYTES) {
+  const bundleVersion = headerView.getUint16(4, true);
+  if (headerView.getUint32(0, true) !== MAGIC || bundleVersion !== VERSION && bundleVersion !== PROFILED_VERSION || headerView.getUint16(6, true) !== HEADER_BYTES) {
     throw new Error("Unsupported routing bundle format.");
   }
-  const tileCount = headerView.getUint32(8, true);
+  const profiled = bundleVersion === PROFILED_VERSION;
+  const defaultProfileId = headerView.getUint8(20);
+  const defaultVehicle = vehiclePresetName(headerView.getUint8(21)) ?? void 0;
+  const headerSpeedKph = headerView.getUint16(22, true);
+  const available = profiled ? profilesIn(headerView.getUint32(24, true)) : [defaultProfileId || ProfileId.car];
+  for (const id of available) {
+    if (id && !getRoutingProfileById(id)) throw new Error(`This routing bundle was compiled for a profile this build does not support (id ${id}).`);
+  }
+  const chosenId = options.profile ? getRoutingProfile(options.profile).id : defaultProfileId;
+  if (!profiled && getRoutingProfileById(chosenId)?.usesPhysicalLimits) {
+    throw new Error(`A "${getRoutingProfileById(chosenId).name}" bundle must carry its physical limits, which this one cannot: it was written in the single-chunk layout. Recompile it.`);
+  }
+  if (options.profile && !available.includes(chosenId)) {
+    const names = available.map((id) => getRoutingProfileById(id)?.name ?? `id ${id}`).join(", ");
+    throw new Error(`This routing bundle does not hold the "${options.profile}" profile. It holds: ${names}.`);
+  }
+  const entryCount = headerView.getUint32(8, true);
   const directoryOffset = headerView.getUint32(12, true);
   const directoryLength = headerView.getUint32(16, true);
-  if (!tileCount || directoryLength !== tileCount * DIRECTORY_ENTRY_BYTES) throw new Error("Invalid routing bundle directory.");
+  if (!entryCount || directoryLength !== entryCount * DIRECTORY_ENTRY_BYTES) throw new Error("Invalid routing bundle directory.");
   const directory = await fetchRange(url, directoryOffset, directoryOffset + directoryLength - 1, fetcher);
   const directoryView = new DataView(directory);
   const tiles = [];
-  for (let index = 0; index < tileCount; index += 1) {
+  const byTileId = /* @__PURE__ */ new Map();
+  for (let index = 0; index < entryCount; index += 1) {
     const entry = index * DIRECTORY_ENTRY_BYTES;
     const compression = directoryView.getUint16(entry + 32, true);
     if (compression !== BundleCompression.none && compression !== BundleCompression.gzip) throw new Error("Unsupported routing bundle chunk compression.");
-    tiles.push({
-      id: directoryView.getUint32(entry, true),
+    const chunk = {
+      offset: directoryView.getUint32(entry + 20, true),
+      byteLength: directoryView.getUint32(entry + 24, true),
+      rawByteLength: directoryView.getUint32(entry + 28, true),
+      compression
+    };
+    const id = directoryView.getUint32(entry, true);
+    const rowProfile = profiled ? directoryView.getUint8(entry + 34) : SHARED_CHUNK;
+    if (rowProfile !== SHARED_CHUNK) {
+      const tile2 = byTileId.get(id);
+      if (!tile2) throw new Error("Invalid routing bundle directory: a profile chunk arrives before its tile.");
+      (tile2.profileChunks ??= /* @__PURE__ */ new Map()).set(rowProfile, chunk);
+      continue;
+    }
+    const tile = {
+      id,
       bounds: {
         minLat: fromFixed(directoryView.getInt32(entry + 4, true)),
         minLng: fromFixed(directoryView.getInt32(entry + 8, true)),
         maxLat: fromFixed(directoryView.getInt32(entry + 12, true)),
         maxLng: fromFixed(directoryView.getInt32(entry + 16, true))
       },
-      offset: directoryView.getUint32(entry + 20, true),
-      byteLength: directoryView.getUint32(entry + 24, true),
-      rawByteLength: directoryView.getUint32(entry + 28, true),
-      compression
-    });
+      ...chunk,
+      ...profiled ? { profileChunks: /* @__PURE__ */ new Map() } : {}
+    };
+    tiles.push(tile);
+    byTileId.set(id, tile);
+  }
+  if (profiled) {
+    for (const tile of tiles) {
+      if (!tile.profileChunks?.has(chosenId)) throw new Error(`Invalid routing bundle: tile ${tile.id} has no chunk for the selected profile.`);
+    }
   }
+  const fetchChunk = async (chunk) => decompressChunk(await fetchRange(url, chunk.offset, chunk.offset + chunk.byteLength - 1, fetcher), chunk.compression);
+  const sharedCache = /* @__PURE__ */ new Map();
+  const profileCache = /* @__PURE__ */ new Map();
   const cache = /* @__PURE__ */ new Map();
-  const loadTile = (tile) => {
-    let graph = cache.get(tile.id);
-    if (!graph) {
+  const loadTile = (tile, profileId) => {
+    const key = `${tile.id}:${profileId}`;
+    let graph = cache.get(key);
+    if (graph) return graph;
+    if (!tile.profileChunks) {
       graph = fetchRange(url, tile.offset, tile.offset + tile.byteLength - 1, fetcher).then((buffer) => decodeChunk(buffer, tile.compression));
-      cache.set(tile.id, graph);
+    } else {
+      let shared = sharedCache.get(tile.id);
+      if (!shared) {
+        shared = fetchChunk(tile).then(decodeSharedGraph);
+        sharedCache.set(tile.id, shared);
+        shared.catch(() => sharedCache.delete(tile.id));
+      }
+      let columns = profileCache.get(key);
+      if (!columns) {
+        columns = fetchChunk(tile.profileChunks.get(profileId)).then(decodeProfileChunk);
+        profileCache.set(key, columns);
+        columns.catch(() => profileCache.delete(key));
+      }
+      graph = Promise.all([shared, columns]).then(([half, vehicle]) => withSpatialIndex(combineProfiledGraph(half, vehicle)));
     }
+    cache.set(key, graph);
+    graph.catch(() => cache.delete(key));
     return graph;
   };
   const routeTiles = (origin, destination, ring) => {
@@ -452,25 +826,47 @@ async function openRoadGraphBundle(url, fetcher = fetch) {
       maxLng: corridor.maxLng + longitudePadding
     }));
   };
-  const loadTiles = async (routeTiles2) => {
+  const mergedLimit = Math.max(0, Math.trunc(options.mergedCacheSize ?? Math.max(DEFAULT_MERGED_CACHE_SIZE, available.length)));
+  const merged = /* @__PURE__ */ new Map();
+  const loadTiles = async (routeTiles2, profileId = chosenId) => {
     if (!routeTiles2.length) throw new RouterError("ROUTE_ACROSS_TILES", "No local graph tiles cover the route corridor.");
-    if (routeTiles2.length === 1) return loadTile(routeTiles2[0]);
-    return mergeRoadGraphs(await Promise.all(routeTiles2.map(loadTile)));
+    if (routeTiles2.length === 1) return loadTile(routeTiles2[0], profileId);
+    const key = `${profileId}/${routeTiles2.map((tile) => tile.id).sort((a, b) => a - b).join(",")}`;
+    const held = merged.get(key);
+    if (held) {
+      merged.delete(key);
+      merged.set(key, held);
+      return held;
+    }
+    const graph = Promise.all(routeTiles2.map((tile) => loadTile(tile, profileId))).then(mergeRoadGraphs);
+    if (mergedLimit) {
+      merged.set(key, graph);
+      for (const oldest of merged.keys()) {
+        if (merged.size <= mergedLimit) break;
+        merged.delete(oldest);
+      }
+      graph.catch(() => merged.delete(key));
+    }
+    return graph;
   };
   return {
     url,
     tiles,
+    profileId: chosenId,
+    maxSpeedKph: headerSpeedKph,
+    profiles: available,
+    ...defaultVehicle ? { defaultVehicle } : {},
     tilesWithinBudget(origin, destination, budgetMeters) {
       return tiles.filter((tile) => contains2(tile.bounds, origin) || contains2(tile.bounds, destination) || distanceToBounds(origin, tile.bounds) + distanceToBounds(destination, tile.bounds) <= budgetMeters);
     },
-    loadTiles(requested) {
-      return loadTiles(requested);
+    loadTiles(requested, profileId) {
+      return loadTiles(requested, profileId ?? chosenId);
     },
     async loadForRoute(origin, destination) {
       const originTile = tiles.find((tile) => contains2(tile.bounds, origin));
       const destinationTile = tiles.find((tile) => contains2(tile.bounds, destination));
       if (!originTile || !destinationTile) throw new RouterError("ROUTE_OUTSIDE_COVERAGE", "The route is outside the available bundle coverage.");
-      if (originTile.id === destinationTile.id) return loadTile(originTile);
+      if (originTile.id === destinationTile.id) return loadTile(originTile, chosenId);
       return loadTiles(routeTiles(origin, destination, 0));
     },
     async loadExpandedForRoute(origin, destination) {
@@ -480,7 +876,6 @@ async function openRoadGraphBundle(url, fetcher = fetch) {
 }
 
 // src/road-router.ts
-var MAX_SPEED_MPS = carRoutingProfile.maxSpeedKph * 1e3 / 3600;
 var INITIAL_DETOUR_FACTOR = 1.4;
 var MINIMUM_BUDGET_METERS = 5e3;
 var SEARCH_WIDENING_FACTORS = [3, 8, Infinity];
@@ -496,26 +891,85 @@ function haversineMeters2(a, b) {
   return 6371e3 * 2 * Math.atan2(Math.sqrt(value), Math.sqrt(1 - value));
 }
 var RoadRouter = class _RoadRouter {
-  constructor(graph, loader, options = {}) {
+  constructor(graph, loader, options = {}, profileId, bundleVehicle) {
     this.graph = graph;
     this.loader = loader;
     this.options = options;
+    this.profileId = profileId;
+    this.bundleVehicle = bundleVehicle;
+    const profile = getRoutingProfileById(profileId ?? 0);
+    this.vehicle = profile?.usesPhysicalLimits && options.vehicle !== null ? resolveVehicle(options.vehicle ?? void 0, bundleVehicle ?? DEFAULT_VEHICLE_PRESET) : void 0;
   }
   graph;
   loader;
   options;
+  profileId;
+  bundleVehicle;
+  /** The lorry these routes are for, where the profile depends on one. */
+  vehicle;
   static fromGraph(graph) {
     return new _RoadRouter(graph);
   }
+  /**
+   * Asking for dimensions a profile cannot act on is a mistake worth saying
+   * out loud: accepting them silently would look like they had been applied.
+   * It is checked where the caller made the pairing, not when switching
+   * profiles, where carrying them over is deliberate.
+   */
+  static assertVehicleApplies(profileId, options) {
+    if (options.vehicle === void 0 || options.vehicle === null) return;
+    const profile = getRoutingProfileById(profileId);
+    if (profile && !profile.usesPhysicalLimits) {
+      throw new Error(`The "${profile.name}" profile does not use vehicle dimensions; only a profile that stores physical limits does.`);
+    }
+  }
   static async open(source, fetcher, options = {}) {
-    if (typeof source !== "string") return _RoadRouter.fromGraph(source);
-    if (source.endsWith(".efrb")) return new _RoadRouter(void 0, await openRoadGraphBundle(source, fetcher), options);
+    if (typeof source !== "string") {
+      _RoadRouter.assertVehicleApplies(source.profileId ?? 0, options);
+      return new _RoadRouter(source, void 0, options, source.profileId);
+    }
+    if (source.endsWith(".efrb")) {
+      const bundle = await openRoadGraphBundle(source, fetcher, { mergedCacheSize: options.mergedCacheSize, profile: options.profile });
+      _RoadRouter.assertVehicleApplies(bundle.profileId, options);
+      return new _RoadRouter(void 0, bundle, options, bundle.profileId, bundle.defaultVehicle);
+    }
     return new _RoadRouter(void 0, await createRouteGraphLoader(source, fetcher), options);
   }
-  async route(from, to, preference = "fastest") {
-    if (this.graph) return route(this.graph, from, to, preference);
-    if (isBundle(this.loader)) return this.routeOverBundle(this.loader, from, to, preference);
-    return this.routeOverLoader(this.loader, from, to, preference);
+  /** The vehicle this router is routing as, when the source names one. */
+  get profile() {
+    return getRoutingProfileById(this.profileId ?? 0)?.name;
+  }
+  /**
+   * Every vehicle this source can be read as, so a caller can offer a choice
+   * without knowing how the bundle was compiled. A bundle holding one vehicle
+   * reports that one, and a plain graph reports none.
+   */
+  get profiles() {
+    if (!isBundle(this.loader)) return this.profile ? [this.profile] : [];
+    return this.loader.profiles.map((id) => getRoutingProfileById(id)?.name).filter((name) => Boolean(name));
+  }
+  /**
+   * The same bundle read as another vehicle. The shared half of every tile is
+   * already downloaded and stays so, which is the point of storing the road
+   * network once: switching vehicle costs only the small per-vehicle chunks.
+   */
+  withProfile(name) {
+    const wanted = getRoutingProfile(name);
+    if (!isBundle(this.loader)) throw new Error("Only a multi-profile bundle can be read as another vehicle.");
+    if (!this.loader.profiles.includes(wanted.id)) {
+      throw new Error(`This routing bundle does not hold the "${name}" profile. It holds: ${this.loader.profiles.map((id) => getRoutingProfileById(id)?.name ?? `id ${id}`).join(", ")}.`);
+    }
+    return new _RoadRouter(void 0, this.loader, this.options, wanted.id, this.bundleVehicle);
+  }
+  /**
+   * `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
@@ -526,10 +980,44 @@ 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 reachFor = (result) => Math.min(ceiling, preference === "fastest" ? result.durationSeconds * MAX_SPEED_MPS : result.distanceMeters);
+    const selected = this.profileId ?? bundle.profileId;
+    const maxSpeedMps = maxSpeedMpsFor({ profileId: selected, maxSpeedKph: bundle.profiles.length > 1 ? void 0 : bundle.maxSpeedKph || void 0 });
+    const reachFor = (result) => Math.min(ceiling, preference === "fastest" ? result.durationSeconds * maxSpeedMps : result.distanceMeters);
     let budget = Math.max(MINIMUM_BUDGET_METERS, Math.min(ceiling, straightLine * INITIAL_DETOUR_FACTOR));
     let loaded = [];
     let graph = null;
@@ -539,7 +1027,7 @@ var RoadRouter = class _RoadRouter {
       const wanted = bundle.tilesWithinBudget(from, to, nextBudget);
       if (wanted.length <= loaded.length && wanted.every((tile) => loaded.some((held) => held.id === tile.id))) return false;
       loaded = wanted;
-      graph = await bundle.loadTiles(wanted);
+      graph = await bundle.loadTiles(wanted, selected);
       return true;
     };
     await widen(budget);
@@ -547,70 +1035,124 @@ 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);
+        best = route(graph, from, to, preference, { vehicle: this.vehicle, ...when });
         break;
       } catch (error) {
         failure = error;
         if (error.code !== "NO_ROUTE") throw error;
       }
     }
-    if (!best) throw failure ?? new RouterError("NO_ROUTE", "No car route connects the selected points.");
+    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 });
+        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);
+      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);
+      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,
+  VEHICLE_PRESETS,
   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,
   decodeGraph,
+  decodeProfileChunk,
+  decodeSharedGraph,
   distanceToBounds,
+  edgeAllowed,
   edgePolyline,
   edgeSource,
   edgeSpatialIndexFor,
   encodeCompactGraph,
   encodeCompressedRoadGraphBundle,
   encodeGraph,
+  encodeProfileChunk,
+  encodeProfiledRoadGraphBundle,
   encodeRoadGraphBundle,
+  encodeSharedGraph,
   findNearestNode,
+  fromDecimetres,
+  fromHalfTonnes,
   getRoutingProfile,
+  getRoutingProfileById,
+  guardedJunctionsFor,
   isTurnBanned,
+  maxSpeedMpsFor,
   mergeRoadGraphs,
+  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,
   withSpatialIndex,
   zigzag
 };