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

package/dist/index.js

@@ -17,10 +17,10 @@ import {
 import {
   Fragment,
   useImperativeHandle,
-  useLayoutEffect as useLayoutEffect2,
-  useMemo as useMemo2,
+  useLayoutEffect as useLayoutEffect3,
+  useMemo as useMemo3,
   useRef,
-  useState,
+  useState as useState2,
   useSyncExternalStore
 } from "react";
 import { AppState, findNodeHandle, View as View2 } from "react-native";
@@ -1268,6 +1268,9 @@ function createMapLifecycle(create, retire) {
     getSourceState() {
       return active?.owner.getSourceState();
     },
+    retry() {
+      active?.owner.retry();
+    },
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);
@@ -1350,9 +1353,157 @@ function createMapLifecycle(create, retire) {
   });
 }
 
+// src/native-boundary-feature-state.tsx
+import { VectorSource } from "@maplibre/maplibre-react-native";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useState } from "react";
+import {
+  createBoundaryFeatureState,
+  tileflowBoundaryFamilies
+} from "@tileflow/core/native";
+
+// src/native-boundary-feature-state-owner.ts
+var retryDelaysMs = [16, 50, 150, 400, 1e3];
+var timer = (run, delayMs) => {
+  const handle = setTimeout(run, delayMs);
+  return () => clearTimeout(handle);
+};
+function createNativeBoundaryFeatureStateOwner(sourceId, schedule = timer) {
+  const listeners = /* @__PURE__ */ new Set();
+  let source = null;
+  let style = {};
+  let loaded = false;
+  let replacing = false;
+  const present = () => !replacing && loaded && source !== null && declaredVectorSource(style, sourceId);
+  let notified = false;
+  const notify = () => {
+    const next = present();
+    if (next === notified) return;
+    notified = next;
+    for (const listener of [...listeners]) listener();
+  };
+  const absentThenNotify = () => {
+    replacing = true;
+    notify();
+    replacing = false;
+    notify();
+  };
+  let attempt = 0;
+  let cancelRetry;
+  const reset = () => {
+    cancelRetry?.();
+    cancelRetry = void 0;
+    attempt = 0;
+  };
+  const rejected = (target) => {
+    if (cancelRetry || target !== source || !present() || attempt >= retryDelaysMs.length) return;
+    cancelRetry = schedule(() => {
+      cancelRetry = void 0;
+      if (target === source && present()) absentThenNotify();
+    }, retryDelaysMs[attempt++]);
+  };
+  const write = (operation) => {
+    const target = source;
+    if (!target) return;
+    void operation(target).then(
+      () => {
+        if (target === source && !cancelRetry) attempt = 0;
+      },
+      () => rejected(target)
+    );
+  };
+  const map = {
+    getSource: (id) => id === sourceId && present() ? {} : void 0,
+    getStyle: () => style,
+    on: (_type, listener) => listeners.add(listener),
+    off: (_type, listener) => listeners.delete(listener),
+    setFeatureState({ id, sourceLayer }, state) {
+      if (!sourceLayer) return;
+      write((target) => target.setFeatureState({ id, sourceLayer }, state));
+    },
+    removeFeatureState({ id, sourceLayer }, key2) {
+      if (!sourceLayer || id === void 0) return;
+      write((target) => target.removeFeatureState({ id, sourceLayer }, key2));
+    }
+  };
+  return Object.freeze({
+    map,
+    /** A newly committed style is loading until MapLibre reports it loaded. */
+    setStyle(next, nextLoaded) {
+      if (next !== style) {
+        reset();
+        replacing = true;
+        notify();
+        replacing = false;
+      }
+      style = next;
+      loaded = nextLoaded;
+      notify();
+    },
+    setSource(next) {
+      if (next !== source) reset();
+      source = next;
+      notify();
+    }
+  });
+}
+function declaredVectorSource(style, id) {
+  const value = style.sources?.[id];
+  return value?.type === "vector";
+}
+
+// src/native-boundary-feature-state.tsx
+import { jsx } from "react/jsx-runtime";
+function NativeBoundaryFeatureState({
+  input,
+  style,
+  loaded
+}) {
+  const family = input.family ?? "boundaries";
+  const sourceId = Object.hasOwn(tileflowBoundaryFamilies, family) ? tileflowBoundaryFamilies[family].sourceId : family;
+  const owner = useMemo(() => createNativeBoundaryFeatureStateOwner(sourceId), [sourceId]);
+  const [controller, setController] = useState(null);
+  const [adopted, setAdopted] = useState(false);
+  const bind2 = useCallback(
+    (node) => {
+      owner.setSource(node);
+      setAdopted(node !== null);
+    },
+    [owner]
+  );
+  useLayoutEffect(() => owner.setStyle(style, loaded), [owner, style, loaded]);
+  const { labels, state, values } = input;
+  useEffect(() => {
+    const created = createBoundaryFeatureState(owner.map, {
+      family,
+      ...labels === void 0 ? {} : { labels },
+      ...state === void 0 ? {} : { state }
+    });
+    setController(created);
+    return () => {
+      setController(null);
+      created.dispose();
+    };
+  }, [owner, family, labels, state]);
+  useEffect(() => {
+    if (!controller) return;
+    if (values) controller.set(values);
+    else controller.clear();
+  }, [controller, values]);
+  if (!declaredVectorSource(style, sourceId) || !loaded && !adopted) return null;
+  const tiles = (style.sources?.[sourceId]).tiles;
+  return /* @__PURE__ */ jsx(
+    VectorSource,
+    {
+      id: sourceId,
+      ref: bind2,
+      ...Array.isArray(tiles) ? { tiles } : {}
+    }
+  );
+}
+
 // src/native-marker.tsx
 import { Marker as NativeMarker } from "@maplibre/maplibre-react-native";
-import { useLayoutEffect, useMemo } from "react";
+import { useLayoutEffect as useLayoutEffect2, useMemo as useMemo2 } from "react";
 import { Pressable, processColor, View } from "react-native";
 
 // src/native-marker-model.ts
@@ -1399,7 +1550,7 @@ function resolveNativeMarkerContent(context, render) {
 }
 
 // src/native-marker.tsx
-import { jsx } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 var button = Object.freeze({
   minWidth: 44,
   minHeight: 44,
@@ -1421,7 +1572,7 @@ function NativeAnnotationMarker({
   lifecycle,
   renderMarker
 }) {
-  const model = useMemo(() => nativeMarkerModel(annotation, enabled), [annotation, enabled]);
+  const model = useMemo2(() => nativeMarkerModel(annotation, enabled), [annotation, enabled]);
   const rendered = resolveNativeMarkerContent(model.context, renderMarker);
   let color = defaultColor;
   let invalidColor = false;
@@ -1435,14 +1586,14 @@ function NativeAnnotationMarker({
     }
   }
   const diagnostic = rendered.diagnostic ?? (!rendered.content && invalidColor ? "INVALID_FIELD" : void 0);
-  useLayoutEffect(() => {
+  useLayoutEffect2(() => {
     if (diagnostic) lifecycle.interactionDiagnostic(sceneKey, diagnostic);
   }, [annotation, diagnostic, lifecycle, sceneKey]);
   const press = (event) => {
     event?.stopPropagation();
     lifecycle.markerPress(sceneKey, annotation);
   };
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx2(
     NativeMarker,
     {
       id: `tileflow-annotation-${model.key}`,
@@ -1453,7 +1604,7 @@ function NativeAnnotationMarker({
         lifecycle.beginTouch(sceneKey);
         press();
       },
-      children: /* @__PURE__ */ jsx(
+      children: /* @__PURE__ */ jsx2(
         Pressable,
         {
           accessible: false,
@@ -1464,14 +1615,14 @@ function NativeAnnotationMarker({
             event.stopPropagation();
           },
           onPress: press,
-          children: /* @__PURE__ */ jsx(
+          children: /* @__PURE__ */ jsx2(
             View,
             {
               pointerEvents: "none",
               accessible: false,
               accessibilityElementsHidden: true,
               importantForAccessibility: "no-hide-descendants",
-              children: rendered.content ?? /* @__PURE__ */ jsx(View, { style: [dot, { backgroundColor: color }] })
+              children: rendered.content ?? /* @__PURE__ */ jsx2(View, { style: [dot, { backgroundColor: color }] })
             }
           )
         }
@@ -1809,6 +1960,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;
@@ -1847,6 +2005,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.",
@@ -1858,18 +2024,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) {
@@ -1979,7 +2149,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;
@@ -2013,6 +2205,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 };
     }
@@ -2020,20 +2213,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();
@@ -2042,8 +2243,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 failure3 = safeError(normalized);
+            terminal = failure3;
+            const rejectedSession = activeSession;
+            if (rejectedSession) {
+              rejectedSession.authority = null;
+              rejectedSession.error = failure3;
+            }
+            for (const pending of [...operations]) {
+              pending.abort(failure3.code, failure3.reason);
+            }
+            if (binding === operationBinding && rejectedSession) {
+              publishSession(rejectedSession, "error", failure3);
+            }
+          }
+          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;
@@ -2069,20 +2288,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 failure3 = statusError(response.status, body, size);
+      const delay = retryAfterMs(response.headers, now);
+      if (delay !== null) retryAfterDelays.set(failure3, delay);
+      throw failure3;
+    }
     if (!hasNoStore(response.headers.get("cache-control"))) {
       throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
     }
@@ -2155,6 +2383,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",
@@ -2206,6 +2444,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);
@@ -2260,7 +2499,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 {
@@ -2279,6 +2518,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;
@@ -2301,9 +2545,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");
@@ -2398,7 +2660,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 = {
@@ -2529,7 +2792,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 = "";
@@ -2577,18 +2840,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);
@@ -2611,12 +2916,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({
@@ -2631,9 +2937,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 {
@@ -2644,11 +2951,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());
@@ -2887,6 +3195,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");
     }
@@ -2947,6 +3257,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,
@@ -2976,9 +3297,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();
@@ -5502,6 +5840,20 @@ function themeBlendKey(blend) {
 }
 
 // src/mounted-map-owner.ts
+var timer2 = (run, delayMs) => {
+  const handle = setTimeout(run, delayMs);
+  return () => clearTimeout(handle);
+};
+var REOPEN_LIMIT = 3;
+var sessionErrorCodes = /* @__PURE__ */ new Set([
+  "NATIVE_SESSION_CREDENTIAL_REJECTED",
+  "NATIVE_SESSION_MAP_MISMATCH",
+  "NATIVE_SESSION_MAP_NOT_FOUND",
+  "NATIVE_SESSION_QUOTA_EXCEEDED",
+  "NATIVE_SESSION_REJECTED",
+  "NATIVE_SESSION_INPUT_INVALID"
+]);
+var SERVICE_CODE2 = /^[A-Z][A-Z0-9_]{0,63}$/u;
 function themeSource(source, name3) {
   const theme = Object.hasOwn(source.map.themes, name3) ? source.map.themes[name3] : void 0;
   if (!theme) throw new NativePreparationError();
@@ -5584,7 +5936,9 @@ function createMountedMapOwner(ports2) {
   let sourceState;
   let current;
   let lastReadiness = "";
+  let reopenings = 0;
   let disposal;
+  const schedule = ports2.schedule ?? timer2;
   const retired = /* @__PURE__ */ new Set();
   const tasks = /* @__PURE__ */ new Set();
   const listeners = /* @__PURE__ */ new Set();
@@ -5619,10 +5973,11 @@ function createMountedMapOwner(ports2) {
       if (lastReadiness === identity) return;
       lastReadiness = identity;
     }
+    if (event.type === "load") reopenings = 0;
     try {
       let result;
       if (event.type === "load") result = props.onLoad?.(event);
-      else if (event.type === "renderer-error" || event.type === "source-error")
+      else if (event.type === "renderer-error" || event.type === "source-error" || event.type === "session-error")
         result = props.onError?.(event);
       else if (event.type === "readiness-change") result = props.onReadinessChange?.(event);
       else result = props.onThemeChange?.(event);
@@ -5699,11 +6054,29 @@ function createMountedMapOwner(ports2) {
       }
     }
   }
+  function cancelRetry(epoch) {
+    const cancel = epoch.retry;
+    epoch.retry = void 0;
+    cancel?.();
+  }
+  function retryLater(epoch, source) {
+    const delay = epoch.map?.retryDelay();
+    if (typeof delay !== "number") return;
+    cancelRetry(epoch);
+    const cancel = schedule(() => {
+      if (epoch.retry !== cancel) return;
+      epoch.retry = void 0;
+      if (!disposed && foreground && current === epoch && epoch.live && core.state === source)
+        prepare(epoch, source);
+    }, delay);
+    epoch.retry = cancel;
+  }
   function retire(epoch) {
     if (epoch.retirement) return epoch.retirement;
     epoch.live = false;
     retired.add(epoch);
     cancelJob(epoch);
+    cancelRetry(epoch);
     epoch.cache.clear();
     epoch.binding.dispose();
     const context2 = epoch.map?.retire();
@@ -5727,6 +6100,29 @@ function createMountedMapOwner(ports2) {
     });
     return track(attempt);
   }
+  function restart(epoch) {
+    current = void 0;
+    void retire(epoch).catch(() => void 0);
+    current = createEpoch(epoch.developmentOrigin);
+    select();
+  }
+  function reopen(epoch) {
+    if (disposed || current !== epoch || !epoch.live || !props) return;
+    rendererError();
+    if (reopenings >= REOPEN_LIMIT) return;
+    reopenings += 1;
+    restart(epoch);
+  }
+  function sessionError(epoch, code, reason) {
+    if (disposed || current !== epoch || !epoch.live || !sessionErrorCodes.has(code)) return;
+    const detail = code === "NATIVE_SESSION_REJECTED" && typeof reason === "string" && SERVICE_CODE2.test(reason) ? { reason } : {};
+    const error = Object.freeze({
+      code,
+      kind: "terminal",
+      ...detail
+    });
+    emit({ type: "session-error", generation: generation(), error });
+  }
   function createEpoch(developmentOrigin) {
     const epoch = {
       live: true,
@@ -5754,7 +6150,17 @@ function createMountedMapOwner(ports2) {
         if (!epoch.live || current !== epoch) throw new NativePreparationError();
         const binding = await epoch.binding.replace(source);
         if (!epoch.live || current !== epoch) throw new NativePreparationError();
-        epoch.lease = ports2.installation.open({ binding, resources: [], now: ports2.now });
+        epoch.lease = ports2.installation.open({
+          binding,
+          resources: [],
+          now: ports2.now,
+          // Admission reports from inside its own cleanup and session publication; defer.
+          onRetired: () => void Promise.resolve().then(() => reopen(epoch)),
+          onSessionError: (error) => {
+            if (error.kind !== "terminal") return;
+            void Promise.resolve().then(() => sessionError(epoch, error.code, error.reason));
+          }
+        });
         const map = await epoch.lease.ready;
         epoch.map = map;
         if (!epoch.live || current !== epoch || map.state.status !== "active") {
@@ -5763,7 +6169,9 @@ function createMountedMapOwner(ports2) {
         }
         return map;
       });
-      void epoch.context.catch(() => void 0);
+      void epoch.context.catch(() => {
+        epoch.contextFailed = true;
+      });
     }
     return epoch.context;
   }
@@ -5905,6 +6313,7 @@ function createMountedMapOwner(ports2) {
       }
       rendererError();
       epoch.renderer?.preparationFailed(source.generation);
+      retryLater(epoch, source);
     }).finally(() => {
       if (epoch.job === job) epoch.job = void 0;
     });
@@ -5962,6 +6371,7 @@ function createMountedMapOwner(ports2) {
       foreground = false;
       if (current) {
         cancelJob(current);
+        cancelRetry(current);
         current.renderer?.background();
       }
       return;
@@ -6060,6 +6470,22 @@ function createMountedMapOwner(ports2) {
       if (state?.status !== "ready") select();
     },
     nativeLifecycle,
+    /** Loads again after a stopped session, a failed source or a failed context. */
+    retry() {
+      const epoch = current;
+      if (disposed || !props || !epoch?.live) return;
+      reopenings = 0;
+      const map = epoch.map;
+      if (epoch.contextFailed || map?.state.status === "retired") {
+        restart(epoch);
+        return;
+      }
+      map?.retry();
+      cancelRetry(epoch);
+      const state = core.state;
+      if (state?.status === "error") select();
+      else if (state?.status === "ready" && map && foreground) prepare(epoch, state);
+    },
     async whenIdle() {
       while (tasks.size) await Promise.allSettled([...tasks]);
       await current?.renderer?.whenIdle();
@@ -6097,7 +6523,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
@@ -6128,10 +6556,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 invalid4();
   const status = reply.status;
   const cacheControl = reply.cacheControl;
+  const retryAfter = reply.retryAfter || null;
   let bytes = decodeBoundedBase64(reply.bodyBase64);
   let readerTaken = false;
   let done = false;
@@ -6145,7 +6574,9 @@ function responseFromWire(reply, isAborted, release) {
     status,
     headers: Object.freeze({
       get(name3) {
-        return name3.toLowerCase() === "cache-control" ? cacheControl : null;
+        const header = name3.toLowerCase();
+        if (header === "cache-control") return cacheControl;
+        return header === "retry-after" ? retryAfter : null;
       }
     }),
     body: Object.freeze({
@@ -7272,7 +7703,7 @@ function createNativeMapOwner() {
 }
 
 // src/map.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 var fill = Object.freeze({ flex: 1 });
 function NativeScene({
   scene,
@@ -7281,7 +7712,8 @@ function NativeScene({
   children,
   interactions,
   interactionEnabled,
-  renderMarker
+  renderMarker,
+  boundaryFeatureState
 }) {
   const view = useRef(null);
   const camera = useRef(null);
@@ -7291,7 +7723,10 @@ function NativeScene({
   const laidOut = useRef(false);
   const styleLoaded = useRef(false);
   const attachRequested = useRef(false);
-  const host = useMemo2(() => {
+  const latestStyle = useRef(scene.style);
+  latestStyle.current = scene.style;
+  const [loadedStyle, setLoadedStyle] = useState2(void 0);
+  const host = useMemo3(() => {
     const value = Object.freeze({
       key: scene.key,
       style: scene.style,
@@ -7305,7 +7740,7 @@ function NativeScene({
     });
     return value;
   }, [scene.key, scene.style]);
-  useLayoutEffect2(() => {
+  useLayoutEffect3(() => {
     committedHost.current = host;
     lifecycle.bindInteractionHost(host);
     return () => {
@@ -7313,11 +7748,11 @@ function NativeScene({
       lifecycle.unbindInteractionHost(host);
     };
   }, [host, lifecycle]);
-  const mapStyle = useMemo2(
+  const mapStyle = useMemo3(
     () => JSON.stringify(scene.style),
     [scene.style]
   );
-  const [initialViewState] = useState(() => {
+  const [initialViewState] = useState2(() => {
     const center = [scene.initialView.center[0], scene.initialView.center[1]];
     Object.freeze(center);
     return Object.freeze({
@@ -7343,7 +7778,7 @@ function NativeScene({
   };
   const annotations = interactions?.annotations;
   const byId = new globalThis.Map(annotations?.map((annotation) => [annotation.id, annotation]));
-  return /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsx3(
     View2,
     {
       ref: bind2,
@@ -7381,10 +7816,11 @@ function NativeScene({
           },
           onDidFinishLoadingStyle: () => {
             styleLoaded.current = true;
+            setLoadedStyle(latestStyle.current);
             attach();
           },
           children: [
-            /* @__PURE__ */ jsx2(
+            /* @__PURE__ */ jsx3(
               NativeCamera,
               {
                 ref: camera,
@@ -7394,9 +7830,9 @@ function NativeScene({
               },
               "tileflow-camera"
             ),
-            /* @__PURE__ */ jsx2(Fragment, { children: interactions?.plan.order.map((id) => {
+            /* @__PURE__ */ jsx3(Fragment, { children: interactions?.plan.order.map((id) => {
               const annotation = byId.get(id);
-              return annotation ? /* @__PURE__ */ jsx2(
+              return annotation ? /* @__PURE__ */ jsx3(
                 NativeAnnotationMarker,
                 {
                   annotation,
@@ -7408,6 +7844,15 @@ function NativeScene({
                 annotation.id
               ) : null;
             }) }, "tileflow-annotations"),
+            boundaryFeatureState ? /* @__PURE__ */ jsx3(
+              NativeBoundaryFeatureState,
+              {
+                input: boundaryFeatureState,
+                style: scene.style,
+                loaded: loadedStyle === scene.style
+              },
+              "tileflow-boundary-feature-state"
+            ) : null,
             children
           ]
         }
@@ -7416,7 +7861,7 @@ function NativeScene({
   );
 }
 function Map2(props) {
-  const [lifecycle] = useState(
+  const [lifecycle] = useState2(
     () => createMapLifecycle(createNativeMapOwner, retireNativeMapOwner)
   );
   const snapshot = useSyncExternalStore(
@@ -7424,10 +7869,12 @@ function Map2(props) {
     lifecycle.getSnapshot,
     lifecycle.getSnapshot
   );
-  useImperativeHandle(props.ref, () => Object.freeze({ getSourceState: lifecycle.getSourceState }), [
-    lifecycle
-  ]);
-  useLayoutEffect2(() => {
+  useImperativeHandle(
+    props.ref,
+    () => Object.freeze({ getSourceState: lifecycle.getSourceState, retry: lifecycle.retry }),
+    [lifecycle]
+  );
+  useLayoutEffect3(() => {
     const unmount = lifecycle.mount();
     if (AppState.currentState !== "active") lifecycle.background();
     const subscription = AppState.addEventListener("change", (state) => {
@@ -7439,10 +7886,10 @@ function Map2(props) {
       unmount();
     };
   }, [lifecycle]);
-  useLayoutEffect2(() => {
+  useLayoutEffect3(() => {
     lifecycle.update(props);
   });
-  return /* @__PURE__ */ jsx2(View2, { style: props.style, testID: props.testID, children: snapshot.renderer ? /* @__PURE__ */ jsx2(
+  return /* @__PURE__ */ jsx3(View2, { style: props.style, testID: props.testID, children: snapshot.renderer ? /* @__PURE__ */ jsx3(
     NativeScene,
     {
       scene: snapshot.renderer,
@@ -7451,6 +7898,7 @@ function Map2(props) {
       interactions: snapshot.interactions,
       interactionEnabled: snapshot.interactionEnabled === true,
       renderMarker: props.renderMarker,
+      boundaryFeatureState: props.boundaryFeatureState,
       children: props.children
     },
     snapshot.renderer.key