@tileflow/routing 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/dist/chunk-ECBK2QPL.js

@@ -0,0 +1,450 @@
+// src/contract.ts
+import { z } from "zod";
+var routingModes = ["driving", "walking", "cycling", "truck"];
+var routingAvoidances = ["tolls", "highways", "ferries"];
+var routingTrafficKinds = ["none"];
+var routingLanguages = [
+  "ar-SA",
+  "bg-BG",
+  "ca-ES",
+  "cs-CZ",
+  "da-DK",
+  "de-DE",
+  "el-GR",
+  "en-AU",
+  "en-GB",
+  "en-US",
+  "es-ES",
+  "et-EE",
+  "fi-FI",
+  "fr-FR",
+  "hi-IN",
+  "hu-HU",
+  "it-IT",
+  "ja-JP",
+  "ko-KR",
+  "mn-MN",
+  "nb-NO",
+  "nl-NL",
+  "pl-PL",
+  "pt-BR",
+  "pt-PT",
+  "ro-RO",
+  "ru-RU",
+  "sk-SK",
+  "sl-SI",
+  "sv-SE",
+  "tr-TR",
+  "uk-UA",
+  "vi-VN"
+];
+var routingLimits = Object.freeze({
+  maximumRequestBytes: 8 * 1024,
+  maximumResponseBytes: 4 * 1024 * 1024,
+  minimumLocations: 2,
+  maximumLocations: 5,
+  maximumAlternatives: 2,
+  /** Sum of straight-line distances between consecutive locations, per mode. */
+  maximumDirectDistanceMeters: Object.freeze({
+    driving: 1e6,
+    walking: 1e5,
+    cycling: 3e5,
+    truck: 1e6
+  }),
+  maximumMatrixSources: 25,
+  maximumMatrixTargets: 25,
+  /** Straight-line distance between any matrix source and target, per mode. */
+  maximumMatrixDistanceMeters: Object.freeze({
+    driving: 2e5,
+    walking: 1e4,
+    cycling: 1e4,
+    truck: 2e5
+  }),
+  minimumTracePositions: 2,
+  maximumTracePositions: 100,
+  /** Sum of straight-line distances between consecutive trace positions. */
+  maximumTraceDistanceMeters: 2e5,
+  /** Straight-line distance between consecutive trace positions. */
+  maximumTraceGapMeters: 2e3,
+  maximumTraceAccuracyMeters: 100,
+  maximumRoads: 2e3,
+  maximumContours: 4,
+  minimumMinutes: 1,
+  maximumMinutes: 60,
+  maximumSteps: 2e3,
+  maximumGeometryPositions: 2e5,
+  maximumIsochroneVertices: 2e5
+});
+var routingAttribution = "\xA9 OpenStreetMap contributors";
+var longitude = z.number().finite().min(-180).max(180);
+var latitude = z.number().finite().min(-90).max(90);
+var routingPositionSchema = z.tuple([longitude, latitude]);
+function routingDirectDistance(a, b) {
+  const radians = Math.PI / 180;
+  const dLat = (b[1] - a[1]) * radians;
+  const dLng = (b[0] - a[0]) * radians;
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(a[1] * radians) * Math.cos(b[1] * radians) * Math.sin(dLng / 2) ** 2;
+  return 2 * 63710088e-1 * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+var routingVehicleSchema = z.object({
+  heightMeters: z.number().finite().min(1).max(10),
+  widthMeters: z.number().finite().min(1).max(5),
+  lengthMeters: z.number().finite().min(1).max(40),
+  weightTonnes: z.number().finite().min(0.5).max(100),
+  axleLoadTonnes: z.number().finite().min(0.5).max(40),
+  axleCount: z.number().int().min(2).max(20),
+  hazardousMaterials: z.boolean()
+}).partial().strict();
+var travelOptions = {
+  mode: z.enum(routingModes),
+  /** Only for `truck`. */
+  vehicle: routingVehicleSchema.optional(),
+  avoid: z.array(z.enum(routingAvoidances)).max(routingAvoidances.length).optional(),
+  traffic: z.enum(routingTrafficKinds).optional()
+};
+function refineTravelOptions(request, context) {
+  if (request.vehicle && request.mode !== "truck") {
+    context.addIssue({
+      code: "custom",
+      path: ["vehicle"],
+      message: "Vehicle dimensions apply only to truck."
+    });
+  }
+  if (request.avoid && new Set(request.avoid).size !== request.avoid.length) {
+    context.addIssue({ code: "custom", path: ["avoid"], message: "Avoid each kind once." });
+  }
+}
+var routingRouteRequestSchema = z.object({
+  locations: z.array(routingPositionSchema).min(routingLimits.minimumLocations).max(routingLimits.maximumLocations),
+  ...travelOptions,
+  alternatives: z.number().int().min(0).max(routingLimits.maximumAlternatives).optional(),
+  language: z.enum(routingLanguages).optional()
+}).strict().superRefine((request, context) => {
+  refineTravelOptions(request, context);
+  if ((request.alternatives ?? 0) > 0 && request.locations.length !== 2) {
+    context.addIssue({
+      code: "custom",
+      path: ["alternatives"],
+      message: "Alternatives are available only between two locations."
+    });
+  }
+  let distance = 0;
+  for (let index = 1; index < request.locations.length; index += 1) {
+    distance += routingDirectDistance(request.locations[index - 1], request.locations[index]);
+  }
+  if (distance > routingLimits.maximumDirectDistanceMeters[request.mode]) {
+    context.addIssue({
+      code: "custom",
+      path: ["locations"],
+      message: `The locations are too far apart for ${request.mode}.`
+    });
+  }
+});
+var routingIsochroneRequestSchema = z.object({
+  location: routingPositionSchema,
+  ...travelOptions,
+  minutes: z.array(z.number().int().min(routingLimits.minimumMinutes).max(routingLimits.maximumMinutes)).min(1).max(routingLimits.maximumContours)
+}).strict().superRefine((request, context) => {
+  refineTravelOptions(request, context);
+  for (let index = 1; index < request.minutes.length; index += 1) {
+    if (request.minutes[index] <= request.minutes[index - 1]) {
+      context.addIssue({
+        code: "custom",
+        path: ["minutes"],
+        message: "Minutes rise strictly."
+      });
+      return;
+    }
+  }
+});
+var routingMatrixRequestSchema = z.object({
+  sources: z.array(routingPositionSchema).min(1).max(routingLimits.maximumMatrixSources),
+  targets: z.array(routingPositionSchema).min(1).max(routingLimits.maximumMatrixTargets),
+  ...travelOptions
+}).strict().superRefine((request, context) => {
+  refineTravelOptions(request, context);
+  const limit = routingLimits.maximumMatrixDistanceMeters[request.mode];
+  for (const source of request.sources) {
+    for (const target of request.targets) {
+      if (routingDirectDistance(source, target) > limit) {
+        context.addIssue({
+          code: "custom",
+          path: ["targets"],
+          message: `A source and a target are too far apart for ${request.mode}.`
+        });
+        return;
+      }
+    }
+  }
+});
+var routingMatchRequestSchema = z.object({
+  trace: z.array(routingPositionSchema).min(routingLimits.minimumTracePositions).max(routingLimits.maximumTracePositions),
+  /** Seconds since the Unix epoch at each trace position, non-decreasing. */
+  timestamps: z.array(z.number().int().min(0).max(4102444800)).optional(),
+  /** GPS accuracy in metres; the default suits a phone outdoors. */
+  accuracy: z.number().finite().min(1).max(routingLimits.maximumTraceAccuracyMeters).optional(),
+  mode: z.enum(routingModes),
+  vehicle: routingVehicleSchema.optional()
+}).strict().superRefine((request, context) => {
+  refineTravelOptions(request, context);
+  if (request.timestamps) {
+    if (request.timestamps.length !== request.trace.length) {
+      context.addIssue({
+        code: "custom",
+        path: ["timestamps"],
+        message: "Give one timestamp per trace position."
+      });
+    } else if (request.timestamps.some(
+      (time, index) => index > 0 && time < request.timestamps[index - 1]
+    )) {
+      context.addIssue({
+        code: "custom",
+        path: ["timestamps"],
+        message: "Timestamps never go back."
+      });
+    }
+  }
+  let distance = 0;
+  for (let index = 1; index < request.trace.length; index += 1) {
+    const gap = routingDirectDistance(request.trace[index - 1], request.trace[index]);
+    if (gap > routingLimits.maximumTraceGapMeters) {
+      context.addIssue({
+        code: "custom",
+        path: ["trace", index],
+        message: "Consecutive trace positions are more than 2 km apart."
+      });
+      return;
+    }
+    distance += gap;
+  }
+  if (distance > routingLimits.maximumTraceDistanceMeters) {
+    context.addIssue({ code: "custom", path: ["trace"], message: "The trace is too long." });
+  }
+});
+var routingNearestRequestSchema = z.object({ location: routingPositionSchema, mode: z.enum(routingModes) }).strict();
+var routingManeuvers = [
+  "depart",
+  "arrive",
+  "continue",
+  "slight-right",
+  "right",
+  "sharp-right",
+  "u-turn",
+  "sharp-left",
+  "left",
+  "slight-left",
+  "ramp-straight",
+  "ramp-right",
+  "ramp-left",
+  "exit-right",
+  "exit-left",
+  "keep-straight",
+  "keep-right",
+  "keep-left",
+  "merge",
+  "merge-right",
+  "merge-left",
+  "roundabout-enter",
+  "roundabout-exit",
+  "ferry-enter",
+  "ferry-exit",
+  "elevator",
+  "stairs",
+  "escalator",
+  "building-enter",
+  "building-exit"
+];
+var meters = z.number().finite().min(0);
+var seconds = z.number().finite().min(0);
+var text = z.string().min(1).max(500);
+var routingStepSchema = z.object({
+  maneuver: z.enum(routingManeuvers),
+  instruction: text,
+  /** Street names and road numbers the step follows, as OpenStreetMap records them. */
+  names: z.array(z.string().min(1).max(200)).max(8).optional(),
+  /** Exit number of a highway exit. */
+  exit: z.string().min(1).max(50).optional(),
+  /** Destinations signed at a highway exit or ramp. */
+  toward: z.array(z.string().min(1).max(200)).max(8).optional(),
+  /** Exit to take at a roundabout, counted from the entry. */
+  roundaboutExit: z.number().int().min(1).max(32).optional(),
+  distance: meters,
+  duration: seconds,
+  location: routingPositionSchema
+}).strict();
+var routingLineStringSchema = z.object({
+  type: z.literal("LineString"),
+  coordinates: z.array(routingPositionSchema).min(2).max(routingLimits.maximumGeometryPositions)
+}).strict();
+var routingLegSchema = z.object({
+  distance: meters,
+  duration: seconds,
+  steps: z.array(routingStepSchema).min(1).max(routingLimits.maximumSteps)
+}).strict();
+var routingRouteSchema = z.object({
+  distance: meters,
+  duration: seconds,
+  /** Whether the route uses a toll road, a highway or a ferry. */
+  hasTolls: z.boolean(),
+  hasHighways: z.boolean(),
+  hasFerries: z.boolean(),
+  geometry: routingLineStringSchema,
+  legs: z.array(routingLegSchema).min(1).max(routingLimits.maximumLocations - 1)
+}).strict();
+var routingNetworkSchema = z.object({ releaseId: z.string().regex(/^[a-z0-9][a-z0-9._-]{0,126}[a-z0-9]$/u) }).strict();
+var routingUsageSchema = z.object({ units: z.number().int().min(0) }).strict();
+var routingRoadClasses = [
+  "motorway",
+  "trunk",
+  "primary",
+  "secondary",
+  "tertiary",
+  "unclassified",
+  "residential",
+  "service"
+];
+var routingRoadSurfaces = [
+  "paved-smooth",
+  "paved",
+  "paved-rough",
+  "compacted",
+  "dirt",
+  "gravel",
+  "path",
+  "impassable"
+];
+var routingRoadSchema = z.object({
+  names: z.array(z.string().min(1).max(200)).max(8),
+  /** The OpenStreetMap way the road belongs to. */
+  wayId: z.number().int().positive().optional(),
+  class: z.enum(routingRoadClasses),
+  surface: z.enum(routingRoadSurfaces).optional(),
+  lanes: z.number().int().min(1).max(16).optional(),
+  /** The speed limit as tagged in OpenStreetMap, or `null` where none is recorded. */
+  speedLimit: z.object({ kmh: z.number().int().min(1).max(300), source: z.literal("tagged") }).strict().nullable(),
+  toll: z.boolean(),
+  bridge: z.boolean(),
+  tunnel: z.boolean(),
+  roundabout: z.boolean(),
+  length: meters
+}).strict();
+var ring = z.array(routingPositionSchema).min(4);
+var polygon = z.object({ type: z.literal("Polygon"), coordinates: z.array(ring).min(1) }).strict();
+var multiPolygon = z.object({ type: z.literal("MultiPolygon"), coordinates: z.array(z.array(ring).min(1)).min(1) }).strict();
+var routingIsochroneFeatureSchema = z.object({
+  type: z.literal("Feature"),
+  properties: z.object({
+    minutes: z.number().int().min(routingLimits.minimumMinutes).max(routingLimits.maximumMinutes)
+  }).strict(),
+  geometry: z.union([polygon, multiPolygon])
+}).strict();
+var routingIsochroneCollectionSchema = z.object({
+  type: z.literal("FeatureCollection"),
+  features: z.array(routingIsochroneFeatureSchema).min(1).max(routingLimits.maximumContours)
+}).strict();
+var answer = {
+  schemaVersion: z.literal(1),
+  network: routingNetworkSchema,
+  attribution: z.literal(routingAttribution),
+  traffic: z.enum(routingTrafficKinds)
+};
+var routingRouteResponseSchema = z.object({
+  ...answer,
+  routes: z.array(routingRouteSchema).min(1).max(routingLimits.maximumAlternatives + 1),
+  usage: routingUsageSchema
+}).strict();
+var routingIsochroneResponseSchema = z.object({ ...answer, isochrones: routingIsochroneCollectionSchema, usage: routingUsageSchema }).strict();
+var routingMatrixResponseSchema = z.object({
+  ...answer,
+  /**
+   * Seconds from each source (rows) to each target (columns); `null` where no route was found,
+   * because none exists or because the service could not find it within its deadline.
+   */
+  durations: z.array(z.array(seconds.nullable()).min(1).max(routingLimits.maximumMatrixTargets)).min(1).max(routingLimits.maximumMatrixSources),
+  /** Metres, in the same order; `null` where no route was found. */
+  distances: z.array(z.array(meters.nullable()).min(1).max(routingLimits.maximumMatrixTargets)).min(1).max(routingLimits.maximumMatrixSources),
+  usage: routingUsageSchema
+}).strict();
+var routingMatchResponseSchema = z.object({
+  ...answer,
+  distance: meters,
+  duration: seconds,
+  geometry: routingLineStringSchema,
+  /** One entry per trace position: where it was matched, or `null` when it was not. */
+  points: z.array(z.object({ location: routingPositionSchema, distance: meters }).strict().nullable()).min(routingLimits.minimumTracePositions).max(routingLimits.maximumTracePositions),
+  /** The roads of the matched path, in order; consecutive pieces of one road are merged. */
+  roads: z.array(routingRoadSchema).min(1).max(routingLimits.maximumRoads),
+  usage: routingUsageSchema
+}).strict();
+var routingNearestResponseSchema = z.object({
+  ...answer,
+  /** The point of the road nearest to the request, and its distance from it in metres. */
+  location: routingPositionSchema,
+  distance: meters,
+  road: routingRoadSchema,
+  usage: routingUsageSchema
+}).strict();
+var routingOperations = ["route", "isochrone", "matrix", "match", "nearest"];
+var routingErrorCodes = [
+  "ROUTING_INVALID_REQUEST",
+  "ROUTING_REQUEST_TOO_LARGE",
+  "ROUTING_ACCESS_DENIED",
+  "ROUTING_ORIGIN_NOT_ALLOWED",
+  "ROUTING_NO_ROUTE",
+  "ROUTING_RATE_LIMITED",
+  "ROUTING_QUOTA_EXCEEDED",
+  "ROUTING_CANCELLED",
+  "ROUTING_INVALID_RESPONSE",
+  "ROUTING_UNAVAILABLE",
+  "ROUTING_TIMEOUT"
+];
+var routingErrorStatus = Object.freeze({
+  ROUTING_INVALID_REQUEST: 400,
+  ROUTING_REQUEST_TOO_LARGE: 413,
+  ROUTING_ACCESS_DENIED: 403,
+  ROUTING_ORIGIN_NOT_ALLOWED: 403,
+  ROUTING_NO_ROUTE: 422,
+  ROUTING_RATE_LIMITED: 429,
+  ROUTING_QUOTA_EXCEEDED: 429,
+  ROUTING_CANCELLED: 499,
+  ROUTING_INVALID_RESPONSE: 502,
+  ROUTING_UNAVAILABLE: 503,
+  ROUTING_TIMEOUT: 504
+});
+
+export {
+  routingModes,
+  routingAvoidances,
+  routingTrafficKinds,
+  routingLanguages,
+  routingLimits,
+  routingAttribution,
+  routingPositionSchema,
+  routingDirectDistance,
+  routingVehicleSchema,
+  routingRouteRequestSchema,
+  routingIsochroneRequestSchema,
+  routingMatrixRequestSchema,
+  routingMatchRequestSchema,
+  routingNearestRequestSchema,
+  routingManeuvers,
+  routingStepSchema,
+  routingLineStringSchema,
+  routingLegSchema,
+  routingRouteSchema,
+  routingNetworkSchema,
+  routingUsageSchema,
+  routingRoadClasses,
+  routingRoadSurfaces,
+  routingRoadSchema,
+  routingIsochroneFeatureSchema,
+  routingIsochroneCollectionSchema,
+  routingRouteResponseSchema,
+  routingIsochroneResponseSchema,
+  routingMatrixResponseSchema,
+  routingMatchResponseSchema,
+  routingNearestResponseSchema,
+  routingOperations,
+  routingErrorCodes,
+  routingErrorStatus
+};

package/dist/chunk-MCATD4FU.js

@@ -0,0 +1,256 @@
+import {
+  routingErrorCodes,
+  routingErrorStatus,
+  routingIsochroneRequestSchema,
+  routingIsochroneResponseSchema,
+  routingLimits,
+  routingMatchRequestSchema,
+  routingMatchResponseSchema,
+  routingMatrixRequestSchema,
+  routingMatrixResponseSchema,
+  routingNearestRequestSchema,
+  routingNearestResponseSchema,
+  routingRouteRequestSchema,
+  routingRouteResponseSchema
+} from "./chunk-ECBK2QPL.js";
+
+// src/client.ts
+import { z } from "zod";
+var RoutingError = class extends Error {
+  code;
+  requestId;
+  status;
+  retryAfterSeconds;
+  constructor(message, input) {
+    super(message);
+    this.name = "RoutingError";
+    this.code = input.code ?? null;
+    this.requestId = input.requestId ?? null;
+    this.status = input.status;
+    this.retryAfterSeconds = input.retryAfterSeconds ?? null;
+  }
+};
+async function route(request, options) {
+  const parsed = routingRouteRequestSchema.safeParse(request);
+  if (!parsed.success) throw new Error("Invalid Tileflow route request");
+  const legs = parsed.data.locations.length - 1;
+  return requestRouting(
+    "/v1/routing/route",
+    parsed.data,
+    options,
+    routingRouteResponseSchema,
+    (response) => response.routes.length <= (parsed.data.alternatives ?? 0) + 1 && response.routes.every((candidate) => candidate.legs.length === legs)
+  );
+}
+async function isochrone(request, options) {
+  const parsed = routingIsochroneRequestSchema.safeParse(request);
+  if (!parsed.success) throw new Error("Invalid Tileflow isochrone request");
+  return requestRouting(
+    "/v1/routing/isochrone",
+    parsed.data,
+    options,
+    routingIsochroneResponseSchema,
+    (response) => response.isochrones.features.length === parsed.data.minutes.length && response.isochrones.features.every(
+      (feature, index) => feature.properties.minutes === parsed.data.minutes[index]
+    )
+  );
+}
+async function matrix(request, options) {
+  const parsed = routingMatrixRequestSchema.safeParse(request);
+  if (!parsed.success) throw new Error("Invalid Tileflow matrix request");
+  const rows = parsed.data.sources.length;
+  const columns = parsed.data.targets.length;
+  const isGrid = (grid) => grid.length === rows && grid.every((row) => row.length === columns);
+  return requestRouting(
+    "/v1/routing/matrix",
+    parsed.data,
+    options,
+    routingMatrixResponseSchema,
+    (response) => isGrid(response.durations) && isGrid(response.distances)
+  );
+}
+async function match(request, options) {
+  const parsed = routingMatchRequestSchema.safeParse(request);
+  if (!parsed.success) throw new Error("Invalid Tileflow match request");
+  return requestRouting(
+    "/v1/routing/match",
+    parsed.data,
+    options,
+    routingMatchResponseSchema,
+    (response) => response.points.length === parsed.data.trace.length
+  );
+}
+async function nearest(request, options) {
+  const parsed = routingNearestRequestSchema.safeParse(request);
+  if (!parsed.success) throw new Error("Invalid Tileflow nearest request");
+  return requestRouting(
+    "/v1/routing/nearest",
+    parsed.data,
+    options,
+    routingNearestResponseSchema,
+    () => true
+  );
+}
+var safeErrorText = z.string().trim().min(1).max(512).refine((value) => !/\p{Cc}/u.test(value));
+var requestId = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u);
+var routingErrorResponseSchema = z.object({ code: z.enum(routingErrorCodes), error: safeErrorText, requestId: requestId.optional() }).strict();
+async function requestRouting(path, request, options, responseSchema, isExpectedResponse) {
+  const bodyText = JSON.stringify(request);
+  if (new TextEncoder().encode(bodyText).byteLength > routingLimits.maximumRequestBytes)
+    throw new Error("Tileflow Routing request is too large");
+  const apiKey = normalizeApiKey(options.apiKey);
+  const app = normalizeApp(options.app);
+  const apiUrl = normalizeApiUrl(options.apiUrl ?? "https://api.tileflow.dev");
+  const fetcher = options.fetch ?? fetch;
+  let response;
+  try {
+    response = await fetcher(`${apiUrl}${path}`, {
+      body: bodyText,
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        ...app ? { "X-Tileflow-App": app.id } : {},
+        ...app?.certificateSha256 ? { "X-Tileflow-App-Certificate": app.certificateSha256 } : {}
+      },
+      method: "POST",
+      redirect: "error",
+      signal: options.signal
+    });
+  } catch (error) {
+    if (options.signal?.aborted) throw options.signal.reason ?? error;
+    throw new RoutingError("Tileflow Routing request failed", { status: 0 });
+  }
+  if (response.redirected) {
+    void response.body?.cancel().catch(() => void 0);
+    throw new RoutingError("Tileflow Routing request failed", { status: response.status });
+  }
+  if (!response.ok) throw await readRoutingError(response, options.signal);
+  let body;
+  try {
+    body = await readBoundedJson(response, routingLimits.maximumResponseBytes, options.signal);
+  } catch (error) {
+    if (options.signal?.aborted) throw options.signal.reason ?? error;
+    throw new RoutingError("Tileflow Routing returned an invalid response", {
+      status: response.status
+    });
+  }
+  const parsed = responseSchema.safeParse(body);
+  if (!parsed.success || !isExpectedResponse(parsed.data))
+    throw new RoutingError("Tileflow Routing returned an invalid response", {
+      status: response.status
+    });
+  return parsed.data;
+}
+function normalizeApp(value) {
+  if (value === void 0) return null;
+  const certificate = value?.certificateSha256?.replaceAll(":", "").toLowerCase();
+  if (typeof value?.id !== "string" || value.id.length > 255 || !/^[A-Za-z][A-Za-z0-9_-]*(\.[A-Za-z0-9_-]+)+$/u.test(value.id) || certificate !== void 0 && !/^[0-9a-f]{64}$/u.test(certificate))
+    throw new Error("Invalid Tileflow app identity");
+  return { id: value.id, certificateSha256: certificate };
+}
+function normalizeApiKey(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 4096 || value !== value.trim() || /\p{Cc}/u.test(value))
+    throw new Error("Invalid Tileflow API key");
+  return value;
+}
+function normalizeApiUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Invalid Tileflow API URL");
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback) || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "")
+    throw new Error("Invalid Tileflow API URL");
+  return url.href.replace(/\/$/u, "");
+}
+async function readRoutingError(response, signal) {
+  const value = response.headers.get("Retry-After");
+  const retryAfterSeconds = value && /^\d{1,8}$/u.test(value) ? Number(value) : null;
+  let body;
+  try {
+    body = await readBoundedJson(response, 8 * 1024, signal);
+  } catch (error) {
+    if (signal?.aborted) throw signal.reason ?? error;
+    return new RoutingError("Tileflow Routing request failed", {
+      status: response.status,
+      retryAfterSeconds
+    });
+  }
+  const parsed = routingErrorResponseSchema.safeParse(body);
+  const expected = parsed.success && (routingErrorStatus[parsed.data.code] === response.status || parsed.data.code === "ROUTING_ACCESS_DENIED" && response.status === 401);
+  if (!parsed.success || !expected)
+    return new RoutingError("Tileflow Routing request failed", {
+      status: response.status,
+      retryAfterSeconds
+    });
+  return new RoutingError(parsed.data.error, {
+    code: parsed.data.code,
+    status: response.status,
+    retryAfterSeconds,
+    ...parsed.data.requestId ? { requestId: parsed.data.requestId } : {}
+  });
+}
+async function readBoundedJson(response, maximumBytes, signal) {
+  const declared = response.headers.get("Content-Length");
+  if (declared !== null && (!/^\d+$/u.test(declared) || Number(declared) > maximumBytes)) {
+    void response.body?.cancel().catch(() => void 0);
+    throw new Error("Tileflow Routing response is too large");
+  }
+  if (!response.body) throw new Error("Tileflow Routing response is empty");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  try {
+    while (true) {
+      const { done, value } = await readResponseChunk(reader, signal);
+      if (done) break;
+      byteLength += value.byteLength;
+      if (byteLength > maximumBytes) {
+        void reader.cancel().catch(() => void 0);
+        throw new Error("Tileflow Routing response is too large");
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+}
+async function readResponseChunk(reader, signal) {
+  if (!signal) return reader.read();
+  let aborted = false;
+  const abort = () => {
+    aborted = true;
+    void reader.cancel(signal.reason).catch(() => void 0);
+  };
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+  try {
+    const chunk = await reader.read();
+    if (aborted) throw signal.reason ?? new Error("Tileflow Routing request was aborted");
+    return chunk;
+  } catch (error) {
+    if (aborted) throw signal.reason ?? error;
+    throw error;
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+export {
+  RoutingError,
+  route,
+  isochrone,
+  matrix,
+  match,
+  nearest
+};