@unmap/sdk 0.12.0 → 0.14.0

package/README.md

@@ -1,7 +1,9 @@
 # @unmap/sdk
 
-One key, the whole [unmap](https://unmap.dev) platform: a MapLibre GL map, a geocoder, and a
-router behind a single `um_live_` or `um_test_` key. Canadian-first, privacy-first.
+One key, the whole [unmap](https://unmap.dev) platform: a worldwide MapLibre GL basemap, Canadian
+geocoding and routing, and the rest of the API behind a single `um_live_` or `um_test_` key.
+The basemap supports 41 upstream Protomaps label-language tags; geocoding and routing remain
+Canada-scoped. Canadian-built, privacy-first.
 
 ```bash
 npm i @unmap/sdk
@@ -14,7 +16,8 @@ import 'maplibre-gl/dist/maplibre-gl.css'
 const map = new Unmap({ key: 'um_live_...', container: '#map', center: [-114.07, 51.05] })
 ```
 
-That is the whole Hello World: a Calgary basemap in the `#map` element. Without a `container`
+That is the whole Hello World: a worldwide basemap initially centered on Calgary in the `#map`
+element. Without a `container`
 you still get the geocoder and router:
 
 ```ts
@@ -26,20 +29,46 @@ await unmap.router.route([-114.07, 51.05], [-113.99, 51.05], { mode: 'bicycle' }
 await unmap.router.isochrone([-114.07, 51.05], { minutes: [10, 20] })
 ```
 
+The SDK also carries the departure-time transit contract:
+
+```ts
+await unmap.router.route(from, to, { mode: 'transit', departAt: new Date() })
+```
+
+Production answers TTC trips. The type requires `departAt`; there is no `arriveBy`, transit
+matrix, or realtime claim. Other static feeds stay schedule-only.
+
+Static transit data has its own release gate and client:
+
+```ts
+const stops = await unmap.transit.nearbyStops([-79.3832, 43.6532], { radius: 800 })
+const departures = stops.data[0]
+  ? await unmap.transit.departures(stops.data[0].id, { at: new Date(), window: 60 })
+  : undefined
+
+await unmap.transit.agencies()
+await unmap.transit.getStop('um:transit:stop:ttc:1234')
+await unmap.transit.getRoute('um:transit:route:ttc:1')
+```
+
+Those methods return `{ data, meta }`, where `meta` carries source, freshness and attribution.
+They return a retryable `503` until a versioned GTFS release is enabled. Departures are scheduled,
+including service after midnight and `calendar_dates.txt` exceptions; they are not realtime.
+
 ## Without a build step
 
 The same SDK loads from a script tag, with MapLibre already inside it:
 
 ```html
-<link rel="stylesheet" href="https://cdn.unmap.dev/sdk/0.12.0/unmap.css">
+<link rel="stylesheet" href="https://cdn.unmap.dev/sdk/0.14.0/unmap.css">
 <div id="map" style="height: 400px"></div>
-<script src="https://cdn.unmap.dev/sdk/0.12.0/unmap.js"></script>
+<script src="https://cdn.unmap.dev/sdk/0.14.0/unmap.js"></script>
 <script>
   unmap.createMap({ key: 'um_live_...', container: '#map', center: [-114.07, 51.05] })
 </script>
 ```
 
-Everything above is on the `unmap` global: `unmap.Unmap`, `unmap.Geocoder`, `unmap.Router`, `unmap.maplibregl`. Pin the exact version in production; `/sdk/0.12/` follows patches and `/sdk/latest/` follows everything.
+Everything above is on the `unmap` global: `unmap.Unmap`, `unmap.Geocoder`, `unmap.Router`, `unmap.maplibregl`. Pin the exact version in production; `/sdk/0.14/` follows patches and `/sdk/latest/` follows everything.
 
 ## Options
 
@@ -51,7 +80,7 @@ Everything above is on the `unmap` global: `unmap.Unmap`, `unmap.Geocoder`, `unm
 | `style`     | `string`                | `base` (default), `muted`, `outdoor`, `blueprint`, `blush`, `orchid`, `canopy`, `lagoon`, `tropic`, `sunset`, `bold`, `pastel`, or a full style URL. |
 | `flavor`    | `string`                | Older spelling of `style`: a style name, read only when `style` is omitted.    |
 | `mode`      | `string`                | `light` or `dark`. Selects the mode of the named style.                       |
-| `lang`      | `string`                | Label language, e.g. `fr`. Omit to follow the browser's `Accept-Language`.    |
+| `lang`      | `string`                | Basemap label language. Supports the 41 Protomaps language tags (including `ja`, `ko`, `zh-Hans`, and `zh-Hant`); omit to follow the browser's `Accept-Language`. |
 | `theme`     | `string`                | A theme code (`u…` or `ut1.`) from [unmap.dev/create](https://unmap.dev/create). |
 | `center`    | `[lng, lat]`            | Initial centre.                                                              |
 | `zoom`      | `number`                | Initial zoom.                                                                |
@@ -59,8 +88,9 @@ Everything above is on the `unmap` global: `unmap.Unmap`, `unmap.Geocoder`, `unm
 | `controls`  | `boolean \| { position }` | Zoom and compass buttons. `true` by default; `false` for a bare canvas.     |
 
 The instance exposes `.map` (MapLibre GL `Map`, only with a `container`), `.geocoder`
-(`@unmap/geocoding`), and `.router` (`@unmap/routing`). Everything from those two packages and
-from `@unmap/maps` is re-exported here, including `maplibregl` for markers and popups.
+(`@unmap/geocoding`), `.router` (`@unmap/routing`), `.transit`, `.places`, `.roads`, `.feedback`
+and `.elevation`. Everything from the packages and `@unmap/maps` is re-exported here, including
+`maplibregl` for markers and popups.
 
 ## Stylesheet
 
@@ -76,12 +106,12 @@ reliably resolve inside a bundler's module graph. Bundler users make a one-time
 call after copying `maplibre-gl-worker.mjs` and `maplibre-gl-shared.mjs` into their own `public/`.
 Skip it and the map never finishes loading, with no error thrown and no failed request — see
 [@unmap/maps](https://www.npmjs.com/package/@unmap/maps#web-worker) for the script and the call, or
-[the quickstart](https://unmap.dev/docs/quickstart#if-the-map-never-finishes-loading).
+[the quickstart](https://unmap.dev/docs/start/quickstart#if-the-map-never-finishes-loading).
 
 ## Docs
 
-- [Quickstart](https://unmap.dev/docs/quickstart) and [Overview](https://unmap.dev/docs/overview)
-- [Tiles & Styles](https://unmap.dev/docs/tiles-and-styles), [Geocoding API](https://unmap.dev/docs/geocoding-api), [Routing API](https://unmap.dev/docs/routing-api)
-- [Errors](https://unmap.dev/docs/errors) and [Plans & Limits](https://unmap.dev/docs/plans-and-limits)
+- [Quickstart](https://unmap.dev/docs/start/quickstart) and [Overview](https://unmap.dev/docs/start/overview)
+- [Tiles & Styles](https://unmap.dev/docs/apis/maps), [Geocoding API](https://unmap.dev/docs/apis/geocoding), [Routing API](https://unmap.dev/docs/apis/routing), [Transit API](https://unmap.dev/docs/apis/transit)
+- [Errors](https://unmap.dev/docs/reference/errors) and [Plans & Limits](https://unmap.dev/docs/reference/plans)
 
-Documentation en français : [unmap.dev/fr/docs](https://unmap.dev/fr/docs/quickstart).
+Documentation en français : [unmap.dev/fr/docs](https://unmap.dev/fr/docs/start/quickstart).

package/dist/index.d.ts

@@ -1,17 +1,540 @@
 import { Map, MapProfile, UnmapMapOptions, UnmapControlsOptions } from '@unmap/maps';
 export { DEMO_CITIES, DemoCity, Map, MapProfile, Projection, STYLE_NAMES, StyleInput, StyleName, UnmapControlsOptions, UnmapMapOptions, createMap, maplibregl, unmapStyle } from '@unmap/maps';
-import { Geocoder, QueryOptions, QueryResponse, IdentifyOptions, IdentifyResponse } from '@unmap/geocoding';
+import { Geocoder, Places, QueryOptions, QueryResponse, IdentifyOptions, IdentifyResponse } from '@unmap/geocoding';
 export * from '@unmap/geocoding';
+import { RetryPolicy, UnmapError } from '@unmap/core';
+export { RetryPolicy, UnmapError, parseRetryAfter } from '@unmap/core';
 import { Router } from '@unmap/routing';
 export * from '@unmap/routing';
 import { Elevation } from '@unmap/elevation';
 export * from '@unmap/elevation';
 
+/**
+ * Typed clients for road events (`/incidents`, `/closures`, `/road-conditions`) and for data
+ * correction (`POST /feedback`).
+ *
+ * These live in `@unmap/sdk` rather than in packages of their own. A twelfth and thirteenth npm
+ * package would each need an entry in the changesets fixed group and a trusted publisher
+ * configured on npmjs.com, which is founder work, and neither has a framework wrapper the way
+ * geocoding and routing do. If a customer ever wants roads without the rest of the SDK, that is
+ * the moment to split it out.
+ */
+type RoadEventType = "closure" | "incident" | "construction" | "weather" | "restriction" | "ferry" | "hazard" | "special_event" | "unknown";
+type RoadCondition = "dry" | "wet" | "snow" | "ice" | "packed_snow" | "reduced_visibility" | "travel_not_recommended" | "closed" | "unknown";
+type RoadSeverity = "minor" | "major" | "unknown";
+interface AffectedRoad {
+    name: string;
+    direction: "north" | "south" | "east" | "west" | "both" | "unknown";
+    /** True only when the publisher says closed. Never inferred from the description. */
+    closed: boolean;
+    from?: string;
+    to?: string;
+    condition: RoadCondition;
+}
+interface RoadEvent {
+    /** `um:road:<jurisdiction>:<publisher id>`. */
+    id: string;
+    /** The publisher's own id, so a report can be taken back to them. */
+    source_id: string;
+    /** ISO 3166-2, e.g. `CA-BC`. */
+    jurisdiction: string;
+    type: RoadEventType;
+    /** The publisher's own subtype strings, untranslated. */
+    subtypes: string[];
+    status: "active" | "planned" | "archived";
+    severity: RoadSeverity;
+    /**
+     * The publisher's description, verbatim.
+     *
+     * Believe this over `type` when they disagree: our categories are a lossy projection of someone
+     * else's taxonomy, and the sentence a driver needs is in the prose.
+     */
+    description: string;
+    headline?: string;
+    /** The worst surface condition across this event's roads. */
+    condition: RoadCondition;
+    roads: AffectedRoad[];
+    /** GeoJSON Point or LineString, WGS84. */
+    geometry: {
+        type: string;
+        coordinates: unknown;
+    } | null;
+    starts_at: string | null;
+    ends_at: string | null;
+    source_updated_at: string | null;
+    unmap_updated_at: string;
+    source: string;
+}
+interface RoadEventsResponse {
+    data: RoadEvent[];
+    meta: {
+        status: "current" | "stale" | "partial" | "unknown";
+        attribution: string;
+        unmap_updated_at: string;
+        /**
+         * Jurisdictions that could not be reached, each with a reason.
+         *
+         * **Check this.** On `/closures` an empty `data` reads as "nothing is shut" to someone
+         * deciding whether to drive, and that is a very different answer from "we could not reach
+         * British Columbia".
+         */
+        unavailable?: {
+            jurisdiction: string;
+            reason: string;
+        }[];
+    };
+}
+interface RoadEventQuery {
+    /** Comma-separated ISO 3166-2 codes, or an array. An uncovered code is a 400, not an empty list. */
+    jurisdiction?: string | readonly string[];
+    bbox?: [number, number, number, number];
+    near?: [number, number];
+    /** Metres from `near`. Default 25000, max 500000. */
+    radius?: number;
+    type?: RoadEventType | readonly RoadEventType[];
+    severity?: RoadSeverity | readonly RoadSeverity[];
+    status?: "active" | "planned" | "archived";
+    /** ISO 8601. Only events the publisher changed at or after this time. */
+    updated_since?: string;
+    /** 1 to 500, default 100. Applied AFTER the endpoint's own narrowing. */
+    limit?: number;
+    signal?: AbortSignal;
+}
+interface RoadsOptions {
+    key: string;
+    gateway?: string;
+    fetch?: typeof fetch;
+    /**
+     * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.
+     *
+     * On by default. `Retry-After` is on a `429` other than `billing_required`, and on a container
+     * `503`. A `502` has none: routing uses `routing_failed`, and `/elevation` uses
+     * `upstream_error`. With no header the client backs off itself. A wait longer than
+     * `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds` instead.
+     * See `RetryPolicy` in `@unmap/core`.
+     */
+    retry?: RetryPolicy | false;
+}
+/**
+ * A road events failure.
+ *
+ * Extends `UnmapError`, so `catch (e) { if (e instanceof UnmapError) }` catches this alongside
+ * every other unmap client's errors. `instanceof RoadsError` keeps working, and `status` and `code`
+ * are still where they were; `retryAfterSeconds` is new and comes from the header.
+ */
+declare class RoadsError extends UnmapError {
+    constructor(status: number, message: string, code?: string, retryAfterSeconds?: number);
+}
+/**
+ * Canadian road events.
+ *
+ *   const { data, meta } = await unmap.roads.closures({ jurisdiction: "CA-BC" });
+ *
+ * A 503 means every requested jurisdiction was unreachable; the body still carries
+ * `meta.unavailable`, so the thrown error is the exception rather than the information. Prefer
+ * reading `meta.unavailable` on a 200 over treating an empty list as good news.
+ */
+declare class Roads {
+    private readonly key;
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly retry;
+    constructor(opts: RoadsOptions);
+    /** Every current road event. */
+    incidents(query?: RoadEventQuery): Promise<RoadEventsResponse>;
+    /** The subset where a road is actually shut. Narrowed before `limit` is applied. */
+    closures(query?: RoadEventQuery): Promise<RoadEventsResponse>;
+    /**
+     * The subset carrying a surface condition.
+     *
+     * Thin for British Columbia by design: its feed reports lane availability rather than the
+     * surface, so unmap answers `unknown` instead of inferring a dry road from open lanes.
+     */
+    conditions(query?: RoadEventQuery): Promise<RoadEventsResponse>;
+    private request;
+}
+type FeedbackProduct = "tiles" | "terrain" | "names" | "geocoding" | "places" | "routing" | "layers" | "transit" | "roads" | "ev";
+type FeedbackCategory = "incorrect_location" | "incorrect_address" | "missing_place" | "wrong_place_name" | "wrong_category" | "bad_route" | "missing_road_closure" | "incorrect_road_condition" | "incorrect_transit_result" | "other";
+interface FeedbackReport {
+    product: FeedbackProduct;
+    category: FeedbackCategory;
+    /** Up to 2000 characters, stored exactly as written. One of this or `resultId` is required. */
+    description?: string;
+    /** The unmap id of the result being reported. */
+    resultId?: string;
+    /**
+     * The request being reported.
+     *
+     * **Only send this with the reporter's explicit agreement.** The gateway refuses it without
+     * `include_context: true`, which this sets whenever `context` is present, and that flag is
+     * meant to record a person's choice rather than a client default. unmap redacts query strings
+     * from its own logs; a client that attached them here would undo that.
+     */
+    context?: unknown;
+    signal?: AbortSignal;
+}
+interface FeedbackReceipt {
+    /** Quote this in a follow-up. */
+    id: string;
+    status: string;
+    created_at: string;
+    /** Whether a request context was actually kept. `false` when none was offered. */
+    context_stored: boolean;
+}
+/**
+ * Report wrong data.
+ *
+ *   await unmap.feedback.submit({
+ *     product: "geocoding",
+ *     category: "incorrect_location",
+ *     description: "17 Ave SW returns a street in Edmonton.",
+ *   });
+ *
+ * Authenticated like everything else and **never metered**: telling us our data is wrong does not
+ * cost a call. At most 200 reports per account per day.
+ */
+declare class Feedback {
+    private readonly key;
+    private readonly base;
+    private readonly fetchImpl;
+    constructor(opts: RoadsOptions);
+    submit(report: FeedbackReport): Promise<FeedbackReceipt>;
+    /** A report about one place. `product` and `result_id` come from the path. */
+    aboutPlace(placeId: string, report: Omit<FeedbackReport, "product" | "resultId">): Promise<FeedbackReceipt>;
+    private post;
+}
+
+type TransitMetaStatus = "current" | "stale" | "partial" | "unknown";
+interface TransitMeta {
+    /** Static GTFS is scheduled data. Realtime will use a different value and updated_at. */
+    schedule_type: "scheduled";
+    source?: string;
+    source_updated_at?: string | null;
+    source_version?: string;
+    content_hash?: string | null;
+    sources?: readonly {
+        id: string;
+        source: string;
+        source_url: string;
+        attribution: string;
+        source_updated_at: string | null;
+        source_version: string;
+        content_hash: string | null;
+        status: "current" | "stale" | "unknown";
+    }[];
+    unmap_updated_at: string;
+    data_version?: string;
+    status: TransitMetaStatus;
+    attribution: string;
+}
+interface TransitResponse<T> {
+    data: T;
+    meta: TransitMeta;
+}
+interface TransitAgency {
+    id: string;
+    feed: string;
+    name: string;
+    url?: string;
+    timezone: string;
+    lang?: string;
+    phone?: string;
+    fare_url?: string;
+}
+interface TransitStop {
+    id: string;
+    feed: string;
+    name: string;
+    coordinates: [number, number];
+    code?: string;
+    description?: string;
+    zone_id?: string;
+    parent_station_id?: string;
+    wheelchair_boarding?: 0 | 1 | 2;
+    route_ids: string[];
+    /** Metres from the requested point. Present only on nearbyStops. */
+    distance?: number;
+}
+interface TransitRoute {
+    id: string;
+    feed: string;
+    agency_id: string;
+    short_name?: string;
+    long_name?: string;
+    description?: string;
+    route_type: number;
+    colour?: string;
+    text_colour?: string;
+    url?: string;
+}
+interface TransitDeparture {
+    stop_id: string;
+    route_id: string;
+    trip_id: string;
+    headsign?: string;
+    arrival: string;
+    departure: string;
+    stop_sequence: number;
+    /** 2 = phone agency; 3 = coordinate with driver. Omitted for ordinary pickup. */
+    pickup_type?: 2 | 3;
+    schedule_type: "scheduled";
+}
+interface NearbyStopsOptions {
+    /** Metres. Default 1000, range 50 to 10000. */
+    radius?: number;
+    /** Default 20, maximum 100. */
+    limit?: number;
+    signal?: AbortSignal;
+}
+interface DepartureOptions {
+    /** An instant. Date values serialize to ISO; strings must include Z or an offset. Default now. */
+    at?: Date | string;
+    /** Minutes after at. Default 60, maximum 240. */
+    window?: number;
+    /** Default 50, maximum 200. */
+    limit?: number;
+    signal?: AbortSignal;
+}
+interface TransitOptions {
+    key: string;
+    gateway?: string;
+    fetch?: typeof fetch;
+    /**
+     * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.
+     *
+     * On by default. `Retry-After` is on a `429` other than `billing_required`, and on a container
+     * `503`. A `502` has none: routing uses `routing_failed`, and `/elevation` uses
+     * `upstream_error`. With no header the client backs off itself. A wait longer than
+     * `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds` instead.
+     * See `RetryPolicy` in `@unmap/core`.
+     */
+    retry?: RetryPolicy | false;
+}
+/**
+ * A transit failure.
+ *
+ * Extends `UnmapError`, so `catch (e) { if (e instanceof UnmapError) }` catches this alongside
+ * every other unmap client's errors. `instanceof TransitError` keeps working, and `status` and `code`
+ * are still where they were; `retryAfterSeconds` is new and comes from the header.
+ */
+declare class TransitError extends UnmapError {
+    constructor(status: number, message: string, code?: string, retryAfterSeconds?: number);
+}
+/** Static Canadian GTFS data. Scheduled departures ship before realtime. */
+declare class Transit {
+    private readonly key;
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly retry;
+    constructor(opts: TransitOptions);
+    agencies(signal?: AbortSignal): Promise<TransitResponse<TransitAgency[]>>;
+    nearbyStops(near: [number, number], options?: NearbyStopsOptions): Promise<TransitResponse<TransitStop[]>>;
+    getStop(id: string, signal?: AbortSignal): Promise<TransitResponse<TransitStop>>;
+    getRoute(id: string, signal?: AbortSignal): Promise<TransitResponse<TransitRoute>>;
+    departures(id: string, options?: DepartureOptions): Promise<TransitResponse<TransitDeparture[]>>;
+    private get;
+}
+
+/** Freshness of a capability or a source. `unknown` means no cadence was declared. */
+type CoverageFreshness = "current" | "stale" | "unknown";
+interface CoverageSource {
+    id: string;
+    provider: string;
+    /** Bilingual, like every human-readable field in this document. */
+    dataset_name: {
+        en: string;
+        fr: string;
+    };
+    canonical_url: string;
+    licence: {
+        en: string;
+        fr: string;
+    };
+    licence_url: string;
+    attribution: string;
+    jurisdiction: string[];
+    /** ISO 8601 duration, e.g. `P1D`. */
+    refresh_interval: string;
+    last_checked_at: string;
+    last_success_at: string;
+    source_version: string;
+    content_hash: string | null;
+    freshness: CoverageFreshness;
+    stale_after: string | null;
+    coverage: string;
+    known_gaps: {
+        en: string;
+        fr: string;
+    };
+    quality_status: string;
+}
+interface CoverageCapability {
+    /** `tiles`, `geocoding`, `routing`, `places`, `transit`, `roads`, and so on. */
+    id: string;
+    display_name: {
+        en: string;
+        fr: string;
+    };
+    /** `planned` is published as honestly as `live`: a capability absent from the page reads as "not our problem". */
+    availability: "live" | "planned";
+    /** The endpoints that serve it. Empty while planned. */
+    endpoints: string[];
+    coverage: {
+        en: string;
+        fr: string;
+    };
+    /** Written to be accurate rather than flattering. Read this before promising coverage to a user. */
+    known_gaps: {
+        en: string;
+        fr: string;
+    };
+    /** ISO 3166-2 subdivisions, or `CA` for national. */
+    jurisdictions: string[];
+    freshness: CoverageFreshness;
+    sources: CoverageSource[];
+}
+interface CoverageDocument {
+    generated_at: string;
+    freshness_basis: string;
+    capabilities: CoverageCapability[];
+    jurisdictions: unknown;
+}
+declare class CoverageError extends UnmapError {
+    constructor(status: number, message: string, code?: string, retryAfterSeconds?: number);
+}
+interface CoverageOptions {
+    gateway?: string;
+    /** Override the fetch implementation (tests, non-global environments). */
+    fetch?: typeof fetch;
+    retry?: RetryPolicy | false;
+}
+/** Where unmap works. Takes no key: the endpoint is unauthenticated and unmetered. */
+declare class Coverage {
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly retry;
+    constructor(opts?: CoverageOptions);
+    /** The whole document. Cached an hour at the edge, so polling it is cheap. */
+    get(opts?: {
+        signal?: AbortSignal;
+    }): Promise<CoverageDocument>;
+    /**
+     * One capability by id, or `undefined` when the document does not describe it.
+     *
+     *   const transit = await unmap.coverage.capability("transit");
+     *   if (!transit?.jurisdictions.includes("CA-ON")) return "not available here yet";
+     */
+    capability(id: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<CoverageCapability | undefined>;
+}
+
+interface TimezoneResult {
+    timezone: string | null;
+    offset: string | null;
+    offsetSeconds: number | null;
+    dst: boolean | null;
+}
+interface TimezoneLookupOptions {
+    /** Instant the offset is evaluated at. Omit it for the current time. */
+    at?: Date;
+    signal?: AbortSignal;
+}
+declare class TimezoneError extends UnmapError {
+    constructor(status: number, message: string, code?: string, retryAfterSeconds?: number);
+}
+interface TimezoneOptions {
+    key: string;
+    gateway?: string;
+    fetch?: typeof fetch;
+    retry?: RetryPolicy | false;
+}
+/**
+ * IANA timezone for a coordinate.
+ *
+ *   const zone = await unmap.timezone.lookup([-114.0719, 51.0447]);
+ *
+ * The coordinate is `[longitude, latitude]`, the same order as the rest of the SDK.
+ * `at` selects the offset. It does not change which zone the coordinate falls in.
+ */
+declare class Timezone {
+    private readonly key;
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly retry;
+    constructor(opts: TimezoneOptions);
+    lookup(coordinate: [number, number], opts?: TimezoneLookupOptions): Promise<TimezoneResult>;
+}
+
+interface GeolocationOptions {
+    key: string;
+    gateway?: string;
+    fetch?: typeof fetch;
+    /**
+     * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.
+     *
+     * On by default. A wait longer than `maxDelayMs` (10 s) is not slept through; the error
+     * carries `retryAfterSeconds` instead.
+     */
+    retry?: RetryPolicy | false;
+}
+interface IpGeolocationResult {
+    ip: string | null;
+    location: {
+        lat: number | null;
+        lng: number | null;
+    };
+    city: string | null;
+    region: string | null;
+    regionCode: string | null;
+    postalCode: string | null;
+    country: string | null;
+    continent: string | null;
+    timezone: string | null;
+    network: {
+        asn: number | null;
+        organization: string | null;
+    };
+    precision: "approximate";
+}
+declare class GeolocationError extends UnmapError {
+    constructor(status: number, message: string, code?: string, retryAfterSeconds?: number);
+}
+/** Typed client for `GET /ip`. One call, one metered request, on the shared pool. */
+declare class Geolocation {
+    private readonly key;
+    private readonly base;
+    private readonly fetchImpl;
+    private readonly retry;
+    constructor(opts: GeolocationOptions);
+    /**
+     * Approximate country, region, city, coordinates, and timezone of this request.
+     *
+     *   const location = await unmap.geolocation.ip();
+     *
+     * A field the network did not identify is `null`. The call still resolves.
+     */
+    ip(opts?: {
+        signal?: AbortSignal;
+    }): Promise<IpGeolocationResult>;
+}
+
 interface UnmapOptions {
     key: string;
     gateway?: string;
     /** Override the fetch implementation (tests, non-global environments). */
     fetch?: typeof fetch;
+    /**
+     * Retry policy shared by every client on this instance. `false` disables it.
+     *
+     * On by default for `429`, `502`, `503` and transport failures. `Retry-After` is on a `429`
+     * other than `billing_required`, and on a container `503`. A `502` has none. A wait longer
+     * than `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds`
+     * instead, because a cold land or energy container asks for 60 and parking a request handler
+     * for a minute is a worse surprise than an error. Feedback submissions are never retried:
+     * they create a record and carry no idempotency key.
+     */
+    retry?: RetryPolicy | false;
     /** If provided, a map is mounted in this container. */
     container?: string | HTMLElement;
     style?: string;
@@ -34,8 +557,8 @@ interface UnmapOptions {
     controls?: boolean | UnmapControlsOptions;
 }
 /**
- * One Stripe-style key, the whole platform. With a `container` you get a rendered map;
- * `geocoder`, `router` and `elevation` are always available.
+ * One Stripe-style key, the whole platform. With a `container` you get a rendered map.
+ * `geocoder`, `router`, `elevation`, `timezone`, and `geolocation` are always available.
  *
  *   const map = new Unmap({ key: "um_live_...", container: "#map", center: [-75.69, 45.42] });
  */
@@ -43,6 +566,26 @@ declare class Unmap {
     readonly geocoder: Geocoder;
     readonly router: Router;
     readonly elevation: Elevation;
+    /** IANA timezone and the UTC offset at an instant. One call, anywhere. */
+    readonly timezone: Timezone;
+    /** Canadian points of interest. Same corpus as the geocoder, in the Place shape. */
+    readonly places: Places;
+    /** Closures, incidents, construction and road conditions. */
+    readonly roads: Roads;
+    /** Report wrong data. Never metered. */
+    readonly feedback: Feedback;
+    /** Scheduled public-transit agencies, stops, routes and departures. */
+    readonly transit: Transit;
+    /**
+     * Where each capability actually works. Unauthenticated and unmetered, so checking costs
+     * nothing: read it before promising a user an answer, because transit routing is one agency
+     * and road events are one province.
+     */
+    readonly coverage: Coverage;
+    /**
+     * Approximate location of the current request. Not device GPS. One call on the shared pool.
+     */
+    readonly geolocation: Geolocation;
     readonly data: {
         query(opts: QueryOptions): Promise<QueryResponse>;
     };
@@ -52,4 +595,4 @@ declare class Unmap {
     identify(opts: IdentifyOptions): Promise<IdentifyResponse>;
 }
 
-export { Unmap, type UnmapOptions };
+export { type AffectedRoad, Coverage, type CoverageCapability, type CoverageDocument, CoverageError, type CoverageFreshness, type CoverageOptions, type CoverageSource, type DepartureOptions, Feedback, type FeedbackCategory, type FeedbackProduct, type FeedbackReceipt, type FeedbackReport, Geolocation, GeolocationError, type GeolocationOptions, type IpGeolocationResult, type NearbyStopsOptions, type RoadCondition, type RoadEvent, type RoadEventQuery, type RoadEventType, type RoadEventsResponse, type RoadSeverity, Roads, RoadsError, type RoadsOptions, Timezone, TimezoneError, type TimezoneLookupOptions, type TimezoneOptions, type TimezoneResult, Transit, type TransitAgency, type TransitDeparture, TransitError, type TransitMeta, type TransitMetaStatus, type TransitOptions, type TransitResponse, type TransitRoute, type TransitStop, Unmap, type UnmapOptions };

package/dist/index.js

@@ -2,23 +2,381 @@
 import {
   createMap
 } from "@unmap/maps";
-import { Geocoder } from "@unmap/geocoding";
+import { Geocoder, Places } from "@unmap/geocoding";
+
+// src/roads.ts
+import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter } from "@unmap/core";
+var RoadsError = class extends UnmapError {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "RoadsError";
+  }
+};
+function list(value) {
+  if (value === void 0) return void 0;
+  return Array.isArray(value) ? value.join(",") : String(value);
+}
+async function errorFrom(res, path, name) {
+  const fallback = `${name} ${res.status} on ${path}`;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = void 0;
+  }
+  const reason = typeof body?.error === "string" ? body.error : void 0;
+  const code = typeof body?.code === "string" ? body.code : void 0;
+  const retryAfter = parseRetryAfter(res.headers?.get("retry-after") ?? null) ?? void 0;
+  return new RoadsError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);
+}
+var Roads = class {
+  key;
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts) {
+    this.retry = opts.retry;
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  /** Every current road event. */
+  incidents(query = {}) {
+    return this.request("/incidents", query);
+  }
+  /** The subset where a road is actually shut. Narrowed before `limit` is applied. */
+  closures(query = {}) {
+    return this.request("/closures", query);
+  }
+  /**
+   * The subset carrying a surface condition.
+   *
+   * Thin for British Columbia by design: its feed reports lane availability rather than the
+   * surface, so unmap answers `unknown` instead of inferring a dry road from open lanes.
+   */
+  conditions(query = {}) {
+    return this.request("/road-conditions", query);
+  }
+  async request(path, query) {
+    const q = new URLSearchParams({ key: this.key });
+    const params = {
+      jurisdiction: list(query.jurisdiction),
+      bbox: query.bbox?.join(","),
+      near: query.near?.join(","),
+      radius: query.radius != null ? String(query.radius) : void 0,
+      type: list(query.type),
+      severity: list(query.severity),
+      status: query.status,
+      updated_since: query.updated_since,
+      limit: query.limit != null ? String(query.limit) : void 0
+    };
+    for (const [k, v] of Object.entries(params)) if (v != null && v !== "") q.set(k, v);
+    const res = await fetchWithRetry(
+      this.fetchImpl,
+      `${this.base}${path}?${q}`,
+      { signal: query.signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) throw await errorFrom(res, path, "roads");
+    return await res.json();
+  }
+};
+var Feedback = class {
+  key;
+  base;
+  fetchImpl;
+  constructor(opts) {
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  submit(report) {
+    return this.post("/feedback", {
+      product: report.product,
+      category: report.category,
+      ...report.description ? { description: report.description } : {},
+      ...report.resultId ? { result_id: report.resultId } : {},
+      ...report.context !== void 0 ? { include_context: true, context: report.context } : {}
+    }, report.signal);
+  }
+  /** A report about one place. `product` and `result_id` come from the path. */
+  aboutPlace(placeId, report) {
+    return this.post(`/places/${encodeURIComponent(placeId)}/feedback`, {
+      category: report.category,
+      ...report.description ? { description: report.description } : {},
+      ...report.context !== void 0 ? { include_context: true, context: report.context } : {}
+    }, report.signal);
+  }
+  async post(path, body, signal) {
+    const res = await this.fetchImpl(`${this.base}${path}`, {
+      method: "POST",
+      signal,
+      headers: { "content-type": "application/json", authorization: `Bearer ${this.key}` },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) throw await errorFrom(res, path, "feedback");
+    return await res.json();
+  }
+};
+
+// src/transit.ts
+import { DEFAULT_GATEWAY as DEFAULT_GATEWAY2, UnmapError as UnmapError2, fetchWithRetry as fetchWithRetry2, parseRetryAfter as parseRetryAfter2 } from "@unmap/core";
+var TransitError = class extends UnmapError2 {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "TransitError";
+  }
+};
+async function errorFrom2(res, path) {
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+  }
+  const message = typeof body.error === "string" ? body.error : `transit ${res.status} on ${path}`;
+  const code = typeof body.code === "string" ? body.code : void 0;
+  const retryAfter = parseRetryAfter2(res.headers?.get("retry-after") ?? null) ?? void 0;
+  return new TransitError(res.status, message, code, retryAfter);
+}
+var Transit = class {
+  key;
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts) {
+    this.retry = opts.retry;
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY2).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  agencies(signal) {
+    return this.get("/transit/agencies", void 0, signal);
+  }
+  nearbyStops(near, options = {}) {
+    return this.get("/transit/stops", {
+      near: near.join(","),
+      radius: options.radius,
+      limit: options.limit
+    }, options.signal);
+  }
+  getStop(id, signal) {
+    return this.get(`/transit/stops/${encodeURIComponent(id)}`, void 0, signal);
+  }
+  getRoute(id, signal) {
+    return this.get(`/transit/routes/${encodeURIComponent(id)}`, void 0, signal);
+  }
+  departures(id, options = {}) {
+    return this.get(`/transit/stops/${encodeURIComponent(id)}/departures`, {
+      at: options.at instanceof Date ? options.at.toISOString() : options.at,
+      window: options.window,
+      limit: options.limit
+    }, options.signal);
+  }
+  async get(path, values, signal) {
+    const query = new URLSearchParams({ key: this.key });
+    for (const [name, value] of Object.entries(values ?? {})) {
+      if (value !== void 0) query.set(name, String(value));
+    }
+    const response = await fetchWithRetry2(
+      this.fetchImpl,
+      `${this.base}${path}?${query}`,
+      { signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!response.ok) throw await errorFrom2(response, path);
+    return await response.json();
+  }
+};
+
+// src/coverage.ts
+import { DEFAULT_GATEWAY as DEFAULT_GATEWAY3, UnmapError as UnmapError3, fetchWithRetry as fetchWithRetry3, parseRetryAfter as parseRetryAfter3 } from "@unmap/core";
+var COVERAGE_PATH = "/coverage.json";
+var CoverageError = class extends UnmapError3 {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "CoverageError";
+  }
+};
+var Coverage = class {
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts = {}) {
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY3).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.retry = opts.retry;
+  }
+  /** The whole document. Cached an hour at the edge, so polling it is cheap. */
+  async get(opts = {}) {
+    const res = await fetchWithRetry3(
+      this.fetchImpl,
+      `${this.base}${COVERAGE_PATH}`,
+      { signal: opts.signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) {
+      const retryAfter = parseRetryAfter3(res.headers?.get?.("retry-after") ?? null) ?? void 0;
+      throw new CoverageError(res.status, `coverage ${res.status}`, void 0, retryAfter);
+    }
+    return await res.json();
+  }
+  /**
+   * One capability by id, or `undefined` when the document does not describe it.
+   *
+   *   const transit = await unmap.coverage.capability("transit");
+   *   if (!transit?.jurisdictions.includes("CA-ON")) return "not available here yet";
+   */
+  async capability(id, opts = {}) {
+    const doc = await this.get(opts);
+    return doc.capabilities.find((c) => c.id === id);
+  }
+};
+
+// src/timezone.ts
+import { DEFAULT_GATEWAY as DEFAULT_GATEWAY4, UnmapError as UnmapError4, fetchWithRetry as fetchWithRetry4, parseRetryAfter as parseRetryAfter4 } from "@unmap/core";
+var TIMEZONE_PATH = "/timezone";
+var TimezoneError = class extends UnmapError4 {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "TimezoneError";
+  }
+};
+var Timezone = class {
+  key;
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts) {
+    this.retry = opts.retry;
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY4).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  async lookup(coordinate, opts = {}) {
+    const [lon, lat] = coordinate;
+    const q = new URLSearchParams({ key: this.key, lon: String(lon), lat: String(lat) });
+    if (opts.at) q.set("at", opts.at.toISOString());
+    const res = await fetchWithRetry4(
+      this.fetchImpl,
+      `${this.base}${TIMEZONE_PATH}?${q}`,
+      { signal: opts.signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) throw await errorFrom3(res);
+    return await res.json();
+  }
+};
+async function errorFrom3(res) {
+  const retryAfter = parseRetryAfter4(res.headers?.get?.("retry-after") ?? null) ?? void 0;
+  let message = res.statusText || `timezone ${res.status}`;
+  let code;
+  try {
+    const body = await res.json();
+    if (typeof body.error === "string" && body.error) message = body.error;
+    if (typeof body.code === "string") code = body.code;
+  } catch {
+  }
+  return new TimezoneError(res.status, message, code, retryAfter);
+}
+
+// src/geolocation.ts
+import { DEFAULT_GATEWAY as DEFAULT_GATEWAY5, UnmapError as UnmapError5, fetchWithRetry as fetchWithRetry5, parseRetryAfter as parseRetryAfter5 } from "@unmap/core";
+var IP_PATH = "/ip";
+var GeolocationError = class extends UnmapError5 {
+  constructor(status, message, code, retryAfterSeconds) {
+    super(status, message, code, retryAfterSeconds);
+    this.name = "GeolocationError";
+  }
+};
+var Geolocation = class {
+  key;
+  base;
+  fetchImpl;
+  retry;
+  constructor(opts) {
+    this.key = opts.key;
+    this.base = (opts.gateway ?? DEFAULT_GATEWAY5).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+    this.retry = opts.retry;
+  }
+  /**
+   * Approximate country, region, city, coordinates, and timezone of this request.
+   *
+   *   const location = await unmap.geolocation.ip();
+   *
+   * A field the network did not identify is `null`. The call still resolves.
+   */
+  async ip(opts = {}) {
+    const q = new URLSearchParams({ key: this.key });
+    const res = await fetchWithRetry5(
+      this.fetchImpl,
+      `${this.base}${IP_PATH}?${q}`,
+      { signal: opts.signal, headers: { accept: "application/json" } },
+      this.retry
+    );
+    if (!res.ok) throw await errorFrom4(res);
+    return await res.json();
+  }
+};
+async function errorFrom4(res) {
+  const fallback = `geolocation ${res.status}`;
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    body = void 0;
+  }
+  const reason = typeof body?.error === "string" ? body.error : void 0;
+  const code = typeof body?.code === "string" ? body.code : void 0;
+  const retryAfter = parseRetryAfter5(res.headers?.get("retry-after") ?? null) ?? void 0;
+  return new GeolocationError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);
+}
+
+// src/index.ts
 import { Router } from "@unmap/routing";
 import { Elevation } from "@unmap/elevation";
 export * from "@unmap/geocoding";
 export * from "@unmap/routing";
 export * from "@unmap/elevation";
 import { createMap as createMap2, unmapStyle, DEMO_CITIES, STYLE_NAMES, maplibregl } from "@unmap/maps";
+import { UnmapError as UnmapError6, parseRetryAfter as parseRetryAfter6 } from "@unmap/core";
 var Unmap = class {
   geocoder;
   router;
   elevation;
+  /** IANA timezone and the UTC offset at an instant. One call, anywhere. */
+  timezone;
+  /** Canadian points of interest. Same corpus as the geocoder, in the Place shape. */
+  places;
+  /** Closures, incidents, construction and road conditions. */
+  roads;
+  /** Report wrong data. Never metered. */
+  feedback;
+  /** Scheduled public-transit agencies, stops, routes and departures. */
+  transit;
+  /**
+   * Where each capability actually works. Unauthenticated and unmetered, so checking costs
+   * nothing: read it before promising a user an answer, because transit routing is one agency
+   * and road events are one province.
+   */
+  coverage;
+  /**
+   * Approximate location of the current request. Not device GPS. One call on the shared pool.
+   */
+  geolocation;
   data;
   map;
   constructor(opts) {
     this.geocoder = new Geocoder(opts);
     this.router = new Router(opts);
     this.elevation = new Elevation(opts);
+    this.timezone = new Timezone(opts);
+    this.places = new Places(opts);
+    this.roads = new Roads(opts);
+    this.feedback = new Feedback(opts);
+    this.transit = new Transit(opts);
+    this.coverage = new Coverage(opts);
+    this.geolocation = new Geolocation(opts);
     this.data = { query: (queryOpts) => this.geocoder.queryLayer(queryOpts) };
     if (opts.container) {
       this.map = createMap({ ...opts, container: opts.container });
@@ -30,11 +388,24 @@ var Unmap = class {
   }
 };
 export {
+  Coverage,
+  CoverageError,
   DEMO_CITIES,
+  Feedback,
+  Geolocation,
+  GeolocationError,
+  Roads,
+  RoadsError,
   STYLE_NAMES,
+  Timezone,
+  TimezoneError,
+  Transit,
+  TransitError,
   Unmap,
+  UnmapError6 as UnmapError,
   createMap2 as createMap,
   maplibregl,
+  parseRetryAfter6 as parseRetryAfter,
   unmapStyle
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import {\n  createMap,\n  type Map as MaplibreMap,\n  type MapProfile,\n  type UnmapControlsOptions,\n  type UnmapMapOptions,\n} from \"@unmap/maps\";\nimport { Geocoder, type IdentifyOptions, type IdentifyResponse, type QueryOptions, type QueryResponse } from \"@unmap/geocoding\";\nimport { Router } from \"@unmap/routing\";\nimport { Elevation } from \"@unmap/elevation\";\n\nexport * from \"@unmap/geocoding\";\nexport * from \"@unmap/routing\";\nexport * from \"@unmap/elevation\";\nexport { createMap, unmapStyle, DEMO_CITIES, STYLE_NAMES, maplibregl } from \"@unmap/maps\";\nexport type {\n  Map,\n  UnmapMapOptions,\n  UnmapControlsOptions,\n  DemoCity,\n  StyleName,\n  StyleInput,\n  Projection,\n  MapProfile,\n} from \"@unmap/maps\";\n\nexport interface UnmapOptions {\n  key: string;\n  gateway?: string;\n  /** Override the fetch implementation (tests, non-global environments). */\n  fetch?: typeof fetch;\n  /** If provided, a map is mounted in this container. */\n  container?: string | HTMLElement;\n  style?: string;\n  flavor?: string;\n  /** \"light\" or \"dark\". Selects the mode half of the named style. */\n  mode?: string;\n  /** Label language, e.g. \"fr\". Omit to follow the request's Accept-Language. */\n  lang?: string;\n  /** Compact `ut1.` theme code from unmap.dev/create. Wins over the path style on the gateway. */\n  theme?: string;\n  /** Catalog layer ids composed onto the style (`municipalities`, `survey.dls`, …). */\n  overlays?: readonly string[];\n  /** Composition preset. Not a style. Explicit overlays replace the profile list. */\n  profile?: MapProfile;\n  /** `\"globe\"` or `\"mercator\"`. See `@unmap/maps` `UnmapMapOptions.projection`. */\n  projection?: UnmapMapOptions[\"projection\"];\n  center?: [number, number];\n  zoom?: number;\n  /** On-map controls. `true` (the default) adds zoom and compass buttons; `false` adds none. */\n  controls?: boolean | UnmapControlsOptions;\n}\n\n/**\n * One Stripe-style key, the whole platform. With a `container` you get a rendered map;\n * `geocoder`, `router` and `elevation` are always available.\n *\n *   const map = new Unmap({ key: \"um_live_...\", container: \"#map\", center: [-75.69, 45.42] });\n */\nexport class Unmap {\n  readonly geocoder: Geocoder;\n  readonly router: Router;\n  readonly elevation: Elevation;\n  readonly data: { query(opts: QueryOptions): Promise<QueryResponse> };\n  readonly map?: MaplibreMap;\n\n  constructor(opts: UnmapOptions) {\n    this.geocoder = new Geocoder(opts);\n    this.router = new Router(opts);\n    this.elevation = new Elevation(opts);\n    this.data = { query: (queryOpts) => this.geocoder.queryLayer(queryOpts) };\n    if (opts.container) {\n      this.map = createMap({ ...opts, container: opts.container } as UnmapMapOptions);\n    }\n  }\n\n  /** Which catalog features contain a point. See `Geocoder.identify`. */\n  identify(opts: IdentifyOptions): Promise<IdentifyResponse> {\n    return this.geocoder.identify(opts);\n  }\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,OAKK;AACP,SAAS,gBAAoG;AAC7G,SAAS,cAAc;AACvB,SAAS,iBAAiB;AAE1B,cAAc;AACd,cAAc;AACd,cAAc;AACd,SAAS,aAAAA,YAAW,YAAY,aAAa,aAAa,kBAAkB;AA6CrE,IAAM,QAAN,MAAY;AAAA,EACR;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAET,YAAY,MAAoB;AAC9B,SAAK,WAAW,IAAI,SAAS,IAAI;AACjC,SAAK,SAAS,IAAI,OAAO,IAAI;AAC7B,SAAK,YAAY,IAAI,UAAU,IAAI;AACnC,SAAK,OAAO,EAAE,OAAO,CAAC,cAAc,KAAK,SAAS,WAAW,SAAS,EAAE;AACxE,QAAI,KAAK,WAAW;AAClB,WAAK,MAAM,UAAU,EAAE,GAAG,MAAM,WAAW,KAAK,UAAU,CAAoB;AAAA,IAChF;AAAA,EACF;AAAA;AAAA,EAGA,SAAS,MAAkD;AACzD,WAAO,KAAK,SAAS,SAAS,IAAI;AAAA,EACpC;AACF;","names":["createMap"]}
+{"version":3,"sources":["../src/index.ts","../src/roads.ts","../src/transit.ts","../src/coverage.ts","../src/timezone.ts","../src/geolocation.ts"],"sourcesContent":["import {\n  createMap,\n  type Map as MaplibreMap,\n  type MapProfile,\n  type UnmapControlsOptions,\n  type UnmapMapOptions,\n} from \"@unmap/maps\";\nimport { Geocoder, Places, type IdentifyOptions, type IdentifyResponse, type QueryOptions, type QueryResponse } from \"@unmap/geocoding\";\nimport { Feedback, Roads } from \"./roads\";\nimport { Transit } from \"./transit\";\nimport { Coverage } from \"./coverage\";\nimport { Timezone } from \"./timezone\";\nimport { Geolocation } from \"./geolocation\";\nimport { Router } from \"@unmap/routing\";\nimport { Elevation } from \"@unmap/elevation\";\nimport type { RetryPolicy } from \"@unmap/core\";\n\nexport * from \"@unmap/geocoding\";\nexport * from \"@unmap/routing\";\nexport * from \"@unmap/elevation\";\nexport * from \"./roads\";\nexport * from \"./transit\";\nexport * from \"./coverage\";\nexport * from \"./timezone\";\nexport * from \"./geolocation\";\nexport { createMap, unmapStyle, DEMO_CITIES, STYLE_NAMES, maplibregl } from \"@unmap/maps\";\nexport type {\n  Map,\n  UnmapMapOptions,\n  UnmapControlsOptions,\n  DemoCity,\n  StyleName,\n  StyleInput,\n  Projection,\n  MapProfile,\n} from \"@unmap/maps\";\n\nexport interface UnmapOptions {\n  key: string;\n  gateway?: string;\n  /** Override the fetch implementation (tests, non-global environments). */\n  fetch?: typeof fetch;\n  /**\n   * Retry policy shared by every client on this instance. `false` disables it.\n   *\n   * On by default for `429`, `502`, `503` and transport failures. `Retry-After` is on a `429`\n   * other than `billing_required`, and on a container `503`. A `502` has none. A wait longer\n   * than `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds`\n   * instead, because a cold land or energy container asks for 60 and parking a request handler\n   * for a minute is a worse surprise than an error. Feedback submissions are never retried:\n   * they create a record and carry no idempotency key.\n   */\n  retry?: RetryPolicy | false;\n  /** If provided, a map is mounted in this container. */\n  container?: string | HTMLElement;\n  style?: string;\n  flavor?: string;\n  /** \"light\" or \"dark\". Selects the mode half of the named style. */\n  mode?: string;\n  /** Label language, e.g. \"fr\". Omit to follow the request's Accept-Language. */\n  lang?: string;\n  /** Compact `ut1.` theme code from unmap.dev/create. Wins over the path style on the gateway. */\n  theme?: string;\n  /** Catalog layer ids composed onto the style (`municipalities`, `survey.dls`, …). */\n  overlays?: readonly string[];\n  /** Composition preset. Not a style. Explicit overlays replace the profile list. */\n  profile?: MapProfile;\n  /** `\"globe\"` or `\"mercator\"`. See `@unmap/maps` `UnmapMapOptions.projection`. */\n  projection?: UnmapMapOptions[\"projection\"];\n  center?: [number, number];\n  zoom?: number;\n  /** On-map controls. `true` (the default) adds zoom and compass buttons; `false` adds none. */\n  controls?: boolean | UnmapControlsOptions;\n}\n\n/**\n * One Stripe-style key, the whole platform. With a `container` you get a rendered map.\n * `geocoder`, `router`, `elevation`, `timezone`, and `geolocation` are always available.\n *\n *   const map = new Unmap({ key: \"um_live_...\", container: \"#map\", center: [-75.69, 45.42] });\n */\nexport class Unmap {\n  readonly geocoder: Geocoder;\n  readonly router: Router;\n  readonly elevation: Elevation;\n  /** IANA timezone and the UTC offset at an instant. One call, anywhere. */\n  readonly timezone: Timezone;\n  /** Canadian points of interest. Same corpus as the geocoder, in the Place shape. */\n  readonly places: Places;\n  /** Closures, incidents, construction and road conditions. */\n  readonly roads: Roads;\n  /** Report wrong data. Never metered. */\n  readonly feedback: Feedback;\n  /** Scheduled public-transit agencies, stops, routes and departures. */\n  readonly transit: Transit;\n  /**\n   * Where each capability actually works. Unauthenticated and unmetered, so checking costs\n   * nothing: read it before promising a user an answer, because transit routing is one agency\n   * and road events are one province.\n   */\n  readonly coverage: Coverage;\n  /**\n   * Approximate location of the current request. Not device GPS. One call on the shared pool.\n   */\n  readonly geolocation: Geolocation;\n  readonly data: { query(opts: QueryOptions): Promise<QueryResponse> };\n  readonly map?: MaplibreMap;\n\n  constructor(opts: UnmapOptions) {\n    this.geocoder = new Geocoder(opts);\n    this.router = new Router(opts);\n    this.elevation = new Elevation(opts);\n    this.timezone = new Timezone(opts);\n    this.places = new Places(opts);\n    this.roads = new Roads(opts);\n    this.feedback = new Feedback(opts);\n    this.transit = new Transit(opts);\n    this.coverage = new Coverage(opts);\n    this.geolocation = new Geolocation(opts);\n    this.data = { query: (queryOpts) => this.geocoder.queryLayer(queryOpts) };\n    if (opts.container) {\n      this.map = createMap({ ...opts, container: opts.container } as UnmapMapOptions);\n    }\n  }\n\n  /** Which catalog features contain a point. See `Geocoder.identify`. */\n  identify(opts: IdentifyOptions): Promise<IdentifyResponse> {\n    return this.geocoder.identify(opts);\n  }\n}\n\n// The shared error type and retry policy, re-exported so a caller who installed only this\n// package can `catch (e) { if (e instanceof UnmapError) }` without adding @unmap/core.\nexport { UnmapError, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n","import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n\n/**\n * Typed clients for road events (`/incidents`, `/closures`, `/road-conditions`) and for data\n * correction (`POST /feedback`).\n *\n * These live in `@unmap/sdk` rather than in packages of their own. A twelfth and thirteenth npm\n * package would each need an entry in the changesets fixed group and a trusted publisher\n * configured on npmjs.com, which is founder work, and neither has a framework wrapper the way\n * geocoding and routing do. If a customer ever wants roads without the rest of the SDK, that is\n * the moment to split it out.\n */\n\nexport type RoadEventType =\n  | \"closure\"\n  | \"incident\"\n  | \"construction\"\n  | \"weather\"\n  | \"restriction\"\n  | \"ferry\"\n  | \"hazard\"\n  | \"special_event\"\n  | \"unknown\";\n\nexport type RoadCondition =\n  | \"dry\"\n  | \"wet\"\n  | \"snow\"\n  | \"ice\"\n  | \"packed_snow\"\n  | \"reduced_visibility\"\n  | \"travel_not_recommended\"\n  | \"closed\"\n  | \"unknown\";\n\nexport type RoadSeverity = \"minor\" | \"major\" | \"unknown\";\n\nexport interface AffectedRoad {\n  name: string;\n  direction: \"north\" | \"south\" | \"east\" | \"west\" | \"both\" | \"unknown\";\n  /** True only when the publisher says closed. Never inferred from the description. */\n  closed: boolean;\n  from?: string;\n  to?: string;\n  condition: RoadCondition;\n}\n\nexport interface RoadEvent {\n  /** `um:road:<jurisdiction>:<publisher id>`. */\n  id: string;\n  /** The publisher's own id, so a report can be taken back to them. */\n  source_id: string;\n  /** ISO 3166-2, e.g. `CA-BC`. */\n  jurisdiction: string;\n  type: RoadEventType;\n  /** The publisher's own subtype strings, untranslated. */\n  subtypes: string[];\n  status: \"active\" | \"planned\" | \"archived\";\n  severity: RoadSeverity;\n  /**\n   * The publisher's description, verbatim.\n   *\n   * Believe this over `type` when they disagree: our categories are a lossy projection of someone\n   * else's taxonomy, and the sentence a driver needs is in the prose.\n   */\n  description: string;\n  headline?: string;\n  /** The worst surface condition across this event's roads. */\n  condition: RoadCondition;\n  roads: AffectedRoad[];\n  /** GeoJSON Point or LineString, WGS84. */\n  geometry: { type: string; coordinates: unknown } | null;\n  starts_at: string | null;\n  ends_at: string | null;\n  source_updated_at: string | null;\n  unmap_updated_at: string;\n  source: string;\n}\n\nexport interface RoadEventsResponse {\n  data: RoadEvent[];\n  meta: {\n    status: \"current\" | \"stale\" | \"partial\" | \"unknown\";\n    attribution: string;\n    unmap_updated_at: string;\n    /**\n     * Jurisdictions that could not be reached, each with a reason.\n     *\n     * **Check this.** On `/closures` an empty `data` reads as \"nothing is shut\" to someone\n     * deciding whether to drive, and that is a very different answer from \"we could not reach\n     * British Columbia\".\n     */\n    unavailable?: { jurisdiction: string; reason: string }[];\n  };\n}\n\nexport interface RoadEventQuery {\n  /** Comma-separated ISO 3166-2 codes, or an array. An uncovered code is a 400, not an empty list. */\n  jurisdiction?: string | readonly string[];\n  bbox?: [number, number, number, number];\n  near?: [number, number];\n  /** Metres from `near`. Default 25000, max 500000. */\n  radius?: number;\n  type?: RoadEventType | readonly RoadEventType[];\n  severity?: RoadSeverity | readonly RoadSeverity[];\n  status?: \"active\" | \"planned\" | \"archived\";\n  /** ISO 8601. Only events the publisher changed at or after this time. */\n  updated_since?: string;\n  /** 1 to 500, default 100. Applied AFTER the endpoint's own narrowing. */\n  limit?: number;\n  signal?: AbortSignal;\n}\n\nexport interface RoadsOptions {\n  key: string;\n  gateway?: string;\n  fetch?: typeof fetch;\n  /**\n   * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.\n   *\n   * On by default. `Retry-After` is on a `429` other than `billing_required`, and on a container\n   * `503`. A `502` has none: routing uses `routing_failed`, and `/elevation` uses\n   * `upstream_error`. With no header the client backs off itself. A wait longer than\n   * `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds` instead.\n   * See `RetryPolicy` in `@unmap/core`.\n   */\n  retry?: RetryPolicy | false;\n}\n\n/**\n * A road events failure.\n *\n * Extends `UnmapError`, so `catch (e) { if (e instanceof UnmapError) }` catches this alongside\n * every other unmap client's errors. `instanceof RoadsError` keeps working, and `status` and `code`\n * are still where they were; `retryAfterSeconds` is new and comes from the header.\n */\nexport class RoadsError extends UnmapError {\n  constructor(status: number, message: string, code?: string, retryAfterSeconds?: number) {\n    super(status, message, code, retryAfterSeconds);\n    this.name = \"RoadsError\";\n  }\n}\n\nfunction list(value: string | readonly string[] | undefined): string | undefined {\n  if (value === undefined) return undefined;\n  return Array.isArray(value) ? value.join(\",\") : String(value);\n}\n\nasync function errorFrom(res: Response, path: string, name: string): Promise<RoadsError> {\n  const fallback = `${name} ${res.status} on ${path}`;\n  let body: { error?: unknown; code?: unknown } | undefined;\n  try {\n    body = (await res.json()) as { error?: unknown; code?: unknown };\n  } catch {\n    body = undefined;\n  }\n  const reason = typeof body?.error === \"string\" ? body.error : undefined;\n  const code = typeof body?.code === \"string\" ? body.code : undefined;\n  const retryAfter = parseRetryAfter(res.headers?.get(\"retry-after\") ?? null) ?? undefined;\n  return new RoadsError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);\n}\n\n/**\n * Canadian road events.\n *\n *   const { data, meta } = await unmap.roads.closures({ jurisdiction: \"CA-BC\" });\n *\n * A 503 means every requested jurisdiction was unreachable; the body still carries\n * `meta.unavailable`, so the thrown error is the exception rather than the information. Prefer\n * reading `meta.unavailable` on a 200 over treating an empty list as good news.\n */\nexport class Roads {\n  private readonly key: string;\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n  private readonly retry: RetryPolicy | false | undefined;\n\n  constructor(opts: RoadsOptions) {\n    this.retry = opts.retry;\n    this.key = opts.key;\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n  }\n\n  /** Every current road event. */\n  incidents(query: RoadEventQuery = {}): Promise<RoadEventsResponse> {\n    return this.request(\"/incidents\", query);\n  }\n\n  /** The subset where a road is actually shut. Narrowed before `limit` is applied. */\n  closures(query: RoadEventQuery = {}): Promise<RoadEventsResponse> {\n    return this.request(\"/closures\", query);\n  }\n\n  /**\n   * The subset carrying a surface condition.\n   *\n   * Thin for British Columbia by design: its feed reports lane availability rather than the\n   * surface, so unmap answers `unknown` instead of inferring a dry road from open lanes.\n   */\n  conditions(query: RoadEventQuery = {}): Promise<RoadEventsResponse> {\n    return this.request(\"/road-conditions\", query);\n  }\n\n  private async request(path: string, query: RoadEventQuery): Promise<RoadEventsResponse> {\n    const q = new URLSearchParams({ key: this.key });\n    const params: Record<string, string | undefined> = {\n      jurisdiction: list(query.jurisdiction),\n      bbox: query.bbox?.join(\",\"),\n      near: query.near?.join(\",\"),\n      radius: query.radius != null ? String(query.radius) : undefined,\n      type: list(query.type),\n      severity: list(query.severity),\n      status: query.status,\n      updated_since: query.updated_since,\n      limit: query.limit != null ? String(query.limit) : undefined,\n    };\n    for (const [k, v] of Object.entries(params)) if (v != null && v !== \"\") q.set(k, v);\n\n    const res = await fetchWithRetry(\n      this.fetchImpl,\n      `${this.base}${path}?${q}`,\n      { signal: query.signal, headers: { accept: \"application/json\" } },\n      this.retry,\n    );\n    if (!res.ok) throw await errorFrom(res, path, \"roads\");\n    return (await res.json()) as RoadEventsResponse;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------\n// Feedback\n// ---------------------------------------------------------------------------------------------\n\nexport type FeedbackProduct =\n  | \"tiles\"\n  | \"terrain\"\n  | \"names\"\n  | \"geocoding\"\n  | \"places\"\n  | \"routing\"\n  | \"layers\"\n  | \"transit\"\n  | \"roads\"\n  | \"ev\";\n\nexport type FeedbackCategory =\n  | \"incorrect_location\"\n  | \"incorrect_address\"\n  | \"missing_place\"\n  | \"wrong_place_name\"\n  | \"wrong_category\"\n  | \"bad_route\"\n  | \"missing_road_closure\"\n  | \"incorrect_road_condition\"\n  | \"incorrect_transit_result\"\n  | \"other\";\n\nexport interface FeedbackReport {\n  product: FeedbackProduct;\n  category: FeedbackCategory;\n  /** Up to 2000 characters, stored exactly as written. One of this or `resultId` is required. */\n  description?: string;\n  /** The unmap id of the result being reported. */\n  resultId?: string;\n  /**\n   * The request being reported.\n   *\n   * **Only send this with the reporter's explicit agreement.** The gateway refuses it without\n   * `include_context: true`, which this sets whenever `context` is present, and that flag is\n   * meant to record a person's choice rather than a client default. unmap redacts query strings\n   * from its own logs; a client that attached them here would undo that.\n   */\n  context?: unknown;\n  signal?: AbortSignal;\n}\n\nexport interface FeedbackReceipt {\n  /** Quote this in a follow-up. */\n  id: string;\n  status: string;\n  created_at: string;\n  /** Whether a request context was actually kept. `false` when none was offered. */\n  context_stored: boolean;\n}\n\n/**\n * Report wrong data.\n *\n *   await unmap.feedback.submit({\n *     product: \"geocoding\",\n *     category: \"incorrect_location\",\n *     description: \"17 Ave SW returns a street in Edmonton.\",\n *   });\n *\n * Authenticated like everything else and **never metered**: telling us our data is wrong does not\n * cost a call. At most 200 reports per account per day.\n */\nexport class Feedback {\n  private readonly key: string;\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n\n  constructor(opts: RoadsOptions) {\n    this.key = opts.key;\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n  }\n\n  submit(report: FeedbackReport): Promise<FeedbackReceipt> {\n    return this.post(\"/feedback\", {\n      product: report.product,\n      category: report.category,\n      ...(report.description ? { description: report.description } : {}),\n      ...(report.resultId ? { result_id: report.resultId } : {}),\n      ...(report.context !== undefined ? { include_context: true, context: report.context } : {}),\n    }, report.signal);\n  }\n\n  /** A report about one place. `product` and `result_id` come from the path. */\n  aboutPlace(\n    placeId: string,\n    report: Omit<FeedbackReport, \"product\" | \"resultId\">,\n  ): Promise<FeedbackReceipt> {\n    return this.post(`/places/${encodeURIComponent(placeId)}/feedback`, {\n      category: report.category,\n      ...(report.description ? { description: report.description } : {}),\n      ...(report.context !== undefined ? { include_context: true, context: report.context } : {}),\n    }, report.signal);\n  }\n\n  private async post(path: string, body: unknown, signal?: AbortSignal): Promise<FeedbackReceipt> {\n    // Deliberately NOT routed through `fetchWithRetry`, unlike every read on this client.\n    //\n    // A feedback submission creates a record and carries no idempotency key, so a retry after a\n    // timeout or a 503 risks filing the same report twice. Retrying a read costs a round trip;\n    // retrying this costs the quality programme a duplicate, and the caller is the only one who\n    // knows whether their report already landed.\n    const res = await this.fetchImpl(`${this.base}${path}`, {\n      method: \"POST\",\n      signal,\n      headers: { \"content-type\": \"application/json\", authorization: `Bearer ${this.key}` },\n      body: JSON.stringify(body),\n    });\n    if (!res.ok) throw await errorFrom(res, path, \"feedback\");\n    return (await res.json()) as FeedbackReceipt;\n  }\n}\n","import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n\nexport type TransitMetaStatus = \"current\" | \"stale\" | \"partial\" | \"unknown\";\n\nexport interface TransitMeta {\n  /** Static GTFS is scheduled data. Realtime will use a different value and updated_at. */\n  schedule_type: \"scheduled\";\n  source?: string;\n  source_updated_at?: string | null;\n  source_version?: string;\n  content_hash?: string | null;\n  sources?: readonly {\n    id: string;\n    source: string;\n    source_url: string;\n    attribution: string;\n    source_updated_at: string | null;\n    source_version: string;\n    content_hash: string | null;\n    status: \"current\" | \"stale\" | \"unknown\";\n  }[];\n  unmap_updated_at: string;\n  data_version?: string;\n  status: TransitMetaStatus;\n  attribution: string;\n}\n\nexport interface TransitResponse<T> {\n  data: T;\n  meta: TransitMeta;\n}\n\nexport interface TransitAgency {\n  id: string;\n  feed: string;\n  name: string;\n  url?: string;\n  timezone: string;\n  lang?: string;\n  phone?: string;\n  fare_url?: string;\n}\n\nexport interface TransitStop {\n  id: string;\n  feed: string;\n  name: string;\n  coordinates: [number, number];\n  code?: string;\n  description?: string;\n  zone_id?: string;\n  parent_station_id?: string;\n  wheelchair_boarding?: 0 | 1 | 2;\n  route_ids: string[];\n  /** Metres from the requested point. Present only on nearbyStops. */\n  distance?: number;\n}\n\nexport interface TransitRoute {\n  id: string;\n  feed: string;\n  agency_id: string;\n  short_name?: string;\n  long_name?: string;\n  description?: string;\n  route_type: number;\n  colour?: string;\n  text_colour?: string;\n  url?: string;\n}\n\nexport interface TransitDeparture {\n  stop_id: string;\n  route_id: string;\n  trip_id: string;\n  headsign?: string;\n  arrival: string;\n  departure: string;\n  stop_sequence: number;\n  /** 2 = phone agency; 3 = coordinate with driver. Omitted for ordinary pickup. */\n  pickup_type?: 2 | 3;\n  schedule_type: \"scheduled\";\n}\n\nexport interface NearbyStopsOptions {\n  /** Metres. Default 1000, range 50 to 10000. */\n  radius?: number;\n  /** Default 20, maximum 100. */\n  limit?: number;\n  signal?: AbortSignal;\n}\n\nexport interface DepartureOptions {\n  /** An instant. Date values serialize to ISO; strings must include Z or an offset. Default now. */\n  at?: Date | string;\n  /** Minutes after at. Default 60, maximum 240. */\n  window?: number;\n  /** Default 50, maximum 200. */\n  limit?: number;\n  signal?: AbortSignal;\n}\n\nexport interface TransitOptions {\n  key: string;\n  gateway?: string;\n  fetch?: typeof fetch;\n  /**\n   * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.\n   *\n   * On by default. `Retry-After` is on a `429` other than `billing_required`, and on a container\n   * `503`. A `502` has none: routing uses `routing_failed`, and `/elevation` uses\n   * `upstream_error`. With no header the client backs off itself. A wait longer than\n   * `maxDelayMs` (10 s) is not slept through; the error carries `retryAfterSeconds` instead.\n   * See `RetryPolicy` in `@unmap/core`.\n   */\n  retry?: RetryPolicy | false;\n}\n\n/**\n * A transit failure.\n *\n * Extends `UnmapError`, so `catch (e) { if (e instanceof UnmapError) }` catches this alongside\n * every other unmap client's errors. `instanceof TransitError` keeps working, and `status` and `code`\n * are still where they were; `retryAfterSeconds` is new and comes from the header.\n */\nexport class TransitError extends UnmapError {\n  constructor(status: number, message: string, code?: string, retryAfterSeconds?: number) {\n    super(status, message, code, retryAfterSeconds);\n    this.name = \"TransitError\";\n  }\n}\n\n/**\n * The gateway's error body, as a `TransitError`.\n *\n * Named rather than inline since 2026-09-20: `fetchWithRetry` needs to inspect the failure to\n * decide whether to wait, and the throw needs to build the same error. Two copies of this would\n * be two chances for the retry predicate and the thrown error to disagree.\n */\nasync function errorFrom(res: Response, path: string): Promise<TransitError> {\n  let body: { error?: unknown; code?: unknown } = {};\n  try {\n    body = (await res.json()) as typeof body;\n  } catch {\n    /* use the bounded fallback */\n  }\n  const message = typeof body.error === \"string\" ? body.error : `transit ${res.status} on ${path}`;\n  const code = typeof body.code === \"string\" ? body.code : undefined;\n  const retryAfter = parseRetryAfter(res.headers?.get(\"retry-after\") ?? null) ?? undefined;\n  return new TransitError(res.status, message, code, retryAfter);\n}\n\n/** Static Canadian GTFS data. Scheduled departures ship before realtime. */\nexport class Transit {\n  private readonly key: string;\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n  private readonly retry: RetryPolicy | false | undefined;\n\n  constructor(opts: TransitOptions) {\n    this.retry = opts.retry;\n    this.key = opts.key;\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n  }\n\n  agencies(signal?: AbortSignal): Promise<TransitResponse<TransitAgency[]>> {\n    return this.get(\"/transit/agencies\", undefined, signal);\n  }\n\n  nearbyStops(near: [number, number], options: NearbyStopsOptions = {}): Promise<TransitResponse<TransitStop[]>> {\n    return this.get(\"/transit/stops\", {\n      near: near.join(\",\"),\n      radius: options.radius,\n      limit: options.limit,\n    }, options.signal);\n  }\n\n  getStop(id: string, signal?: AbortSignal): Promise<TransitResponse<TransitStop>> {\n    return this.get(`/transit/stops/${encodeURIComponent(id)}`, undefined, signal);\n  }\n\n  getRoute(id: string, signal?: AbortSignal): Promise<TransitResponse<TransitRoute>> {\n    return this.get(`/transit/routes/${encodeURIComponent(id)}`, undefined, signal);\n  }\n\n  departures(id: string, options: DepartureOptions = {}): Promise<TransitResponse<TransitDeparture[]>> {\n    return this.get(`/transit/stops/${encodeURIComponent(id)}/departures`, {\n      at: options.at instanceof Date ? options.at.toISOString() : options.at,\n      window: options.window,\n      limit: options.limit,\n    }, options.signal);\n  }\n\n  private async get<T>(\n    path: string,\n    values?: Record<string, string | number | undefined>,\n    signal?: AbortSignal,\n  ): Promise<TransitResponse<T>> {\n    const query = new URLSearchParams({ key: this.key });\n    for (const [name, value] of Object.entries(values ?? {})) {\n      if (value !== undefined) query.set(name, String(value));\n    }\n    const response = await fetchWithRetry(\n      this.fetchImpl,\n      `${this.base}${path}?${query}`,\n      { signal, headers: { accept: \"application/json\" } },\n      this.retry,\n    );\n    if (!response.ok) throw await errorFrom(response, path);\n    return await response.json() as TransitResponse<T>;\n  }\n}\n","import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n\n/**\n * `GET /coverage.json` — where each capability actually works, and where it does not.\n *\n * The document is generated from the gateway's source registry rather than written by hand, so\n * it cannot claim a capability with no registered source behind it. It is also the only place\n * that answers \"is transit routing live in this city\" before you promise a user an answer:\n * routing is one agency, road events are one province, and Places coverage is OpenStreetMap's,\n * which is thin outside cities.\n *\n * Unauthenticated and unmetered on the gateway, which is why this client takes no key: a\n * developer deciding whether to use unmap has no key yet, and a customer checking whether a gap\n * has closed should not pay a call to be told it has not.\n */\n\n/** The one path this client calls. A literal so the gateway's SDK-parity audit can see it. */\nconst COVERAGE_PATH = \"/coverage.json\";\n\n/** Freshness of a capability or a source. `unknown` means no cadence was declared. */\nexport type CoverageFreshness = \"current\" | \"stale\" | \"unknown\";\n\nexport interface CoverageSource {\n  id: string;\n  provider: string;\n  /** Bilingual, like every human-readable field in this document. */\n  dataset_name: { en: string; fr: string };\n  canonical_url: string;\n  licence: { en: string; fr: string };\n  licence_url: string;\n  attribution: string;\n  jurisdiction: string[];\n  /** ISO 8601 duration, e.g. `P1D`. */\n  refresh_interval: string;\n  last_checked_at: string;\n  last_success_at: string;\n  source_version: string;\n  content_hash: string | null;\n  freshness: CoverageFreshness;\n  stale_after: string | null;\n  coverage: string;\n  known_gaps: { en: string; fr: string };\n  quality_status: string;\n}\n\nexport interface CoverageCapability {\n  /** `tiles`, `geocoding`, `routing`, `places`, `transit`, `roads`, and so on. */\n  id: string;\n  display_name: { en: string; fr: string };\n  /** `planned` is published as honestly as `live`: a capability absent from the page reads as \"not our problem\". */\n  availability: \"live\" | \"planned\";\n  /** The endpoints that serve it. Empty while planned. */\n  endpoints: string[];\n  coverage: { en: string; fr: string };\n  /** Written to be accurate rather than flattering. Read this before promising coverage to a user. */\n  known_gaps: { en: string; fr: string };\n  /** ISO 3166-2 subdivisions, or `CA` for national. */\n  jurisdictions: string[];\n  freshness: CoverageFreshness;\n  sources: CoverageSource[];\n}\n\nexport interface CoverageDocument {\n  generated_at: string;\n  freshness_basis: string;\n  capabilities: CoverageCapability[];\n  jurisdictions: unknown;\n}\n\nexport class CoverageError extends UnmapError {\n  constructor(status: number, message: string, code?: string, retryAfterSeconds?: number) {\n    super(status, message, code, retryAfterSeconds);\n    this.name = \"CoverageError\";\n  }\n}\n\nexport interface CoverageOptions {\n  gateway?: string;\n  /** Override the fetch implementation (tests, non-global environments). */\n  fetch?: typeof fetch;\n  retry?: RetryPolicy | false;\n}\n\n/** Where unmap works. Takes no key: the endpoint is unauthenticated and unmetered. */\nexport class Coverage {\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n  private readonly retry: RetryPolicy | false | undefined;\n\n  constructor(opts: CoverageOptions = {}) {\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n    this.retry = opts.retry;\n  }\n\n  /** The whole document. Cached an hour at the edge, so polling it is cheap. */\n  async get(opts: { signal?: AbortSignal } = {}): Promise<CoverageDocument> {\n    const res = await fetchWithRetry(\n      this.fetchImpl,\n      `${this.base}${COVERAGE_PATH}`,\n      { signal: opts.signal, headers: { accept: \"application/json\" } },\n      this.retry,\n    );\n    if (!res.ok) {\n      const retryAfter = parseRetryAfter(res.headers?.get?.(\"retry-after\") ?? null) ?? undefined;\n      throw new CoverageError(res.status, `coverage ${res.status}`, undefined, retryAfter);\n    }\n    return (await res.json()) as CoverageDocument;\n  }\n\n  /**\n   * One capability by id, or `undefined` when the document does not describe it.\n   *\n   *   const transit = await unmap.coverage.capability(\"transit\");\n   *   if (!transit?.jurisdictions.includes(\"CA-ON\")) return \"not available here yet\";\n   */\n  async capability(id: string, opts: { signal?: AbortSignal } = {}): Promise<CoverageCapability | undefined> {\n    const doc = await this.get(opts);\n    return doc.capabilities.find((c) => c.id === id);\n  }\n}\n","import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n\n/** The one path this client calls. A literal so the gateway's SDK-parity audit can see it. */\nconst TIMEZONE_PATH = \"/timezone\";\n\nexport interface TimezoneResult {\n  timezone: string | null;\n  offset: string | null;\n  offsetSeconds: number | null;\n  dst: boolean | null;\n}\n\nexport interface TimezoneLookupOptions {\n  /** Instant the offset is evaluated at. Omit it for the current time. */\n  at?: Date;\n  signal?: AbortSignal;\n}\n\nexport class TimezoneError extends UnmapError {\n  constructor(status: number, message: string, code?: string, retryAfterSeconds?: number) {\n    super(status, message, code, retryAfterSeconds);\n    this.name = \"TimezoneError\";\n  }\n}\n\nexport interface TimezoneOptions {\n  key: string;\n  gateway?: string;\n  fetch?: typeof fetch;\n  retry?: RetryPolicy | false;\n}\n\n/**\n * IANA timezone for a coordinate.\n *\n *   const zone = await unmap.timezone.lookup([-114.0719, 51.0447]);\n *\n * The coordinate is `[longitude, latitude]`, the same order as the rest of the SDK.\n * `at` selects the offset. It does not change which zone the coordinate falls in.\n */\nexport class Timezone {\n  private readonly key: string;\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n  private readonly retry: RetryPolicy | false | undefined;\n\n  constructor(opts: TimezoneOptions) {\n    this.retry = opts.retry;\n    this.key = opts.key;\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n  }\n\n  async lookup(coordinate: [number, number], opts: TimezoneLookupOptions = {}): Promise<TimezoneResult> {\n    const [lon, lat] = coordinate;\n    const q = new URLSearchParams({ key: this.key, lon: String(lon), lat: String(lat) });\n    if (opts.at) q.set(\"at\", opts.at.toISOString());\n    const res = await fetchWithRetry(\n      this.fetchImpl,\n      `${this.base}${TIMEZONE_PATH}?${q}`,\n      { signal: opts.signal, headers: { accept: \"application/json\" } },\n      this.retry,\n    );\n    if (!res.ok) throw await errorFrom(res);\n    return (await res.json()) as TimezoneResult;\n  }\n}\n\nasync function errorFrom(res: Response): Promise<TimezoneError> {\n  const retryAfter = parseRetryAfter(res.headers?.get?.(\"retry-after\") ?? null) ?? undefined;\n  let message = res.statusText || `timezone ${res.status}`;\n  let code: string | undefined;\n  try {\n    const body = (await res.json()) as { error?: unknown; code?: unknown };\n    if (typeof body.error === \"string\" && body.error) message = body.error;\n    if (typeof body.code === \"string\") code = body.code;\n  } catch {\n    /* a non-JSON failure still carries the status */\n  }\n  return new TimezoneError(res.status, message, code, retryAfter);\n}\n","import { DEFAULT_GATEWAY, UnmapError, fetchWithRetry, parseRetryAfter, type RetryPolicy } from \"@unmap/core\";\n\n/**\n * Approximate location of the current request (`GET /ip`).\n *\n * This is the network the request arrived on, not a device fix and not a lookup of an\n * address you choose. `precision` is always `\"approximate\"`.\n */\n\n/** The one path this client calls. A literal so the gateway's SDK-parity audit can see it. */\nconst IP_PATH = \"/ip\";\n\nexport interface GeolocationOptions {\n  key: string;\n  gateway?: string;\n  fetch?: typeof fetch;\n  /**\n   * Retry policy for `429`, `502`, `503` and transport failures. `false` disables it.\n   *\n   * On by default. A wait longer than `maxDelayMs` (10 s) is not slept through; the error\n   * carries `retryAfterSeconds` instead.\n   */\n  retry?: RetryPolicy | false;\n}\n\nexport interface IpGeolocationResult {\n  ip: string | null;\n  location: {\n    lat: number | null;\n    lng: number | null;\n  };\n  city: string | null;\n  region: string | null;\n  regionCode: string | null;\n  postalCode: string | null;\n  country: string | null;\n  continent: string | null;\n  timezone: string | null;\n  network: {\n    asn: number | null;\n    organization: string | null;\n  };\n  precision: \"approximate\";\n}\n\nexport class GeolocationError extends UnmapError {\n  constructor(status: number, message: string, code?: string, retryAfterSeconds?: number) {\n    super(status, message, code, retryAfterSeconds);\n    this.name = \"GeolocationError\";\n  }\n}\n\n/** Typed client for `GET /ip`. One call, one metered request, on the shared pool. */\nexport class Geolocation {\n  private readonly key: string;\n  private readonly base: string;\n  private readonly fetchImpl: typeof fetch;\n  private readonly retry: RetryPolicy | false | undefined;\n\n  constructor(opts: GeolocationOptions) {\n    this.key = opts.key;\n    this.base = (opts.gateway ?? DEFAULT_GATEWAY).replace(/\\/+$/, \"\");\n    this.fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);\n    this.retry = opts.retry;\n  }\n\n  /**\n   * Approximate country, region, city, coordinates, and timezone of this request.\n   *\n   *   const location = await unmap.geolocation.ip();\n   *\n   * A field the network did not identify is `null`. The call still resolves.\n   */\n  async ip(opts: { signal?: AbortSignal } = {}): Promise<IpGeolocationResult> {\n    const q = new URLSearchParams({ key: this.key });\n    const res = await fetchWithRetry(\n      this.fetchImpl,\n      `${this.base}${IP_PATH}?${q}`,\n      { signal: opts.signal, headers: { accept: \"application/json\" } },\n      this.retry,\n    );\n    if (!res.ok) throw await errorFrom(res);\n    return (await res.json()) as IpGeolocationResult;\n  }\n}\n\nasync function errorFrom(res: { status: number; headers?: Headers; json(): Promise<unknown> }): Promise<GeolocationError> {\n  const fallback = `geolocation ${res.status}`;\n  let body: { error?: unknown; code?: unknown } | undefined;\n  try {\n    body = (await res.json()) as { error?: unknown; code?: unknown };\n  } catch {\n    body = undefined;\n  }\n  const reason = typeof body?.error === \"string\" ? body.error : undefined;\n  const code = typeof body?.code === \"string\" ? body.code : undefined;\n  const retryAfter = parseRetryAfter(res.headers?.get(\"retry-after\") ?? null) ?? undefined;\n  return new GeolocationError(res.status, reason ? `${reason} (${fallback})` : fallback, code, retryAfter);\n}\n"],"mappings":"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","names":["DEFAULT_GATEWAY","UnmapError","fetchWithRetry","parseRetryAfter","errorFrom","DEFAULT_GATEWAY","UnmapError","fetchWithRetry","parseRetryAfter","DEFAULT_GATEWAY","UnmapError","fetchWithRetry","parseRetryAfter","errorFrom","DEFAULT_GATEWAY","UnmapError","fetchWithRetry","parseRetryAfter","errorFrom","createMap","UnmapError","parseRetryAfter"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unmap/sdk",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "One key, the whole unmap platform: map + geocoder + router",
   "license": "MIT",
   "keywords": [
@@ -12,7 +12,7 @@
     "routing",
     "sdk"
   ],
-  "homepage": "https://unmap.dev/docs/quickstart",
+  "homepage": "https://unmap.dev/docs/start/quickstart",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/unmap-dev/unmap.git",
@@ -40,11 +40,11 @@
   },
   "dependencies": {
     "maplibre-gl": "^6.7.0",
-    "@unmap/core": "0.12.0",
-    "@unmap/elevation": "0.12.0",
-    "@unmap/geocoding": "0.12.0",
-    "@unmap/maps": "0.12.0",
-    "@unmap/routing": "0.12.0"
+    "@unmap/core": "0.14.0",
+    "@unmap/elevation": "0.14.0",
+    "@unmap/geocoding": "0.14.0",
+    "@unmap/maps": "0.14.0",
+    "@unmap/routing": "0.14.0"
   },
   "devDependencies": {
     "tsup": "^8.3.0",