roadgraph-router-v2 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -38,6 +38,37 @@ interface RoadGraph {
     edgeDistanceScale?: number;
     /** Edge duration values are multiplied by this scale. Omitted means seconds. */
     edgeDurationScale?: number;
+    /**
+     * The routing profile this graph was compiled for, as a `ProfileId`. Absent
+     * means the graph predates profile metadata, and every such graph is a car
+     * graph. A graph only answers for the vehicle it was compiled for: a car
+     * graph has no footpaths in it to walk along.
+     */
+    profileId?: number;
+    /**
+     * The profile's speed ceiling in km/h, carried so a reader can bound its A*
+     * heuristic and its tile budget without knowing the profile's rules. Absent
+     * falls back to the profile's own ceiling.
+     */
+    maxSpeedKph?: number;
+    /**
+     * One bit per edge saying whether this profile may use it, present only on a
+     * graph assembled from a shared topology that several profiles share. Absent
+     * means every edge is usable. See `./access`.
+     */
+    edgeAccess?: Uint8Array;
+    /**
+     * The physical limits in force on the few edges that state any. Present only
+     * for a profile whose routes depend on the vehicle's size. See `./limits`.
+     */
+    edgeLimits?: EdgeLimits;
+    /** Conditional restrictions for the edges that carry one; absent when none do. */
+    edgeConditions?: EdgeConditions;
+    /**
+     * One bit per turn restriction, saying whether this vehicle obeys it. The
+     * pairs come first, then the sequences. Absent means all of them apply.
+     */
+    restrictionMask?: Uint8Array;
     /** Optional intermediate vertices per directed edge, stored using coordinateScale. */
     edgeShapeOffsets?: Uint32Array;
     edgeShapeLatitudes?: Int32Array;
@@ -71,6 +102,14 @@ interface RouteSnap {
     point: Coordinate;
     /** How far the requested coordinate was from that road. */
     distanceMeters: number;
+    /**
+     * How far the route actually travels along that road, for an end that
+     * begins or finishes part-way along one. Zero where the end sits on a
+     * junction, and zero at the destination of a route that never leaves a
+     * single road, whose whole length is reported at the origin instead so
+     * that adding the two up gives the route and not twice the route.
+     */
+    travelledMeters?: number;
 }
 interface RouteResult {
     geometry: GeoJsonLineString;
@@ -92,6 +131,71 @@ declare class RouterError extends Error {
     readonly code: RouterErrorCode;
     constructor(code: RouterErrorCode, message: string);
 }
+/**
+ * Signed height, width, length and weight limits, for the edges that have them.
+ *
+ * A side table rather than four columns over every edge: the overwhelming
+ * majority of roads state no limit at all, so columns would spend four bytes
+ * per edge saying nothing nearly everywhere. `edges` is sorted, and the four
+ * arrays run alongside it. A zero means the limit is not stated, which is not
+ * the same as a limit of zero.
+ */
+interface EdgeLimits {
+    edges: Uint32Array;
+    /** Tenths of a metre. */
+    heightDecimetres: Uint8Array;
+    widthDecimetres: Uint8Array;
+    lengthDecimetres: Uint8Array;
+    /** Half-tonnes. */
+    weightHalfTonnes: Uint8Array;
+}
+/**
+ * Conditional restrictions for the few edges carrying one: the raw
+ * `value @ condition` text, kept as written and parsed when a bundle opens.
+ *
+ * A side table for the same reason the limits are one — a country has a few
+ * thousand of these among millions of edges. The text is deduplicated into
+ * `values`, because the same working-hours ban is repeated along every segment
+ * of the street it applies to. One edge may have several rows: a lorry ban and
+ * a night speed limit are both conditional and both apply.
+ */
+interface EdgeConditions {
+    /** Sorted by edge, then by kind; an edge may appear more than once. */
+    edges: Uint32Array;
+    /** What the value means: 0 is access, 1 is a speed limit in km/h. */
+    kinds: Uint8Array;
+    /** Index into `values`. */
+    rules: Uint16Array;
+    /** The deduplicated conditional values, as tagged. */
+    values: string[];
+}
+/**
+ * A tile's vehicle-independent half: everything a v7 `shared` chunk holds.
+ * It is not routable on its own — a profile supplies the durations.
+ */
+type SharedRoadGraph = Omit<RoadGraph, "edgeDurationsSeconds" | "edgeDurationScale" | "profileId" | "maxSpeedKph" | "edgeAccess">;
+/** A tile's vehicle-dependent half: what a v7 `profile` chunk holds. */
+interface ProfileChunk {
+    profileId: number;
+    maxSpeedKph: number;
+    edgeDurationScale: number;
+    edgeDurationsSeconds: Uint16Array;
+    /** One bit per edge; absent means this profile may use every road in the tile. */
+    edgeAccess?: Uint8Array;
+    /** Signed limits for the few edges that state any; absent for vehicles whose size does not matter. */
+    edgeLimits?: EdgeLimits;
+    /** Conditional restrictions for the edges that carry one; absent when none do. */
+    edgeConditions?: EdgeConditions;
+    /**
+     * One bit per turn restriction the shared chunk holds, saying whether this
+     * vehicle obeys it. `except=hgv` lifts a restriction for lorries and not for
+     * cars, so a shared restriction list needs a per-vehicle answer. Absent
+     * means every restriction applies.
+     */
+    restrictionMask?: Uint8Array;
+    /** How many restrictions that mask covers: the pairs, then the sequences. */
+    restrictionCount?: number;
+}
 
 declare function encodeGraph(graph: RoadGraph): ArrayBuffer;
 declare function decodeGraph(buffer: ArrayBuffer): RoadGraph;
@@ -110,6 +214,27 @@ type CompactEncodeOptions = {
     layout?: "packed" | "legacy";
 };
 declare function encodeCompactGraph(graph: RoadGraph, options?: CompactEncodeOptions): ArrayBuffer;
+/**
+ * The parts of a tile that do not depend on the vehicle. Identical to the v6
+ * layout except that the duration column is left out, because that is the one
+ * per-edge value a profile changes.
+ */
+declare function encodeSharedGraph(graph: RoadGraph): ArrayBuffer;
+/**
+ * The vehicle-dependent half of a tile: the duration of every edge for this
+ * profile, and which edges it may use at all. An access mask that lets
+ * everything through is left out, which is the usual case for the profile a
+ * tile's topology was built around.
+ */
+declare function encodeProfileChunk(chunk: ProfileChunk): ArrayBuffer;
+declare function decodeProfileChunk(buffer: ArrayBuffer): ProfileChunk;
+/**
+ * The vehicle-independent half of a tile. Not routable on its own: every
+ * duration is zero until a profile chunk supplies them.
+ */
+declare function decodeSharedGraph(buffer: ArrayBuffer): SharedRoadGraph;
+/** Joins a tile's two halves into the routable graph the rest of the library uses. */
+declare function combineProfiledGraph(shared: SharedRoadGraph, profile: ProfileChunk): RoadGraph;
 
 /**
  * LEB128 variable-length integers, with zigzag for signed values.
@@ -155,6 +280,529 @@ type CompactGraphOptions = {
  */
 declare function compactGraph(graph: RoadGraph, options?: CompactGraphOptions): RoadGraph;
 
+/**
+ * Which edges a profile may use, as one bit per edge.
+ *
+ * A multi-profile bundle stores the road network once and the vehicle-specific
+ * parts separately, so the shared topology holds every road any of its
+ * profiles can drive. A profile that cannot use a road marks its bit clear
+ * rather than having the edge removed: edge numbers are what turn restrictions
+ * and shape references are written against, so they have to stay put.
+ */
+declare function accessMaskFor(edges: number, allowed: (edge: number) => boolean): Uint8Array<ArrayBuffer>;
+/** An absent mask means every edge is usable, which is what a single-profile graph holds. */
+declare function edgeAllowed(mask: Uint8Array | undefined, edge: number): boolean;
+/** True when the mask lets every edge through, in which case it need not be stored. */
+declare function allowsEverything(mask: Uint8Array, edges: number): boolean;
+
+/**
+ * The two constants an A* search needs from a graph, measured once per graph
+ * rather than assumed.
+ *
+ * Both exist to keep the heuristic admissible — never larger than the true
+ * remaining cost — while making it as cheap and as tight as the data allows.
+ * An inadmissible heuristic does not merely slow a search down; it lets A*
+ * settle for a route that is not the best one.
+ */
+
+type SearchBounds = {
+    /**
+     * The fastest any edge in this graph is actually travelled. Quantising a
+     * short edge's duration downwards can imply a speed above the profile's
+     * own ceiling, and dividing by the lower number would overestimate what
+     * remains, so the measured value is used rather than the declared one.
+     */
+    maxSpeedMps: number;
+    /**
+     * Scales a longitude difference into metres using the highest latitude in
+     * the graph, where a degree of longitude is shortest. Under-estimating that
+     * everywhere keeps the straight-line estimate below the true distance.
+     */
+    longitudeMetresPerDegree: number;
+};
+declare function searchBoundsFor(graph: RoadGraph): SearchBounds;
+/**
+ * A lower bound on the great-circle distance between two points, without the
+ * four trigonometric calls a haversine needs. The heuristic asks for this once
+ * per relaxation — millions of times on a long route — and only ever needs a
+ * number that cannot exceed the truth.
+ */
+declare function straightLineAtMost(latitudeA: number, longitudeA: number, latitudeB: number, longitudeB: number, longitudeMetresPerDegree: number): number;
+
+/**
+ * Which parts of a graph are joined to which.
+ *
+ * A road network is not one piece. Service roads inside a compound, a path
+ * fragment behind a fence, a stretch clipped by the edge of a tile — all sit
+ * apart from the rest, and a point a couple of metres from one of them snaps
+ * to it rather than to the road just beyond. The route then fails although a
+ * perfectly good road was in reach.
+ *
+ * Labels are weak: an edge joins its two nodes whichever way it points. That
+ * is deliberately the cheap question. Two nodes in different pieces certainly
+ * cannot reach each other, which is what the snapper needs to know; two in the
+ * same piece usually can, and where a one-way trap says otherwise the search
+ * finds out for itself.
+ */
+
+/** One label per node. Nodes sharing a label are joined, ignoring direction. */
+declare function componentsFor(graph: RoadGraph): Int32Array;
+/** How many nodes carry each label, so the smaller piece can be recognised. */
+declare function componentSizes(labels: Int32Array): Map<number, number>;
+
+/**
+ * Roads the caller knows are shut.
+ *
+ * A compiled bundle is as current as the extract it came from: roadworks, a
+ * burst main, a festival closing the square are all things that happened
+ * after it was built, and nothing inside it can know about them. What it can
+ * do is let whoever does know say so at the time of asking.
+ *
+ * An area rather than a road, because a caller reading an incident feed has a
+ * place and a radius, not an edge number. Anything the circle touches is
+ * closed to the search and to snapping, exactly as a tagged restriction would
+ * be, so a route neither drives through a closure nor starts in the middle of
+ * one.
+ */
+
+/** A circle of road that cannot be driven, whatever the map says. */
+type AvoidArea = {
+    lat: number;
+    lng: number;
+    /** How far the closure reaches from that point. */
+    radiusMeters: number;
+};
+/**
+ * Whether any part of this edge lies inside the circle.
+ *
+ * The whole of each segment counts, not only its ends: a motorway crossing a
+ * closed junction may have no shape point anywhere near it, and testing the
+ * ends alone would drive a route straight through.
+ */
+declare function touchesArea(graph: RoadGraph, edge: number, area: AvoidArea, centre?: Coordinate): boolean;
+/**
+ * The access mask with every road the caller has closed cleared as well.
+ *
+ * Only the roads near each circle are looked at, so closing a junction costs
+ * the same whether the graph holds a town or a country.
+ */
+declare function accessAvoiding(graph: RoadGraph, areas: AvoidArea[] | undefined, base?: Uint8Array): Uint8Array | undefined;
+/** How many roads these closures take away, for reporting rather than routing. */
+declare function countAvoided(graph: RoadGraph, areas: AvoidArea[] | undefined): number;
+
+/**
+ * Reading a speed off an OSM tag.
+ *
+ * It lives on its own because both the profiles and the conditional
+ * restrictions need it, and a conditional limit is written in the same units
+ * as a plain one: `maxspeed:conditional = 30 mph @ (Mo-Fr 07:00-19:00)` means
+ * 30 mph, not 30 km/h.
+ */
+/** Kilometres per hour, or null when the value is not a speed this reads. */
+declare function parseMaxSpeedKph(value: string | undefined): number | null;
+
+/**
+ * Routing profiles turn raw OSM tags into routable facts: may a vehicle use
+ * this way, in which directions, and how fast. Keeping the rules behind one
+ * interface lets the compiler stay generic — it never inspects a tag itself —
+ * and lets the rules be unit-tested without a PBF file.
+ */
+
+type OsmTags = Record<string, string | undefined>;
+/** How a profile may traverse one OSM way. */
+type WayTraversal = {
+    /**
+     * Conditional restrictions tagged on the way, kept as written for the
+     * router to evaluate against a departure time. They apply to both
+     * directions: OSM states these per vehicle class, not per direction.
+     */
+    conditions?: {
+        kind: number;
+        value: string;
+    }[];
+    /** Travel from the first node reference towards the last is allowed. */
+    forward: boolean;
+    /** Travel from the last node reference towards the first is allowed. */
+    backward: boolean;
+    /** Travel speed in km/h in each direction; both are clamped to the profile range. */
+    forwardSpeedKph: number;
+    backwardSpeedKph: number;
+    /** Physical limits in force along this way, where the data states any. */
+    forwardLimits?: VehicleLimits;
+    backwardLimits?: VehicleLimits;
+};
+/** A turn restriction relation reduced to the only two cases routing cares about. */
+type TurnRestrictionKind = "no" | "only";
+/**
+ * A physical limit OSM states for a way. Every field is optional because an
+ * untagged limit is unknown, not absent: most bridges carry no `maxheight` at
+ * all, and treating silence as "no limit" is the assumption this library makes
+ * and says so, rather than inventing a number.
+ */
+type VehicleLimits = {
+    heightMeters?: number;
+    widthMeters?: number;
+    lengthMeters?: number;
+    weightTonnes?: number;
+};
+type ParsedTurnRestriction = {
+    kind: TurnRestrictionKind;
+    /** The raw OSM value, kept for diagnostics only. */
+    value: string;
+};
+/**
+ * Stable numeric ids written into compiled graphs. They are part of the file
+ * format, so a value is never reused for a different profile; 0 is reserved
+ * for graphs compiled before profiles were recorded, which were all cars.
+ */
+declare const ProfileId: {
+    readonly unspecified: 0;
+    readonly car: 1;
+    readonly truck: 2;
+    readonly motorcycle: 3;
+    readonly bicycle: 4;
+    readonly pedestrian: 5;
+};
+type ProfileId = (typeof ProfileId)[keyof typeof ProfileId];
+interface RoutingProfile {
+    readonly name: string;
+    /** The id this profile is stored under. See `ProfileId`. */
+    readonly id: ProfileId;
+    /** Way tag keys the compiler must request from the PBF reader. */
+    readonly wayTagKeys: readonly string[];
+    /** Relation tag keys the compiler must request from the PBF reader. */
+    readonly relationTagKeys: readonly string[];
+    /** The fastest speed the profile can ever return, used for admissible A* heuristics. */
+    readonly maxSpeedKph: number;
+    /** Returns null when the way is not usable by this profile at all. */
+    evaluateWay(tags: OsmTags): WayTraversal | null;
+    /** Returns null when the relation is not a turn restriction this profile obeys. */
+    evaluateTurnRestriction(tags: OsmTags): ParsedTurnRestriction | null;
+    /**
+     * Whether this profile's routes depend on the vehicle's physical size, which
+     * tells the compiler to keep the limits `evaluateWay` reports.
+     */
+    readonly usesPhysicalLimits?: boolean;
+    /** Node tag keys the compiler must request, for barriers. */
+    readonly nodeTagKeys?: readonly string[];
+    /**
+     * Whether this traveller gets past a barrier on the road. Returns true when
+     * the node is not a barrier at all, so an absent answer means "carry on".
+     */
+    evaluateBarrier?(tags: OsmTags): boolean;
+}
+/**
+ * Reads a `maxheight`-style value in metres. Feet and inches are accepted
+ * because they are how the limit is written wherever it is signed that way;
+ * anything that is not a measurement reads as unknown rather than as zero,
+ * which would close the road to everything.
+ */
+declare function parseLengthMeters(value: string | undefined): number | null;
+/** Reads a `maxweight`-style value in tonnes. A bare number is tonnes, as OSM defines it. */
+declare function parseWeightTonnes(value: string | undefined): number | null;
+declare const carRoutingProfile: RoutingProfile;
+/**
+ * Motorcycles use the same roads and the same speed limits as cars almost
+ * everywhere, so the difference is which tags apply to them: `motorcycle=no`
+ * closes a road a car may still use, `oneway:motorcycle=no` opens one, and
+ * `except=motorcar` on a turn restriction does not let a motorcycle through.
+ */
+declare const motorcycleRoutingProfile: RoutingProfile;
+/**
+ * Heavy goods vehicles. `hgv` is the OSM key for them, and it sits below
+ * `motor_vehicle` in the same ladder every motor vehicle uses.
+ *
+ * Two things set a lorry apart. It is slower: a heavy vehicle is capped below
+ * the posted limit almost everywhere, so a truck graph that reused car
+ * durations would give wrong arrival times on roads it is perfectly entitled
+ * to use. And it is large: height, width, length and weight limits decide
+ * whether a road is usable at all, which depends on the lorry rather than on
+ * the map, so those limits are carried through to be applied at routing time.
+ */
+declare const truckRoutingProfile: RoutingProfile;
+declare const routingProfiles: Record<string, RoutingProfile>;
+declare function getRoutingProfile(name: string): RoutingProfile;
+/** The profile a stored id refers to, or null when this build does not know it. */
+declare function getRoutingProfileById(id: number): RoutingProfile | null;
+/**
+ * A graph compiled before profiles were recorded is a car graph, which is what
+ * every bundle published up to v0.1.0 holds.
+ */
+declare function profileOf(graph: {
+    profileId?: number;
+}): RoutingProfile;
+/**
+ * The speed ceiling a search may assume, in metres per second. The value
+ * stored in the graph wins over this build's table, so a bundle compiled by a
+ * newer version still bounds an older reader's heuristic correctly.
+ */
+declare function maxSpeedMpsFor(graph: {
+    profileId?: number;
+    maxSpeedKph?: number;
+}): number;
+
+/**
+ * The lorry a truck route iscalculated for.
+ *
+ * A caller who says nothing still gets a vehicle, because refusing to route
+ * until a form is filled in is worse than routing for a stated default. The
+ * danger is not having a default, it is a default nobody can see, so the
+ * resolved dimensions ride on every truck route.
+ *
+ * There is no globally neutral lorry. EU general circulation is 2.55m wide,
+ * 16.5m long articulated and 40t on a five-axle vehicle no taller than 4m;
+ * a US semi is wider and taller at 2.59m and about 4.11m but lighter at
+ * 36.3t, and Nordic combinations run longer and heavier still. Guessing large
+ * on every axis is not safe either: `maxheight=4.0` and `maxweight=40` are
+ * among the commonly tagged limits in Europe, so a 4.2m default would refuse
+ * bridges an ordinary lorry crosses daily. The presets below are therefore
+ * vehicle classes a caller picks, not a guess about where they are.
+ */
+
+type VehicleDimensions = {
+    heightMeters: number;
+    widthMeters: number;
+    lengthMeters: number;
+    weightTonnes: number;
+};
+/**
+ * Stable ids, so a bundle can name its default vehicle in one byte. They are
+ * part of the file format: a value is never reused for a different class, and
+ * 0 means the bundle states no default, which falls back to the library's.
+ */
+declare const VehiclePresetId: Record<string, number>;
+declare function vehiclePresetName(id: number): string | null;
+declare const VEHICLE_PRESETS: Record<string, VehicleDimensions>;
+/**
+ * What a truck route uses when nothing else says otherwise. An articulated
+ * lorry is what most people mean by "truck" for freight, and it matches the
+ * envelope European road data is implicitly tagged against.
+ */
+declare const DEFAULT_VEHICLE_PRESET = "articulated";
+/** A preset name, a full set of dimensions, or a preset with fields overridden. */
+type VehicleInput = string | Partial<VehicleDimensions> & {
+    preset?: string;
+};
+declare function vehiclePreset(name: string): VehicleDimensions;
+/**
+ * Resolves what a caller asked for against a preset, so `{ preset:
+ * "articulated", heightMeters: 4.3 }` is a standard lorry with a taller load
+ * rather than a vehicle with three dimensions missing.
+ */
+declare function resolveVehicle(input: VehicleInput | undefined, fallbackPreset?: string): VehicleDimensions;
+
+/**
+ * Turning signed limits into the handful of bytes a bundle stores, and back
+ * into a yes or no for one lorry.
+ *
+ * Quantisation always rounds a limit *down*, so a stored value never permits
+ * what the sign forbids. A limit too large to store is stored as "not stated"
+ * rather than clamped, because a clamped value would forbid what the sign
+ * permits, and a limit that high restricts nothing any lorry cares about.
+ */
+
+/** Zero means "not stated"; a limit above what fits is treated the same way. */
+declare function toDecimetres(metres: number | undefined): number;
+declare function toHalfTonnes(tonnes: number | undefined): number;
+declare const fromDecimetres: (value: number) => number;
+declare const fromHalfTonnes: (value: number) => number;
+/** Collects the per-edge limits a compiler gathered into the stored side table. */
+declare function packEdgeLimits(entries: {
+    edge: number;
+    limits: VehicleLimits;
+}[]): EdgeLimits | undefined;
+/**
+ * The access mask a search should use for one lorry: the profile's own mask
+ * with the roads this vehicle is too big or too heavy for cleared as well.
+ * Roads stating no limit stay open, which is the assumption this library makes
+ * and documents: an untagged bridge is not a measured one.
+ */
+declare function accessForVehicle(graph: RoadGraph, vehicle: VehicleDimensions | undefined): Uint8Array | undefined;
+/** How many edges this vehicle may not use, for reporting rather than routing. */
+declare function countBlocked(graph: RoadGraph, vehicle: VehicleDimensions): number;
+
+/**
+ * Conditional restrictions: `hgv:conditional = no @ (Mo-Fr 07:00-19:00)`.
+ *
+ * A road can be closed overnight, a square pedestrianised on Sundays, a bridge
+ * limited to 7.5 tonnes only for vehicles over a certain length. Until now
+ * every one of those read as permanently open, which is the limitation most
+ * likely to make a route wrong rather than merely longer.
+ *
+ * The value is a list of `value @ condition` pairs separated by semicolons,
+ * and where several match, OpenStreetMap says the **last** one wins — the
+ * convention being to write the general rule first and the specific one last.
+ *
+ * Not every condition can be answered. Weather, a driver's occupation and a
+ * stay duration are not things a compiled graph knows, and a rule resting on
+ * one is kept but marked, so a caller can count what was not understood
+ * instead of being told silently that a road is open.
+ */
+
+/**
+ * How many distinct conditional values one table can hold. The stored index
+ * is sixteen bits wide, so the values are numbered 0 to 65535.
+ */
+declare const MAX_STORED_VALUES = 65536;
+/** When a journey passes, in the local time of the road it passes on. */
+type TravelTime = {
+    /** 0 is Monday, 6 is Sunday. */
+    weekday: number;
+    /** Minutes since midnight, 0 to 1439. */
+    minutes: number;
+    /** 1 to 12, for a seasonal rule. */
+    month: number;
+    /**
+     * The day of the month, 1 to 31. Only a span running past midnight needs
+     * it, to know whether the morning it ends on began in the month before.
+     * Leaving it out treats such a morning as belonging to the current month,
+     * which is right on every day but the first.
+     */
+    dayOfMonth?: number;
+    /** Whether it is a public holiday there, which only a caller can know. */
+    publicHoliday?: boolean;
+};
+/** A span of minutes within a day, which may run past midnight. */
+type MinuteSpan = {
+    from: number;
+    to: number;
+};
+/** An inclusive range of weekdays, months, or anything else counted in order. */
+type Range = {
+    from: number;
+    to: number;
+};
+/** A measurement of the vehicle compared against a number, as `weight>7.5`. */
+type VehicleComparison = {
+    property: "weight" | "height" | "width" | "length";
+    operator: "<" | "<=" | ">" | ">=" | "=";
+    amount: number;
+};
+/** One `(...)` group: every part present must hold for the group to match. */
+type Condition = {
+    days?: Range[];
+    times?: MinuteSpan[];
+    months?: Range[];
+    publicHoliday?: boolean;
+    vehicle?: VehicleComparison[];
+    /**
+     * Circumstances this library cannot know by itself: the weather, who is
+     * driving, what for. They are read from the tag and answered only by a
+     * caller who says so; unanswered, the condition does not hold.
+     */
+    circumstances?: string[];
+    /**
+     * The part of the condition this parser could not read at all — a stay
+     * duration, a form of words nobody has taught it. A condition carrying one
+     * is never matched, and is counted so it can be reported rather than
+     * quietly ignored.
+     */
+    unreadable?: string;
+};
+/**
+ * What the caller knows that the map does not: whether it is raining, who is
+ * at the wheel, what the journey is for. A conditional rule resting on one of
+ * these is ignored unless the answer is given here.
+ */
+type Circumstances = {
+    /** Named states of the road or sky, such as `wet`, `snow`, `ice`. */
+    conditions?: string[];
+    /** Who is driving, such as `disabled`, `resident`, `emergency`. */
+    userGroups?: string[];
+    /** Why, such as `delivery`, `destination`, `agricultural`. */
+    purposes?: string[];
+};
+type ConditionalRule = {
+    /** What applies when the condition holds: `no`, `destination`, `30`, `7.5`. */
+    value: string;
+    /** Any of these matching makes the rule apply, as `Mo-Fr 07:00-19:00, Sa 08:00-12:00`. */
+    conditions: Condition[];
+};
+/**
+ * Reads a `*:conditional` value into its rules. An empty list means the value
+ * was not a conditional expression at all.
+ */
+declare function parseConditional(value: string | undefined): ConditionalRule[];
+/** Whether one condition group holds at this moment, for this vehicle. */
+declare function conditionHolds(condition: Condition, when: TravelTime, vehicle?: VehicleDimensions, circumstances?: Circumstances): boolean;
+/**
+ * What a conditional value comes to at this moment, or null when none of its
+ * rules applies. Where several match, the last wins, which is what
+ * OpenStreetMap says and why the convention is general first, specific last.
+ */
+declare function conditionalValue(rules: ConditionalRule[], when: TravelTime, vehicle?: VehicleDimensions, circumstances?: Circumstances): string | null;
+/**
+ * How many of these rules rest on something this parser cannot read at all.
+ * A rule resting on the weather or on who is driving is readable and is not
+ * counted here; it simply needs a caller to answer it.
+ */
+declare function unreadableConditions(rules: ConditionalRule[]): number;
+/**
+ * The moment a journey is travelled.
+ *
+ * Without a time zone the date is read as the machine reads it, which is
+ * right when the roads and the reader are in the same place and wrong by
+ * however many hours when they are not. Naming the zone the roads are in —
+ * `"Europe/Lisbon"` — reads the date there instead, which is what a
+ * restriction written in local time means.
+ *
+ * The zone names are the IANA ones the platform already knows; nothing is
+ * bundled for this.
+ */
+declare function travelTimeFrom(date: Date, publicHoliday?: boolean, timeZone?: string): TravelTime;
+/** What a stored conditional row says: an access rule or a speed limit. */
+declare const ConditionKind: {
+    readonly access: 0;
+    readonly maxspeed: 1;
+};
+/** Collects what a compiler found into the stored side table. */
+declare function packEdgeConditions(entries: {
+    edge: number;
+    kind: number;
+    value: string;
+}[]): EdgeConditions | undefined;
+/** A bundle's conditional values parsed once, rather than per edge per search. */
+type ParsedConditions = {
+    table: EdgeConditions;
+    parsed: ConditionalRule[][];
+};
+declare function parseEdgeConditions(table: EdgeConditions | undefined): ParsedConditions | undefined;
+/**
+ * What the conditional rules say about one edge at one moment: whether it is
+ * closed, and any speed limit that applies.
+ *
+ * `destination` and the permit-style values count as closed because this
+ * library has no notion of a journey's purpose, and treating "only if you live
+ * here" as open would route strangers down a residents' street.
+ */
+declare function conditionsOnEdge(conditions: ParsedConditions, edge: number, when: TravelTime, vehicle?: VehicleDimensions, circumstances?: Circumstances): {
+    closed: boolean;
+    speedKph: number | undefined;
+};
+/**
+ * The access mask for a departure time: the graph's own with the roads shut at
+ * that moment cleared as well.
+ *
+ * Only closures are applied. A road whose plain tags already forbid it stays
+ * forbidden even where a conditional value would open it, because the stored
+ * mask has already dropped it and reopening one would need the compiler to
+ * keep roads it currently discards. That errs towards refusing a road that is
+ * in fact usable, which is the direction this library errs in everywhere else.
+ */
+declare function accessAtTime(graph: Pick<RoadGraph, "edgeTargets" | "edgeAccess">, conditions: ParsedConditions | undefined, when: TravelTime | undefined, vehicle?: VehicleDimensions, base?: Uint8Array, circumstances?: Circumstances): Uint8Array | undefined;
+/** How many edges this moment closes, for reporting rather than routing. */
+declare function countClosedAt(graph: Pick<RoadGraph, "edgeTargets" | "edgeAccess">, conditions: ParsedConditions | undefined, when: TravelTime, vehicle?: VehicleDimensions): number;
+declare function conditionsOf(graph: Pick<RoadGraph, "edgeConditions">): ParsedConditions | undefined;
+/**
+ * The edges a conditional speed limit slows at this moment, as whole seconds.
+ *
+ * A conditional limit may only slow an edge, never speed it up. A faster
+ * stored duration is left alone, because the A* bound is built from the
+ * profile's ceiling and an edge quicker than the graph says would break the
+ * guarantee that the route found is the best one.
+ */
+declare function conditionalDurations(graph: Pick<RoadGraph, "edgeTargets" | "edgeDistancesMeters" | "edgeDistanceScale" | "edgeDurationsSeconds" | "edgeDurationScale">, conditions: ParsedConditions | undefined, when: TravelTime, vehicle?: VehicleDimensions, circumstances?: Circumstances): Map<number, number> | undefined;
+
 /**
  * The nearest routing node to a coordinate. After topology simplification a
  * node is a junction rather than an arbitrary point on a road, so on a long
@@ -170,9 +818,235 @@ declare function findNearestNode(graph: RoadGraph, coordinate: Coordinate, maxDi
  */
 type RouteOptions = {
     costBound?: number;
+    /**
+     * The lorry being routed, where the graph states physical limits. Roads it
+     * is too large or too heavy for are closed to the search and to snapping.
+     */
+    vehicle?: VehicleDimensions;
+    /**
+     * When the journey starts, in the local time of the roads being travelled.
+     *
+     * Leaving it out ignores every conditional restriction, which is what this
+     * library did before it could read them: a road closed only at certain hours
+     * counts as open. Supplying it closes the roads shut at that moment and
+     * slows the ones a conditional speed limit slows.
+     *
+     * One moment is used for the whole route rather than an arrival time per
+     * edge. A route crossing a boundary as a restriction begins is therefore
+     * judged by where it set out, which is the honest limit of a departure time.
+     */
+    departAt?: Date | TravelTime;
+    /** Whether that day is a public holiday, which only a caller can know. */
+    publicHoliday?: boolean;
+    /**
+     * The time zone the roads are in, as an IANA name such as
+     * `"Europe/Lisbon"`. A restriction is written in the local time of the road
+     * it is on, so a caller routing somewhere other than where it is running
+     * should say where. Left out, a `Date` is read as this machine reads it.
+     */
+    timeZone?: string;
+    /**
+     * What the map cannot know: whether it is raining, who is driving, what the
+     * journey is for. A conditional rule resting on one of these is ignored
+     * unless it is answered here, so a road shut `@ (wet)` stays open until a
+     * caller says it is wet.
+     */
+    circumstances?: Circumstances;
+    /**
+     * Roads the caller knows are shut — roadworks, an incident, an event. A
+     * compiled bundle cannot know about any of them; whoever is reading a feed
+     * of them can say so here, and the search will neither drive through a
+     * closure nor begin in the middle of one.
+     */
+    avoid?: AvoidArea[];
+    /**
+     * Multipliers making certain edges dearer to the search than they really
+     * are, used to push a search away from a route already found. The route
+     * reported back is always priced at the graph's own cost, so a penalty
+     * changes which roads are chosen and never what they are said to cost.
+     */
+    costPenalties?: ReadonlyMap<number, number>;
+    /**
+     * Whether a route that cannot reach the road nearest its destination may
+     * finish on one a little further away. On by default, because the nearest
+     * road is sometimes one the network cannot legally enter — a pocket of
+     * one-way streets behind banned turns, an island of service roads — and
+     * refusing to route at all is a worse answer than finishing nearby.
+     *
+     * Turn it off to be told plainly that the point asked for cannot be
+     * reached. `RouteResult.destinationSnap.distanceMeters` reports how far
+     * short a route finished either way.
+     */
+    finishOnANearbyRoad?: boolean;
 };
 declare function route(graph: RoadGraph, from: Coordinate, to: Coordinate, preference?: RoutePreference, options?: RouteOptions): RouteResult;
 
+/**
+ * Several ways to get there, not just the best one.
+ *
+ * A second route is only worth offering if it is genuinely different and not
+ * much worse. The method here is the simple one: find the best route, make the
+ * roads it used dearer to the search than they really are, and search again.
+ * A road that is the only sensible way through survives the penalty and is
+ * used again; one that was merely convenient gives way to its neighbour.
+ *
+ * The penalty never reaches the answer. A route is always reported at the
+ * graph's own cost, so an alternative's distance and duration are what it
+ * would really take, not what the search was told to believe.
+ *
+ * Candidates are then filtered rather than trusted: one that reuses most of a
+ * route already offered, or that is far worse than the best, is not an
+ * alternative anybody wants. What comes back is in order, best first.
+ */
+
+type AlternativeRoutesOptions = Omit<RouteOptions, "costPenalties" | "costBound"> & {
+    /** How many routes to return at most, the best one included. Default 3. */
+    count?: number;
+    /**
+     * How much worse than the best route an alternative may be. 1.4 allows one
+     * taking 40% longer; raising it offers more routes and worse ones.
+     */
+    maxStretch?: number;
+    /**
+     * How much of the routes already offered an alternative may reuse, measured
+     * by distance. 0.75 rejects one that is three-quarters the same road.
+     */
+    maxSharing?: number;
+    /**
+     * How much dearer a road already used is made to look. Too small and the
+     * search returns the same route again; too large and it flees onto
+     * absurdities. Default 2.
+     */
+    penaltyFactor?: number;
+    /**
+     * Whether to download the wider corridor an alternative might lie in.
+     *
+     * On by default, because an alternative is allowed to be worse than the
+     * best by `maxStretch` and the tiles holding one therefore reach further
+     * than the tiles that proved the best route. On a long journey that is
+     * about three megabytes more map. Turning it off keeps the download to
+     * what one route needed and offers only the alternatives already inside
+     * it, which on a dense network is usually most of them.
+     */
+    searchWiderCorridor?: boolean;
+};
+/**
+ * Rejects options that would make the search unbounded or meaningless.
+ *
+ * Exported so the public entry point can refuse them before it downloads
+ * anything: a caller who passed `count: NaN` should be told so, not billed
+ * for a corridor first.
+ */
+declare function checkAlternativeOptions(options: AlternativeRoutesOptions): void;
+/**
+ * Routes from one point to another, best first, with up to `count - 1`
+ * genuinely different alternatives after it.
+ *
+ * Returns at least the best route; fewer than `count` means the graph held
+ * nothing else worth offering, which is the usual answer on a road network
+ * with one obvious way through.
+ */
+declare function routeAlternatives(graph: RoadGraph, from: Coordinate, to: Coordinate, preference?: RoutePreference, options?: AlternativeRoutesOptions): RouteResult[];
+
+type FetchLike$2 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Caps how far off the straight line the confirmation pass will reach, as a
+ * multiple of the direct distance. `Infinity` leaves the search bounded only
+ * by the route already found, which makes the answer the best the compiled
+ * graph holds; a finite value trades that proof for a smaller download and
+ * still ignores tile size, since the limit is a ground distance.
+ */
+type RoadRouterOptions = {
+    maxDetourFactor?: number;
+    /** How many stitched corridors a bundle keeps; see `BundleOpenOptions`. */
+    mergedCacheSize?: number;
+    /**
+     * Which vehicle to route as. Only a multi-profile bundle offers a choice;
+     * leaving it out uses the vehicle the bundle was compiled around.
+     */
+    profile?: string;
+    /**
+     * The lorry's size and weight, for a profile whose routes depend on them. A
+     * preset name, a set of dimensions, or a preset with fields overridden.
+     * `null` turns the filtering off, which is a decision to accept routes no
+     * real lorry may be able to drive.
+     */
+    vehicle?: VehicleInput | null;
+};
+/**
+ * High-level route entry point. `open()` accepts an EFRB bundle, an EFRT
+ * manifest, or an already-decoded graph.
+ */
+/** When a journey starts, for the conditional restrictions that depend on it. */
+type DepartureOptions = Pick<RouteOptions, "departAt" | "publicHoliday" | "timeZone" | "circumstances" | "avoid">;
+declare class RoadRouter {
+    private readonly graph?;
+    private readonly loader?;
+    private readonly options;
+    private readonly profileId?;
+    private readonly bundleVehicle?;
+    private constructor();
+    /** The lorry these routes are for, where the profile depends on one. */
+    readonly vehicle?: VehicleDimensions;
+    static fromGraph(graph: RoadGraph): RoadRouter;
+    /**
+     * 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.
+     */
+    private static assertVehicleApplies;
+    static open(source: string | RoadGraph, fetcher?: FetchLike$2, options?: RoadRouterOptions): Promise<RoadRouter>;
+    /** The vehicle this router is routing as, when the source names one. */
+    get profile(): string | undefined;
+    /**
+     * 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(): string[];
+    /**
+     * 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: string): RoadRouter;
+    /**
+     * `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.
+     */
+    route(from: Coordinate, to: Coordinate, preference?: RoutePreference, when?: DepartureOptions): Promise<RouteResult>;
+    /**
+     * Downloads a corridor, routes, then asks whether any tile left out could
+     * still hold something better. A route through a tile costs at least the
+     * detour to reach it, so the answer is a geometric test against the route
+     * already found: tiles that fail it are provably useless and stay
+     * undownloaded, and when none passes, the route is the best the compiled
+     * graph contains. Because the test measures ground distance rather than
+     * counting neighbours, the answer does not depend on the tile size.
+     */
+    /**
+     * 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.
+     */
+    routeAlternatives(from: Coordinate, to: Coordinate, preference?: RoutePreference, options?: AlternativeRoutesOptions): Promise<RouteResult[]>;
+    private routeOverBundle;
+    /**
+     * 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.
+     */
+    private bestOverBundle;
+    private routeOverLoader;
+}
+
 /** Where a coordinate lands on one directed edge. */
 type EdgeProjection = {
     edge: number;
@@ -210,7 +1084,7 @@ type GraphSnap = {
  * lies within `maxDistanceMeters` of the coordinate — measured to the road
  * surface, not to the nearest junction.
  */
-declare function snapToGraph(graph: RoadGraph, coordinate: Coordinate, maxDistanceMeters?: number): GraphSnap | null;
+declare function snapToGraph(graph: RoadGraph, coordinate: Coordinate, maxDistanceMeters?: number, access?: Uint8Array | undefined, accept?: (node: number) => boolean, everyNearbyRoad?: boolean): GraphSnap | null;
 
 /**
  * A uniform-grid index over directed edges. Snapping needs the nearest *road*,
@@ -239,42 +1113,6 @@ declare function nearbyEdgeIds(index: EdgeSpatialIndex, coordinate: Coordinate,
 declare function createSpatialIndex(graph: RoadGraph, cellSizeDegrees?: number): NodeSpatialIndex;
 declare function withSpatialIndex(graph: RoadGraph, cellSizeDegrees?: number): RoadGraph;
 
-type FetchLike$2 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-/**
- * Caps how far off the straight line the confirmation pass will reach, as a
- * multiple of the direct distance. `Infinity` leaves the search bounded only
- * by the route already found, which makes the answer the best the compiled
- * graph holds; a finite value trades that proof for a smaller download and
- * still ignores tile size, since the limit is a ground distance.
- */
-type RoadRouterOptions = {
-    maxDetourFactor?: number;
-};
-/**
- * High-level route entry point. `open()` accepts an EFRB bundle, an EFRT
- * manifest, or an already-decoded graph.
- */
-declare class RoadRouter {
-    private readonly graph?;
-    private readonly loader?;
-    private readonly options;
-    private constructor();
-    static fromGraph(graph: RoadGraph): RoadRouter;
-    static open(source: string | RoadGraph, fetcher?: FetchLike$2, options?: RoadRouterOptions): Promise<RoadRouter>;
-    route(from: Coordinate, to: Coordinate, preference?: RoutePreference): Promise<RouteResult>;
-    /**
-     * Downloads a corridor, routes, then asks whether any tile left out could
-     * still hold something better. A route through a tile costs at least the
-     * detour to reach it, so the answer is a geometric test against the route
-     * already found: tiles that fail it are provably useless and stay
-     * undownloaded, and when none passes, the route is the best the compiled
-     * graph contains. Because the test measures ground distance rather than
-     * counting neighbours, the answer does not depend on the tile size.
-     */
-    private routeOverBundle;
-    private routeOverLoader;
-}
-
 declare const BundleCompression: {
     readonly none: 0;
     readonly gzip: 1;
@@ -287,17 +1125,42 @@ type BundleBounds = {
     maxLat: number;
     maxLng: number;
 };
-type BundleTile = {
-    id: number;
-    bounds: BundleBounds;
+/** Where one chunk sits in the file. */
+type BundleChunkRef = {
     offset: number;
     byteLength: number;
     rawByteLength: number;
     compression: BundleCompression;
 };
+/**
+ * A tile. The flat chunk fields address its graph in a v1 bundle and its
+ * shared chunk in a v2 one; `profileChunks` is present only in v2 and holds
+ * the per-vehicle half, keyed by profile id.
+ */
+type BundleTile = BundleChunkRef & {
+    id: number;
+    bounds: BundleBounds;
+    profileChunks?: Map<number, BundleChunkRef>;
+};
 type RoadGraphBundle = {
     url: string;
     tiles: BundleTile[];
+    /**
+     * The profile every tile in this bundle was compiled for, read from the
+     * header so a caller knows the vehicle before downloading a single tile.
+     * `0` means a bundle written before profiles were recorded: a car bundle.
+     */
+    profileId: number;
+    /** The profile's speed ceiling in km/h, or 0 when the bundle predates it. */
+    maxSpeedKph: number;
+    /** Every profile this bundle can route, by id. A v1 bundle lists its one. */
+    profiles: number[];
+    /**
+     * The vehicle class this bundle was compiled to suggest, where it names one.
+     * Whoever compiled the extract chose it knowingly; a caller's own `vehicle`
+     * still wins, and the library's default applies when neither says anything.
+     */
+    defaultVehicle?: string;
     loadForRoute(origin: Coordinate, destination: Coordinate): Promise<RoadGraph>;
     loadExpandedForRoute(origin: Coordinate, destination: Coordinate): Promise<RoadGraph>;
     /**
@@ -308,14 +1171,43 @@ type RoadGraphBundle = {
      * distance, which is what makes it independent of how the bundle was tiled.
      */
     tilesWithinBudget(origin: Coordinate, destination: Coordinate, budgetMeters: number): BundleTile[];
-    /** Merges the given tiles, reusing any chunk already downloaded. */
-    loadTiles(tiles: BundleTile[]): Promise<RoadGraph>;
+    /**
+     * Merges the given tiles, reusing any chunk already downloaded. `profileId`
+     * picks the vehicle in a multi-profile bundle; the bundle's own default is
+     * used when it is left out.
+     */
+    loadTiles(tiles: BundleTile[], profileId?: number): Promise<RoadGraph>;
 };
 type BundleGraphTile = {
     id: number;
     bounds: BundleBounds;
     graph: RoadGraph;
 };
+/**
+ * One tile of a multi-profile bundle: the road network once, and the
+ * vehicle-dependent columns once per vehicle.
+ */
+type BundleProfiledTile = {
+    id: number;
+    bounds: BundleBounds;
+    graph: RoadGraph;
+    profiles: ProfileChunk[];
+};
+/**
+ * `mergedCacheSize` is how many stitched corridors to keep. Stitching is the
+ * most expensive part of answering a route, and consecutive routes usually ask
+ * for the same tiles, so one is worth holding. Each entry is a whole merged
+ * corridor, so raising this trades memory for repeat speed; `0` keeps none and
+ * restores the behaviour of releasing a corridor as soon as the route is done.
+ */
+type BundleOpenOptions = {
+    mergedCacheSize?: number;
+    /**
+     * Which vehicle to route as, by profile name. Only a multi-profile bundle
+     * offers a choice; leaving it out uses the bundle's own default.
+     */
+    profile?: string;
+};
 type BundleEncodeOptions = {
     compression?: "none" | "gzip";
 };
@@ -325,7 +1217,14 @@ declare function distanceToBounds(coordinate: Coordinate, bounds: BundleBounds):
 declare function encodeRoadGraphBundle(tiles: BundleGraphTile[]): ArrayBuffer;
 /** Creates a bundle with independently gzip-compressed EFR2 chunks. */
 declare function encodeCompressedRoadGraphBundle(tiles: BundleGraphTile[], options?: BundleEncodeOptions): Promise<ArrayBuffer>;
-declare function openRoadGraphBundle(url: string, fetcher?: FetchLike$1): Promise<RoadGraphBundle>;
+/**
+ * Creates a bundle serving several vehicles from one copy of the road network.
+ * Each tile contributes its shared chunk once and a small chunk per vehicle,
+ * and the directory lists them separately so a reader downloads only the
+ * vehicle it asked for.
+ */
+declare function encodeProfiledRoadGraphBundle(tiles: BundleProfiledTile[], options?: BundleEncodeOptions): Promise<ArrayBuffer>;
+declare function openRoadGraphBundle(url: string, fetcher?: FetchLike$1, options?: BundleOpenOptions): Promise<RoadGraphBundle>;
 
 type GraphBounds = {
     minLat: number;
@@ -426,53 +1325,31 @@ declare function packTurnSequences(sequences: number[][]): {
     turnRestrictionSequenceOffsets: Uint32Array<ArrayBuffer>;
     turnRestrictionSequenceEdges: Uint32Array<ArrayBuffer>;
 };
-
 /**
- * Routing profiles turn raw OSM tags into routable facts: may a vehicle use
- * this way, in which directions, and how fast. Keeping the rules behind one
- * interface lets the compiler stay generic — it never inspects a tag itself —
- * and lets the rules be unit-tested without a PBF file.
+ * Which junctions a search has to remember its approach at.
+ *
+ * Obeying a banned turn means knowing which road you arrived on, and the only
+ * state that can express that is "arrived at this node along that edge" — one
+ * state per directed edge rather than one per node. Carrying that everywhere
+ * doubles the search for the sake of the few junctions that need it: in a
+ * Portugal corridor, 16,620 junctions of 1,244,262 carry a restriction, which
+ * is 1.3%.
+ *
+ * So the approach is remembered only where it can change the answer. A node is
+ * guarded when a banned pair turns on it, or when any edge of a banned run
+ * ends there — a run spans several junctions, and the search has to know how
+ * far along it has driven at each of them.
  */
-type OsmTags = Record<string, string | undefined>;
-/** How a profile may traverse one OSM way. */
-type WayTraversal = {
-    /** Travel from the first node reference towards the last is allowed. */
-    forward: boolean;
-    /** Travel from the last node reference towards the first is allowed. */
-    backward: boolean;
-    /** Travel speed in km/h in each direction; both are clamped to the profile range. */
-    forwardSpeedKph: number;
-    backwardSpeedKph: number;
-};
-/** A turn restriction relation reduced to the only two cases routing cares about. */
-type TurnRestrictionKind = "no" | "only";
-type ParsedTurnRestriction = {
-    kind: TurnRestrictionKind;
-    /** The raw OSM value, kept for diagnostics only. */
-    value: string;
+type GuardedJunctions = {
+    /** One byte per node: does arriving matter here? */
+    guarded: Uint8Array;
+    /** For an edge ending at a guarded node, its own state; -1 otherwise. */
+    stateOfEdge: Int32Array;
+    /** The edge each guarded state arrived along. */
+    edgeOfState: Int32Array;
+    /** How many states the guarded junctions take up. */
+    count: number;
 };
-interface RoutingProfile {
-    readonly name: string;
-    /** Way tag keys the compiler must request from the PBF reader. */
-    readonly wayTagKeys: readonly string[];
-    /** Relation tag keys the compiler must request from the PBF reader. */
-    readonly relationTagKeys: readonly string[];
-    /** The fastest speed the profile can ever return, used for admissible A* heuristics. */
-    readonly maxSpeedKph: number;
-    /** Returns null when the way is not usable by this profile at all. */
-    evaluateWay(tags: OsmTags): WayTraversal | null;
-    /** Returns null when the relation is not a turn restriction this profile obeys. */
-    evaluateTurnRestriction(tags: OsmTags): ParsedTurnRestriction | null;
-}
-/**
- * Reads a `maxspeed`-style value. Returns null for every value that is not a
- * plain number with an optional unit — country codes such as `PT:urban`,
- * `none`, `signals` and `variable` included — so the caller can fall back to a
- * class default instead of inventing a country-specific table.
- */
-declare function parseMaxSpeedKph(value: string | undefined): number | null;
-declare const carRoutingProfile: RoutingProfile;
-declare const routingProfiles: Record<string, RoutingProfile>;
-declare function getRoutingProfile(name: string): RoutingProfile;
+declare function guardedJunctionsFor(graph: RoadGraph, restrictions: TurnRestrictionIndex | null, sequences: TurnSequenceIndex | null): GuardedJunctions;
 
-export { type BundleBounds, BundleCompression, type BundleEncodeOptions, type BundleGraphTile, type BundleTile, type CompactEncodeOptions, type CompactGraphOptions, type Coordinate, type CoordinateStorage, type EdgeProjection, type EdgeSpatialIndex, type EdgeWeightStorage, type GeoJsonLineString, type GeoJsonPosition, type GraphBounds, type GraphSnap, type GraphTile, type NodeSpatialIndex, type OsmTags, type ParsedTurnRestriction, type RoadGraph, type RoadGraphBundle, RoadRouter, type RoadRouterOptions, type RouteGraphLoader, type RouteGraphManifest, type RouteOptions, type RoutePreference, type RouteResult, type RouteSnap, RouterError, type RouterErrorCode, type RoutingProfile, type TurnRestrictionIndex, type TurnRestrictionKind, type TurnSequenceIndex, VarintReader, VarintWriter, type WayTraversal, buildTurnRestrictionIndex, buildTurnSequenceIndex, carRoutingProfile, compactGraph, createEdgeSpatialIndex, createRouteGraphLoader, createSpatialIndex, decodeGraph, distanceToBounds, edgePolyline, edgeSource, edgeSpatialIndexFor, encodeCompactGraph, encodeCompressedRoadGraphBundle, encodeGraph, encodeRoadGraphBundle, findNearestNode, getRoutingProfile, isTurnBanned, mergeRoadGraphs, nearbyEdgeIds, openRoadGraphBundle, packTurnRestrictions, packTurnSequences, parseMaxSpeedKph, route, routingProfiles, snapToGraph, unzigzag, withSpatialIndex, zigzag };
+export { type AlternativeRoutesOptions, type AvoidArea, type BundleBounds, type BundleChunkRef, BundleCompression, type BundleEncodeOptions, type BundleGraphTile, type BundleOpenOptions, type BundleProfiledTile, type BundleTile, type Circumstances, type CompactEncodeOptions, type CompactGraphOptions, type Condition, ConditionKind, type ConditionalRule, type Coordinate, type CoordinateStorage, DEFAULT_VEHICLE_PRESET, type DepartureOptions, type EdgeConditions, type EdgeLimits, type EdgeProjection, type EdgeSpatialIndex, type EdgeWeightStorage, type GeoJsonLineString, type GeoJsonPosition, type GraphBounds, type GraphSnap, type GraphTile, type GuardedJunctions, MAX_STORED_VALUES, type MinuteSpan, type NodeSpatialIndex, type OsmTags, type ParsedConditions, type ParsedTurnRestriction, type ProfileChunk, ProfileId, type RoadGraph, type RoadGraphBundle, RoadRouter, type RoadRouterOptions, type RouteGraphLoader, type RouteGraphManifest, type RouteOptions, type RoutePreference, type RouteResult, type RouteSnap, RouterError, type RouterErrorCode, type RoutingProfile, type SearchBounds, type SharedRoadGraph, type TravelTime, type TurnRestrictionIndex, type TurnRestrictionKind, type TurnSequenceIndex, VEHICLE_PRESETS, VarintReader, VarintWriter, type VehicleComparison, type VehicleDimensions, type VehicleInput, type VehicleLimits, VehiclePresetId, type WayTraversal, 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 };