@chaosity/location-client 0.11.0 → 0.13.0

package/dist/cjs/transport/errors.js

@@ -8,14 +8,20 @@ const LocationServiceException_js_1 = require("../errors/LocationServiceExceptio
 /**
  * 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.
+ * The API answers every failure with a `code`, in one of three envelopes:
  *
- *   { message, code, requestId }         service Lambdas — already correct
- *   { error, error_description }         /auth/token, OAuth shape
- *   { message: "Unauthorized" }          API Gateway's own responses
+ *   { 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.
  */
 function parseErrorResponse(status, statusText, body, headers) {
     let message = `Request failed: ${statusText || status}`;
@@ -24,17 +30,19 @@ function parseErrorResponse(status, statusText, body, headers) {
     let details;
     try {
         const data = JSON.parse(body);
-        if (typeof data.message === 'string')
-            message = data.message;
-        if (typeof data.code === 'string')
-            code = data.code;
-        if (typeof data.requestId === 'string')
-            requestId = data.requestId;
-        // OAuth envelope from /auth/token
-        if (!code && typeof data.error === 'string') {
-            message = data.error_description ?? data.error;
-            code = oauthCode(data.error, status);
-            details = { oauthError: data.error };
+        const text = (value) => typeof value === 'string' ? value : undefined;
+        message =
+            text(data.error_description) ??
+                text(data.message) ??
+                text(data.error) ??
+                message;
+        code = text(data.code);
+        requestId = text(data.requestId);
+        // OAuth `error`, from /auth/token and the gateway's 401 on it
+        const oauthError = text(data.error);
+        if (oauthError) {
+            code ?? (code = oauthCode(oauthError, status));
+            details = { oauthError };
         }
     }
     catch {

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

@@ -38,6 +38,24 @@ export interface RequestOptions {
         maxAttempts?: number;
     };
 }
+/**
+ * A call's options once it has begun: `deadline` is when `overallTimeoutMs`
+ * runs out, fixed at the call's entry, so that a wait before the request — a
+ * token — spends the same budget the request then gets the rest of (#62).
+ */
+export interface CallOptions extends RequestOptions {
+    deadline: number;
+}
+/** Fix a call's deadline at its entry (#62). */
+export declare function startCall<T extends RequestOptions>(options?: T): T & CallOptions;
+/**
+ * Wait for `work` within the call: reject with `AbortedException` when the
+ * caller's signal aborts, and with `TimeoutException` when its deadline
+ * passes, whichever comes first (#62). `work` itself is left running, because
+ * it may be shared: one caller's abort must not fail another waiting on the
+ * same token fetch.
+ */
+export declare function withinCall<T>(work: Promise<T>, call: CallOptions): Promise<T>;
 /** Exponential backoff with FULL jitter, so retries never march in lockstep. */
 export declare function backoffMs(attempt: number, random?: () => number): number;
 /**

package/dist/cjs/transport/http.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_MAX_ATTEMPTS = exports.DEFAULT_OVERALL_TIMEOUT_MS = exports.DEFAULT_TIMEOUT_MS = void 0;
+exports.startCall = startCall;
+exports.withinCall = withinCall;
 exports.backoffMs = backoffMs;
 exports.requestJson = requestJson;
 exports.requestBlob = requestBlob;
@@ -34,6 +36,40 @@ exports.DEFAULT_OVERALL_TIMEOUT_MS = 30000;
 exports.DEFAULT_MAX_ATTEMPTS = 3;
 const BACKOFF_BASE_MS = 250;
 const BACKOFF_CAP_MS = 4000;
+/** Fix a call's deadline at its entry (#62). */
+function startCall(options = {}) {
+    return {
+        ...options,
+        deadline: Date.now() + (options.overallTimeoutMs ?? exports.DEFAULT_OVERALL_TIMEOUT_MS),
+    };
+}
+/**
+ * Wait for `work` within the call: reject with `AbortedException` when the
+ * caller's signal aborts, and with `TimeoutException` when its deadline
+ * passes, whichever comes first (#62). `work` itself is left running, because
+ * it may be shared: one caller's abort must not fail another waiting on the
+ * same token fetch.
+ */
+function withinCall(work, call) {
+    const { signal, deadline } = call;
+    const overallTimeoutMs = call.overallTimeoutMs ?? exports.DEFAULT_OVERALL_TIMEOUT_MS;
+    if (signal?.aborted)
+        return Promise.reject(abortedException(signal));
+    const left = deadline - Date.now();
+    if (left <= 0)
+        return Promise.reject(overallTimeoutException(overallTimeoutMs));
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => finish(() => reject(overallTimeoutException(overallTimeoutMs))), left);
+        const onAbort = () => finish(() => reject(abortedException(signal)));
+        signal?.addEventListener('abort', onAbort, { once: true });
+        function finish(settle) {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            settle();
+        }
+        work.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+    });
+}
 /**
  * Combine the caller's signal with a per-attempt timeout.
  *
@@ -115,7 +151,9 @@ async function request(url, init, options, read) {
             details: { source: 'client' },
         });
     }
-    const deadline = Date.now() + overallTimeoutMs;
+    // A call that began before this request (#62) brings its own deadline, so
+    // the request has only what the wait before it left.
+    const deadline = options.deadline ?? Date.now() + overallTimeoutMs;
     let lastError;
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
         // Checked before every attempt: a signal aborted during backoff must not fire one more.

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

@@ -1,3 +1,4 @@
+import type { VerifyAddressCommand, VerifyAddressResponse } from '../client/commands.js';
 /**
  * At least one of `token`, `getToken` or `refreshToken` must supply a token, or
  * `send` refuses locally with `InvalidCredentialsException` rather than putting
@@ -52,6 +53,30 @@ export interface ClientConfig {
 export interface GeoPlacesCommand {
     readonly input: object;
 }
+/**
+ * The part of an AWS SDK command that carries its output type: the request
+ * handler its `resolveMiddleware` builds resolves with `{ output }`. The SDK's
+ * own `send` reads the output from the command the same way.
+ */
+interface SdkCommandOutputs<O extends object = object> {
+    resolveMiddleware(...args: never[]): (...args: never[]) => Promise<{
+        output: O;
+    }>;
+}
+/**
+ * A command whose output `send` can name (#68): every SDK command, this
+ * package's narrowed Places commands among them, and `VerifyAddressCommand`.
+ */
+export type CommandWithOutput = SdkCommandOutputs | VerifyAddressCommand;
+/**
+ * What `send` resolves with for a command (#68): an SDK command's own
+ * `…CommandOutput`, and `VerifyAddressResponse` for `VerifyAddressCommand`,
+ * which is this package's and has no handler.
+ *
+ * @example
+ * type Out = CommandOutput<AutocompleteCommand> // AutocompleteCommandOutput
+ */
+export type CommandOutput<C extends CommandWithOutput> = C extends SdkCommandOutputs<infer O> ? O : VerifyAddressResponse;
 /**
  * Minimal interface for a MapLibre Map instance.
  * Using a structural type avoids hard coupling to a specific maplibre-gl version.
@@ -69,3 +94,4 @@ export interface MapLike {
     getLayoutProperty(layerId: string, name: string): unknown;
     setLayoutProperty(layerId: string, name: string, value: unknown): void;
 }
+export {};

package/dist/client/GeoPlacesClient.d.ts

@@ -1,18 +1,22 @@
 import type { RequestOptions } from '../transport/http.js';
-import type { ClientConfig } from '../types/index.js';
+import type { ClientConfig, CommandOutput, CommandWithOutput } from '../types/index.js';
 import type { AppConfigClaims } from '../utils/tokenClaims.js';
 import type { VerifyAddressResponse } from './commands.js';
 export type SendOptions = RequestOptions;
 /**
  * GeoPlacesClient — AWS Location Service compatible client with custom auth.
  *
- * Uses AWS SDK command classes but replaces SigV4 with a Bearer token. All
- * request and response types are identical to AWS Location Service.
+ * Uses AWS SDK command classes but replaces SigV4 with a Bearer token. The
+ * request and response types are the AWS SDK's, except that the Places
+ * commands take neither `IntendedUse` nor `Key` (#40), and `VerifyAddressCommand`
+ * is this package's own (#54).
  *
  * Pass `getToken` in config for live refresh without recreating the client.
  */
 export declare class GeoPlacesClient {
     private clientConfig;
+    /** A token the API refused, and why, until the hold lapses (#38). */
+    private readonly refused;
     readonly config: {
         serviceId: string;
     };
@@ -36,6 +40,11 @@ export declare class GeoPlacesClient {
     getAppConfig(): AppConfigClaims;
     /** Prefer the getToken callback (live ref) over a static token string. */
     private currentToken;
+    /**
+     * `refreshToken`, held to the caller's signal and deadline (#62). A slow or
+     * stuck callback used to hold `send` past both.
+     */
+    private askRefreshToken;
     /**
      * A token to send, or a refusal — never `undefined`.
      *
@@ -44,10 +53,21 @@ export declare class GeoPlacesClient {
      */
     private ensureToken;
     /**
+     * Send a command, and resolve with its output:
+     * `await client.send(new AutocompleteCommand(…))` is an
+     * `AutocompleteCommandOutput`, with nothing to annotate (#68).
+     *
      * @param options `signal` to cancel, `timeoutMs` per attempt,
      *   `overallTimeoutMs` for the whole call, `retry: false` to disable the
      *   retry loop. Every failure throws LocationServiceException.
      */
+    send<C extends CommandWithOutput>(command: C, options?: SendOptions): Promise<CommandOutput<C>>;
+    /**
+     * The signature `send` had before it inferred its output (#68). It stays
+     * so that a call naming both type arguments, and a client typed by a
+     * structural `send<TInput, TOutput>` — as `@chaosity/address-form` types
+     * its client — still compile.
+     */
     send<TInput, TOutput>(command: TInput, options?: SendOptions): Promise<TOutput>;
     /**
      * Verify a PlaceId: `send(new VerifyAddressCommand({ PlaceId }))`, typed

package/dist/client/GeoPlacesClient.js

@@ -1,20 +1,30 @@
 import debug from 'debug';
+import { TokenHold, sendRetryingOnce } from '../auth/tokenHold.js';
 import { resolveEndpoint } from '../transport/endpoints.js';
-import { isTokenRejected, noTokenAvailable } from '../transport/errors.js';
-import { requestJson } from '../transport/http.js';
+import { noTokenAvailable } from '../transport/errors.js';
+import { requestJson, startCall, withinCall } from '../transport/http.js';
 import { readAppConfigClaims } from '../utils/tokenClaims.js';
 import { VerifyAddressCommand } from './commands.js';
 const log = debug('location-client:api');
+/**
+ * What a hold is kept against when there was no token in hand to key it to.
+ * `ensureToken` treats an empty token as none, so no real token is this.
+ */
+const NO_TOKEN = '';
 /**
  * GeoPlacesClient — AWS Location Service compatible client with custom auth.
  *
- * Uses AWS SDK command classes but replaces SigV4 with a Bearer token. All
- * request and response types are identical to AWS Location Service.
+ * Uses AWS SDK command classes but replaces SigV4 with a Bearer token. The
+ * request and response types are the AWS SDK's, except that the Places
+ * commands take neither `IntendedUse` nor `Key` (#40), and `VerifyAddressCommand`
+ * is this package's own (#54).
  *
  * Pass `getToken` in config for live refresh without recreating the client.
  */
 export class GeoPlacesClient {
     constructor(config) {
+        /** A token the API refused, and why, until the hold lapses (#38). */
+        this.refused = new TokenHold();
         this.clientConfig = config;
         this.config = { serviceId: 'Geo Places' };
     }
@@ -41,29 +51,48 @@ export class GeoPlacesClient {
     currentToken() {
         return this.clientConfig.getToken?.() ?? this.clientConfig.token;
     }
+    /**
+     * `refreshToken`, held to the caller's signal and deadline (#62). A slow or
+     * stuck callback used to hold `send` past both.
+     */
+    askRefreshToken(call) {
+        const asked = this.clientConfig.refreshToken?.();
+        return asked ? withinCall(asked, call) : Promise.resolve(undefined);
+    }
     /**
      * A token to send, or a refusal — never `undefined`.
      *
      * `refreshToken` is asked only when there is nothing at all in hand, so a
      * client configured the ordinary way pays nothing for this.
      */
-    async ensureToken() {
-        // `||`, not `??`: an empty string is a token source with nothing to give,
-        // not a decision to send an empty one. With `??` it survived the coalesce,
-        // skipped `refreshToken`, and then failed the check two lines below — so
+    async ensureToken(call) {
+        // Truthiness, not `??`: an empty string is a token source with nothing to
+        // give, not a decision to send an empty one. With `??` it survived the
+        // coalesce, skipped `refreshToken`, and then failed the check below — so
         // `getToken: () => undefined` got the refresh ask and `getToken: () => ''`
         // did not, which is a distinction no caller means to draw.
-        const token = this.currentToken() || (await this.clientConfig.refreshToken?.());
+        const inHand = this.currentToken();
+        if (inHand)
+            return inHand;
+        // `refreshToken` refused a moment ago, and there is still nothing in hand:
+        // answer with that rather than ask it again on every send (#38). The hold
+        // is kept against "no token", so one arriving from `getToken` ends it.
+        const held = this.refused.check(NO_TOKEN)?.error;
+        if (held)
+            throw held;
+        let token;
+        try {
+            token = await this.askRefreshToken(call);
+        }
+        catch (refusal) {
+            this.refused.remember(refusal, NO_TOKEN);
+            throw refusal;
+        }
         if (!token) {
             throw noTokenAvailable('the client has no token yet. Pass `token`, or a `getToken`/`refreshToken` that has one.');
         }
         return token;
     }
-    /**
-     * @param options `signal` to cancel, `timeoutMs` per attempt,
-     *   `overallTimeoutMs` for the whole call, `retry: false` to disable the
-     *   retry loop. Every failure throws LocationServiceException.
-     */
     async send(command, options) {
         const cmd = command;
         const url = `${this.clientConfig.apiUrl}${resolveEndpoint(cmd)}`;
@@ -74,26 +103,15 @@ export class GeoPlacesClient {
         // source has not produced one yet spent a whole round trip to learn
         // something it already knew. Ask the refresh source instead, and refuse if
         // there is still nothing.
-        const token = await this.ensureToken();
-        try {
-            return await this.dispatch(url, token, cmd, options);
-        }
-        catch (err) {
-            if (!isTokenRejected(err))
-                throw err;
-            // One shot. `refreshToken` is the only way to actually obtain a new
-            // token here — `getToken` is synchronous and returns the one already in
-            // hand — but it is re-read as a fallback because a provider that
-            // refreshes in the background may have landed a new one while this
-            // request was in flight.
-            const fresh = (await this.clientConfig.refreshToken?.()) ?? this.currentToken();
-            // Nothing new to send. Repeating the request would fail identically — a
-            // second round trip for the same 401.
-            if (!fresh || fresh === token)
-                throw err;
-            log('401 — retrying %s once with a refreshed token', cmd.constructor?.name);
-            return await this.dispatch(url, fresh, cmd, options);
-        }
+        // The call's deadline starts here, before any wait for a token (#62).
+        const call = startCall(options);
+        const token = await this.ensureToken(call);
+        // One shot, through `sendRetryingOnce` like every 401 retry here (#38).
+        // `refreshToken` is the only way to actually obtain a new token here —
+        // `getToken` is synchronous and returns the one already in hand — but it
+        // is re-read as a fallback because a provider that refreshes in the
+        // background may have landed a new one while this request was in flight.
+        return sendRetryingOnce(this.refused, token, (t) => this.dispatch(url, t, cmd, call), async () => (await this.askRefreshToken(call)) ?? this.currentToken(), () => log('401 — retrying %s once with a refreshed token', cmd.constructor?.name));
     }
     /**
      * Verify a PlaceId: `send(new VerifyAddressCommand({ PlaceId }))`, typed

package/dist/client/commands.d.ts

@@ -125,9 +125,8 @@ export interface VerifyAddressCommandInput {
  * Japan, which may not be stored at all. Every other Places result is for
  * display.
  *
- * Keep the PlaceId you sent beside it. The answer's own `PlaceId` can differ,
- * and for a unit it does: the service fails that one on every Places route,
- * while the one you sent verifies again.
+ * Its `PlaceId` is the one sent, for a unit as for a building, so a stored
+ * verification can be verified, or looked up, again by its own `PlaceId`.
  */
 export type VerifyAddressResponse = Omit<GetPlaceResponse, 'PricingBucket'> & {
     /**

package/dist/errors/LocationServiceException.d.ts

@@ -12,9 +12,36 @@
  * caller hears of it; there is no check to make beforehand.
  */
 export declare const FEATURE_NOT_ENTITLED = "FeatureNotEntitledException";
+/**
+ * Every `code` the API sends (#38): its error contract, published at
+ * https://docs.chaosity.cloud/api/errors, plus the Amazon Location exception
+ * names it passes through from upstream.
+ *
+ * A few are worth knowing apart. `RateLimitExceededException` is the
+ * application's own throttle; `ThrottlingException` is Amazon Location
+ * throttling the service; `IpRateLimitExceededException` is the per-address
+ * limit in front of `/auth/token`. `ApplicationNotActiveException` (403) is an
+ * application that is new, suspended or off its plan.
+ * `TokenExpiredException` is in the contract but never sent: an expired token
+ * arrives as `UnauthorizedException`.
+ */
+export declare const API_ERROR_CODES: readonly ["AccessDeniedException", "ApplicationNotActiveException", "ClientException", "FeatureNotEntitledException", "ForbiddenException", "InternalException", "InternalServerException", "InvalidCredentialsException", "IpRateLimitExceededException", "NotAcceptableException", "NotFoundException", "OriginNotAllowedException", "RateLimitExceededException", "ResourceNotFoundException", "ServiceUnavailableException", "ThrottlingException", "TimeoutException", "TokenExpiredException", "UnauthorizedException", "UpstreamException", "ValidationException"];
+/**
+ * The codes only this package raises, for failures that never reached the
+ * API. It raises some of the API's codes too — `TimeoutException` for its own
+ * timeout, `InvalidCredentialsException` for a missing token — and those are
+ * in the list above.
+ */
+export declare const CLIENT_ERROR_CODES: readonly ["AbortedException", "NetworkException", "ServiceException", "UnknownCommandException"];
+export declare const LOCATION_SERVICE_ERROR_CODES: readonly ["AccessDeniedException", "ApplicationNotActiveException", "ClientException", "FeatureNotEntitledException", "ForbiddenException", "InternalException", "InternalServerException", "InvalidCredentialsException", "IpRateLimitExceededException", "NotAcceptableException", "NotFoundException", "OriginNotAllowedException", "RateLimitExceededException", "ResourceNotFoundException", "ServiceUnavailableException", "ThrottlingException", "TimeoutException", "TokenExpiredException", "UnauthorizedException", "UpstreamException", "ValidationException", "AbortedException", "NetworkException", "ServiceException", "UnknownCommandException"];
+/**
+ * A `LocationServiceException`'s `code`: one of these, or a code the API adds
+ * after this release, which arrives all the same.
+ */
+export type LocationServiceErrorCode = (typeof LOCATION_SERVICE_ERROR_CODES)[number];
 export interface LocationServiceExceptionOptions {
     message: string;
-    code: string;
+    code: LocationServiceErrorCode | (string & {});
     /** Absent for failures that never reached the server: network, timeout, abort. */
     statusCode?: number;
     requestId?: string;
@@ -32,7 +59,8 @@ export interface LocationServiceExceptionOptions {
  * rather than sniffing at `TypeError` vs `DOMException` vs a bare `Error`.
  */
 export declare class LocationServiceException extends Error {
-    readonly code: string;
+    /** See `LocationServiceErrorCode`: typed, and open to a code added later. */
+    readonly code: LocationServiceErrorCode | (string & {});
     readonly statusCode?: number;
     readonly requestId?: string;
     readonly details?: Record<string, unknown>;

package/dist/errors/LocationServiceException.js

@@ -12,6 +12,58 @@
  * caller hears of it; there is no check to make beforehand.
  */
 export const FEATURE_NOT_ENTITLED = 'FeatureNotEntitledException';
+/**
+ * Every `code` the API sends (#38): its error contract, published at
+ * https://docs.chaosity.cloud/api/errors, plus the Amazon Location exception
+ * names it passes through from upstream.
+ *
+ * A few are worth knowing apart. `RateLimitExceededException` is the
+ * application's own throttle; `ThrottlingException` is Amazon Location
+ * throttling the service; `IpRateLimitExceededException` is the per-address
+ * limit in front of `/auth/token`. `ApplicationNotActiveException` (403) is an
+ * application that is new, suspended or off its plan.
+ * `TokenExpiredException` is in the contract but never sent: an expired token
+ * arrives as `UnauthorizedException`.
+ */
+export const API_ERROR_CODES = [
+    'AccessDeniedException',
+    'ApplicationNotActiveException',
+    'ClientException',
+    'FeatureNotEntitledException',
+    'ForbiddenException',
+    'InternalException',
+    'InternalServerException',
+    'InvalidCredentialsException',
+    'IpRateLimitExceededException',
+    'NotAcceptableException',
+    'NotFoundException',
+    'OriginNotAllowedException',
+    'RateLimitExceededException',
+    'ResourceNotFoundException',
+    'ServiceUnavailableException',
+    'ThrottlingException',
+    'TimeoutException',
+    'TokenExpiredException',
+    'UnauthorizedException',
+    'UpstreamException',
+    'ValidationException',
+];
+/**
+ * The codes only this package raises, for failures that never reached the
+ * API. It raises some of the API's codes too — `TimeoutException` for its own
+ * timeout, `InvalidCredentialsException` for a missing token — and those are
+ * in the list above.
+ */
+export const CLIENT_ERROR_CODES = [
+    'AbortedException',
+    'NetworkException',
+    'ServiceException',
+    'UnknownCommandException',
+];
+export const LOCATION_SERVICE_ERROR_CODES = [
+    ...API_ERROR_CODES,
+    ...CLIENT_ERROR_CODES,
+];
 /**
  * The single error type this package throws.
  *

package/dist/index.d.ts

@@ -4,11 +4,10 @@ export { DEFAULT_MAX_ATTEMPTS, DEFAULT_OVERALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, }
 export type { RequestOptions } from './transport/http.js';
 export { TOKEN_REFRESH_BUFFER_SECONDS, readTokenExpiry, } from './auth/tokenRefresh.js';
 export { FEATURE_NOT_ENTITLED, LocationServiceException, } from './errors/LocationServiceException.js';
-export type { LocationServiceExceptionOptions } from './errors/LocationServiceException.js';
-export * from '@aws-sdk/client-geo-places';
+export type { LocationServiceErrorCode, LocationServiceExceptionOptions, } from './errors/LocationServiceException.js';
+export * from './aws.js';
 export { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, VerifyAddressCommand, } from './client/commands.js';
 export type { AutocompleteCommandInput, AutocompleteRequest, GeocodeCommandInput, GeocodeRequest, GetPlaceCommandInput, GetPlaceRequest, NeverForwarded, ReverseGeocodeCommandInput, ReverseGeocodeRequest, SearchNearbyCommandInput, SearchNearbyRequest, SearchTextCommandInput, SearchTextRequest, SuggestCommandInput, SuggestRequest, VerifyAddressCommandInput, VerifyAddressResponse, } from './client/commands.js';
-export * from '@aws/amazon-location-utilities-datatypes';
 export { GeoPlaces } from './adapters/GeoPlaces.js';
 export type { GeoPlacesDetailOptions, GeoPlacesOptions, } from './adapters/GeoPlaces.js';
 export { createTransformRequest } from './maps/createTransformRequest.js';
@@ -17,10 +16,12 @@ export { POI_CATEGORIES, setAllPoiVisibility, setPoiVisibility, } from './maps/m
 export type { PoiCategory } from './maps/mapPoi.js';
 export { buildMapStyleUrl, fetchMapStyle } from './maps/mapStyle.js';
 export type { MapStyleOptions } from './maps/mapStyle.js';
+export { refreshTokenOnUnauthorized } from './maps/mapToken.js';
+export type { MapTokenSource, MapTokens, TokenRefreshMap, } from './maps/mapToken.js';
 export { buildStaticMapUrl, fetchStaticMap, staticMapAccept, } from './maps/staticMap.js';
 export type { StaticMapFileName, StaticMapOptions } from './maps/staticMap.js';
 export { BUILDINGS, COLOR_SCHEMES, CONTOUR_DENSITIES, LABEL_SIZES, MAP_FEATURE_MODES, MAP_STYLES, POI_DENSITIES, SCALE_BAR_UNITS, SPRITE_VARIANTS, STATIC_MAP_STYLES, STYLE_POI_CATEGORIES, TERRAINS, TRAFFIC_MODES, TRAVEL_MODES, } from './maps/mapEnums.js';
 export type { Buildings, ColorScheme, ContourDensity, LabelSize, MapFeatureMode, MapStyle, PoiDensity, ScaleBarUnit, SpriteVariant, StaticMapStyle, StylePoiCategory, Terrain, TrafficMode, TravelMode, } from './maps/mapEnums.js';
 export { transformRequest } from './maps/Utils.js';
-export type { ClientConfig, GeoPlacesCommand, MapLike } from './types/index.js';
+export type { ClientConfig, CommandOutput, CommandWithOutput, GeoPlacesCommand, MapLike, } from './types/index.js';
 export type { AppConfigClaims } from './utils/tokenClaims.js';

package/dist/index.js

@@ -6,15 +6,18 @@ export { DEFAULT_MAX_ATTEMPTS, DEFAULT_OVERALL_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, }
 export { TOKEN_REFRESH_BUFFER_SECONDS, readTokenExpiry, } from './auth/tokenRefresh.js';
 // Errors
 export { FEATURE_NOT_ENTITLED, LocationServiceException, } from './errors/LocationServiceException.js';
-// Re-export AWS SDK commands and types
-export * from '@aws-sdk/client-geo-places';
-// …except the seven Places commands and their inputs, which take neither
-// IntendedUse nor Key: the service strips both from every request (#40). A
-// named export wins over the `export *` above, as GeoPlacesClient's does.
+// The AWS SDK's commands and types, and AWS Location Utilities' converters
+// (#42): generated into ./aws.ts, values by name and types by `export type *`.
+// Not `export *` of the packages themselves, which kept ~93 KB of SDK in the
+// bundle of a consumer importing only a map helper — scripts/sdk-exports.mjs
+// says why. A name this file exports itself is left out of ./aws.ts.
+export * from './aws.js';
+// The seven Places commands and their inputs are this package's own: they take
+// neither IntendedUse nor Key, which the service strips from every request
+// (#40). A named export wins over `export *`, as GeoPlacesClient's does, and
+// ./aws.ts leaves them out.
 // VerifyAddressCommand is this package's own: its route has no SDK command (#54).
 export { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, VerifyAddressCommand, } from './client/commands.js';
-// Re-export AWS Location Utilities (data type conversions)
-export * from '@aws/amazon-location-utilities-datatypes';
 // Adapters (Custom - for MapLibre integration)
 export { GeoPlaces } from './adapters/GeoPlaces.js';
 // Maps utilities
@@ -22,6 +25,7 @@ export { createTransformRequest } from './maps/createTransformRequest.js';
 export { applyMapLanguage } from './maps/mapLanguage.js';
 export { POI_CATEGORIES, setAllPoiVisibility, setPoiVisibility, } from './maps/mapPoi.js';
 export { buildMapStyleUrl, fetchMapStyle } from './maps/mapStyle.js';
+export { refreshTokenOnUnauthorized } from './maps/mapToken.js';
 export { buildStaticMapUrl, fetchStaticMap, staticMapAccept, } from './maps/staticMap.js';
 // Accepted values for every map parameter, as VALUES so a picker can be built
 // from them, plus the matching types. Case sensitive — see mapEnums.ts.

package/dist/maps/createTransformRequest.d.ts

@@ -1,4 +1,29 @@
 import type { RequestTransformFunction } from 'maplibre-gl';
+/**
+ * Does this URL belong to our API?
+ *
+ * This decides who receives the customer's bearer token, and it used to be
+ * `url.startsWith(apiUrl)` — a string test standing in for a URL test. For
+ * `apiUrl = "https://api.example.com"`, the host `api.example.com.evil.test`
+ * is a prefix match, so a style referencing
+ * `https://api.example.com.evil.test/tiles/1/2/3` was handed
+ * `Authorization: Bearer <token>` and the token left the building (#34).
+ *
+ * That is reachable because a style descriptor is DATA: its `sprite`, `glyphs`
+ * and `sources` entries are URLs the style author chose, and MapLibre asks
+ * transformRequest about every one of them. Any style not wholly ours — a
+ * customer's own, or one edited through a tool — can name a host it likes.
+ *
+ * Compared as URLs instead, which also gets host case-folding, default ports
+ * (`https://api.test:443` === `https://api.test`) and userinfo right for free,
+ * and adds a path check so a shared host serving another tenant under a
+ * different base path is not "ours" either.
+ *
+ * Fails CLOSED: anything that will not parse gets no token. The only way to
+ * reach that is a relative `apiUrl` in a runtime with no `location` to resolve
+ * it against — i.e. not a browser, which is the only place MapLibre runs.
+ */
+export declare function isOurApi(url: string, apiUrl: string): boolean;
 /**
  * Creates a transformRequest function for MapLibre that adds authentication
  * and proper Accept headers for AWS Location Service API requests.

package/dist/maps/createTransformRequest.js

@@ -22,7 +22,7 @@
  * reach that is a relative `apiUrl` in a runtime with no `location` to resolve
  * it against — i.e. not a browser, which is the only place MapLibre runs.
  */
-function isOurApi(url, apiUrl) {
+export function isOurApi(url, apiUrl) {
     const base = typeof location === 'undefined' ? undefined : location.href;
     let ours;
     let theirs;

package/dist/maps/mapPoi.d.ts

@@ -1,20 +1,25 @@
 import type { Map } from 'maplibre-gl';
 /**
  * Mapping of POI category names to their MapLibre layer IDs in AWS GeoMaps tiles.
- * Layer IDs are stable across Standard, Monochrome, and Hybrid map styles.
+ *
+ * Standard and Hybrid carry the same sixteen `poi*` layers; Monochrome carries
+ * only the three park layers, and Satellite none. A category whose layers a
+ * style does not carry is skipped. AWS publishes no list of these ids, so
+ * `test/map-poi-layers.test.ts` holds this map to each style's layers as the
+ * service served them: every `poi*` layer in exactly one category (#33).
  */
 export declare const POI_CATEGORIES: {
     readonly food_drink: readonly ["poi_100_food_drink"];
     readonly entertainment: readonly ["poi_200_going_out_entertainment"];
     readonly sights: readonly ["poi_300_sights_museums"];
-    readonly transit: readonly ["poi_400_transit"];
+    readonly transit: readonly ["poi_400_transit", "poi_400_transit_small"];
     readonly accommodations: readonly ["poi_500_accommodations"];
     readonly leisure: readonly ["poi_550_leisure_outdoor"];
     readonly shopping: readonly ["poi_600_shopping"];
-    readonly business: readonly ["poi_700_business_services"];
-    readonly facilities: readonly ["poi_800_facilities"];
+    readonly business: readonly ["poi_700_business_services", "poi_700_business_services_generic"];
+    readonly facilities: readonly ["poi_800_facilities", "poi_800_facilities_generic"];
     readonly areas: readonly ["poi_900_areas_buildings"];
-    readonly parks: readonly ["poi_landuse_park", "poi_landuse_public_complex"];
+    readonly parks: readonly ["poi_landuse_park", "poi_landuse_park_lowzoom", "poi_landuse_public_complex"];
 };
 export type PoiCategory = keyof typeof POI_CATEGORIES;
 /**