@murphai/murph 0.1.18 → 0.2.5

package/node_modules/@murphai/assistant-engine/dist/mapbox-route.js

@@ -0,0 +1,670 @@
+/**
+ * Shared Mapbox route estimation helper used by the CLI surface.
+ *
+ * Privacy posture:
+ * - the access token stays in env only
+ * - forward geocoding stays temporary and is not cached by this helper
+ * - route geometry is only returned when explicitly requested
+ * - elevation, when requested, is approximate and derived from bounded contour samples
+ */
+import { errorMessage, normalizeNullableString } from '@murphai/operator-config/text/shared';
+import { z } from 'zod';
+const MAPBOX_DIRECTIONS_API_VERSION = 'v5';
+const MAPBOX_GEOCODING_API_VERSION = 'v6';
+const DEFAULT_MAPBOX_TIMEOUT_MS = 10_000;
+const MAX_MAPBOX_TIMEOUT_MS = 30_000;
+const DEFAULT_ELEVATION_QUERY_RADIUS_METERS = 50;
+const DEFAULT_ELEVATION_SAMPLE_SPACING_METERS = 500;
+const DEFAULT_MAX_ELEVATION_SAMPLES = 16;
+const MAX_ELEVATION_SAMPLES = 24;
+const MAX_ROUTE_COORDINATES = 25;
+const MAX_ROUTE_WAYPOINTS = MAX_ROUTE_COORDINATES - 2;
+const coordinateLiteralPattern = /^\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*(-?(?:\d+(?:\.\d+)?|\.\d+))\s*$/u;
+export const mapboxRouteProfileValues = [
+    'walking',
+    'cycling',
+    'driving',
+    'driving-traffic',
+];
+export const mapboxRouteProfileSchema = z.enum(mapboxRouteProfileValues);
+const longitudeSchema = z.number().gte(-180).lte(180);
+const latitudeSchema = z.number().gte(-90).lte(90);
+const coordinateTupleSchema = z.tuple([longitudeSchema, latitudeSchema]);
+const coordinatePointSchema = z.object({
+    longitude: longitudeSchema,
+    latitude: latitudeSchema,
+    name: z.string().min(1).optional(),
+});
+const pointRoleSchema = z.enum(['origin', 'waypoint', 'destination']);
+const pointSourceSchema = z.enum([
+    'coordinates',
+    'coordinate-literal',
+    'geocoded-query',
+]);
+const elevationSourceSchema = z.enum(['none', 'mapbox-terrain-v2-contour']);
+export const mapboxRouteLocationInputSchema = z.union([
+    z.string().min(1),
+    coordinatePointSchema,
+]);
+export const mapboxRouteEstimateInputSchema = z.object({
+    origin: mapboxRouteLocationInputSchema,
+    destination: mapboxRouteLocationInputSchema,
+    waypoints: z.array(mapboxRouteLocationInputSchema).max(MAX_ROUTE_WAYPOINTS).optional(),
+    profile: mapboxRouteProfileSchema.optional(),
+    includeGeometry: z.boolean().optional(),
+    includeElevation: z.boolean().optional(),
+    country: z
+        .array(z.string().regex(/^[A-Za-z]{2}$/u))
+        .max(10)
+        .optional(),
+    language: z.string().min(1).max(10).optional(),
+    elevationSampleSpacingMeters: z.number().positive().max(10_000).optional(),
+    maxElevationSamples: z.number().int().positive().max(MAX_ELEVATION_SAMPLES).optional(),
+});
+const routeGeometrySchema = z
+    .object({
+    type: z.literal('LineString'),
+    coordinates: z.array(coordinateTupleSchema).min(2),
+})
+    .strict();
+const resolvedPointSchema = z
+    .object({
+    role: pointRoleSchema,
+    source: pointSourceSchema,
+    displayName: z.string().min(1),
+    longitude: longitudeSchema,
+    latitude: latitudeSchema,
+    routableLongitude: longitudeSchema,
+    routableLatitude: latitudeSchema,
+    accuracy: z.string().min(1).nullable(),
+    matchType: z.string().min(1).nullable(),
+    routablePointName: z.string().min(1).nullable(),
+})
+    .strict();
+const routeLegSchema = z
+    .object({
+    index: z.number().int().nonnegative(),
+    distanceMeters: z.number().nonnegative(),
+    durationSeconds: z.number().nonnegative(),
+    summary: z.string().min(1).nullable(),
+})
+    .strict();
+const elevationSummarySchema = z
+    .object({
+    approximate: z.literal(true),
+    source: z.literal('mapbox-terrain-v2-contour'),
+    sampleCount: z.number().int().positive(),
+    resolvedSampleCount: z.number().int().positive(),
+    sampleSpacingMeters: z.number().positive(),
+    queryRadiusMeters: z.number().positive(),
+    gainMeters: z.number(),
+    lossMeters: z.number(),
+    netChangeMeters: z.number(),
+    minimumMeters: z.number(),
+    maximumMeters: z.number(),
+    startMeters: z.number(),
+    endMeters: z.number(),
+    notes: z.array(z.string().min(1)),
+})
+    .strict();
+const routeSummarySchema = z
+    .object({
+    distanceMeters: z.number().nonnegative(),
+    distanceKilometers: z.number().nonnegative(),
+    durationSeconds: z.number().nonnegative(),
+    durationMinutes: z.number().nonnegative(),
+})
+    .strict();
+const providerMetadataSchema = z
+    .object({
+    name: z.literal('mapbox'),
+    directionsApiVersion: z.literal(MAPBOX_DIRECTIONS_API_VERSION),
+    geocodingApiVersion: z.literal(MAPBOX_GEOCODING_API_VERSION),
+    elevationSource: elevationSourceSchema,
+})
+    .strict();
+const routePrivacySchema = z
+    .object({
+    tokenSource: z.literal('env'),
+    persistedByTool: z.literal(false),
+    geocodingStorage: z.enum(['temporary', 'not-used']),
+    geocodedPointCount: z.number().int().nonnegative(),
+    geometryIncluded: z.boolean(),
+})
+    .strict();
+export const mapboxRouteEstimateResultSchema = z
+    .object({
+    provider: providerMetadataSchema,
+    profile: mapboxRouteProfileSchema,
+    summary: routeSummarySchema,
+    points: z.array(resolvedPointSchema).min(2),
+    legs: z.array(routeLegSchema),
+    elevation: elevationSummarySchema.nullable(),
+    geometry: routeGeometrySchema.nullable(),
+    privacy: routePrivacySchema,
+    warnings: z.array(z.string().min(1)),
+})
+    .strict();
+export async function estimateMapboxRoute(rawInput, dependencies = {}) {
+    const input = mapboxRouteEstimateInputSchema.parse(rawInput);
+    const env = dependencies.env ?? process.env;
+    const fetchImpl = dependencies.fetchImpl ?? fetch;
+    const accessToken = readMapboxAccessToken(env);
+    if (!accessToken) {
+        throw new Error('Mapbox routing is not configured. Set MAPBOX_ACCESS_TOKEN in the runtime environment before using route estimation.');
+    }
+    const timeoutMs = resolveMapboxTimeoutMs(env);
+    const wantsGeometry = Boolean(input.includeGeometry || input.includeElevation);
+    const warnings = [];
+    const resolvedPoints = await resolveRoutePoints({
+        accessToken,
+        country: input.country,
+        destination: input.destination,
+        fetchImpl,
+        language: input.language,
+        origin: input.origin,
+        timeoutMs,
+        waypoints: input.waypoints ?? [],
+    });
+    const directionsRoute = await requestDirections({
+        accessToken,
+        fetchImpl,
+        points: resolvedPoints,
+        profile: input.profile ?? 'walking',
+        timeoutMs,
+        wantsGeometry,
+    });
+    const geometry = wantsGeometry
+        ? normalizeRouteGeometry(directionsRoute.geometry)
+        : null;
+    let elevation = null;
+    if (input.includeElevation) {
+        if (!geometry) {
+            warnings.push('Elevation was requested but the routed geometry was unavailable.');
+        }
+        else {
+            elevation = await summarizeRouteElevation({
+                accessToken,
+                fetchImpl,
+                geometry,
+                maxSamples: input.maxElevationSamples ?? DEFAULT_MAX_ELEVATION_SAMPLES,
+                sampleSpacingMeters: input.elevationSampleSpacingMeters ??
+                    DEFAULT_ELEVATION_SAMPLE_SPACING_METERS,
+                timeoutMs,
+            });
+            if (!elevation) {
+                warnings.push('Elevation is unavailable for this route. When returned, it is only an approximation based on sampled contour queries.');
+            }
+        }
+    }
+    if (input.includeElevation) {
+        warnings.push('Elevation is approximate and based on sampled contour queries against Mapbox Terrain rather than a full-resolution trail profile.');
+    }
+    const result = {
+        provider: {
+            name: 'mapbox',
+            directionsApiVersion: MAPBOX_DIRECTIONS_API_VERSION,
+            geocodingApiVersion: MAPBOX_GEOCODING_API_VERSION,
+            elevationSource: input.includeElevation ? 'mapbox-terrain-v2-contour' : 'none',
+        },
+        profile: input.profile ?? 'walking',
+        summary: {
+            distanceMeters: roundTo(directionsRoute.distance ?? 0, 1),
+            distanceKilometers: roundTo((directionsRoute.distance ?? 0) / 1000, 3),
+            durationSeconds: roundTo(directionsRoute.duration ?? 0, 1),
+            durationMinutes: roundTo((directionsRoute.duration ?? 0) / 60, 1),
+        },
+        points: resolvedPoints,
+        legs: (directionsRoute.legs ?? []).map((leg, index) => ({
+            index,
+            distanceMeters: roundTo(leg.distance ?? 0, 1),
+            durationSeconds: roundTo(leg.duration ?? 0, 1),
+            summary: normalizeNullableString(leg.summary) ?? null,
+        })),
+        elevation,
+        geometry: input.includeGeometry ? geometry : null,
+        privacy: {
+            tokenSource: 'env',
+            persistedByTool: false,
+            geocodingStorage: resolvedPoints.some((point) => point.source === 'geocoded-query')
+                ? 'temporary'
+                : 'not-used',
+            geocodedPointCount: resolvedPoints.filter((point) => point.source === 'geocoded-query').length,
+            geometryIncluded: Boolean(input.includeGeometry && geometry),
+        },
+        warnings,
+    };
+    return mapboxRouteEstimateResultSchema.parse(result);
+}
+async function resolveRoutePoints(input) {
+    const sources = [
+        { role: 'origin', value: input.origin },
+        ...input.waypoints.map((value) => ({
+            role: 'waypoint',
+            value,
+        })),
+        { role: 'destination', value: input.destination },
+    ];
+    return await Promise.all(sources.map(async ({ role, value }) => await resolveRoutePoint(value, {
+        accessToken: input.accessToken,
+        country: input.country,
+        fetchImpl: input.fetchImpl,
+        language: input.language,
+        role,
+        timeoutMs: input.timeoutMs,
+    })));
+}
+async function resolveRoutePoint(input, options) {
+    if (typeof input !== 'string') {
+        return buildCoordinatePoint(input, options.role, 'coordinates');
+    }
+    const coordinateLiteral = parseCoordinateLiteral(input);
+    if (coordinateLiteral) {
+        return buildCoordinatePoint(coordinateLiteral, options.role, 'coordinate-literal');
+    }
+    return await geocodeRoutePoint(input, options);
+}
+function buildCoordinatePoint(input, role, source) {
+    const displayName = normalizeNullableString(input.name) ??
+        formatCoordinateLiteral(input.longitude, input.latitude);
+    return {
+        role,
+        source,
+        displayName,
+        longitude: input.longitude,
+        latitude: input.latitude,
+        routableLongitude: input.longitude,
+        routableLatitude: input.latitude,
+        accuracy: null,
+        matchType: null,
+        routablePointName: null,
+    };
+}
+async function geocodeRoutePoint(query, input) {
+    const url = new URL(`https://api.mapbox.com/search/geocode/${MAPBOX_GEOCODING_API_VERSION}/forward`);
+    url.searchParams.set('q', query);
+    url.searchParams.set('access_token', input.accessToken);
+    url.searchParams.set('limit', '1');
+    url.searchParams.set('autocomplete', 'false');
+    url.searchParams.set('permanent', 'false');
+    if (input.country && input.country.length > 0) {
+        url.searchParams.set('country', input.country.join(','));
+    }
+    if (input.language) {
+        url.searchParams.set('language', input.language);
+    }
+    const payload = await fetchMapboxJson({
+        fetchImpl: input.fetchImpl,
+        timeoutMs: input.timeoutMs,
+        url,
+        requestLabel: `${input.role} geocoding`,
+    });
+    const feature = payload.features?.[0];
+    if (!feature) {
+        throw new Error(`Mapbox could not geocode the ${input.role}.`);
+    }
+    const featureCoordinates = readFeatureCoordinates(feature);
+    if (!featureCoordinates) {
+        throw new Error(`Mapbox returned an unusable coordinate for the ${input.role}.`);
+    }
+    const routablePoint = selectRoutablePoint(feature);
+    const displayName = readFeatureDisplayName(feature);
+    const accuracy = normalizeNullableString(feature.properties?.coordinates?.accuracy) ?? null;
+    const matchType = normalizeNullableString(feature.properties?.feature_type) ?? null;
+    return {
+        role: input.role,
+        source: 'geocoded-query',
+        displayName,
+        longitude: featureCoordinates.longitude,
+        latitude: featureCoordinates.latitude,
+        routableLongitude: routablePoint?.longitude ?? featureCoordinates.longitude,
+        routableLatitude: routablePoint?.latitude ?? featureCoordinates.latitude,
+        accuracy,
+        matchType,
+        routablePointName: normalizeNullableString(routablePoint?.name) ?? null,
+    };
+}
+function readFeatureCoordinates(feature) {
+    const propertiesCoordinates = feature.properties?.coordinates;
+    const longitude = typeof propertiesCoordinates?.longitude === 'number'
+        ? propertiesCoordinates.longitude
+        : feature.geometry?.coordinates?.[0];
+    const latitude = typeof propertiesCoordinates?.latitude === 'number'
+        ? propertiesCoordinates.latitude
+        : feature.geometry?.coordinates?.[1];
+    if (typeof longitude !== 'number' || typeof latitude !== 'number') {
+        return null;
+    }
+    return {
+        longitude,
+        latitude,
+    };
+}
+function selectRoutablePoint(feature) {
+    const routablePoints = feature.properties?.coordinates?.routable_points ?? [];
+    const selectedPoint = routablePoints.find((point) => normalizeNullableString(point.name)?.toLowerCase() === 'default') ?? routablePoints[0];
+    if (!selectedPoint ||
+        typeof selectedPoint.longitude !== 'number' ||
+        typeof selectedPoint.latitude !== 'number') {
+        return null;
+    }
+    return {
+        longitude: selectedPoint.longitude,
+        latitude: selectedPoint.latitude,
+        name: normalizeNullableString(selectedPoint.name) ?? undefined,
+    };
+}
+function readFeatureDisplayName(feature) {
+    const fullAddress = normalizeNullableString(feature.properties?.full_address);
+    if (fullAddress) {
+        return fullAddress;
+    }
+    const preferredName = normalizeNullableString(feature.properties?.name_preferred) ??
+        normalizeNullableString(feature.properties?.name);
+    const placeFormatted = normalizeNullableString(feature.properties?.place_formatted);
+    const composite = [preferredName, placeFormatted].filter(Boolean).join(', ');
+    return composite || 'Resolved location';
+}
+async function requestDirections(input) {
+    const coordinatePath = input.points
+        .map((point) => `${point.routableLongitude},${point.routableLatitude}`)
+        .join(';');
+    const url = new URL(`https://api.mapbox.com/directions/${MAPBOX_DIRECTIONS_API_VERSION}/mapbox/${input.profile}/${coordinatePath}`);
+    url.searchParams.set('access_token', input.accessToken);
+    url.searchParams.set('alternatives', 'false');
+    url.searchParams.set('steps', 'false');
+    url.searchParams.set('overview', input.wantsGeometry ? 'full' : 'false');
+    if (input.wantsGeometry) {
+        url.searchParams.set('geometries', 'geojson');
+    }
+    const payload = await fetchMapboxJson({
+        fetchImpl: input.fetchImpl,
+        timeoutMs: input.timeoutMs,
+        url,
+        requestLabel: 'directions',
+    });
+    if (payload.code !== 'Ok') {
+        throw new Error(normalizeNullableString(payload.message) ??
+            'Mapbox did not return a route for these points.');
+    }
+    const route = payload.routes?.[0];
+    if (!route) {
+        throw new Error('Mapbox did not return a route for these points.');
+    }
+    return route;
+}
+function normalizeRouteGeometry(geometry) {
+    if (geometry?.type !== 'LineString' ||
+        !Array.isArray(geometry.coordinates) ||
+        geometry.coordinates.length < 2) {
+        return null;
+    }
+    const coordinates = geometry.coordinates.flatMap((point) => {
+        if (Array.isArray(point) &&
+            point.length >= 2 &&
+            typeof point[0] === 'number' &&
+            typeof point[1] === 'number') {
+            return [[point[0], point[1]]];
+        }
+        return [];
+    });
+    if (coordinates.length < 2) {
+        return null;
+    }
+    return {
+        type: 'LineString',
+        coordinates,
+    };
+}
+async function summarizeRouteElevation(input) {
+    const totalDistanceMeters = measureLineDistanceMeters(input.geometry.coordinates);
+    const sampleCount = resolveElevationSampleCount({
+        maxSamples: input.maxSamples,
+        sampleSpacingMeters: input.sampleSpacingMeters,
+        totalDistanceMeters,
+    });
+    const sampledPoints = sampleLineCoordinates(input.geometry.coordinates, sampleCount);
+    const elevations = await Promise.all(sampledPoints.map(async ([longitude, latitude]) => ({
+        elevationMeters: await queryElevationAtPoint({
+            accessToken: input.accessToken,
+            fetchImpl: input.fetchImpl,
+            latitude,
+            longitude,
+            timeoutMs: input.timeoutMs,
+        }),
+        latitude,
+        longitude,
+    })));
+    const knownSamples = elevations.filter((sample) => typeof sample.elevationMeters === 'number');
+    if (knownSamples.length < 2) {
+        return null;
+    }
+    let gainMeters = 0;
+    let lossMeters = 0;
+    let previousSample = knownSamples[0];
+    for (const sample of knownSamples.slice(1)) {
+        const delta = sample.elevationMeters - previousSample.elevationMeters;
+        if (delta > 0) {
+            gainMeters += delta;
+        }
+        else if (delta < 0) {
+            lossMeters += Math.abs(delta);
+        }
+        previousSample = sample;
+    }
+    const elevationValues = knownSamples.map((sample) => sample.elevationMeters);
+    const notes = [
+        'Approximate profile from Mapbox Terrain contour features sampled along the routed line.',
+        'Contour-derived elevations are quantized and may understate short, steep changes.',
+    ];
+    if (knownSamples.length !== elevations.length) {
+        notes.push('Some sampled points did not return nearby contour data, so the profile is partially interpolated from nearby samples only.');
+    }
+    return {
+        approximate: true,
+        source: 'mapbox-terrain-v2-contour',
+        sampleCount: elevations.length,
+        resolvedSampleCount: knownSamples.length,
+        sampleSpacingMeters: roundTo(input.sampleSpacingMeters, 1),
+        queryRadiusMeters: DEFAULT_ELEVATION_QUERY_RADIUS_METERS,
+        gainMeters: roundTo(gainMeters, 1),
+        lossMeters: roundTo(lossMeters, 1),
+        netChangeMeters: roundTo(knownSamples[knownSamples.length - 1].elevationMeters - knownSamples[0].elevationMeters, 1),
+        minimumMeters: Math.min(...elevationValues),
+        maximumMeters: Math.max(...elevationValues),
+        startMeters: knownSamples[0].elevationMeters,
+        endMeters: knownSamples[knownSamples.length - 1].elevationMeters,
+        notes,
+    };
+}
+function resolveElevationSampleCount(input) {
+    if (input.totalDistanceMeters <= 0) {
+        return 1;
+    }
+    const desiredSamples = Math.ceil(input.totalDistanceMeters / input.sampleSpacingMeters) + 1;
+    return Math.max(2, Math.min(input.maxSamples, desiredSamples));
+}
+function sampleLineCoordinates(coordinates, sampleCount) {
+    if (coordinates.length === 0) {
+        return [];
+    }
+    if (coordinates.length === 1 || sampleCount <= 1) {
+        return [[coordinates[0][0], coordinates[0][1]]];
+    }
+    const cumulativeDistances = [0];
+    for (let index = 1; index < coordinates.length; index += 1) {
+        cumulativeDistances.push(cumulativeDistances[index - 1] +
+            haversineMeters(coordinates[index - 1], coordinates[index]));
+    }
+    const totalDistanceMeters = cumulativeDistances[cumulativeDistances.length - 1];
+    if (totalDistanceMeters <= 0) {
+        return [[coordinates[0][0], coordinates[0][1]]];
+    }
+    const samples = [];
+    let segmentIndex = 0;
+    for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+        const targetDistance = sampleCount === 1
+            ? 0
+            : (totalDistanceMeters * sampleIndex) / (sampleCount - 1);
+        while (segmentIndex < cumulativeDistances.length - 2 &&
+            cumulativeDistances[segmentIndex + 1] < targetDistance) {
+            segmentIndex += 1;
+        }
+        const start = coordinates[segmentIndex];
+        const end = coordinates[Math.min(segmentIndex + 1, coordinates.length - 1)];
+        const segmentStartDistance = cumulativeDistances[segmentIndex];
+        const segmentEndDistance = cumulativeDistances[Math.min(segmentIndex + 1, cumulativeDistances.length - 1)];
+        const ratio = segmentEndDistance > segmentStartDistance
+            ? (targetDistance - segmentStartDistance) /
+                (segmentEndDistance - segmentStartDistance)
+            : 0;
+        samples.push(interpolateCoordinate(start, end, ratio));
+    }
+    return dedupeAdjacentCoordinates(samples);
+}
+function interpolateCoordinate(start, end, ratio) {
+    const safeRatio = Math.max(0, Math.min(1, ratio));
+    return [
+        start[0] + (end[0] - start[0]) * safeRatio,
+        start[1] + (end[1] - start[1]) * safeRatio,
+    ];
+}
+function dedupeAdjacentCoordinates(coordinates) {
+    const deduped = [];
+    for (const coordinate of coordinates) {
+        const previous = deduped[deduped.length - 1];
+        if (previous && previous[0] === coordinate[0] && previous[1] === coordinate[1]) {
+            continue;
+        }
+        deduped.push([coordinate[0], coordinate[1]]);
+    }
+    return deduped;
+}
+async function queryElevationAtPoint(input) {
+    const url = new URL(`https://api.mapbox.com/v4/mapbox.mapbox-terrain-v2/tilequery/${input.longitude},${input.latitude}.json`);
+    url.searchParams.set('access_token', input.accessToken);
+    url.searchParams.set('radius', String(DEFAULT_ELEVATION_QUERY_RADIUS_METERS));
+    url.searchParams.set('limit', '10');
+    url.searchParams.set('layers', 'contour');
+    url.searchParams.set('geometry', 'linestring');
+    const payload = await fetchMapboxJson({
+        allowNotFound: true,
+        fetchImpl: input.fetchImpl,
+        timeoutMs: input.timeoutMs,
+        url,
+        requestLabel: 'terrain elevation',
+    });
+    if (!payload) {
+        return null;
+    }
+    const feature = payload.features?.find((candidate) => {
+        const elevation = candidate.properties?.ele;
+        return typeof elevation === 'number' || typeof elevation === 'string';
+    });
+    const candidateElevation = feature?.properties?.ele;
+    if (typeof candidateElevation === 'number') {
+        return candidateElevation;
+    }
+    if (typeof candidateElevation === 'string') {
+        const parsed = Number.parseFloat(candidateElevation);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+async function fetchMapboxJson(input) {
+    let response;
+    try {
+        response = await input.fetchImpl(input.url, {
+            headers: {
+                accept: 'application/json',
+            },
+            signal: AbortSignal.timeout(input.timeoutMs),
+        });
+    }
+    catch (error) {
+        throw new Error(`Mapbox ${input.requestLabel} request failed: ${errorMessage(error)}.`);
+    }
+    if (input.allowNotFound && response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Mapbox ${input.requestLabel} request failed (${await describeFailedMapboxResponse(response)}).`);
+    }
+    return (await response.json());
+}
+async function describeFailedMapboxResponse(response) {
+    const fallback = `HTTP ${response.status}`;
+    try {
+        const payload = (await response.json());
+        const message = typeof payload.message === 'string'
+            ? normalizeNullableString(payload.message)
+            : null;
+        return message ? `${fallback}: ${message}` : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function parseCoordinateLiteral(value) {
+    const match = coordinateLiteralPattern.exec(value);
+    if (!match) {
+        return null;
+    }
+    const longitude = Number.parseFloat(match[1] ?? '');
+    const latitude = Number.parseFloat(match[2] ?? '');
+    if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) {
+        return null;
+    }
+    if (longitude < -180 || longitude > 180 || latitude < -90 || latitude > 90) {
+        return null;
+    }
+    return {
+        longitude,
+        latitude,
+    };
+}
+function formatCoordinateLiteral(longitude, latitude) {
+    return `${longitude.toFixed(6)}, ${latitude.toFixed(6)}`;
+}
+function readMapboxAccessToken(env) {
+    return normalizeNullableString(env.MAPBOX_ACCESS_TOKEN);
+}
+function resolveMapboxTimeoutMs(env) {
+    const configured = normalizeNullableString(env.MURPH_MAPBOX_TIMEOUT_MS);
+    if (!configured) {
+        return DEFAULT_MAPBOX_TIMEOUT_MS;
+    }
+    const parsed = Number.parseInt(configured, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        return DEFAULT_MAPBOX_TIMEOUT_MS;
+    }
+    return Math.min(parsed, MAX_MAPBOX_TIMEOUT_MS);
+}
+function measureLineDistanceMeters(coordinates) {
+    let totalDistance = 0;
+    for (let index = 1; index < coordinates.length; index += 1) {
+        totalDistance += haversineMeters(coordinates[index - 1], coordinates[index]);
+    }
+    return totalDistance;
+}
+function haversineMeters(start, end) {
+    const earthRadiusMeters = 6_371_000;
+    const startLatitudeRadians = toRadians(start[1]);
+    const endLatitudeRadians = toRadians(end[1]);
+    const deltaLatitudeRadians = toRadians(end[1] - start[1]);
+    const deltaLongitudeRadians = toRadians(end[0] - start[0]);
+    const haversineValue = Math.sin(deltaLatitudeRadians / 2) ** 2 +
+        Math.cos(startLatitudeRadians) *
+            Math.cos(endLatitudeRadians) *
+            Math.sin(deltaLongitudeRadians / 2) ** 2;
+    const centralAngle = 2 * Math.atan2(Math.sqrt(haversineValue), Math.sqrt(1 - haversineValue));
+    return earthRadiusMeters * centralAngle;
+}
+function toRadians(value) {
+    return (value * Math.PI) / 180;
+}
+function roundTo(value, decimals) {
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+//# sourceMappingURL=mapbox-route.js.map