@chaosity/location-client 0.11.0 → 0.13.0

package/dist/cjs/maps/mapToken.d.ts

@@ -0,0 +1,84 @@
+import type { CallOptions } from '../transport/http.js';
+/**
+ * Where a map helper gets its token, and how it gets a new one (#72).
+ *
+ * `getToken` is synchronous by contract: MapLibre's `transformRequest` calls
+ * it for every tile and cannot wait. `refreshToken` is how a map recovers when
+ * the API refuses the token in hand before its `exp` — a rotated secret, for
+ * one — which nothing else in the map path can do. It is the escape hatch
+ * `GeoPlacesClient` takes, under the same name.
+ */
+export interface MapTokens {
+    /** The token in hand, now. */
+    getToken: () => string | undefined;
+    /** Obtain a new token after the API refused the one in hand. */
+    refreshToken?: () => Promise<string | undefined>;
+}
+/** A bare `getToken`, which behaves as it always has, or `MapTokens`. */
+export type MapTokenSource = (() => string | undefined) | MapTokens;
+/**
+ * Send with the token in hand, and after a 401 once more with a different one
+ * from `refreshToken`, all within the call's signal and deadline (#62). A 403
+ * is never retried, and neither is the token the API refused.
+ */
+export declare function sendWithTokenRefresh<T>(source: MapTokenSource, noTokenAdvice: string, call: CallOptions, send: (token: string) => Promise<T>): Promise<T>;
+/** A tile's coordinates, as `map.refreshTiles` takes them. */
+interface TileCoordinates {
+    x: number;
+    y: number;
+    z: number;
+}
+/** What MapLibre's `error` event carries for a refused request. */
+interface MapErrorEvent {
+    error?: {
+        status?: number;
+        url?: string;
+    };
+    sourceId?: string;
+    tile?: {
+        tileID: {
+            canonical: TileCoordinates;
+        };
+    };
+}
+/** The part of a MapLibre `Map` that `refreshTokenOnUnauthorized` uses. */
+export interface TokenRefreshMap {
+    on(type: 'error', listener: (event: MapErrorEvent) => void): unknown;
+    off(type: 'error', listener: (event: MapErrorEvent) => void): unknown;
+    refreshTiles(sourceId: string, tileIds?: TileCoordinates[]): void;
+}
+/**
+ * Recover the tiles MapLibre fetches itself when the API refuses the token
+ * (#72).
+ *
+ * `createTransformRequest` builds each request synchronously and never sees
+ * the answer, so a refused tile used to leave a hole until the page reloaded.
+ * This listens for MapLibre's `error` events. On a 401 from a URL of our API it
+ * asks `refreshToken` once for the whole burst. When `getToken` then returns a
+ * different token, it reloads each refused tile with `map.refreshTiles`, whose
+ * requests carry that token. So `refreshToken` must make `getToken` return
+ * what it obtained: the tiles have no other way to receive it. A refused
+ * request that is not a tile (a glyph, a sprite) has the token replaced for
+ * the next one, and nothing reloaded.
+ *
+ * Tiles are reloaded by id, never a whole source: MapLibre 6 reloads a source's
+ * errored tiles as still loading, and they wait for a load that never comes.
+ *
+ * What it learns is held as the fetch helpers hold it, and shared with them
+ * when they are handed the same `tokens` object (#38): a token `refreshToken`
+ * could not replace, and a failure that says when to ask again, are not asked
+ * about again until they lapse or the token in hand changes.
+ *
+ * Returns a function that stops listening.
+ *
+ * @example
+ * const tokens = { getToken, refreshToken }
+ * const map = new Map({
+ *   container: 'map',
+ *   style: await fetchMapStyle(API_URL, 'Standard', tokens),
+ *   transformRequest: createTransformRequest(API_URL, getToken),
+ * })
+ * refreshTokenOnUnauthorized(map, API_URL, tokens)
+ */
+export declare function refreshTokenOnUnauthorized(map: TokenRefreshMap, apiUrl: string, tokens: Required<MapTokens>): () => void;
+export {};

package/dist/cjs/maps/mapToken.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendWithTokenRefresh = sendWithTokenRefresh;
+exports.refreshTokenOnUnauthorized = refreshTokenOnUnauthorized;
+const tokenHold_js_1 = require("../auth/tokenHold.js");
+const LocationServiceException_js_1 = require("../errors/LocationServiceException.js");
+const errors_js_1 = require("../transport/errors.js");
+const http_js_1 = require("../transport/http.js");
+const createTransformRequest_js_1 = require("./createTransformRequest.js");
+/**
+ * One hold per `MapTokens` object, so the helpers handed the same one share
+ * what the API and `refreshToken` said (#38): a refusal one of them met is not
+ * asked again by the next. A bare `getToken` never asks again, and needs none.
+ */
+const holds = new WeakMap();
+function holdOf(tokens) {
+    let hold = holds.get(tokens);
+    if (!hold)
+        holds.set(tokens, (hold = new tokenHold_js_1.TokenHold()));
+    return hold;
+}
+/**
+ * Send with the token in hand, and after a 401 once more with a different one
+ * from `refreshToken`, all within the call's signal and deadline (#62). A 403
+ * is never retried, and neither is the token the API refused.
+ */
+async function sendWithTokenRefresh(source, noTokenAdvice, call, send) {
+    const tokens = typeof source === 'function' ? { getToken: source } : source;
+    const token = tokens.getToken();
+    if (!token)
+        throw (0, errors_js_1.noTokenAvailable)(noTokenAdvice);
+    const { refreshToken } = tokens;
+    if (!refreshToken)
+        return send(token);
+    return (0, tokenHold_js_1.sendRetryingOnce)(holdOf(tokens), token, send, async () => (await (0, http_js_1.withinCall)(refreshToken(), call)) ?? tokens.getToken());
+}
+/**
+ * Recover the tiles MapLibre fetches itself when the API refuses the token
+ * (#72).
+ *
+ * `createTransformRequest` builds each request synchronously and never sees
+ * the answer, so a refused tile used to leave a hole until the page reloaded.
+ * This listens for MapLibre's `error` events. On a 401 from a URL of our API it
+ * asks `refreshToken` once for the whole burst. When `getToken` then returns a
+ * different token, it reloads each refused tile with `map.refreshTiles`, whose
+ * requests carry that token. So `refreshToken` must make `getToken` return
+ * what it obtained: the tiles have no other way to receive it. A refused
+ * request that is not a tile (a glyph, a sprite) has the token replaced for
+ * the next one, and nothing reloaded.
+ *
+ * Tiles are reloaded by id, never a whole source: MapLibre 6 reloads a source's
+ * errored tiles as still loading, and they wait for a load that never comes.
+ *
+ * What it learns is held as the fetch helpers hold it, and shared with them
+ * when they are handed the same `tokens` object (#38): a token `refreshToken`
+ * could not replace, and a failure that says when to ask again, are not asked
+ * about again until they lapse or the token in hand changes.
+ *
+ * Returns a function that stops listening.
+ *
+ * @example
+ * const tokens = { getToken, refreshToken }
+ * const map = new Map({
+ *   container: 'map',
+ *   style: await fetchMapStyle(API_URL, 'Standard', tokens),
+ *   transformRequest: createTransformRequest(API_URL, getToken),
+ * })
+ * refreshTokenOnUnauthorized(map, API_URL, tokens)
+ */
+function refreshTokenOnUnauthorized(map, apiUrl, tokens) {
+    const hold = holdOf(tokens);
+    // Each source's refused tiles, keyed `z/x/y` so a tile refused twice is
+    // reloaded once.
+    const refused = new Map();
+    let asking = false;
+    const onError = ({ error, sourceId, tile }) => {
+        if (error?.status !== 401 || !error.url || !(0, createTransformRequest_js_1.isOurApi)(error.url, apiUrl))
+            return;
+        if (sourceId && tile) {
+            const { x, y, z } = tile.tileID.canonical;
+            const tiles = refused.get(sourceId) ?? new Map();
+            refused.set(sourceId, tiles.set(`${z}/${x}/${y}`, { x, y, z }));
+        }
+        if (asking)
+            return;
+        const inHand = tokens.getToken();
+        const held = hold.check(inHand);
+        if (held && !held.askAgain)
+            return;
+        asking = true;
+        // Asked inside an executor, so a `refreshToken` that throws instead of
+        // rejecting lands in the catch below rather than in MapLibre's emitter.
+        new Promise((resolve) => resolve(tokens.refreshToken()))
+            .then(() => {
+            // A reloaded tile takes its token from `getToken`, as every tile does,
+            // so that is the token that must have changed. Reloading on what
+            // `refreshToken` returned alone would send the refused one again, and
+            // its 401 would ask again: a loop of refreshes and reloads.
+            const now = tokens.getToken();
+            if (!now || now === inHand) {
+                // MapLibre's error carries none of the API's fields, so the refusal
+                // is remembered as the 401 it was.
+                hold.remember(new LocationServiceException_js_1.LocationServiceException({
+                    code: 'UnauthorizedException',
+                    message: 'The API refused the token, and getToken has no other since refreshToken settled.',
+                    statusCode: 401,
+                }), inHand);
+                return;
+            }
+            for (const [id, tiles] of refused)
+                map.refreshTiles(id, [...tiles.values()]);
+        })
+            .catch((refusal) => {
+            // Only a failure that says when to ask again is remembered; any other
+            // leaves the next refused tile to ask, as the send paths do.
+            if ((0, tokenHold_js_1.holdFor)(refusal) > 0)
+                hold.remember(refusal, inHand);
+        })
+            .finally(() => {
+            refused.clear();
+            asking = false;
+        });
+    };
+    map.on('error', onError);
+    return () => map.off('error', onError);
+}

package/dist/cjs/maps/staticMap.d.ts

@@ -1,5 +1,6 @@
 import type { RequestOptions } from '../transport/http.js';
 import type { ColorScheme, LabelSize, MapFeatureMode, ScaleBarUnit, StaticMapStyle } from './mapEnums.js';
+import type { MapTokenSource } from './mapToken.js';
 /**
  * Static maps: build the URL, send the right headers, get a Blob.
  *
@@ -110,11 +111,14 @@ export declare function buildStaticMapUrl(apiUrl: string, options: StaticMapOpti
  *
  * A refused plan feature — a Satellite `style`, the default when none is
  * given, or a `politicalView` — rejects with a `LocationServiceException`
- * whose `isFeatureNotEntitled` is true, as `fetchMapStyle` does.
+ * whose `isFeatureNotEntitled` is true, as `fetchMapStyle` does. Given
+ * `{ getToken, refreshToken }`, a refused token is replaced once, as
+ * `fetchMapStyle` does it (#72).
  *
  * @param apiUrl   Base URL of the Location Service API
  * @param options  Render options; exactly one of center / boundingBox / boundedPositions
- * @param getToken Callback returning the current auth token
+ * @param tokens   Callback returning the current auth token, or
+ *   `{ getToken, refreshToken }` to recover from a refused one
  * @param request  Transport options: `signal` to cancel, `timeoutMs`, `overallTimeoutMs`, `retry`
  *
  * @example
@@ -124,4 +128,4 @@ export declare function buildStaticMapUrl(apiUrl: string, options: StaticMapOpti
  * }, getToken)
  * const url = URL.createObjectURL(blob)   // remember to revokeObjectURL
  */
-export declare function fetchStaticMap(apiUrl: string, options: StaticMapOptions, getToken: () => string | undefined, request?: RequestOptions): Promise<Blob>;
+export declare function fetchStaticMap(apiUrl: string, options: StaticMapOptions, tokens: MapTokenSource, request?: RequestOptions): Promise<Blob>;

package/dist/cjs/maps/staticMap.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.staticMapAccept = staticMapAccept;
 exports.buildStaticMapUrl = buildStaticMapUrl;
 exports.fetchStaticMap = fetchStaticMap;
-const errors_js_1 = require("../transport/errors.js");
 const http_js_1 = require("../transport/http.js");
+const mapToken_js_1 = require("./mapToken.js");
 /**
  * The Accept header this request must send.
  *
@@ -55,11 +55,14 @@ function buildStaticMapUrl(apiUrl, options) {
  *
  * A refused plan feature — a Satellite `style`, the default when none is
  * given, or a `politicalView` — rejects with a `LocationServiceException`
- * whose `isFeatureNotEntitled` is true, as `fetchMapStyle` does.
+ * whose `isFeatureNotEntitled` is true, as `fetchMapStyle` does. Given
+ * `{ getToken, refreshToken }`, a refused token is replaced once, as
+ * `fetchMapStyle` does it (#72).
  *
  * @param apiUrl   Base URL of the Location Service API
  * @param options  Render options; exactly one of center / boundingBox / boundedPositions
- * @param getToken Callback returning the current auth token
+ * @param tokens   Callback returning the current auth token, or
+ *   `{ getToken, refreshToken }` to recover from a refused one
  * @param request  Transport options: `signal` to cancel, `timeoutMs`, `overallTimeoutMs`, `retry`
  *
  * @example
@@ -69,23 +72,21 @@ function buildStaticMapUrl(apiUrl, options) {
  * }, getToken)
  * const url = URL.createObjectURL(blob)   // remember to revokeObjectURL
  */
-async function fetchStaticMap(apiUrl, options, getToken, request = {}) {
-    const token = getToken();
-    // The same guard as fetchMapStyle and the server connector: a render is not
-    // worth requesting without a token to send (#37).
-    if (!token) {
-        throw (0, errors_js_1.noTokenAvailable)('getToken() returned nothing, so no static map was requested. Check the token provider has finished initialising.');
-    }
+async function fetchStaticMap(apiUrl, options, tokens, request = {}) {
+    const call = (0, http_js_1.startCall)(request);
     // Through the shared transport, so a static map gets the timeout, budget,
     // cancellation and retry every other call has -- and its failures arrive as
     // LocationServiceException rather than as a raw TypeError. The API's own
     // {message, code, requestId} survives, which matters here: the messages are
     // specific and actionable -- "'width' and 'height' are required", "Only one
     // of center, bounding-box or bounded-positions may be set".
-    return (0, http_js_1.requestBlob)(buildStaticMapUrl(apiUrl, options), {
+    //
+    // The same guard as fetchMapStyle and the server connector: a render is not
+    // worth requesting without a token to send (#37).
+    return (0, mapToken_js_1.sendWithTokenRefresh)(tokens, 'getToken() returned nothing, so no static map was requested. Check the token provider has finished initialising.', call, (token) => (0, http_js_1.requestBlob)(buildStaticMapUrl(apiUrl, options), {
         headers: {
             Authorization: `Bearer ${token}`,
             Accept: staticMapAccept(options.style),
         },
-    }, request);
+    }, call));
 }

package/dist/cjs/server/LocationServiceConnector.d.ts

@@ -1,5 +1,7 @@
+import type { GetTokenOptions } from '../auth/TokenProvider.js';
 import type { VerifyAddressResponse } from '../client/commands.js';
 import type { RequestOptions } from '../transport/http.js';
+import type { CommandOutput, CommandWithOutput } from '../types/index.js';
 import type { AppConfigClaims } from '../utils/tokenClaims.js';
 export interface ConnectorConfig {
     /** Falls back to `LOCATION_API_URL` / `LOCATION_SERVICE_API_URL`. */
@@ -14,10 +16,13 @@ export interface ConnectorConfig {
      * a long-lived connector survive expiry.
      *
      * `forceRefresh` is passed as `true` when the API has just rejected the token
-     * this returned — the signature is `TokenProvider.getToken`'s exactly, so
-     * `getToken: (f) => provider.getToken(f)` is a complete implementation.
+     * this returned, and `options` always asks for `cachedUntilExpiry` (#63): a
+     * source that can keep sending its cached token through a throttled refresh
+     * should, since a connector's token never reaches a browser. The signature
+     * is `TokenProvider.getToken`'s, so
+     * `getToken: (f, o) => provider.getToken(f, o)` is a complete implementation.
      */
-    getToken?: (forceRefresh?: boolean) => Promise<string | {
+    getToken?: (forceRefresh?: boolean, options?: GetTokenOptions) => Promise<string | {
         token?: string;
     } | undefined>;
     /** Falls back to `LOCATION_CLIENT_ID` / `LOCATION_SERVICE_CLIENT_ID`. */
@@ -70,6 +75,8 @@ export declare class LocationServiceConnector {
     private readonly config;
     private tokenSource?;
     private readonly origin?;
+    /** A token the API refused, and why, until the hold lapses (#38). */
+    private readonly refused;
     readonly serviceId: string;
     constructor(config?: ConnectorConfig);
     /**
@@ -107,6 +114,16 @@ export declare class LocationServiceConnector {
      * header beats the connector default, whatever the caller capitalised.
      */
     private effectiveOrigin;
+    /**
+     * Send a command, and resolve with its output:
+     * `await connector.send(new SearchTextCommand(…))` is a
+     * `SearchTextCommandOutput`, with nothing to annotate (#68).
+     */
+    send<C extends CommandWithOutput>(command: C, options?: SendOptions): Promise<CommandOutput<C>>;
+    /**
+     * The signature `send` had before it inferred its output (#68), kept for
+     * calls naming both type arguments, as `GeoPlacesClient.send` keeps it.
+     */
     send<TInput, TOutput>(command: TInput, options?: SendOptions): Promise<TOutput>;
     /**
      * Verify a PlaceId: `send(new VerifyAddressCommand({ PlaceId }))`, typed

package/dist/cjs/server/LocationServiceConnector.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocationServiceConnector = void 0;
 const debug_1 = __importDefault(require("debug"));
+const tokenHold_js_1 = require("../auth/tokenHold.js");
 const commands_js_1 = require("../client/commands.js");
 const LocationServiceException_js_1 = require("../errors/LocationServiceException.js");
 const endpoints_js_1 = require("../transport/endpoints.js");
@@ -106,6 +107,8 @@ function explainMissingOrigin(err, sentOrigin) {
  */
 class LocationServiceConnector {
     constructor(config = {}) {
+        /** A token the API refused, and why, until the hold lapses (#38). */
+        this.refused = new tokenHold_js_1.TokenHold();
         this.serviceId = 'Geo Places';
         this.config = config;
         // `||`, not `??`, to match the other four env-completed fields: an empty
@@ -137,7 +140,10 @@ class LocationServiceConnector {
             return {
                 apiUrl: () => requireApiUrl(apiUrl),
                 get: async (forceRefresh) => {
-                    const result = await getToken(forceRefresh);
+                    // As the environment source below asks its provider (#63).
+                    const result = await getToken(forceRefresh, {
+                        cachedUntilExpiry: true,
+                    });
                     if (!result)
                         return undefined;
                     return typeof result === 'string' ? result : result.token;
@@ -159,7 +165,9 @@ class LocationServiceConnector {
             // Already validated by serverTokenSource, which cannot resolve
             // credentials without it.
             apiUrl: () => env.apiUrl,
-            get: async (forceRefresh) => (await env.getToken(forceRefresh)).token,
+            // A throttled refresh keeps the cached token in use until its own exp
+            // (#63): this is a server dispatch, never a token handed to a browser.
+            get: async (forceRefresh) => (await env.getToken(forceRefresh, { cachedUntilExpiry: true })).token,
         };
     }
     /**
@@ -197,8 +205,11 @@ class LocationServiceConnector {
         const source = this.source();
         const cmd = command;
         const url = `${source.apiUrl()}${(0, endpoints_js_1.resolveEndpoint)(cmd)}`;
+        // The call's deadline starts here, before the token is waited for, so the
+        // caller's `overallTimeoutMs` and `signal` bound the whole call (#62).
+        const call = (0, http_js_1.startCall)(options);
         try {
-            return await this.dispatchWithRetry(source, url, cmd, options);
+            return await this.dispatchWithRetry(source, url, cmd, call);
         }
         catch (err) {
             throw explainMissingOrigin(err, this.effectiveOrigin(options));
@@ -216,27 +227,14 @@ class LocationServiceConnector {
         return this.send(new commands_js_1.VerifyAddressCommand({ PlaceId: placeId }), options);
     }
     async dispatchWithRetry(source, url, cmd, options) {
-        const token = await source.get();
+        // Raced against the caller's signal and deadline, not given them: the
+        // token fetch may be shared with other calls (#62).
+        const token = await (0, http_js_1.withinCall)(source.get(), options);
         if (!token)
             throw (0, errors_js_1.noTokenAvailable)(NO_TOKEN_ADVICE);
-        try {
-            return await this.dispatch(url, token, cmd, options);
-        }
-        catch (err) {
-            if (!(0, errors_js_1.isTokenRejected)(err))
-                throw err;
-            // One retry, and only when the replacement is genuinely a different
-            // token. That single comparison covers every source: a fixed `token`
-            // string, a caller `getToken` that ignores `forceRefresh`, and a cached
-            // token the API has revoked before its `exp` all hand back what we
-            // already sent — and re-sending it would be a second doomed request for
-            // the same answer.
-            const fresh = await source.get(true);
-            if (!fresh || fresh === token)
-                throw err;
-            log('401 on a token the API no longer accepts — retrying once, refreshed');
-            return await this.dispatch(url, fresh, cmd, options);
-        }
+        // Through `sendRetryingOnce`, like every 401 retry here (#38). The forced
+        // refresh is raced against the caller as the first ask was (#62).
+        return (0, tokenHold_js_1.sendRetryingOnce)(this.refused, token, (t) => this.dispatch(url, t, cmd, options), () => (0, http_js_1.withinCall)(source.get(true), options), () => log('401 on a token the API no longer accepts — retrying once, refreshed'));
     }
     dispatch(url, token, cmd, options) {
         // The caller's input goes out as the caller wrote it — nothing in the body

package/dist/cjs/server/getClientConfig.d.ts

@@ -1,4 +1,4 @@
-import type { TokenResponse } from '../auth/TokenProvider.js';
+import type { GetTokenOptions, TokenResponse } from '../auth/TokenProvider.js';
 import type { ClientConfig } from '../types/index.js';
 export interface ServerAuthConfig {
     apiUrl?: string;
@@ -60,8 +60,12 @@ export declare function resolveApiUrl(explicit?: string): string | undefined;
  */
 export interface ServerTokenSource {
     apiUrl: string;
-    /** Resolves with a token or rejects; it never resolves tokenless. */
-    getToken(forceRefresh?: boolean): Promise<TokenResponse & {
+    /**
+     * Resolves with a token or rejects; it never resolves tokenless. The options
+     * are `TokenProvider.getToken`'s: the connector asks for `cachedUntilExpiry`
+     * (#63), and `getClientConfig` never does.
+     */
+    getToken(forceRefresh?: boolean, options?: GetTokenOptions): Promise<TokenResponse & {
         token: string;
     }>;
 }
@@ -104,8 +108,9 @@ export declare function serverTokenSource(config?: ServerAuthConfig): ServerToke
  * // Auto-detect from environment
  * const config = await getClientConfig()
  *
- * // Or override specific values
- * const config = await getClientConfig({ apiUrl: 'https://custom.api.com' })
+ * // Or override specific values — the API URL is the one on the
+ * // application's page in the developer portal
+ * const config = await getClientConfig({ apiUrl: 'https://your-api-url.example' })
  *
  * // The API rejected the token before its exp — revoked, or secret rotated
  * const fresh = await getClientConfig({ forceRefresh: true })

package/dist/cjs/server/getClientConfig.js

@@ -78,6 +78,30 @@ function resolveApiUrl(explicit) {
         process.env.LOCATION_API_URL ||
         process.env.LOCATION_SERVICE_API_URL);
 }
+/**
+ * A refusal of the client credentials themselves, as opposed to a refusal
+ * whose sentence already names its cause.
+ *
+ * Two answers qualify. `/auth/token`'s own `Invalid credentials` is a secret
+ * that matched nothing. The gateway's 401 (`UnauthorizedException`) is the
+ * authorizer refusing the Basic pair before `/auth/token` runs. An application
+ * that is not active is a 403 (`ApplicationNotActiveException`) on either
+ * path, whose sentence names its cause, and it is left as the API wrote it,
+ * like every 403.
+ */
+function isCredentialsRefusal(error) {
+    if (!(error instanceof LocationServiceException_js_1.LocationServiceException))
+        return false;
+    if (error.statusCode !== 401)
+        return false;
+    return (error.code === 'UnauthorizedException' ||
+        error.message === 'Invalid credentials');
+}
+/** The API's words as a sentence, so the advice can follow them. */
+const sentence = (text) => (/[.!?]$/.test(text) ? text : `${text}.`);
+function credentialsAdvice(clientId) {
+    return `Check that LOCATION_CLIENT_ID ("${clientId}") and LOCATION_CLIENT_SECRET match your application in the developer portal.`;
+}
 function serverTokenSource(config = {}) {
     log('[serverTokenSource] Starting with config:', {
         hasApiUrl: !!config.apiUrl,
@@ -112,28 +136,27 @@ function serverTokenSource(config = {}) {
     const provider = getTokenProvider(apiUrl, clientId, clientSecret);
     return {
         apiUrl,
-        async getToken(forceRefresh = false) {
+        async getToken(forceRefresh = false, options) {
             log('[serverTokenSource] Fetching token (forceRefresh=%s)', forceRefresh);
             let result;
             try {
-                result = await provider.getToken(forceRefresh);
+                result = await provider.getToken(forceRefresh, options);
             }
             catch (error) {
-                // The provider now rejects rather than resolving with success:false, and
-                // the rejection is typed — so a store outage (503) can be reported as a
-                // store outage instead of as bad credentials.
-                if (error instanceof LocationServiceException_js_1.LocationServiceException) {
-                    if (error.isAuth) {
-                        throw new LocationServiceException_js_1.LocationServiceException({
-                            code: 'InvalidCredentialsException',
-                            message: `Authentication failed for client ID "${clientId}". ` +
-                                `Verify LOCATION_CLIENT_ID and LOCATION_CLIENT_SECRET match your application in the developer portal.`,
-                            statusCode: error.statusCode,
-                            requestId: error.requestId,
-                            cause: error,
-                        });
-                    }
-                    throw error;
+                // The API's code and sentence, passed through (#38). Every 401 and 403
+                // used to become "Verify LOCATION_CLIENT_ID and LOCATION_CLIENT_SECRET",
+                // which sent a suspended application to check a secret that was fine.
+                // The advice is added only where the credentials are what was refused.
+                if (isCredentialsRefusal(error)) {
+                    throw new LocationServiceException_js_1.LocationServiceException({
+                        code: error.code,
+                        message: `${sentence(error.message)} ${credentialsAdvice(clientId)}`,
+                        statusCode: error.statusCode,
+                        requestId: error.requestId,
+                        details: error.details,
+                        retryAfterMs: error.retryAfterMs,
+                        cause: error,
+                    });
                 }
                 throw error;
             }
@@ -190,8 +213,9 @@ function serverTokenSource(config = {}) {
  * // Auto-detect from environment
  * const config = await getClientConfig()
  *
- * // Or override specific values
- * const config = await getClientConfig({ apiUrl: 'https://custom.api.com' })
+ * // Or override specific values — the API URL is the one on the
+ * // application's page in the developer portal
+ * const config = await getClientConfig({ apiUrl: 'https://your-api-url.example' })
  *
  * // The API rejected the token before its exp — revoked, or secret rotated
  * const fresh = await getClientConfig({ forceRefresh: true })

package/dist/cjs/server/index.d.ts

@@ -1,5 +1,5 @@
 export { TokenProvider } from '../auth/TokenProvider.js';
-export type { TokenProviderConfig, TokenResponse, } from '../auth/TokenProvider.js';
+export type { GetTokenOptions, TokenProviderConfig, TokenResponse, } from '../auth/TokenProvider.js';
 export { getClientConfig } from './getClientConfig.js';
 export type { ServerAuthConfig, ServerClientConfig } from './getClientConfig.js';
 export { LocationServiceConnector } from './LocationServiceConnector.js';

package/dist/cjs/transport/errors.d.ts

@@ -2,14 +2,20 @@ import { LocationServiceException } from '../errors/LocationServiceException.js'
 /**
  * Turn a non-2xx response into a LocationServiceException.
  *
- * The API does not yet speak one error shape — that is api#29 (T23) — so this
- * tolerates the three it currently emits and synthesises a `code` for each.
- * RFC-0002 calls this legacy tolerance, and it is what lets the client ship
- * before the API contract lands. Delete the fallbacks once T23 is deployed.
- *
- *   { message, code, requestId }         service Lambdas — already correct
- *   { error, error_description }         /auth/token, OAuth shape
- *   { message: "Unauthorized" }          API Gateway's own responses
+ * The API answers every failure with a `code`, in one of three envelopes:
+ *
+ *   { message, code, requestId }                    data routes; the gateway
+ *   { error, error_description, code, requestId }   /auth/token (OAuth 2.0)
+ *   { code, message }                               the per-address limit
+ *
+ * The sentence is in `message`, or on /auth/token in `error_description`, and
+ * both are read whatever else the body carries (#38). The description used to
+ * be read only from a body with no `code`, and /auth/token has sent one since,
+ * so every refusal from it arrived as "Request failed: Unauthorized": a
+ * suspended application read exactly like a wrong secret.
+ *
+ * A body with no `code` — a proxy's, or an older deployment's — still gets
+ * one: from its OAuth `error`, else from the status.
  */
 export declare function parseErrorResponse(status: number, statusText: string, body: string, headers?: Headers): LocationServiceException;
 /**