@tileflow/react-native 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/internal/camera.d.ts

@@ -1,4 +1,4 @@
-import { M as MapView, a as MapViewChangeEvent, b as MapInitialViewInputs, c as MapCameraProps } from '../contract-By3URNxS.js';
+import { M as MapView, a as MapViewChangeEvent, b as MapInitialViewInputs, c as MapCameraProps } from '../contract-BWT1jxqg.js';
 import '@maplibre/maplibre-react-native';
 import 'react';
 import 'react-native';

package/dist/internal/initial-view.d.ts

@@ -1,4 +1,4 @@
-import { b as MapInitialViewInputs, M as MapView } from '../contract-By3URNxS.js';
+import { b as MapInitialViewInputs, M as MapView } from '../contract-BWT1jxqg.js';
 import '@maplibre/maplibre-react-native';
 import 'react';
 import 'react-native';

package/dist/internal/native-admission-bridge.js

@@ -44,7 +44,9 @@ var nativeBootstrapLimits = Object.freeze({
   queueDepth: 32,
   requestBytes: 2048,
   responseBytes: 65536,
-  timeoutMs: 3e4
+  retryAfterCharacters: 64,
+  // Well inside the 30 s ticket and batch deadlines.
+  timeoutMs: 1e4
 });
 
 // src/native-admission-wire.ts
@@ -75,10 +77,11 @@ function decodeBoundedBase64(value) {
   return bytes;
 }
 function responseFromWire(reply, isAborted, release) {
-  if (!reply || !Number.isInteger(reply.status) || reply.status < 100 || reply.status > 599 || typeof reply.cacheControl !== "string" || reply.cacheControl.length > 1024)
+  if (!reply || !Number.isInteger(reply.status) || reply.status < 100 || reply.status > 599 || typeof reply.cacheControl !== "string" || reply.cacheControl.length > 1024 || reply.retryAfter !== void 0 && (typeof reply.retryAfter !== "string" || reply.retryAfter.length > nativeBootstrapLimits.retryAfterCharacters))
     throw invalid();
   const status = reply.status;
   const cacheControl = reply.cacheControl;
+  const retryAfter = reply.retryAfter || null;
   let bytes = decodeBoundedBase64(reply.bodyBase64);
   let readerTaken = false;
   let done = false;
@@ -92,7 +95,9 @@ function responseFromWire(reply, isAborted, release) {
     status,
     headers: Object.freeze({
       get(name) {
-        return name.toLowerCase() === "cache-control" ? cacheControl : null;
+        const header = name.toLowerCase();
+        if (header === "cache-control") return cacheControl;
+        return header === "retry-after" ? retryAfter : null;
       }
     }),
     body: Object.freeze({

package/dist/internal/native-admission.d.ts

@@ -1,5 +1,5 @@
 import { e as NativeAdmissionCode, a as NativeAdmissionResource, f as NativeAdmissionBridge, d as NativeRemovalAck } from '../native-admission-contract-DFLfUP9X.js';
-import { HostedNativeResourcePolicy, createHostedNativeSessionController, HostedNativeSessionFetch, HostedNativeSessionController } from './session.js';
+import { HostedNativeResourcePolicy, createHostedNativeSessionController, HostedNativeSessionFetch, HostedNativeSessionErrorCode, HostedNativeSessionErrorKind, HostedNativeSessionController } from './session.js';
 
 type SessionInput = Parameters<typeof createHostedNativeSessionController>[0];
 type NativeMapAdmissionInput = Omit<SessionInput, 'fetch' | 'sessionIdFactory'> & Readonly<{
@@ -7,6 +7,12 @@ type NativeMapAdmissionInput = Omit<SessionInput, 'fetch' | 'sessionIdFactory'>
     sessionIdFactory?: () => string;
     resources: readonly NativeAdmissionResource[];
     onRetired?: () => void;
+    /** Each time the session enters an error, including after first preparation. */
+    onSessionError?: (error: Readonly<{
+        code: HostedNativeSessionErrorCode;
+        kind: HostedNativeSessionErrorKind;
+        reason?: string;
+    }>) => void;
 }>;
 type NativeMapAdmission = Readonly<{
     context: string;
@@ -25,6 +31,10 @@ type NativeMapAdmission = Readonly<{
     extendResources(resources: readonly NativeAdmissionResource[]): Promise<Readonly<{
         resources: number;
     }>>;
+    /** Lets a stopped or delayed session bootstrap again on its next acquisition. */
+    retry(): void;
+    /** Milliseconds until the session may bootstrap after a recoverable failure, or null. */
+    retryDelay(): number | null;
     retire(): Promise<Readonly<{
         retired: true;
     }>>;
@@ -63,6 +73,10 @@ declare function createNativeAdmissionOwner(options: {
         extendResources(resources: readonly NativeAdmissionResource[]): Promise<Readonly<{
             resources: number;
         }>>;
+        /** Lets a stopped or delayed session bootstrap again on its next acquisition. */
+        retry(): void;
+        /** Milliseconds until the session may bootstrap after a recoverable failure, or null. */
+        retryDelay(): number | null;
         retire(): Promise<Readonly<{
             retired: true;
         }>>;

package/dist/internal/native-admission.js

@@ -338,6 +338,13 @@ var REFRESH_MARGIN_MS = 3e4;
 var ROTATION_AGE_MS = 6 * 60 * 60 * 1e3;
 var ROTATION_REQUEST_LIMIT = 1e4;
 var FUTURE_ISSUE_SKEW_MS = 3e4;
+var RETRY_INITIAL_MS = 1e3;
+var RETRY_LIMIT_MS = 6e4;
+var RETRY_AFTER_LIMIT_MS = 15 * 60 * 1e3;
+var RETRY_AFTER_SECONDS = /^\d{1,10}$/u;
+var QUOTA_CODES = /* @__PURE__ */ new Set(["COMMERCIAL_MAP_LIMIT_REACHED", "COMMERCIAL_SPENDING_LIMIT_REACHED"]);
+var SERVICE_CODE = /^[A-Z][A-Z0-9_]{0,63}$/u;
+var SERVICE_CODE_BODY_LIMIT = 4096;
 var MOBILE_CREDENTIAL = /^tf_public_[0-9a-f]{48}$/u;
 var MAP_ID = /^map_[A-Za-z0-9_-]{16}$/u;
 var CREDENTIAL_ID = /^key_[A-Za-z0-9_-]{8,80}$/u;
@@ -376,6 +383,14 @@ var SUCCESS_KEYS = /* @__PURE__ */ new Set([
   "tilesetIds"
 ]);
 var RESTART_KEYS = /* @__PURE__ */ new Set(["code", "error", "retryWithNewSession", "sessionId"]);
+var TERMINAL_CODES = /* @__PURE__ */ new Set([
+  "NATIVE_SESSION_INPUT_INVALID",
+  "NATIVE_SESSION_CREDENTIAL_REJECTED",
+  "NATIVE_SESSION_MAP_MISMATCH",
+  "NATIVE_SESSION_MAP_NOT_FOUND",
+  "NATIVE_SESSION_QUOTA_EXCEEDED",
+  "NATIVE_SESSION_REJECTED"
+]);
 var ERROR_MESSAGES = {
   NATIVE_SESSION_INPUT_INVALID: "Native session configuration is invalid.",
   NATIVE_SESSION_RESPONSE_TOO_LARGE: "Native session response exceeded its byte limit.",
@@ -387,18 +402,22 @@ var ERROR_MESSAGES = {
   NATIVE_SESSION_MAP_NOT_FOUND: "Native session Map was not found.",
   NATIVE_SESSION_QUOTA_EXCEEDED: "Native session quota was exceeded.",
   NATIVE_SESSION_REJECTED: "Native session request was rejected.",
+  NATIVE_SESSION_RATE_LIMITED: "Native session requests are rate limited.",
   NATIVE_SESSION_UNAVAILABLE: "Native session service is unavailable.",
   NATIVE_SESSION_REPLACED: "Native session binding was replaced.",
   NATIVE_SESSION_DISPOSED: "Native session controller is disposed."
 };
 var HostedNativeSessionError = class extends Error {
-  constructor(code) {
+  constructor(code, reason) {
     super(ERROR_MESSAGES[code]);
     __publicField(this, "code");
     __publicField(this, "kind");
     this.name = "HostedNativeSessionError";
     this.code = code;
     this.kind = errorKind(code);
+    if (code === "NATIVE_SESSION_REJECTED" && typeof reason === "string" && SERVICE_CODE.test(reason)) {
+      this.reason = reason;
+    }
   }
 };
 function createHostedNativeSessionController(input) {
@@ -508,7 +527,29 @@ function createHostedNativeSessionController(input) {
       })
     );
   }
+  let terminal = null;
+  let failures = 0;
+  let retryAt = null;
+  let retryError = null;
+  function clearRetry() {
+    failures = 0;
+    retryAt = null;
+    retryError = null;
+  }
+  function delayRetry(error) {
+    let at;
+    try {
+      at = readClock();
+    } catch {
+      return;
+    }
+    if (retryAt === null || at >= retryAt) failures = Math.min(failures + 1, 16);
+    const backoff = Math.min(RETRY_INITIAL_MS * 2 ** (failures - 1), RETRY_LIMIT_MS);
+    retryAt = Math.max(retryAt ?? at, at + Math.max(backoff, retryAfterDelays.get(error) ?? 0));
+    retryError = safeError(error);
+  }
   function rotateIfRequired(at) {
+    if (terminal) throw errorFrom(terminal);
     if (!activeSession || binding.kind !== "hosted") return;
     if (at - activeSession.startedAt < ROTATION_AGE_MS && activeSession.requestCount < ROTATION_REQUEST_LIMIT) {
       return;
@@ -542,6 +583,7 @@ function createHostedNativeSessionController(input) {
     return current;
   }
   async function ensureAuthority(session, at) {
+    if (terminal) throw errorFrom(terminal);
     if (session.authority && session.authority.clockEpoch === clock.epoch && session.authority.validUntil - at > REFRESH_MARGIN_MS) {
       return { authority: session.authority, session };
     }
@@ -549,20 +591,28 @@ function createHostedNativeSessionController(input) {
     if (binding.kind !== "hosted") {
       throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
     }
+    if (retryAt !== null && retryError && at < retryAt) {
+      if (session.authority && session.authority.clockEpoch === clock.epoch && session.authority.validUntil > at) {
+        return { authority: session.authority, session };
+      }
+      throw errorFrom(retryError);
+    }
     const operationBinding = binding;
     const abort = new SessionAbortController();
     operations.add(abort);
     const operation = {
       abort,
       promise: Promise.resolve().then(async () => {
-        session.error = null;
-        publishSession(session, "loading");
-        if (abort.signal.aborted) throw abort.error();
         try {
+          if (abort.signal.aborted) throw abort.error();
+          session.error = null;
+          publishSession(session, "loading");
+          if (abort.signal.aborted) throw abort.error();
           const result = await bootstrap(session, operationBinding, abort, true, true);
           if (abort.signal.aborted) throw abort.error();
           result.session.authority = result.authority;
           result.session.error = null;
+          if (binding === operationBinding) clearRetry();
           if (activeSession === result.session) {
             publishSession(result.session, "ready");
             if (abort.signal.aborted) throw abort.error();
@@ -571,8 +621,26 @@ function createHostedNativeSessionController(input) {
         } catch (error) {
           const normalized = abort.signal.aborted ? abort.error() : normalizeError(error);
           const target = latestSession(session);
+          if (normalized.kind === "terminal" && binding === operationBinding && !terminal) {
+            const failure = safeError(normalized);
+            terminal = failure;
+            const rejectedSession = activeSession;
+            if (rejectedSession) {
+              rejectedSession.authority = null;
+              rejectedSession.error = failure;
+            }
+            for (const pending of [...operations]) {
+              pending.abort(failure.code, failure.reason);
+            }
+            if (binding === operationBinding && rejectedSession) {
+              publishSession(rejectedSession, "error", failure);
+            }
+          }
+          if (normalized.kind === "recoverable" && binding === operationBinding && !terminal) {
+            delayRetry(normalized);
+          }
           if (normalized.code !== "NATIVE_SESSION_REPLACED" && normalized.code !== "NATIVE_SESSION_DISPOSED") {
-            target.error = Object.freeze({ code: normalized.code, kind: normalized.kind });
+            target.error = safeError(normalized);
             publishSession(target, "error", target.error);
           }
           throw normalized;
@@ -598,20 +666,29 @@ function createHostedNativeSessionController(input) {
     if (abort.signal.aborted) throw abort.error();
     const expectedSurfaceId = session.authority?.public.surfaceId ?? session.requestedSurfaceId;
     const response = await fetchResponse(hostedBinding, session, expectedSurfaceId, abort);
-    const source = await readBoundedResponse(response, abort);
+    const { source, size } = await readBoundedResponse(response, abort);
     let body;
     try {
       body = source.length ? JSON.parse(source) : null;
     } catch {
-      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_JSON_INVALID");
+      if (response.status === 201) {
+        throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_JSON_INVALID");
+      }
+      body = null;
     }
-    if (response.status === 409 && allowRestart && isExactRestart(body, session.sessionId)) {
+    if (response.status === 409 && isExactRestart(body, session.sessionId)) {
+      if (!allowRestart) throw new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
       assertCurrentSession(session, hostedBinding);
       const replacement = redirectSession(session, readClock());
       if (abort.signal.aborted) throw abort.error();
       return bootstrap(replacement, hostedBinding, abort, false, false);
     }
-    if (response.status !== 201) throw statusError(response.status);
+    if (response.status !== 201) {
+      const failure = statusError(response.status, body, size);
+      const delay = retryAfterMs(response.headers, now);
+      if (delay !== null) retryAfterDelays.set(failure, delay);
+      throw failure;
+    }
     if (!hasNoStore(response.headers.get("cache-control"))) {
       throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
     }
@@ -684,6 +761,16 @@ function createHostedNativeSessionController(input) {
     if (binding.kind === "direct" || !activeSession) {
       return Object.freeze({ status: "idle", source: "direct", lifecycle });
     }
+    if (terminal) {
+      return Object.freeze({
+        status: "error",
+        source: "hosted",
+        lifecycle,
+        mapId: binding.mapId,
+        sessionId: activeSession.sessionId,
+        error: terminal
+      });
+    }
     if (activeSession.operation) {
       return Object.freeze({
         status: "loading",
@@ -735,6 +822,7 @@ function createHostedNativeSessionController(input) {
       if (bindingGeneration !== expectedGeneration) {
         throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
       }
+      if (terminal) throw errorFrom(terminal);
       checkedAt = readClock();
       if (resolved.authority.clockEpoch === clock.epoch && resolved.authority.validUntil > checkedAt) {
         admittedAuthorities.set(resolved.authority.public, resolved.authority);
@@ -789,7 +877,7 @@ function createHostedNativeSessionController(input) {
       }
     },
     transportBudget(authority) {
-      if (disposed || lifecycle !== "foreground") return 0;
+      if (disposed || terminal || lifecycle !== "foreground") return 0;
       const stored = admittedAuthorities.get(authority);
       if (!stored || stored.bindingGeneration !== bindingGeneration) return 0;
       try {
@@ -808,6 +896,11 @@ function createHostedNativeSessionController(input) {
     async resume() {
       if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
       lifecycle = "foreground";
+      if (terminal) {
+        const error = errorFrom(terminal);
+        publish(currentSnapshot());
+        throw error;
+      }
       if (binding.kind === "direct" || !activeSession) {
         publish(currentSnapshot());
         return;
@@ -830,9 +923,27 @@ function createHostedNativeSessionController(input) {
       bindingGeneration += 1;
       for (const operation of operations) operation.abort("NATIVE_SESSION_REPLACED");
       binding = next;
+      terminal = null;
+      clearRetry();
       activeSession = next.kind === "hosted" ? createSession(next.surfaceId, readClock()) : null;
       publish(snapshotIdle(binding, activeSession, lifecycle));
     },
+    retry() {
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (!terminal && retryAt === null) return;
+      terminal = null;
+      clearRetry();
+      if (activeSession && !activeSession.operation) activeSession.error = null;
+      publish(currentSnapshot());
+    },
+    retryDelay() {
+      if (disposed || terminal || retryAt === null) return null;
+      try {
+        return Math.max(0, Math.ceil(retryAt - readClock()));
+      } catch {
+        return null;
+      }
+    },
     subscribe(listener) {
       if (typeof listener !== "function") {
         throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
@@ -927,7 +1038,8 @@ function parseSuccess(value, binding, expectedSessionId, expectedSurfaceId) {
   const issuedAtMs = parseExactIso(value.issuedAt);
   const serverTimeMs = parseExactIso(value.serverTime);
   const expiresAtMs = parseExactIso(value.expiresAt);
-  if (issuedAtMs > serverTimeMs + FUTURE_ISSUE_SKEW_MS || expiresAtMs <= serverTimeMs || expiresAtMs <= issuedAtMs || expiresAtMs - issuedAtMs > MAX_GRANT_LIFETIME_MS || expiresAtMs - issuedAtMs > MAX_GRANT_LIFETIME_MS) {
+  if (issuedAtMs > serverTimeMs + FUTURE_ISSUE_SKEW_MS || expiresAtMs <= serverTimeMs || expiresAtMs <= issuedAtMs || expiresAtMs - issuedAtMs > MAX_GRANT_LIFETIME_MS || // The local deadline is derived from serverTime, so this also bounds the transport budget.
+  expiresAtMs - serverTimeMs > MAX_GRANT_LIFETIME_MS) {
     throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
   }
   const authority = {
@@ -1058,7 +1170,7 @@ async function readBoundedResponse(response, abort) {
     bytes.set(chunk, offset);
     offset += chunk.byteLength;
   }
-  return decodeUtf8(bytes);
+  return { source: decodeUtf8(bytes), size };
 }
 function decodeUtf8(bytes) {
   let result = "";
@@ -1106,18 +1218,60 @@ function decodeUtf8(bytes) {
 function hasNoStore(value) {
   return typeof value === "string" && value.split(",").some((part) => part.trim().toLowerCase() === "no-store");
 }
-function statusError(status) {
+function statusError(status, body, size) {
   if (status === 401) return new HostedNativeSessionError("NATIVE_SESSION_CREDENTIAL_REJECTED");
   if (status === 403) return new HostedNativeSessionError("NATIVE_SESSION_MAP_MISMATCH");
   if (status === 404) return new HostedNativeSessionError("NATIVE_SESSION_MAP_NOT_FOUND");
-  if (status === 429) return new HostedNativeSessionError("NATIVE_SESSION_QUOTA_EXCEEDED");
-  if (status === 503) return new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
-  return new HostedNativeSessionError("NATIVE_SESSION_REJECTED");
+  if (status === 429) {
+    return new HostedNativeSessionError(
+      isRecord(body) && typeof body.code === "string" && QUOTA_CODES.has(body.code) ? "NATIVE_SESSION_QUOTA_EXCEEDED" : "NATIVE_SESSION_RATE_LIMITED"
+    );
+  }
+  if (status === 408 || status >= 500 && status <= 599) {
+    return new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
+  }
+  if (status >= 400 && status <= 499) {
+    return new HostedNativeSessionError(
+      "NATIVE_SESSION_REJECTED",
+      size <= SERVICE_CODE_BODY_LIMIT && isRecord(body) && typeof body.code === "string" ? body.code : void 0
+    );
+  }
+  return new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+}
+function safeError(error) {
+  return Object.freeze(
+    error.reason === void 0 ? { code: error.code, kind: error.kind } : { code: error.code, kind: error.kind, reason: error.reason }
+  );
+}
+function errorFrom(error) {
+  return new HostedNativeSessionError(error.code, error.reason);
+}
+var retryAfterDelays = /* @__PURE__ */ new WeakMap();
+function retryAfterMs(headers, now) {
+  let value;
+  try {
+    value = headers.get("retry-after");
+  } catch {
+    return null;
+  }
+  if (typeof value !== "string" || value.length > 64) return null;
+  const text = value.trim();
+  let delay;
+  if (RETRY_AFTER_SECONDS.test(text)) delay = Number(text) * 1e3;
+  else {
+    const date = Date.parse(text);
+    if (!Number.isFinite(date)) return null;
+    try {
+      delay = date - readWallClock(now);
+    } catch {
+      return null;
+    }
+  }
+  return Math.min(Math.max(0, delay), RETRY_AFTER_LIMIT_MS);
 }
 function errorKind(code) {
   if (code === "NATIVE_SESSION_DISPOSED" || code === "NATIVE_SESSION_REPLACED") return "cancelled";
-  if (code === "NATIVE_SESSION_UNAVAILABLE") return "recoverable";
-  return "terminal";
+  return TERMINAL_CODES.has(code) ? "terminal" : "recoverable";
 }
 function normalizeError(error, fallback = "NATIVE_SESSION_RESPONSE_INVALID") {
   return error instanceof HostedNativeSessionError ? error : new HostedNativeSessionError(fallback);
@@ -1140,12 +1294,13 @@ async function cancelResponse(response) {
   } catch {
   }
 }
-var _aborted, _code, _listeners;
+var _aborted, _code, _reason, _listeners;
 var SessionAbortController = class {
   constructor() {
     __publicField(this, "signal");
     __privateAdd(this, _aborted, false);
     __privateAdd(this, _code, "NATIVE_SESSION_REPLACED");
+    __privateAdd(this, _reason);
     __privateAdd(this, _listeners, /* @__PURE__ */ new Set());
     const isAborted = () => __privateGet(this, _aborted);
     this.signal = Object.freeze({
@@ -1160,9 +1315,10 @@ var SessionAbortController = class {
       }
     });
   }
-  abort(code) {
+  abort(code, reason) {
     if (__privateGet(this, _aborted)) return;
     __privateSet(this, _code, code);
+    __privateSet(this, _reason, reason);
     __privateSet(this, _aborted, true);
     for (const listener of [...__privateGet(this, _listeners)]) {
       try {
@@ -1173,11 +1329,12 @@ var SessionAbortController = class {
     __privateGet(this, _listeners).clear();
   }
   error() {
-    return new HostedNativeSessionError(__privateGet(this, _code));
+    return new HostedNativeSessionError(__privateGet(this, _code), __privateGet(this, _reason));
   }
 };
 _aborted = new WeakMap();
 _code = new WeakMap();
+_reason = new WeakMap();
 _listeners = new WeakMap();
 function raceWithAbort(promise, controller) {
   if (controller.signal.aborted) return Promise.reject(controller.error());
@@ -1416,6 +1573,8 @@ function createNativeAdmissionOwner(options) {
     try {
       resources = normalizeNativeResources(input.resources);
       if (input.onRetired !== void 0 && typeof input.onRetired !== "function") throw cancel();
+      if (input.onSessionError !== void 0 && typeof input.onSessionError !== "function")
+        throw cancel();
     } catch {
       throw cancel("NATIVE_ADMISSION_INVALID");
     }
@@ -1476,6 +1635,17 @@ function createNativeAdmissionOwner(options) {
         controller,
         handle: void 0
       };
+      let reported = null;
+      const releaseSession = controller.subscribe((state) => {
+        const code = state.status === "error" ? state.error.code : null;
+        if (!context.live || code === reported) return;
+        reported = code;
+        if (state.status !== "error") return;
+        try {
+          input.onSessionError?.(Object.freeze({ ...state.error }));
+        } catch {
+        }
+      });
       context.handle = Object.freeze({
         context: context.id,
         generation: context.generation,
@@ -1505,9 +1675,26 @@ function createNativeAdmissionOwner(options) {
         discriminate: catalog.discriminate,
         discriminateForTest: catalog.discriminate,
         extendResources: catalog.extend,
+        retry() {
+          if (!context.live || disposed) return;
+          try {
+            controller.retry?.();
+          } catch {
+          }
+        },
+        retryDelay() {
+          if (!context.live || disposed) return null;
+          try {
+            const delay = controller.retryDelay?.() ?? null;
+            return delay !== null && Number.isSafeInteger(delay) && delay >= 0 ? delay : null;
+          } catch {
+            return null;
+          }
+        },
         retire() {
           if (retirement) return retirement;
           context.live = false;
+          releaseSession();
           context.batch = null;
           context.tickets.clear();
           catalog.retire();

package/dist/internal/native-appearance.d.ts

@@ -1,4 +1,4 @@
-import { z as MapThemeSelection, f as MapColorScheme } from '../contract-By3URNxS.js';
+import { B as MapThemeSelection, g as MapColorScheme } from '../contract-BWT1jxqg.js';
 import '@maplibre/maplibre-react-native';
 import 'react';
 import 'react-native';

package/dist/internal/session.d.ts

@@ -42,12 +42,14 @@ type HostedNativeSessionFetchResponse = Readonly<{
     }> | null;
 }>;
 type HostedNativeSessionFetch = (url: string, init: HostedNativeSessionFetchInit) => Promise<HostedNativeSessionFetchResponse>;
-type HostedNativeSessionErrorCode = 'NATIVE_SESSION_INPUT_INVALID' | 'NATIVE_SESSION_RESPONSE_TOO_LARGE' | 'NATIVE_SESSION_RESPONSE_UTF8_INVALID' | 'NATIVE_SESSION_RESPONSE_JSON_INVALID' | 'NATIVE_SESSION_RESPONSE_INVALID' | 'NATIVE_SESSION_CREDENTIAL_REJECTED' | 'NATIVE_SESSION_MAP_MISMATCH' | 'NATIVE_SESSION_MAP_NOT_FOUND' | 'NATIVE_SESSION_QUOTA_EXCEEDED' | 'NATIVE_SESSION_REJECTED' | 'NATIVE_SESSION_UNAVAILABLE' | 'NATIVE_SESSION_REPLACED' | 'NATIVE_SESSION_DISPOSED';
+type HostedNativeSessionErrorCode = 'NATIVE_SESSION_INPUT_INVALID' | 'NATIVE_SESSION_RESPONSE_TOO_LARGE' | 'NATIVE_SESSION_RESPONSE_UTF8_INVALID' | 'NATIVE_SESSION_RESPONSE_JSON_INVALID' | 'NATIVE_SESSION_RESPONSE_INVALID' | 'NATIVE_SESSION_CREDENTIAL_REJECTED' | 'NATIVE_SESSION_MAP_MISMATCH' | 'NATIVE_SESSION_MAP_NOT_FOUND' | 'NATIVE_SESSION_QUOTA_EXCEEDED' | 'NATIVE_SESSION_REJECTED' | 'NATIVE_SESSION_RATE_LIMITED' | 'NATIVE_SESSION_UNAVAILABLE' | 'NATIVE_SESSION_REPLACED' | 'NATIVE_SESSION_DISPOSED';
 type HostedNativeSessionErrorKind = 'terminal' | 'recoverable' | 'cancelled';
 declare class HostedNativeSessionError extends Error {
     readonly code: HostedNativeSessionErrorCode;
     readonly kind: HostedNativeSessionErrorKind;
-    constructor(code: HostedNativeSessionErrorCode);
+    /** For `NATIVE_SESSION_REJECTED`, the service's code when its answer carried one. */
+    readonly reason?: string;
+    constructor(code: HostedNativeSessionErrorCode, reason?: string);
 }
 type HostedNativeSessionAuthority = Readonly<{
     grant: string;
@@ -71,6 +73,7 @@ type HostedNativeResourcePolicy = Readonly<Pick<HostedNativeSessionAuthority, 'm
 type SafeError = Readonly<{
     code: HostedNativeSessionErrorCode;
     kind: HostedNativeSessionErrorKind;
+    reason?: string;
 }>;
 type Lifecycle = 'foreground' | 'background';
 type HostedNativeSessionState = Readonly<{
@@ -112,6 +115,10 @@ type HostedNativeSessionController = Readonly<{
     background(): void;
     resume(): Promise<void>;
     replaceBinding(binding: HostedNativeSessionBinding): void;
+    /** Clears a terminal stop and any retry delay; the next acquisition bootstraps again. */
+    retry?(): void;
+    /** Milliseconds until a bootstrap may follow a recoverable failure, or null without one. */
+    retryDelay?(): number | null;
     subscribe(listener: (state: HostedNativeSessionState) => void): () => void;
     dispose(): void;
 }>;