roadgraph-router-v2 0.2.0 → 0.3.0

package/dist/{chunk-PXL65P3L.js → chunk-QSIKDM4A.js}

@@ -80,6 +80,365 @@ var VarintReader = class {
   }
 };
 
+// src/speed.ts
+function parseMaxSpeedKph(value) {
+  if (!value) return null;
+  const text = value.trim().toLowerCase();
+  if (text === "walk") return 7;
+  const match = /^(\d+(?:\.\d+)?)\s*(mph|km\/h|kmh|kph|knots)?$/.exec(text);
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  if (match[2] === "mph") return amount * 1.609344;
+  if (match[2] === "knots") return amount * 1.852;
+  return amount;
+}
+
+// src/conditional.ts
+var MAX_STORED_VALUES = 65536;
+function answered(circumstances) {
+  const yes = /* @__PURE__ */ new Set();
+  for (const list of [circumstances?.conditions, circumstances?.userGroups, circumstances?.purposes]) {
+    for (const name of list ?? []) yes.add(name.trim().toLowerCase());
+  }
+  return yes;
+}
+var KNOWN_CIRCUMSTANCES = /* @__PURE__ */ new Set([
+  "wet",
+  "dry",
+  "snow",
+  "ice",
+  "fog",
+  "rain",
+  "disabled",
+  "resident",
+  "residents",
+  "customers",
+  "employees",
+  "emergency",
+  "permit",
+  "school",
+  "delivery",
+  "destination",
+  "agricultural",
+  "forestry",
+  "loading",
+  "unloading"
+]);
+var WEEKDAYS = ["mo", "tu", "we", "th", "fr", "sa", "su"];
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+function splitOutsideBrackets(text, separator) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (character === "(") depth += 1;
+    else if (character === ")") depth = Math.max(0, depth - 1);
+    else if (character === separator && depth === 0) {
+      parts.push(text.slice(start, index));
+      start = index + 1;
+    }
+  }
+  parts.push(text.slice(start));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+function parseClock(text) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(text.trim());
+  if (!match) return null;
+  const hours = Number(match[1]);
+  const minutes = Number(match[2]);
+  if (hours > 24 || minutes > 59) return null;
+  if (hours === 24 && minutes !== 0) return null;
+  return hours * 60 + minutes;
+}
+function parseIndexedRange(text, table) {
+  const [from, to] = text.split("-").map((part) => part.trim().toLowerCase().slice(0, 3));
+  const start = table.indexOf(from);
+  if (start < 0) return null;
+  if (to === void 0) return { from: start, to: start };
+  const end = table.indexOf(to);
+  return end < 0 ? null : { from: start, to: end };
+}
+function parseVehicleComparison(text) {
+  const match = /^(weight|height|width|length)\s*(<=|>=|<|>|=)\s*(\d+(?:\.\d+)?)$/.exec(text.trim().toLowerCase());
+  if (!match) return null;
+  return { property: match[1], operator: match[2], amount: Number(match[3]) };
+}
+function parseCondition(text) {
+  const condition = {};
+  const cleaned = text.trim().replace(/^\(|\)$/g, "").trim();
+  if (!cleaned) return { unreadable: text };
+  if (cleaned.toLowerCase() === "24/7") return { times: [{ from: 0, to: 1440 }] };
+  for (const token of cleaned.split(/\s+(?:and|AND)\s+|\s+/).filter(Boolean)) {
+    const lower = token.toLowerCase().replace(/,$/, "");
+    if (lower === "ph") {
+      condition.publicHoliday = true;
+      continue;
+    }
+    const comparison = parseVehicleComparison(lower);
+    if (comparison) {
+      (condition.vehicle ??= []).push(comparison);
+      continue;
+    }
+    const pieces = lower.split(",").filter(Boolean);
+    const spans = [];
+    const days = [];
+    const months = [];
+    let understood = true;
+    for (const piece of pieces) {
+      const [left, right] = piece.split("-");
+      const from = parseClock(left ?? "");
+      if (from !== null && right !== void 0) {
+        const to = parseClock(right);
+        if (to === null) {
+          understood = false;
+          break;
+        }
+        spans.push({ from, to });
+        continue;
+      }
+      const day = parseIndexedRange(piece, WEEKDAYS);
+      if (day) {
+        days.push(day);
+        continue;
+      }
+      const month = parseIndexedRange(piece, MONTHS);
+      if (month) {
+        months.push(month);
+        continue;
+      }
+      if (KNOWN_CIRCUMSTANCES.has(piece)) {
+        (condition.circumstances ??= []).push(piece);
+        continue;
+      }
+      understood = false;
+      break;
+    }
+    if (!understood) {
+      condition.unreadable = token;
+      continue;
+    }
+    if (spans.length) (condition.times ??= []).push(...spans);
+    if (days.length) (condition.days ??= []).push(...days);
+    if (months.length) (condition.months ??= []).push(...months);
+  }
+  return condition;
+}
+function parseConditional(value) {
+  if (!value || !value.includes("@")) return [];
+  const rules = [];
+  for (const part of splitOutsideBrackets(value, ";")) {
+    const at = part.indexOf("@");
+    if (at < 0) continue;
+    const left = part.slice(0, at).trim();
+    const right = part.slice(at + 1).trim();
+    if (!left || !right) continue;
+    const grouped = right.startsWith("(") && right.endsWith(")") ? right.slice(1, -1) : right;
+    const parts = splitOutsideBrackets(grouped, ";");
+    rules.push({ value: left, conditions: (parts.length ? parts : [grouped]).map(parseCondition) });
+  }
+  return rules;
+}
+var withinRange = (value, range) => range.from <= range.to ? value >= range.from && value <= range.to : value >= range.from || value <= range.to;
+var withinSpan = (minutes, span) => span.from <= span.to ? minutes >= span.from && minutes < span.to : minutes >= span.from || minutes < span.to;
+var YESTERDAY = (weekday) => (weekday + 6) % 7;
+function dayBefore(when) {
+  const rolledOver = when.dayOfMonth === 1;
+  return {
+    weekday: YESTERDAY(when.weekday),
+    month: rolledOver ? when.month === 1 ? 12 : when.month - 1 : when.month
+  };
+}
+function selects(condition, day) {
+  if (condition.days?.length && !condition.days.some((range) => withinRange(day.weekday, range))) return false;
+  if (condition.months?.length && !condition.months.some((range) => withinRange(day.month - 1, range))) return false;
+  return true;
+}
+function dayAndTimeHold(condition, when) {
+  if (!condition.times?.length) return selects(condition, when);
+  return condition.times.some((span) => {
+    if (span.from <= span.to) return selects(condition, when) && withinSpan(when.minutes, span);
+    if (when.minutes >= span.from) return selects(condition, when);
+    if (when.minutes < span.to) return selects(condition, dayBefore(when));
+    return false;
+  });
+}
+function conditionHolds(condition, when, vehicle, circumstances) {
+  if (condition.unreadable !== void 0) return false;
+  if (condition.publicHoliday && !when.publicHoliday) return false;
+  if (condition.circumstances?.length) {
+    const yes = answered(circumstances);
+    if (!condition.circumstances.every((name) => yes.has(name))) return false;
+  }
+  if (!dayAndTimeHold(condition, when)) return false;
+  if (condition.vehicle?.length) {
+    if (!vehicle) return false;
+    for (const test of condition.vehicle) {
+      const measured = test.property === "weight" ? vehicle.weightTonnes : test.property === "height" ? vehicle.heightMeters : test.property === "width" ? vehicle.widthMeters : vehicle.lengthMeters;
+      const holds = test.operator === "<" ? measured < test.amount : test.operator === "<=" ? measured <= test.amount : test.operator === ">" ? measured > test.amount : test.operator === ">=" ? measured >= test.amount : measured === test.amount;
+      if (!holds) return false;
+    }
+  }
+  return true;
+}
+function conditionalValue(rules, when, vehicle, circumstances) {
+  let effective = null;
+  for (const rule of rules) {
+    if (rule.conditions.some((condition) => conditionHolds(condition, when, vehicle, circumstances))) effective = rule.value;
+  }
+  return effective;
+}
+function unreadableConditions(rules) {
+  return rules.reduce((count, rule) => count + rule.conditions.filter((condition) => condition.unreadable !== void 0).length, 0);
+}
+var WEEKDAY_NUMBER = { Mon: 0, Tue: 1, Wed: 2, Thu: 3, Fri: 4, Sat: 5, Sun: 6 };
+function travelTimeFrom(date, publicHoliday = false, timeZone) {
+  if (!timeZone) {
+    return {
+      weekday: (date.getDay() + 6) % 7,
+      minutes: date.getHours() * 60 + date.getMinutes(),
+      month: date.getMonth() + 1,
+      dayOfMonth: date.getDate(),
+      publicHoliday
+    };
+  }
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone,
+    weekday: "short",
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    hour: "numeric",
+    minute: "numeric",
+    hour12: false
+  }).formatToParts(date);
+  const field = (type) => parts.find((part) => part.type === type)?.value ?? "";
+  const hour = Number(field("hour")) % 24;
+  return {
+    weekday: WEEKDAY_NUMBER[field("weekday")] ?? 0,
+    minutes: hour * 60 + Number(field("minute")),
+    month: Number(field("month")),
+    dayOfMonth: Number(field("day")),
+    publicHoliday
+  };
+}
+var ConditionKind = { access: 0, maxspeed: 1 };
+function packEdgeConditions(entries) {
+  const rows = entries.filter((entry) => parseConditional(entry.value).length > 0).sort((a, b) => a.edge - b.edge || a.kind - b.kind);
+  if (!rows.length) return void 0;
+  const index = /* @__PURE__ */ new Map();
+  const values = [];
+  const kept = [];
+  for (const row of rows) {
+    let at = index.get(row.value);
+    if (at === void 0) {
+      if (values.length >= MAX_STORED_VALUES) {
+        throw new RangeError(
+          `A tile holds more than ${MAX_STORED_VALUES} distinct conditional restrictions, which is more than the stored index can name. Compile the region in smaller tiles with --tile-size-km.`
+        );
+      }
+      at = values.push(row.value) - 1;
+      index.set(row.value, at);
+    }
+    kept.push({ edge: row.edge, kind: row.kind, rule: at });
+  }
+  if (!kept.length) return void 0;
+  return {
+    edges: Uint32Array.from(kept, (row) => row.edge),
+    kinds: Uint8Array.from(kept, (row) => row.kind),
+    rules: Uint16Array.from(kept, (row) => row.rule),
+    values
+  };
+}
+function parseEdgeConditions(table) {
+  if (!table?.edges.length) return void 0;
+  return { table, parsed: table.values.map(parseConditional) };
+}
+function firstRowFor(edges, edge) {
+  let low = 0;
+  let high = edges.length - 1;
+  let found = -1;
+  while (low <= high) {
+    const middle = low + high >> 1;
+    if (edges[middle] >= edge) {
+      if (edges[middle] === edge) found = middle;
+      high = middle - 1;
+    } else low = middle + 1;
+  }
+  return found;
+}
+var CLOSED = /* @__PURE__ */ new Set(["no", "private", "destination", "customers", "delivery", "permit", "agricultural", "forestry"]);
+function conditionsOnEdge(conditions, edge, when, vehicle, circumstances) {
+  const { table, parsed } = conditions;
+  let closed = false;
+  let speedKph;
+  for (let row = firstRowFor(table.edges, edge); row >= 0 && row < table.edges.length && table.edges[row] === edge; row += 1) {
+    const value = conditionalValue(parsed[table.rules[row]], when, vehicle, circumstances);
+    if (value === null) continue;
+    if (table.kinds[row] === ConditionKind.access) {
+      if (CLOSED.has(value.trim().toLowerCase())) closed = true;
+    } else {
+      const parsedSpeed = parseMaxSpeedKph(value);
+      if (parsedSpeed !== null && parsedSpeed > 0) speedKph = speedKph === void 0 ? parsedSpeed : Math.min(speedKph, parsedSpeed);
+    }
+  }
+  return { closed, speedKph };
+}
+function accessAtTime(graph, conditions, when, vehicle, base, circumstances) {
+  const start = base ?? graph.edgeAccess;
+  if (!when || !conditions) return start;
+  const edges = graph.edgeTargets.length;
+  let mask;
+  const { table } = conditions;
+  for (let row = 0; row < table.edges.length; row += 1) {
+    const edge = table.edges[row];
+    if (edge >= edges || table.kinds[row] !== ConditionKind.access) continue;
+    if (mask && !edgeAllowed(mask, edge)) continue;
+    if (!conditionsOnEdge(conditions, edge, when, vehicle, circumstances).closed) continue;
+    mask ??= start ? Uint8Array.from(start) : accessMaskFor(edges, () => true);
+    mask[edge >> 3] &= ~(1 << (edge & 7));
+  }
+  return mask ?? start;
+}
+function countClosedAt(graph, conditions, when, vehicle) {
+  const before = graph.edgeAccess;
+  const after = accessAtTime(graph, conditions, when, vehicle);
+  if (after === before) return 0;
+  let closed = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+    if (edgeAllowed(before, edge) && !edgeAllowed(after, edge)) closed += 1;
+  }
+  return closed;
+}
+var parsedByTable = /* @__PURE__ */ new WeakMap();
+function conditionsOf(graph) {
+  const table = graph.edgeConditions;
+  if (!table?.edges.length) return void 0;
+  const existing = parsedByTable.get(table);
+  if (existing) return existing;
+  const parsed = parseEdgeConditions(table);
+  parsedByTable.set(table, parsed);
+  return parsed;
+}
+function conditionalDurations(graph, conditions, when, vehicle, circumstances) {
+  if (!conditions) return void 0;
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  const slowed = /* @__PURE__ */ new Map();
+  const { table } = conditions;
+  for (let row = 0; row < table.edges.length; row += 1) {
+    const edge = table.edges[row];
+    if (table.kinds[row] !== ConditionKind.maxspeed || edge >= graph.edgeTargets.length || slowed.has(edge)) continue;
+    const { speedKph } = conditionsOnEdge(conditions, edge, when, vehicle, circumstances);
+    if (speedKph === void 0) continue;
+    const stored = graph.edgeDurationsSeconds[edge] * durationScale;
+    const limited = graph.edgeDistancesMeters[edge] * distanceScale / (speedKph / 3.6);
+    if (limited > stored) slowed.set(edge, limited);
+  }
+  return slowed.size ? slowed : void 0;
+}
+
 // src/routing-profile.ts
 var ProfileId = {
   unspecified: 0,
@@ -164,18 +523,6 @@ function clampSpeed(value) {
   if (!Number.isFinite(value)) return MINIMUM_SPEED_KPH;
   return Math.min(MAXIMUM_SPEED_KPH, Math.max(MINIMUM_SPEED_KPH, value));
 }
-function parseMaxSpeedKph(value) {
-  if (!value) return null;
-  const text = value.trim().toLowerCase();
-  if (text === "walk") return 7;
-  const match = /^(\d+(?:\.\d+)?)\s*(mph|km\/h|kmh|kph|knots)?$/.exec(text);
-  if (!match) return null;
-  const amount = Number(match[1]);
-  if (!Number.isFinite(amount) || amount <= 0) return null;
-  if (match[2] === "mph") return amount * 1.609344;
-  if (match[2] === "knots") return amount * 1.852;
-  return amount;
-}
 var UNMEASURED = /* @__PURE__ */ new Set(["default", "below_default", "none", "unsigned", "no_sign", "no", "yes", "unknown"]);
 var FEET_METERS = 0.3048;
 var INCH_METERS = 0.0254;
@@ -226,6 +573,22 @@ function limitsFor(tags, mode, direction) {
   }
   return found ? limits : void 0;
 }
+function conditionsFor(tags, accessKeys, speedKeys) {
+  const found = [];
+  let access;
+  for (const key of accessKeys) {
+    const value = tags[`${key}:conditional`];
+    if (value !== void 0) access = value;
+  }
+  if (access) found.push({ kind: ConditionKind.access, value: access });
+  let speed;
+  for (const key of speedKeys) {
+    const value = tags[`${key}:conditional`];
+    if (value !== void 0) speed = value;
+  }
+  if (speed) found.push({ kind: ConditionKind.maxspeed, value: speed });
+  return found.length ? found : void 0;
+}
 function accessAllowed(tags, keys) {
   let allowed = true;
   for (const key of keys) {
@@ -268,9 +631,14 @@ function motorVehicleProfile(options) {
       `maxspeed:${mode}`,
       ...accessKeys,
       ...onewayKeys,
+      // The conditional forms of the same keys, which the router reads against
+      // a departure time rather than the compiler against nothing.
+      ...accessKeys.map((key) => `${key}:conditional`),
+      "maxspeed:conditional",
+      `maxspeed:${mode}:conditional`,
       ...options.physicalLimits ? LIMIT_KEYS.flatMap(([, key]) => [key, `${key}:${mode}`, `${key}:forward`, `${key}:backward`, ...key === "maxheight" || key === "maxwidth" ? [`${key}:physical`] : []]) : []
     ],
-    relationTagKeys: ["type", "except", ...restrictionKeys],
+    relationTagKeys: ["type", "except", ...restrictionKeys, ...restrictionKeys.map((key) => `${key}:conditional`)],
     maxSpeedKph: ceiling,
     nodeTagKeys: BARRIER_TAG_KEYS,
     evaluateBarrier: (tags) => barrierAllows(tags, accessKeys, "motor"),
@@ -293,7 +661,8 @@ function motorVehicleProfile(options) {
         ...options.physicalLimits ? {
           forwardLimits: limitsFor(tags, mode, "forward"),
           backwardLimits: limitsFor(tags, mode, "backward")
-        } : {}
+        } : {},
+        .../* @__PURE__ */ ((conditions) => conditions ? { conditions } : {})(conditionsFor(tags, accessKeys, ["maxspeed", `maxspeed:${mode}`]))
       };
     },
     evaluateTurnRestriction(tags) {
@@ -369,8 +738,16 @@ function activeTravelProfile(options) {
   return {
     name,
     id,
-    wayTagKeys: ["highway", "junction", "maxspeed", ...accessKeys, "oneway", ...onewayKeys],
-    relationTagKeys: ["type", "except", ...restrictionKeys],
+    wayTagKeys: [
+      "highway",
+      "junction",
+      "maxspeed",
+      ...accessKeys,
+      "oneway",
+      ...onewayKeys,
+      ...accessKeys.map((key) => `${key}:conditional`)
+    ],
+    relationTagKeys: ["type", "except", ...restrictionKeys, ...restrictionKeys.map((key) => `${key}:conditional`)],
     maxSpeedKph: ceilingKph,
     nodeTagKeys: BARRIER_TAG_KEYS,
     evaluateBarrier: (tags) => barrierAllows(tags, accessKeys, mode === "foot" ? "foot" : "bicycle"),
@@ -391,7 +768,8 @@ function activeTravelProfile(options) {
       const posted = parseMaxSpeedKph(tags.maxspeed);
       const wanted = Math.min(speeds[highway], posted !== null && posted > 0 ? posted : Infinity);
       const speed = Math.min(ceilingKph, Math.max(floorKph, wanted));
-      return { forward, backward, forwardSpeedKph: speed, backwardSpeedKph: speed };
+      const conditions = conditionsFor(tags, accessKeys, []);
+      return { forward, backward, forwardSpeedKph: speed, backwardSpeedKph: speed, ...conditions ? { conditions } : {} };
     },
     evaluateTurnRestriction(tags) {
       if (tags.type !== "restriction") return null;
@@ -685,6 +1063,32 @@ function buildShapeTable(graph) {
 function encodeSharedGraph(graph) {
   return encodePackedGraph(graph, SPLIT_COMPACT_VERSION);
 }
+function assertEdgeConditions(conditions, edges) {
+  const rows = conditions.edges.length;
+  if (conditions.kinds.length !== rows || conditions.rules.length !== rows) throw new Error("Edge condition columns must all be the same length.");
+  for (let index = 0; index < rows; index += 1) {
+    if (conditions.edges[index] >= edges) throw new Error("Edge condition references an edge outside the graph.");
+    if (index && conditions.edges[index] < conditions.edges[index - 1]) throw new Error("Edge conditions must be sorted by edge.");
+    if (conditions.rules[index] >= conditions.values.length) throw new Error("Edge condition names a value that is not in the table.");
+  }
+  if (conditions.values.some((value) => value.includes("\0"))) throw new Error("A conditional value cannot contain a null byte.");
+}
+function readEdgeConditions(buffer, at, edges) {
+  const view = new DataView(buffer);
+  const rows = view.getUint32(at, true);
+  const textBytes = view.getUint32(at + 4, true);
+  const conditionEdges = new Uint32Array(buffer.slice(at + 8, at + 8 + rows * 4));
+  for (let index = 0; index < rows; index += 1) {
+    if (conditionEdges[index] >= edges) throw new Error("Invalid routing graph: condition references an edge outside the graph.");
+    if (index && conditionEdges[index] < conditionEdges[index - 1]) throw new Error("Invalid routing graph: conditions are not sorted.");
+  }
+  const values = new TextDecoder().decode(new Uint8Array(buffer, alignUp(at + 8 + rows * 7), textBytes)).split("\0");
+  const rules = new Uint16Array(buffer.slice(at + 8 + rows * 4, at + 8 + rows * 6));
+  for (let index = 0; index < rows; index += 1) {
+    if (rules[index] >= values.length) throw new Error("Invalid routing graph: condition names a value that is not in the table.");
+  }
+  return { edges: conditionEdges, rules, kinds: new Uint8Array(buffer.slice(at + 8 + rows * 6, at + 8 + rows * 7)), values };
+}
 function encodePackedGraph(graph, version = PACKED_COMPACT_VERSION) {
   const nodes = graph.nodeLatitudes.length;
   const edges = graph.edgeTargets.length;
@@ -741,7 +1145,14 @@ function encodePackedGraph(graph, version = PACKED_COMPACT_VERSION) {
   const variableBytes = sections.reduce((sum, section) => sum + section.byteLength, 0);
   const weightBytes = edges * (shared ? 2 : 4);
   const restrictionsAt = alignUp(PACKED_HEADER_BYTES + (shared ? 0 : nodes * 8) + weightBytes + variableBytes);
-  const buffer = new ArrayBuffer(restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0));
+  const restrictionsEnd = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
+  const conditions = !shared && graph.edgeConditions?.edges.length ? graph.edgeConditions : void 0;
+  if (conditions) assertEdgeConditions(conditions, edges);
+  const conditionRows = conditions?.edges.length ?? 0;
+  const conditionText = conditions ? new TextEncoder().encode(conditions.values.join("\0")) : void 0;
+  const conditionsAt = alignUp(restrictionsEnd);
+  const conditionTextAt = alignUp(conditionsAt + 8 + conditionRows * 7);
+  const buffer = new ArrayBuffer(conditionRows ? conditionTextAt + (conditionText?.byteLength ?? 0) : restrictionsEnd);
   const view = new DataView(buffer);
   view.setUint32(0, COMPACT_MAGIC, true);
   view.setUint16(4, version, true);
@@ -758,6 +1169,7 @@ function encodePackedGraph(graph, version = PACKED_COMPACT_VERSION) {
   for (let index = 0; index < sections.length; index += 1) view.setUint32(40 + index * 4, sections[index].byteLength, true);
   if (!shared) {
     view.setUint8(60, graph.profileId ?? 0);
+    view.setUint8(61, conditionRows ? 1 : 0);
     view.setUint16(62, Math.round(graph.maxSpeedKph ?? 0), true);
   }
   let offset = PACKED_HEADER_BYTES;
@@ -790,6 +1202,14 @@ function encodePackedGraph(graph, version = PACKED_COMPACT_VERSION) {
     offset += (runs + 1) * 4;
     new Uint32Array(buffer, offset, runEdges).set(graph.turnRestrictionSequenceEdges);
   }
+  if (conditions && conditionRows && conditionText) {
+    view.setUint32(conditionsAt, conditionRows, true);
+    view.setUint32(conditionsAt + 4, conditionText.byteLength, true);
+    new Uint32Array(buffer, conditionsAt + 8, conditionRows).set(conditions.edges);
+    new Uint16Array(buffer, conditionsAt + 8 + conditionRows * 4, conditionRows).set(conditions.rules);
+    new Uint8Array(buffer, conditionsAt + 8 + conditionRows * 6, conditionRows).set(conditions.kinds);
+    new Uint8Array(buffer, conditionTextAt, conditionText.byteLength).set(conditionText);
+  }
   return buffer;
 }
 function decodePackedGraph(buffer, shared = false) {
@@ -806,7 +1226,17 @@ function decodePackedGraph(buffer, shared = false) {
   const lengths = Array.from({ length: shared ? 6 : 5 }, (_, index) => view.getUint32(40 + index * 4, true));
   const variableBytes = lengths.reduce((sum, length) => sum + length, 0);
   const restrictionsAt = alignUp(PACKED_HEADER_BYTES + (shared ? 0 : nodes * 8) + edges * (shared ? 2 : 4) + variableBytes);
-  const expected = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
+  const restrictionsEnd = restrictionsAt + pairs * 8 + (runs ? (runs + 1) * 4 + runEdges * 4 : 0);
+  const hasConditions = !shared && view.getUint8(61) === 1;
+  const conditionsAt = alignUp(restrictionsEnd);
+  let expected = restrictionsEnd;
+  if (hasConditions) {
+    if (buffer.byteLength < conditionsAt + 8) throw new Error("Truncated compact routing graph");
+    const rows = view.getUint32(conditionsAt, true);
+    const textBytes = view.getUint32(conditionsAt + 4, true);
+    if (rows > edges || !textBytes) throw new Error("Invalid compact routing graph: conditions do not fit the graph.");
+    expected = alignUp(conditionsAt + 8 + rows * 7) + textBytes;
+  }
   if (!coordinateScale || !edgeDistanceScale || !edgeDurationScale || buffer.byteLength !== expected) throw new Error("Truncated compact routing graph");
   if (shapeCount > edges) throw new Error("Invalid compact routing graph: more shapes than edges.");
   const profileId = shared ? 0 : view.getUint8(60);
@@ -935,6 +1365,7 @@ function decodePackedGraph(buffer, shared = false) {
   }
   for (const edge of graph.turnRestrictionFromEdges ?? []) if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
   for (const edge of graph.turnRestrictionToEdges ?? []) if (edge >= edges) throw new Error("Invalid routing graph: turn restriction references an edge outside the graph.");
+  if (hasConditions) graph.edgeConditions = readEdgeConditions(buffer, conditionsAt, edges);
   return graph;
 }
 var PROFILE_CHUNK_HEADER_BYTES = 64;
@@ -963,7 +1394,14 @@ function encodeProfileChunk(chunk) {
   const variableAt = PROFILE_CHUNK_HEADER_BYTES + edges * 2 + (mask?.byteLength ?? 0) + (turns?.byteLength ?? 0);
   const limitsAt = alignUp(variableAt);
   const limitRows = limits?.edges.length ?? 0;
-  const buffer = new ArrayBuffer(limitRows ? limitsAt + limitRows * 8 : variableAt);
+  const limitsEnd = limitRows ? limitsAt + limitRows * 8 : variableAt;
+  const conditions = chunk.edgeConditions?.edges.length ? chunk.edgeConditions : void 0;
+  if (conditions) assertEdgeConditions(conditions, edges);
+  const conditionRows = conditions?.edges.length ?? 0;
+  const conditionText = conditions ? new TextEncoder().encode(conditions.values.join("\0")) : void 0;
+  const conditionsAt = alignUp(limitsEnd);
+  const conditionTextAt = alignUp(conditionsAt + conditionRows * 7);
+  const buffer = new ArrayBuffer(conditionRows ? conditionTextAt + (conditionText?.byteLength ?? 0) : limitsEnd);
   const view = new DataView(buffer);
   view.setUint32(0, COMPACT_MAGIC, true);
   view.setUint16(4, SPLIT_COMPACT_VERSION, true);
@@ -976,6 +1414,8 @@ function encodeProfileChunk(chunk) {
   view.setUint32(20, limitRows, true);
   view.setUint32(24, restrictions, true);
   view.setUint32(28, turns?.byteLength ?? 0, true);
+  view.setUint32(32, conditionRows, true);
+  view.setUint32(36, conditionText?.byteLength ?? 0, true);
   new Uint16Array(buffer, PROFILE_CHUNK_HEADER_BYTES, edges).set(chunk.edgeDurationsSeconds);
   if (mask) new Uint8Array(buffer, PROFILE_CHUNK_HEADER_BYTES + edges * 2, mask.byteLength).set(mask);
   if (turns) new Uint8Array(buffer, PROFILE_CHUNK_HEADER_BYTES + edges * 2 + (mask?.byteLength ?? 0), turns.byteLength).set(turns);
@@ -987,6 +1427,12 @@ function encodeProfileChunk(chunk) {
     columns.set(limits.lengthDecimetres, limitRows * 2);
     columns.set(limits.weightHalfTonnes, limitRows * 3);
   }
+  if (conditions && conditionRows && conditionText) {
+    new Uint32Array(buffer, conditionsAt, conditionRows).set(conditions.edges);
+    new Uint16Array(buffer, conditionsAt + conditionRows * 4, conditionRows).set(conditions.rules);
+    new Uint8Array(buffer, conditionsAt + conditionRows * 6, conditionRows).set(conditions.kinds);
+    new Uint8Array(buffer, conditionTextAt, conditionText.byteLength).set(conditionText);
+  }
   return buffer;
 }
 function decodeProfileChunk(buffer) {
@@ -1003,6 +1449,8 @@ function decodeProfileChunk(buffer) {
   const limitRows = view.getUint32(20, true);
   const restrictionCount = view.getUint32(24, true);
   const turnMaskBytes = view.getUint32(28, true);
+  const conditionRows = view.getUint32(32, true);
+  const conditionTextBytes = view.getUint32(36, true);
   if (!profileId || !getRoutingProfileById(profileId)) throw new Error(`Routing graph was compiled for an unsupported profile (id ${profileId}).`);
   if (!edgeDurationScale) throw new Error("Invalid routing profile chunk: zero duration scale.");
   if (maxSpeedKph > MAX_PLAUSIBLE_SPEED_KPH) throw new Error("Invalid routing profile chunk: implausible profile speed ceiling.");
@@ -1010,8 +1458,12 @@ function decodeProfileChunk(buffer) {
   if (turnMaskBytes && turnMaskBytes !== restrictionCount + 7 >> 3) throw new Error("Invalid routing profile chunk: restriction mask does not cover every restriction.");
   const variableAt = PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes + turnMaskBytes;
   const limitsAt = alignUp(variableAt);
-  const expected = limitRows ? limitsAt + limitRows * 8 : variableAt;
+  const limitsEnd = limitRows ? limitsAt + limitRows * 8 : variableAt;
+  const conditionsAt = alignUp(limitsEnd);
+  const conditionTextAt = alignUp(conditionsAt + conditionRows * 7);
+  const expected = conditionRows ? conditionTextAt + conditionTextBytes : limitsEnd;
   if (limitRows > edges) throw new Error("Invalid routing profile chunk: more limits than edges.");
+  if (conditionRows && !conditionTextBytes) throw new Error("Invalid routing profile chunk: conditions with no values.");
   if (buffer.byteLength !== expected) throw new Error("Truncated routing profile chunk");
   let edgeLimits;
   if (limitRows) {
@@ -1029,6 +1481,25 @@ function decodeProfileChunk(buffer) {
       weightHalfTonnes: columns.slice(limitRows * 3)
     };
   }
+  let edgeConditions;
+  if (conditionRows) {
+    const conditionEdges = new Uint32Array(buffer.slice(conditionsAt, conditionsAt + conditionRows * 4));
+    for (let index = 0; index < conditionRows; index += 1) {
+      if (conditionEdges[index] >= edges) throw new Error("Invalid routing profile chunk: condition references an edge outside the graph.");
+      if (index && conditionEdges[index] < conditionEdges[index - 1]) throw new Error("Invalid routing profile chunk: conditions are not sorted.");
+    }
+    const values = new TextDecoder().decode(new Uint8Array(buffer, conditionTextAt, conditionTextBytes)).split("\0");
+    const rules = new Uint16Array(buffer.slice(conditionsAt + conditionRows * 4, conditionsAt + conditionRows * 6));
+    for (let index = 0; index < conditionRows; index += 1) {
+      if (rules[index] >= values.length) throw new Error("Invalid routing profile chunk: condition names a value that is not in the table.");
+    }
+    edgeConditions = {
+      edges: conditionEdges,
+      rules,
+      kinds: new Uint8Array(buffer.slice(conditionsAt + conditionRows * 6, conditionsAt + conditionRows * 7)),
+      values
+    };
+  }
   return {
     profileId,
     maxSpeedKph,
@@ -1037,7 +1508,8 @@ function decodeProfileChunk(buffer) {
     ...maskBytes ? { edgeAccess: new Uint8Array(buffer.slice(PROFILE_CHUNK_HEADER_BYTES + edges * 2, PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes)) } : {},
     ...restrictionCount ? { restrictionCount } : {},
     ...turnMaskBytes ? { restrictionMask: new Uint8Array(buffer.slice(PROFILE_CHUNK_HEADER_BYTES + edges * 2 + maskBytes, variableAt)) } : {},
-    ...edgeLimits ? { edgeLimits } : {}
+    ...edgeLimits ? { edgeLimits } : {},
+    ...edgeConditions ? { edgeConditions } : {}
   };
 }
 function decodeSharedGraph(buffer) {
@@ -1061,6 +1533,7 @@ function combineProfiledGraph(shared, profile) {
     maxSpeedKph: profile.maxSpeedKph,
     ...profile.edgeAccess ? { edgeAccess: profile.edgeAccess } : {},
     ...profile.edgeLimits ? { edgeLimits: profile.edgeLimits } : {},
+    ...profile.edgeConditions ? { edgeConditions: profile.edgeConditions } : {},
     ...profile.restrictionMask ? { restrictionMask: profile.restrictionMask } : {}
   };
 }
@@ -1153,303 +1626,144 @@ function componentSizes(labels) {
   return sizes;
 }
 
-// src/limits.ts
-var DECIMETRE_CEILING = 255;
-var HALF_TONNE_CEILING = 255;
-function toDecimetres(metres) {
-  if (metres === void 0 || !(metres > 0)) return 0;
-  const value = Math.floor(metres * 10);
-  return value > DECIMETRE_CEILING ? 0 : value;
-}
-function toHalfTonnes(tonnes) {
-  if (tonnes === void 0 || !(tonnes > 0)) return 0;
-  const value = Math.floor(tonnes * 2);
-  return value > HALF_TONNE_CEILING ? 0 : value;
-}
-var fromDecimetres = (value) => value / 10;
-var fromHalfTonnes = (value) => value / 2;
-function packEdgeLimits(entries) {
-  const rows = entries.map(({ edge, limits }) => ({
-    edge,
-    height: toDecimetres(limits.heightMeters),
-    width: toDecimetres(limits.widthMeters),
-    length: toDecimetres(limits.lengthMeters),
-    weight: toHalfTonnes(limits.weightTonnes)
-  })).filter((row) => row.height || row.width || row.length || row.weight).sort((a, b) => a.edge - b.edge);
-  if (!rows.length) return void 0;
-  return {
-    edges: Uint32Array.from(rows, (row) => row.edge),
-    heightDecimetres: Uint8Array.from(rows, (row) => row.height),
-    widthDecimetres: Uint8Array.from(rows, (row) => row.width),
-    lengthDecimetres: Uint8Array.from(rows, (row) => row.length),
-    weightHalfTonnes: Uint8Array.from(rows, (row) => row.weight)
-  };
-}
-function blocks(limits, index, vehicle) {
-  const height = limits.heightDecimetres[index];
-  if (height && vehicle.heightMeters > fromDecimetres(height)) return true;
-  const width = limits.widthDecimetres[index];
-  if (width && vehicle.widthMeters > fromDecimetres(width)) return true;
-  const length = limits.lengthDecimetres[index];
-  if (length && vehicle.lengthMeters > fromDecimetres(length)) return true;
-  const weight = limits.weightHalfTonnes[index];
-  return Boolean(weight) && vehicle.weightTonnes > fromHalfTonnes(weight);
+// src/edge-index.ts
+var MAX_CELLS_PER_EDGE = 4096;
+function cellKey(latitudeCell, longitudeCell) {
+  return `${latitudeCell}:${longitudeCell}`;
 }
-function accessForVehicle(graph, vehicle) {
-  const limits = graph.edgeLimits;
-  if (!vehicle || !limits?.edges.length) return graph.edgeAccess;
-  const edges = graph.edgeTargets.length;
-  const mask = graph.edgeAccess ? Uint8Array.from(graph.edgeAccess) : accessMaskFor(edges, () => true);
-  for (let index = 0; index < limits.edges.length; index += 1) {
-    const edge = limits.edges[index];
-    if (edge < edges && blocks(limits, index, vehicle)) mask[edge >> 3] &= ~(1 << (edge & 7));
+function edgeSource(graph, edge) {
+  let low = 0;
+  let high = graph.nodeLatitudes.length - 1;
+  while (low < high) {
+    const middle = low + high + 1 >> 1;
+    if (graph.edgeOffsets[middle] <= edge) low = middle;
+    else high = middle - 1;
   }
-  return mask;
-}
-function countBlocked(graph, vehicle) {
-  const mask = accessForVehicle(graph, vehicle);
-  if (!mask) return 0;
-  let blocked = 0;
-  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) if (!edgeAllowed(mask, edge)) blocked += 1;
-  return blocked;
+  return low;
 }
-
-// src/types.ts
-var RouterError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "RouterError";
+function edgePolyline(graph, edge, source = edgeSource(graph, edge)) {
+  const scale = graph.coordinateScale ?? 1;
+  const target = graph.edgeTargets[edge];
+  const points = [{ lat: graph.nodeLatitudes[source] / scale, lng: graph.nodeLongitudes[source] / scale }];
+  if (graph.edgeShapeOffsets && graph.edgeShapeLatitudes && graph.edgeShapeLongitudes) {
+    for (let point = graph.edgeShapeOffsets[edge]; point < graph.edgeShapeOffsets[edge + 1]; point += 1) {
+      points.push({ lat: graph.edgeShapeLatitudes[point] / scale, lng: graph.edgeShapeLongitudes[point] / scale });
+    }
   }
-  code;
-};
-
-// src/spatial-index.ts
-function cellKey(latitude, longitude, cellSizeDegrees) {
-  return `${Math.floor(latitude / cellSizeDegrees)}:${Math.floor(longitude / cellSizeDegrees)}`;
+  points.push({ lat: graph.nodeLatitudes[target] / scale, lng: graph.nodeLongitudes[target] / scale });
+  return points;
 }
-function coordinateFor(graph, nodeId) {
+function createEdgeSpatialIndex(graph, cellSizeDegrees = 0.02) {
+  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Edge index cell size must be positive.");
   const scale = graph.coordinateScale ?? 1;
-  return { lat: graph.nodeLatitudes[nodeId] / scale, lng: graph.nodeLongitudes[nodeId] / scale };
-}
-function createSpatialIndex(graph, cellSizeDegrees = 0.02) {
-  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Spatial index cell size must be positive.");
   const buckets = /* @__PURE__ */ new Map();
-  for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) {
-    const coordinate = coordinateFor(graph, nodeId);
-    const key = cellKey(coordinate.lat, coordinate.lng, cellSizeDegrees);
-    const bucket = buckets.get(key);
-    if (bucket) bucket.push(nodeId);
-    else buckets.set(key, [nodeId]);
+  const oversized = [];
+  const shapeOffsets = graph.edgeShapeOffsets;
+  const shapeLatitudes = graph.edgeShapeLatitudes;
+  const shapeLongitudes = graph.edgeShapeLongitudes;
+  for (let source = 0; source < graph.nodeLatitudes.length; source += 1) {
+    const sourceLat = graph.nodeLatitudes[source] / scale;
+    const sourceLng = graph.nodeLongitudes[source] / scale;
+    for (let edge = graph.edgeOffsets[source]; edge < graph.edgeOffsets[source + 1]; edge += 1) {
+      const target = graph.edgeTargets[edge];
+      let minLat = Math.min(sourceLat, graph.nodeLatitudes[target] / scale);
+      let maxLat = Math.max(sourceLat, graph.nodeLatitudes[target] / scale);
+      let minLng = Math.min(sourceLng, graph.nodeLongitudes[target] / scale);
+      let maxLng = Math.max(sourceLng, graph.nodeLongitudes[target] / scale);
+      if (shapeOffsets && shapeLatitudes && shapeLongitudes) {
+        for (let point = shapeOffsets[edge]; point < shapeOffsets[edge + 1]; point += 1) {
+          const lat = shapeLatitudes[point] / scale;
+          const lng = shapeLongitudes[point] / scale;
+          if (lat < minLat) minLat = lat;
+          else if (lat > maxLat) maxLat = lat;
+          if (lng < minLng) minLng = lng;
+          else if (lng > maxLng) maxLng = lng;
+        }
+      }
+      const minLatCell = Math.floor(minLat / cellSizeDegrees);
+      const maxLatCell = Math.floor(maxLat / cellSizeDegrees);
+      const minLngCell = Math.floor(minLng / cellSizeDegrees);
+      const maxLngCell = Math.floor(maxLng / cellSizeDegrees);
+      if (!Number.isFinite(minLatCell) || !Number.isFinite(minLngCell) || (maxLatCell - minLatCell + 1) * (maxLngCell - minLngCell + 1) > MAX_CELLS_PER_EDGE) {
+        oversized.push(edge);
+        continue;
+      }
+      for (let latitudeCell = minLatCell; latitudeCell <= maxLatCell; latitudeCell += 1) {
+        for (let longitudeCell = minLngCell; longitudeCell <= maxLngCell; longitudeCell += 1) {
+          const key = cellKey(latitudeCell, longitudeCell);
+          const bucket = buckets.get(key);
+          if (bucket) bucket.push(edge);
+          else buckets.set(key, [edge]);
+        }
+      }
+    }
   }
-  return {
-    cellSizeDegrees,
-    cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)]))
-  };
-}
-function withSpatialIndex(graph, cellSizeDegrees) {
-  return { ...graph, spatialIndex: createSpatialIndex(graph, cellSizeDegrees) };
+  return { cellSizeDegrees, cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)])), oversized: Uint32Array.from(oversized) };
 }
-function nearbyNodeIds(index, coordinate, maxDistanceMeters) {
+var indexes = /* @__PURE__ */ new WeakMap();
+function edgeSpatialIndexFor(graph, cellSizeDegrees) {
+  let index = indexes.get(graph);
+  if (!index) {
+    index = createEdgeSpatialIndex(graph, cellSizeDegrees);
+    indexes.set(graph, index);
+  }
+  return index;
+}
+function nearbyEdgeIds(index, coordinate, maxDistanceMeters) {
   const latitudeDelta = maxDistanceMeters / 110574;
   const longitudeDelta = maxDistanceMeters / Math.max(1, 111320 * Math.cos(coordinate.lat * Math.PI / 180));
   const minLatitudeCell = Math.floor((coordinate.lat - latitudeDelta) / index.cellSizeDegrees);
   const maxLatitudeCell = Math.floor((coordinate.lat + latitudeDelta) / index.cellSizeDegrees);
   const minLongitudeCell = Math.floor((coordinate.lng - longitudeDelta) / index.cellSizeDegrees);
   const maxLongitudeCell = Math.floor((coordinate.lng + longitudeDelta) / index.cellSizeDegrees);
-  const ids = [];
+  const ids = new Set(index.oversized);
   for (let latitudeCell = minLatitudeCell; latitudeCell <= maxLatitudeCell; latitudeCell += 1) {
     for (let longitudeCell = minLongitudeCell; longitudeCell <= maxLongitudeCell; longitudeCell += 1) {
-      const bucket = index.cells.get(`${latitudeCell}:${longitudeCell}`);
-      if (bucket) ids.push(...bucket);
+      const bucket = index.cells.get(cellKey(latitudeCell, longitudeCell));
+      if (bucket) for (const id of bucket) ids.add(id);
     }
   }
   return ids;
 }
 
-// src/turn-restrictions.ts
-function buildTurnRestrictionIndex(graph) {
-  const fromEdges = graph.turnRestrictionFromEdges;
-  const toEdges = graph.turnRestrictionToEdges;
-  if (!fromEdges || !toEdges || !fromEdges.length) return null;
-  if (fromEdges.length !== toEdges.length) throw new Error("Turn restriction arrays must have the same length.");
-  const index = /* @__PURE__ */ new Map();
-  for (let pair = 0; pair < fromEdges.length; pair += 1) {
-    if (!edgeAllowed(graph.restrictionMask, pair)) continue;
-    const banned = index.get(fromEdges[pair]);
-    if (banned) banned.add(toEdges[pair]);
-    else index.set(fromEdges[pair], /* @__PURE__ */ new Set([toEdges[pair]]));
-  }
-  return index.size ? index : null;
-}
-function isTurnBanned(index, fromEdge, toEdge) {
-  return index.get(fromEdge)?.has(toEdge) ?? false;
-}
-function packTurnRestrictions(pairs) {
-  const unique = /* @__PURE__ */ new Set();
-  const sorted = [];
-  for (const [fromEdge, toEdge] of pairs) {
-    const key = `${fromEdge}:${toEdge}`;
-    if (unique.has(key)) continue;
-    unique.add(key);
-    sorted.push([fromEdge, toEdge]);
-  }
-  sorted.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-  return {
-    turnRestrictionFromEdges: Uint32Array.from(sorted, (pair) => pair[0]),
-    turnRestrictionToEdges: Uint32Array.from(sorted, (pair) => pair[1])
-  };
-}
-function buildTurnSequenceIndex(graph) {
-  const offsets = graph.turnRestrictionSequenceOffsets;
-  const edges = graph.turnRestrictionSequenceEdges;
-  if (!offsets || !edges || offsets.length < 2) return null;
-  const sequences = [];
-  const startingAt = /* @__PURE__ */ new Map();
-  const pairs = graph.turnRestrictionFromEdges?.length ?? 0;
-  for (let index = 0; index + 1 < offsets.length; index += 1) {
-    if (!edgeAllowed(graph.restrictionMask, pairs + index)) continue;
-    const sequence = Array.from(edges.subarray(offsets[index], offsets[index + 1]));
-    if (sequence.length < 3) continue;
-    const id = sequences.length;
-    sequences.push(sequence);
-    const bucket = startingAt.get(sequence[0]);
-    if (bucket) bucket.push(id);
-    else startingAt.set(sequence[0], [id]);
-  }
-  if (!sequences.length) return null;
-  const stride = sequences.reduce((longest, sequence) => Math.max(longest, sequence.length), 0) + 1;
-  return { sequences, startingAt, stride };
-}
-function packTurnSequences(sequences) {
-  const kept = sequences.filter((sequence) => sequence.length >= 3);
-  const unique = new Map(kept.map((sequence) => [sequence.join(","), sequence]));
-  const ordered = [...unique.values()].sort((a, b) => a[0] - b[0] || a.length - b.length || a[1] - b[1]);
-  const turnRestrictionSequenceOffsets = new Uint32Array(ordered.length + 1);
-  for (let index = 0; index < ordered.length; index += 1) turnRestrictionSequenceOffsets[index + 1] = turnRestrictionSequenceOffsets[index] + ordered[index].length;
-  const turnRestrictionSequenceEdges = new Uint32Array(turnRestrictionSequenceOffsets[ordered.length]);
-  let at = 0;
-  for (const sequence of ordered) for (const edge of sequence) turnRestrictionSequenceEdges[at++] = edge;
-  return { turnRestrictionSequenceOffsets, turnRestrictionSequenceEdges };
-}
-var guardedCache = /* @__PURE__ */ new WeakMap();
-function guardedJunctionsFor(graph, restrictions, sequences) {
-  const held = guardedCache.get(graph);
-  if (held) return held;
-  const nodes = graph.nodeLatitudes.length;
-  const edges = graph.edgeTargets.length;
-  const guarded = new Uint8Array(nodes);
-  if (restrictions) for (const edge of restrictions.keys()) guarded[graph.edgeTargets[edge]] = 1;
-  if (sequences) {
-    for (const sequence of sequences.sequences) {
-      for (const edge of sequence) guarded[graph.edgeTargets[edge]] = 1;
-    }
-  }
-  const stateOfEdge = new Int32Array(edges).fill(-1);
-  let count = 0;
-  for (let edge = 0; edge < edges; edge += 1) if (guarded[graph.edgeTargets[edge]]) stateOfEdge[edge] = count++;
-  const edgeOfState = new Int32Array(count);
-  for (let edge = 0; edge < edges; edge += 1) if (stateOfEdge[edge] >= 0) edgeOfState[stateOfEdge[edge]] = edge;
-  const index = { guarded, stateOfEdge, edgeOfState, count };
-  guardedCache.set(graph, index);
-  return index;
-}
-
-// src/edge-index.ts
-var MAX_CELLS_PER_EDGE = 4096;
-function cellKey2(latitudeCell, longitudeCell) {
-  return `${latitudeCell}:${longitudeCell}`;
-}
-function edgeSource(graph, edge) {
-  let low = 0;
-  let high = graph.nodeLatitudes.length - 1;
-  while (low < high) {
-    const middle = low + high + 1 >> 1;
-    if (graph.edgeOffsets[middle] <= edge) low = middle;
-    else high = middle - 1;
-  }
-  return low;
+// src/spatial-index.ts
+function cellKey2(latitude, longitude, cellSizeDegrees) {
+  return `${Math.floor(latitude / cellSizeDegrees)}:${Math.floor(longitude / cellSizeDegrees)}`;
 }
-function edgePolyline(graph, edge, source = edgeSource(graph, edge)) {
+function coordinateFor(graph, nodeId) {
   const scale = graph.coordinateScale ?? 1;
-  const target = graph.edgeTargets[edge];
-  const points = [{ lat: graph.nodeLatitudes[source] / scale, lng: graph.nodeLongitudes[source] / scale }];
-  if (graph.edgeShapeOffsets && graph.edgeShapeLatitudes && graph.edgeShapeLongitudes) {
-    for (let point = graph.edgeShapeOffsets[edge]; point < graph.edgeShapeOffsets[edge + 1]; point += 1) {
-      points.push({ lat: graph.edgeShapeLatitudes[point] / scale, lng: graph.edgeShapeLongitudes[point] / scale });
-    }
-  }
-  points.push({ lat: graph.nodeLatitudes[target] / scale, lng: graph.nodeLongitudes[target] / scale });
-  return points;
+  return { lat: graph.nodeLatitudes[nodeId] / scale, lng: graph.nodeLongitudes[nodeId] / scale };
 }
-function createEdgeSpatialIndex(graph, cellSizeDegrees = 0.02) {
-  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Edge index cell size must be positive.");
-  const scale = graph.coordinateScale ?? 1;
+function createSpatialIndex(graph, cellSizeDegrees = 0.02) {
+  if (!Number.isFinite(cellSizeDegrees) || cellSizeDegrees <= 0) throw new Error("Spatial index cell size must be positive.");
   const buckets = /* @__PURE__ */ new Map();
-  const oversized = [];
-  const shapeOffsets = graph.edgeShapeOffsets;
-  const shapeLatitudes = graph.edgeShapeLatitudes;
-  const shapeLongitudes = graph.edgeShapeLongitudes;
-  for (let source = 0; source < graph.nodeLatitudes.length; source += 1) {
-    const sourceLat = graph.nodeLatitudes[source] / scale;
-    const sourceLng = graph.nodeLongitudes[source] / scale;
-    for (let edge = graph.edgeOffsets[source]; edge < graph.edgeOffsets[source + 1]; edge += 1) {
-      const target = graph.edgeTargets[edge];
-      let minLat = Math.min(sourceLat, graph.nodeLatitudes[target] / scale);
-      let maxLat = Math.max(sourceLat, graph.nodeLatitudes[target] / scale);
-      let minLng = Math.min(sourceLng, graph.nodeLongitudes[target] / scale);
-      let maxLng = Math.max(sourceLng, graph.nodeLongitudes[target] / scale);
-      if (shapeOffsets && shapeLatitudes && shapeLongitudes) {
-        for (let point = shapeOffsets[edge]; point < shapeOffsets[edge + 1]; point += 1) {
-          const lat = shapeLatitudes[point] / scale;
-          const lng = shapeLongitudes[point] / scale;
-          if (lat < minLat) minLat = lat;
-          else if (lat > maxLat) maxLat = lat;
-          if (lng < minLng) minLng = lng;
-          else if (lng > maxLng) maxLng = lng;
-        }
-      }
-      const minLatCell = Math.floor(minLat / cellSizeDegrees);
-      const maxLatCell = Math.floor(maxLat / cellSizeDegrees);
-      const minLngCell = Math.floor(minLng / cellSizeDegrees);
-      const maxLngCell = Math.floor(maxLng / cellSizeDegrees);
-      if (!Number.isFinite(minLatCell) || !Number.isFinite(minLngCell) || (maxLatCell - minLatCell + 1) * (maxLngCell - minLngCell + 1) > MAX_CELLS_PER_EDGE) {
-        oversized.push(edge);
-        continue;
-      }
-      for (let latitudeCell = minLatCell; latitudeCell <= maxLatCell; latitudeCell += 1) {
-        for (let longitudeCell = minLngCell; longitudeCell <= maxLngCell; longitudeCell += 1) {
-          const key = cellKey2(latitudeCell, longitudeCell);
-          const bucket = buckets.get(key);
-          if (bucket) bucket.push(edge);
-          else buckets.set(key, [edge]);
-        }
-      }
-    }
+  for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) {
+    const coordinate = coordinateFor(graph, nodeId);
+    const key = cellKey2(coordinate.lat, coordinate.lng, cellSizeDegrees);
+    const bucket = buckets.get(key);
+    if (bucket) bucket.push(nodeId);
+    else buckets.set(key, [nodeId]);
   }
-  return { cellSizeDegrees, cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)])), oversized: Uint32Array.from(oversized) };
+  return {
+    cellSizeDegrees,
+    cells: new Map([...buckets].map(([key, ids]) => [key, Uint32Array.from(ids)]))
+  };
 }
-var indexes = /* @__PURE__ */ new WeakMap();
-function edgeSpatialIndexFor(graph, cellSizeDegrees) {
-  let index = indexes.get(graph);
-  if (!index) {
-    index = createEdgeSpatialIndex(graph, cellSizeDegrees);
-    indexes.set(graph, index);
-  }
-  return index;
+function withSpatialIndex(graph, cellSizeDegrees) {
+  return { ...graph, spatialIndex: createSpatialIndex(graph, cellSizeDegrees) };
 }
-function nearbyEdgeIds(index, coordinate, maxDistanceMeters) {
+function nearbyNodeIds(index, coordinate, maxDistanceMeters) {
   const latitudeDelta = maxDistanceMeters / 110574;
   const longitudeDelta = maxDistanceMeters / Math.max(1, 111320 * Math.cos(coordinate.lat * Math.PI / 180));
   const minLatitudeCell = Math.floor((coordinate.lat - latitudeDelta) / index.cellSizeDegrees);
   const maxLatitudeCell = Math.floor((coordinate.lat + latitudeDelta) / index.cellSizeDegrees);
   const minLongitudeCell = Math.floor((coordinate.lng - longitudeDelta) / index.cellSizeDegrees);
   const maxLongitudeCell = Math.floor((coordinate.lng + longitudeDelta) / index.cellSizeDegrees);
-  const ids = new Set(index.oversized);
+  const ids = [];
   for (let latitudeCell = minLatitudeCell; latitudeCell <= maxLatitudeCell; latitudeCell += 1) {
     for (let longitudeCell = minLongitudeCell; longitudeCell <= maxLongitudeCell; longitudeCell += 1) {
-      const bucket = index.cells.get(cellKey2(latitudeCell, longitudeCell));
-      if (bucket) for (const id of bucket) ids.add(id);
+      const bucket = index.cells.get(`${latitudeCell}:${longitudeCell}`);
+      if (bucket) ids.push(...bucket);
     }
   }
   return ids;
@@ -1461,6 +1775,8 @@ var METERS_PER_DEGREE_LATITUDE = 110574;
 var METERS_PER_DEGREE_LONGITUDE = 111320;
 var NODE_SNAP_TOLERANCE_METERS = 1;
 var TIE_TOLERANCE_METERS = 0.5;
+var DEFAULT_SNAP_RADIUS_METERS = 500;
+var FALLBACK_SNAP_RADIUS_METERS = 1e3;
 function haversineMeters(a, b) {
   const radians = Math.PI / 180;
   const dLat = (b.lat - a.lat) * radians;
@@ -1499,7 +1815,7 @@ function projectOntoPolyline(points, query) {
   }
   return { ...best, totalMeters: total };
 }
-function snapToGraph(graph, coordinate, maxDistanceMeters = 500, access = graph.edgeAccess, accept) {
+function snapToGraph(graph, coordinate, maxDistanceMeters = DEFAULT_SNAP_RADIUS_METERS, access = graph.edgeAccess, accept, everyNearbyRoad = false) {
   const candidates = graph.edgeTargets.length ? nearbyEdgeIds(edgeSpatialIndexFor(graph), coordinate, maxDistanceMeters) : /* @__PURE__ */ new Set();
   let best = null;
   const projections = [];
@@ -1529,9 +1845,9 @@ function snapToGraph(graph, coordinate, maxDistanceMeters = 500, access = graph.
   }
   const startMeters = best.fraction * totalLengthOf(best);
   const endMeters = (1 - best.fraction) * totalLengthOf(best);
-  if (startMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.source, point: best.polyline[0], distanceMeters: best.distanceMeters };
-  if (endMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.target, point: best.polyline[best.polyline.length - 1], distanceMeters: best.distanceMeters };
-  const sameRoad = projections.filter((projection) => projection.distanceMeters <= best.distanceMeters + TIE_TOLERANCE_METERS);
+  if (!everyNearbyRoad && startMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.source, point: best.polyline[0], distanceMeters: best.distanceMeters };
+  if (!everyNearbyRoad && endMeters <= NODE_SNAP_TOLERANCE_METERS) return { kind: "node", node: best.target, point: best.polyline[best.polyline.length - 1], distanceMeters: best.distanceMeters };
+  const sameRoad = everyNearbyRoad ? projections.sort((left, right) => left.distanceMeters - right.distanceMeters) : projections.filter((projection) => projection.distanceMeters <= best.distanceMeters + TIE_TOLERANCE_METERS);
   return { kind: "edge", projections: sameRoad, point: best.point, distanceMeters: best.distanceMeters };
 }
 function totalLengthOf(projection) {
@@ -1542,7 +1858,7 @@ function totalLengthOf(projection) {
 function nearestNodeWithin(graph, coordinate, maxDistanceMeters, accept) {
   let closest = null;
   let closestDistance = maxDistanceMeters;
-  const check = (nodeId) => {
+  const check2 = (nodeId) => {
     if (accept && !accept(nodeId)) return;
     const distance = haversineMeters(coordinate, coordinateFor2(graph, nodeId));
     if (distance <= closestDistance) {
@@ -1550,8 +1866,8 @@ function nearestNodeWithin(graph, coordinate, maxDistanceMeters, accept) {
       closestDistance = distance;
     }
   };
-  if (graph.spatialIndex) for (const nodeId of nearbyNodeIds(graph.spatialIndex, coordinate, maxDistanceMeters)) check(nodeId);
-  else for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) check(nodeId);
+  if (graph.spatialIndex) for (const nodeId of nearbyNodeIds(graph.spatialIndex, coordinate, maxDistanceMeters)) check2(nodeId);
+  else for (let nodeId = 0; nodeId < graph.nodeLatitudes.length; nodeId += 1) check2(nodeId);
   return closest;
 }
 function geometryAfter(projection) {
@@ -1564,6 +1880,230 @@ function geometryBetween(from, to) {
   return [from.point, ...from.polyline.slice(from.vertexIndex + 1, to.vertexIndex + 1), to.point];
 }
 
+// src/avoid.ts
+function check(area, index) {
+  const say = (what) => {
+    throw new RangeError(`avoid[${index}]: ${what}`);
+  };
+  if (!Number.isFinite(area.lat) || area.lat < -90 || area.lat > 90) say(`lat must be a latitude, not ${area.lat}.`);
+  if (!Number.isFinite(area.lng) || area.lng < -180 || area.lng > 180) say(`lng must be a longitude, not ${area.lng}.`);
+  if (!Number.isFinite(area.radiusMeters) || area.radiusMeters <= 0) say(`radiusMeters must be a positive distance, not ${area.radiusMeters}.`);
+}
+var METRES_PER_DEGREE_LATITUDE2 = 111320;
+function touchesArea(graph, edge, area, centre = { lat: area.lat, lng: area.lng }) {
+  const polyline = edgePolyline(graph, edge, edgeSource(graph, edge));
+  const longitudeScale = METRES_PER_DEGREE_LATITUDE2 * Math.cos(centre.lat * Math.PI / 180);
+  const apart = (from, to) => {
+    const delta = from - to;
+    return delta > 180 ? delta - 360 : delta < -180 ? delta + 360 : delta;
+  };
+  const x = (point) => apart(point.lng, centre.lng) * longitudeScale;
+  const y = (point) => (point.lat - centre.lat) * METRES_PER_DEGREE_LATITUDE2;
+  for (let index = 0; index < polyline.length; index += 1) {
+    if (haversineMeters(centre, polyline[index]) <= area.radiusMeters) return true;
+    if (index === 0) continue;
+    const ax = x(polyline[index - 1]);
+    const ay = y(polyline[index - 1]);
+    const bx = x(polyline[index]);
+    const by = y(polyline[index]);
+    const dx = bx - ax;
+    const dy = by - ay;
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared === 0) continue;
+    const along = Math.max(0, Math.min(1, -(ax * dx + ay * dy) / lengthSquared));
+    if (Math.hypot(ax + along * dx, ay + along * dy) <= area.radiusMeters) return true;
+  }
+  return false;
+}
+function accessAvoiding(graph, areas, base) {
+  const start = base ?? graph.edgeAccess;
+  if (!areas?.length) return start;
+  areas.forEach(check);
+  const edges = graph.edgeTargets.length;
+  let mask;
+  const index = edgeSpatialIndexFor(graph);
+  for (const area of areas) {
+    const centre = { lat: area.lat, lng: area.lng };
+    for (const edge of nearbyEdgeIds(index, centre, area.radiusMeters)) {
+      if (edge >= edges) continue;
+      if (mask && !edgeAllowed(mask, edge)) continue;
+      if (!touchesArea(graph, edge, area, centre)) continue;
+      mask ??= start ? Uint8Array.from(start) : accessMaskFor(edges, () => true);
+      mask[edge >> 3] &= ~(1 << (edge & 7));
+    }
+  }
+  return mask ?? start;
+}
+function countAvoided(graph, areas) {
+  const before = graph.edgeAccess;
+  const after = accessAvoiding(graph, areas);
+  if (after === before) return 0;
+  let closed = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) {
+    if (edgeAllowed(before, edge) && !edgeAllowed(after, edge)) closed += 1;
+  }
+  return closed;
+}
+
+// src/limits.ts
+var DECIMETRE_CEILING = 255;
+var HALF_TONNE_CEILING = 255;
+function toDecimetres(metres) {
+  if (metres === void 0 || !(metres > 0)) return 0;
+  const value = Math.floor(metres * 10);
+  return value > DECIMETRE_CEILING ? 0 : value;
+}
+function toHalfTonnes(tonnes) {
+  if (tonnes === void 0 || !(tonnes > 0)) return 0;
+  const value = Math.floor(tonnes * 2);
+  return value > HALF_TONNE_CEILING ? 0 : value;
+}
+var fromDecimetres = (value) => value / 10;
+var fromHalfTonnes = (value) => value / 2;
+function packEdgeLimits(entries) {
+  const rows = entries.map(({ edge, limits }) => ({
+    edge,
+    height: toDecimetres(limits.heightMeters),
+    width: toDecimetres(limits.widthMeters),
+    length: toDecimetres(limits.lengthMeters),
+    weight: toHalfTonnes(limits.weightTonnes)
+  })).filter((row) => row.height || row.width || row.length || row.weight).sort((a, b) => a.edge - b.edge);
+  if (!rows.length) return void 0;
+  return {
+    edges: Uint32Array.from(rows, (row) => row.edge),
+    heightDecimetres: Uint8Array.from(rows, (row) => row.height),
+    widthDecimetres: Uint8Array.from(rows, (row) => row.width),
+    lengthDecimetres: Uint8Array.from(rows, (row) => row.length),
+    weightHalfTonnes: Uint8Array.from(rows, (row) => row.weight)
+  };
+}
+function blocks(limits, index, vehicle) {
+  const height = limits.heightDecimetres[index];
+  if (height && vehicle.heightMeters > fromDecimetres(height)) return true;
+  const width = limits.widthDecimetres[index];
+  if (width && vehicle.widthMeters > fromDecimetres(width)) return true;
+  const length = limits.lengthDecimetres[index];
+  if (length && vehicle.lengthMeters > fromDecimetres(length)) return true;
+  const weight = limits.weightHalfTonnes[index];
+  return Boolean(weight) && vehicle.weightTonnes > fromHalfTonnes(weight);
+}
+function accessForVehicle(graph, vehicle) {
+  const limits = graph.edgeLimits;
+  if (!vehicle || !limits?.edges.length) return graph.edgeAccess;
+  const edges = graph.edgeTargets.length;
+  const mask = graph.edgeAccess ? Uint8Array.from(graph.edgeAccess) : accessMaskFor(edges, () => true);
+  for (let index = 0; index < limits.edges.length; index += 1) {
+    const edge = limits.edges[index];
+    if (edge < edges && blocks(limits, index, vehicle)) mask[edge >> 3] &= ~(1 << (edge & 7));
+  }
+  return mask;
+}
+function countBlocked(graph, vehicle) {
+  const mask = accessForVehicle(graph, vehicle);
+  if (!mask) return 0;
+  let blocked = 0;
+  for (let edge = 0; edge < graph.edgeTargets.length; edge += 1) if (!edgeAllowed(mask, edge)) blocked += 1;
+  return blocked;
+}
+
+// src/types.ts
+var RouterError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RouterError";
+  }
+  code;
+};
+
+// src/turn-restrictions.ts
+function buildTurnRestrictionIndex(graph) {
+  const fromEdges = graph.turnRestrictionFromEdges;
+  const toEdges = graph.turnRestrictionToEdges;
+  if (!fromEdges || !toEdges || !fromEdges.length) return null;
+  if (fromEdges.length !== toEdges.length) throw new Error("Turn restriction arrays must have the same length.");
+  const index = /* @__PURE__ */ new Map();
+  for (let pair = 0; pair < fromEdges.length; pair += 1) {
+    if (!edgeAllowed(graph.restrictionMask, pair)) continue;
+    const banned = index.get(fromEdges[pair]);
+    if (banned) banned.add(toEdges[pair]);
+    else index.set(fromEdges[pair], /* @__PURE__ */ new Set([toEdges[pair]]));
+  }
+  return index.size ? index : null;
+}
+function isTurnBanned(index, fromEdge, toEdge) {
+  return index.get(fromEdge)?.has(toEdge) ?? false;
+}
+function packTurnRestrictions(pairs) {
+  const unique = /* @__PURE__ */ new Set();
+  const sorted = [];
+  for (const [fromEdge, toEdge] of pairs) {
+    const key = `${fromEdge}:${toEdge}`;
+    if (unique.has(key)) continue;
+    unique.add(key);
+    sorted.push([fromEdge, toEdge]);
+  }
+  sorted.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  return {
+    turnRestrictionFromEdges: Uint32Array.from(sorted, (pair) => pair[0]),
+    turnRestrictionToEdges: Uint32Array.from(sorted, (pair) => pair[1])
+  };
+}
+function buildTurnSequenceIndex(graph) {
+  const offsets = graph.turnRestrictionSequenceOffsets;
+  const edges = graph.turnRestrictionSequenceEdges;
+  if (!offsets || !edges || offsets.length < 2) return null;
+  const sequences = [];
+  const startingAt = /* @__PURE__ */ new Map();
+  const pairs = graph.turnRestrictionFromEdges?.length ?? 0;
+  for (let index = 0; index + 1 < offsets.length; index += 1) {
+    if (!edgeAllowed(graph.restrictionMask, pairs + index)) continue;
+    const sequence = Array.from(edges.subarray(offsets[index], offsets[index + 1]));
+    if (sequence.length < 3) continue;
+    const id = sequences.length;
+    sequences.push(sequence);
+    const bucket = startingAt.get(sequence[0]);
+    if (bucket) bucket.push(id);
+    else startingAt.set(sequence[0], [id]);
+  }
+  if (!sequences.length) return null;
+  const stride = sequences.reduce((longest, sequence) => Math.max(longest, sequence.length), 0) + 1;
+  return { sequences, startingAt, stride };
+}
+function packTurnSequences(sequences) {
+  const kept = sequences.filter((sequence) => sequence.length >= 3);
+  const unique = new Map(kept.map((sequence) => [sequence.join(","), sequence]));
+  const ordered = [...unique.values()].sort((a, b) => a[0] - b[0] || a.length - b.length || a[1] - b[1]);
+  const turnRestrictionSequenceOffsets = new Uint32Array(ordered.length + 1);
+  for (let index = 0; index < ordered.length; index += 1) turnRestrictionSequenceOffsets[index + 1] = turnRestrictionSequenceOffsets[index] + ordered[index].length;
+  const turnRestrictionSequenceEdges = new Uint32Array(turnRestrictionSequenceOffsets[ordered.length]);
+  let at = 0;
+  for (const sequence of ordered) for (const edge of sequence) turnRestrictionSequenceEdges[at++] = edge;
+  return { turnRestrictionSequenceOffsets, turnRestrictionSequenceEdges };
+}
+var guardedCache = /* @__PURE__ */ new WeakMap();
+function guardedJunctionsFor(graph, restrictions, sequences) {
+  const held = guardedCache.get(graph);
+  if (held) return held;
+  const nodes = graph.nodeLatitudes.length;
+  const edges = graph.edgeTargets.length;
+  const guarded = new Uint8Array(nodes);
+  if (restrictions) for (const edge of restrictions.keys()) guarded[graph.edgeTargets[edge]] = 1;
+  if (sequences) {
+    for (const sequence of sequences.sequences) {
+      for (const edge of sequence) guarded[graph.edgeTargets[edge]] = 1;
+    }
+  }
+  const stateOfEdge = new Int32Array(edges).fill(-1);
+  let count = 0;
+  for (let edge = 0; edge < edges; edge += 1) if (guarded[graph.edgeTargets[edge]]) stateOfEdge[edge] = count++;
+  const edgeOfState = new Int32Array(count);
+  for (let edge = 0; edge < edges; edge += 1) if (stateOfEdge[edge] >= 0) edgeOfState[stateOfEdge[edge]] = edge;
+  const index = { guarded, stateOfEdge, edgeOfState, count };
+  guardedCache.set(graph, index);
+  return index;
+}
+
 // src/priority-queue.ts
 var MinPriorityQueue = class {
   values = [];
@@ -1608,6 +2148,7 @@ var MinPriorityQueue = class {
 };
 
 // src/router.ts
+var ROADS_TO_TRY = 6;
 function assertGraph(graph) {
   const nodes = graph.nodeLatitudes.length;
   const edges = graph.edgeTargets.length;
@@ -1632,7 +2173,7 @@ function findNearestNode(graph, coordinate, maxDistanceMeters = 500) {
   }
   return closest;
 }
-function searchContext(graph, destinationPoint, preference) {
+function searchContext(graph, destinationPoint, preference, slowed) {
   const distanceScale = graph.edgeDistanceScale ?? 1;
   const durationScale = graph.edgeDurationScale ?? 1;
   const { maxSpeedMps, longitudeMetresPerDegree } = searchBoundsFor(graph);
@@ -1643,7 +2184,11 @@ function searchContext(graph, destinationPoint, preference) {
   const destinationLongitude = destinationPoint.lng;
   const toCost = preference === "fastest" ? 1 / maxSpeedMps : 1;
   return {
-    costOf: (edge) => preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale,
+    // An overridden cost only ever exceeds the graph's own — a conditional
+    // limit slows an edge and a penalty makes it dearer — so the heuristic
+    // built from the graph's fastest edge stays a lower bound and the search
+    // still returns the best route under the costs it was given.
+    costOf: (edge) => slowed?.get(edge) ?? (preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale),
     // Called once per relaxation, millions of times on a long route, so it
     // reads the coordinate arrays directly and avoids a haversine's four
     // trigonometric calls for a number that only has to be a lower bound.
@@ -1656,8 +2201,8 @@ function searchContext(graph, destinationPoint, preference) {
     ) * toCost
   };
 }
-function searchByNode(graph, seeds, finishers, destinationPoint, preference, costBound, access) {
-  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference);
+function searchByNode(graph, seeds, finishers, destinationPoint, preference, costBound, access, slowed) {
+  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference, slowed);
   const nodeCount = graph.nodeLatitudes.length;
   const costs = new Float64Array(nodeCount).fill(Infinity);
   const previousNode = new Int32Array(nodeCount).fill(-1);
@@ -1705,8 +2250,8 @@ function searchByNode(graph, seeds, finishers, destinationPoint, preference, cos
   edges.reverse();
   return { edges, finisher: bestFinisher, seed: seedAt.get(node) };
 }
-function searchWithRestrictions(graph, seeds, finishers, destinationPoint, preference, restrictions, sequenceIndex, costBound, access) {
-  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference);
+function searchWithRestrictions(graph, seeds, finishers, destinationPoint, preference, restrictions, sequenceIndex, costBound, access, slowed) {
+  const { costOf, heuristicFor } = searchContext(graph, destinationPoint, preference, slowed);
   const targets = graph.edgeTargets;
   const { guarded, stateOfEdge, edgeOfState, count: guardedStates } = guardedJunctionsFor(graph, restrictions, sequenceIndex);
   const nodes = graph.nodeLatitudes.length;
@@ -1875,8 +2420,24 @@ function finishersFor(snap, costOf) {
 function projectionOf(snap, edge) {
   return snap.kind === "edge" ? snap.projections.find((projection) => projection.edge === edge) : void 0;
 }
-function snapSummary(snap) {
-  return snap.kind === "node" ? { node: snap.node, edge: -1, point: snap.point, distanceMeters: snap.distanceMeters } : { node: -1, edge: snap.projections[0].edge, point: snap.point, distanceMeters: snap.distanceMeters };
+function snapSummary(snap, travelledMeters = 0) {
+  return snap.kind === "node" ? { node: snap.node, edge: -1, point: snap.point, distanceMeters: snap.distanceMeters, travelledMeters: 0 } : { node: -1, edge: snap.projections[0].edge, point: snap.point, distanceMeters: snap.distanceMeters, travelledMeters };
+}
+function withPenalties(graph, preference, slowed, penalties) {
+  if (!penalties?.size) return slowed;
+  const distanceScale = graph.edgeDistanceScale ?? 1;
+  const durationScale = graph.edgeDurationScale ?? 1;
+  const costs = new Map(slowed);
+  for (const [edge, multiplier] of penalties) {
+    const base = costs.get(edge) ?? (preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale);
+    costs.set(edge, base * multiplier);
+  }
+  return costs;
+}
+function departureTime(options) {
+  const departAt = options.departAt;
+  if (!departAt) return void 0;
+  return departAt instanceof Date ? travelTimeFrom(departAt, options.publicHoliday, options.timeZone) : { ...departAt, publicHoliday: departAt.publicHoliday ?? options.publicHoliday };
 }
 function nodeOfSnap(snap) {
   return snap.kind === "node" ? snap.node : snap.projections[0].source;
@@ -1901,24 +2462,67 @@ function reconnect(graph, from, to, preference, options, access) {
 }
 function route(graph, from, to, preference = "fastest", options = {}) {
   assertGraph(graph);
-  const access = accessForVehicle(graph, options.vehicle);
+  const vehicleAccess = accessForVehicle(graph, options.vehicle);
+  const timed = accessAtTime(graph, conditionsOf(graph), departureTime(options), options.vehicle, vehicleAccess, options.circumstances);
+  const access = accessAvoiding(graph, options.avoid, timed);
   try {
     return routeBetween(graph, from, to, preference, options, access);
   } catch (error) {
     if (!(error instanceof RouterError) || error.code !== "NO_ROUTE") throw error;
-    return reconnect(graph, from, to, preference, options, access) ?? (() => {
+    const mended = reconnect(graph, from, to, preference, options, access);
+    if (mended) return mended;
+    if (options.finishOnANearbyRoad === false) throw error;
+    return onAnotherRoad(graph, from, to, preference, options, access) ?? (() => {
       throw error;
     })();
   }
 }
-function routeBetween(graph, from, to, preference, options, access, acceptOrigin, acceptDestination) {
-  const originSnap = snapToGraph(graph, from, void 0, access, acceptOrigin);
+function roadsNear(graph, point, access) {
+  const nearby = snapToGraph(graph, point, FALLBACK_SNAP_RADIUS_METERS, access, void 0, true);
+  if (!nearby || nearby.kind === "node") return nearby ? [nearby] : [];
+  const byRoad = /* @__PURE__ */ new Map();
+  for (const projection of nearby.projections) {
+    const key = `${Math.min(projection.source, projection.target)}:${Math.max(projection.source, projection.target)}`;
+    const held = byRoad.get(key);
+    if (held) held.push(projection);
+    else byRoad.set(key, [projection]);
+  }
+  return [...byRoad.values()].map((projections) => ({
+    kind: "edge",
+    projections,
+    point: projections[0].point,
+    distanceMeters: projections[0].distanceMeters
+  }));
+}
+function onAnotherRoad(graph, from, to, preference, options, access) {
+  const attempt = (chosen) => {
+    try {
+      return routeBetween(graph, from, to, preference, options, access, void 0, void 0, chosen);
+    } catch {
+      return null;
+    }
+  };
+  for (const destination of roadsNear(graph, to, access).slice(1, ROADS_TO_TRY + 1)) {
+    const found = attempt({ destination });
+    if (found) return found;
+  }
+  for (const origin of roadsNear(graph, from, access).slice(1, ROADS_TO_TRY + 1)) {
+    const found = attempt({ origin });
+    if (found) return found;
+  }
+  return null;
+}
+function routeBetween(graph, from, to, preference, options, access, acceptOrigin, acceptDestination, chosen) {
+  const originSnap = chosen?.origin ?? snapToGraph(graph, from, void 0, access, acceptOrigin);
   if (!originSnap) throw new RouterError("ORIGIN_NOT_ON_GRAPH", "No routable road is close to the origin.");
-  const destinationSnap = snapToGraph(graph, to, void 0, access, acceptDestination);
+  const destinationSnap = chosen?.destination ?? snapToGraph(graph, to, void 0, access, acceptDestination);
   if (!destinationSnap) throw new RouterError("DESTINATION_NOT_ON_GRAPH", "No routable road is close to the destination.");
   const distanceScale = graph.edgeDistanceScale ?? 1;
   const durationScale = graph.edgeDurationScale ?? 1;
-  const costOf = (edge) => preference === "fastest" ? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale;
+  const when = departureTime(options);
+  const conditionallySlowed = preference === "fastest" && when ? conditionalDurations(graph, conditionsOf(graph), when, options.vehicle, options.circumstances) : void 0;
+  const slowed = withPenalties(graph, preference, conditionallySlowed, options.costPenalties);
+  const costOf = (edge) => preference === "fastest" ? conditionallySlowed?.get(edge) ?? graph.edgeDurationsSeconds[edge] * durationScale : graph.edgeDistancesMeters[edge] * distanceScale;
   const seeds = seedsFor(originSnap, costOf);
   const finisherList = finishersFor(destinationSnap, costOf);
   const finishers = /* @__PURE__ */ new Map();
@@ -1940,7 +2544,7 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
   const costBound = options.costBound ?? Infinity;
   const restrictions = buildTurnRestrictionIndex(graph);
   const sequenceIndex = buildTurnSequenceIndex(graph);
-  const outcome = sameNode ? { edges: [], finisher: finisherList[0], seed: seeds[0] } : restrictions || sequenceIndex ? searchWithRestrictions(graph, seeds, finishers, destinationSnap.point, preference, restrictions, sequenceIndex, costBound, access) : searchByNode(graph, seeds, finishers, destinationSnap.point, preference, costBound, access);
+  const outcome = sameNode ? { edges: [], finisher: finisherList[0], seed: seeds[0] } : restrictions || sequenceIndex ? searchWithRestrictions(graph, seeds, finishers, destinationSnap.point, preference, restrictions, sequenceIndex, costBound, access, slowed) : searchByNode(graph, seeds, finishers, destinationSnap.point, preference, costBound, access, slowed);
   if (direct && direct.cost >= costBound) direct = null;
   if (!outcome && !direct) throw new RouterError("NO_ROUTE", `No ${profileOf(graph).name} route connects the selected points.`);
   const searchCost = outcome ? outcome.seed.cost + outcome.edges.reduce((sum, edge) => sum + costOf(edge), 0) + outcome.finisher.cost : Infinity;
@@ -1954,11 +2558,14 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
   let edgeIds = [];
   let distanceMeters = 0;
   let durationSeconds = 0;
+  let travelledAtOrigin = 0;
+  let travelledAtDestination = 0;
   if (direct && direct.cost <= searchCost) {
     for (const point of geometryBetween(direct.origin, direct.destination)) push(point);
     const span = partial(direct.origin, direct.destination.fraction - direct.origin.fraction);
     distanceMeters = span.distance;
     durationSeconds = span.duration;
+    travelledAtOrigin = span.distance;
   } else {
     const { edges, finisher, seed } = outcome;
     edgeIds = edges;
@@ -1969,6 +2576,7 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
       const span = partial(entry, 1 - entry.fraction);
       distanceMeters += span.distance;
       durationSeconds += span.duration;
+      travelledAtOrigin = span.distance;
       nodeIds.push(entry.target);
       push(coordinateFor2(graph, entry.target));
     } else {
@@ -1977,7 +2585,7 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
     const scale = graph.coordinateScale ?? 1;
     for (const edge of edges) {
       distanceMeters += graph.edgeDistancesMeters[edge] * distanceScale;
-      durationSeconds += graph.edgeDurationsSeconds[edge] * durationScale;
+      durationSeconds += conditionallySlowed?.get(edge) ?? graph.edgeDurationsSeconds[edge] * durationScale;
       if (graph.edgeShapeOffsets && graph.edgeShapeLatitudes && graph.edgeShapeLongitudes) {
         for (let point = graph.edgeShapeOffsets[edge]; point < graph.edgeShapeOffsets[edge + 1]; point += 1) {
           coordinates.push([graph.edgeShapeLongitudes[point] / scale, graph.edgeShapeLatitudes[point] / scale]);
@@ -1992,6 +2600,7 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
       const span = partial(exit, exit.fraction);
       distanceMeters += span.distance;
       durationSeconds += span.duration;
+      travelledAtDestination = span.distance;
     }
   }
   return {
@@ -1999,8 +2608,8 @@ function routeBetween(graph, from, to, preference, options, access, acceptOrigin
     edgeIds,
     distanceMeters,
     durationSeconds,
-    originSnap: snapSummary(originSnap),
-    destinationSnap: snapSummary(destinationSnap),
+    originSnap: snapSummary(originSnap, travelledAtOrigin),
+    destinationSnap: snapSummary(destinationSnap, travelledAtDestination),
     geometry: { type: "LineString", coordinates }
   };
 }
@@ -2013,8 +2622,22 @@ export {
   unzigzag,
   VarintWriter,
   VarintReader,
-  ProfileId,
   parseMaxSpeedKph,
+  MAX_STORED_VALUES,
+  parseConditional,
+  conditionHolds,
+  conditionalValue,
+  unreadableConditions,
+  travelTimeFrom,
+  ConditionKind,
+  packEdgeConditions,
+  parseEdgeConditions,
+  conditionsOnEdge,
+  accessAtTime,
+  countClosedAt,
+  conditionsOf,
+  conditionalDurations,
+  ProfileId,
   parseLengthMeters,
   parseWeightTonnes,
   carRoutingProfile,
@@ -2037,6 +2660,17 @@ export {
   straightLineAtMost,
   componentsFor,
   componentSizes,
+  edgeSource,
+  edgePolyline,
+  createEdgeSpatialIndex,
+  edgeSpatialIndexFor,
+  nearbyEdgeIds,
+  createSpatialIndex,
+  withSpatialIndex,
+  snapToGraph,
+  touchesArea,
+  accessAvoiding,
+  countAvoided,
   toDecimetres,
   toHalfTonnes,
   fromDecimetres,
@@ -2045,20 +2679,12 @@ export {
   accessForVehicle,
   countBlocked,
   RouterError,
-  createSpatialIndex,
-  withSpatialIndex,
   buildTurnRestrictionIndex,
   isTurnBanned,
   packTurnRestrictions,
   buildTurnSequenceIndex,
   packTurnSequences,
   guardedJunctionsFor,
-  edgeSource,
-  edgePolyline,
-  createEdgeSpatialIndex,
-  edgeSpatialIndexFor,
-  nearbyEdgeIds,
-  snapToGraph,
   findNearestNode,
   route
 };