@tileflow/react-native 0.0.0-bootstrap.0 → 0.1.0-alpha.0

package/dist/internal/native-admission.js

@@ -0,0 +1,1614 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/native-admission-url.ts
+import {
+  resolveTileflowNativeManifestUrl as resolveTileflowNativeManifestUrl2,
+  resolveTileflowNativeResourceUrl
+} from "@tileflow/core/native";
+
+// src/native-admission-contract.ts
+var nativeAdmissionLimits = Object.freeze({
+  contexts: 16,
+  resources: 128,
+  queueDepth: 128,
+  batchSize: 8,
+  urlCharacters: 2048,
+  bridgeBytes: 524288,
+  grantCharacters: 24576,
+  waitMs: 3e4,
+  validitySafetyMs: 1e3,
+  redirects: 3,
+  responseBytes: 8388608
+});
+var nativeContextParameter = "__tf_native_context";
+
+// src/native-resource-template.ts
+import { resolveTileflowNativeManifestUrl } from "@tileflow/core/native";
+var decimal = "(?:0|[1-9][0-9]{0,9})";
+var coordinate = "-?(?:0|[1-9][0-9]{0,7})(?:\\.[0-9]{1,16})?";
+var slots = Object.freeze({
+  z: "(?:0|[1-9][0-9]?)",
+  x: decimal,
+  y: decimal,
+  ratio: "(?:@2x|@3x)?",
+  quadkey: "[0-3]{0,30}",
+  prefix: "[0-9a-f]{2}",
+  "bbox-epsg-3857": `${coordinate},${coordinate},${coordinate},${coordinate}`,
+  fontstack: "(?:[A-Za-z0-9_.~,+-]|%[0-9a-fA-F]{2}){1,768}",
+  range: `${decimal}-${decimal}`
+});
+var escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+var invalid = () => new Error("Invalid native resource template");
+var compiled = /* @__PURE__ */ new WeakMap();
+function compile(resource) {
+  const names = [];
+  let cursor = 0;
+  let pattern = "^";
+  for (const match of resource.url.matchAll(/\{([a-z0-9-]+)\}/gu)) {
+    const name = match[1];
+    if (!Object.hasOwn(slots, name) || names.length >= 16 || names.length > 0 && match.index === cursor) {
+      throw invalid();
+    }
+    if (resource.template === "glyphs" ? !["fontstack", "range"].includes(name) : ["fontstack", "range"].includes(name)) {
+      throw invalid();
+    }
+    pattern += escape(resource.url.slice(cursor, match.index)) + `(${slots[name]})`;
+    cursor = match.index + match[0].length;
+    names.push(name);
+  }
+  if (!names.length || /[{}]/u.test(resource.url.replace(/\{[a-z0-9-]+\}/gu, ""))) throw invalid();
+  pattern += escape(resource.url.slice(cursor)) + "$";
+  return { pattern: new RegExp(pattern, "u"), names: Object.freeze(names) };
+}
+function normalizeNativeTemplate(resource) {
+  if (resource.template === void 0) {
+    if (resource.fontStacks !== void 0 || /[{}]/u.test(resource.url)) throw invalid();
+    return {};
+  }
+  if (resource.template !== "tile" && resource.template !== "glyphs") throw invalid();
+  if (resource.template === "tile") {
+    if (resource.scope !== "tile" || resource.fontStacks !== void 0) throw invalid();
+    compile(resource);
+    return { template: "tile" };
+  }
+  const stacks = resource.fontStacks;
+  if (resource.scope !== "glyph" || !Array.isArray(stacks) || stacks.length === 0 || stacks.length > 16 || !resource.url.includes("{fontstack}") || !resource.url.includes("{range}") || stacks.some(
+    (value) => typeof value !== "string" || value.length === 0 || value.length > 256 || value !== value.trim() || /[\p{Cc}\\/?#%&=]|tf_native_|tf_public_/iu.test(value) || value.split(",").some((part) => part.length === 0 || part !== part.trim())
+  ) || new Set(stacks).size !== stacks.length)
+    throw invalid();
+  compile(resource);
+  return { template: "glyphs", fontStacks: Object.freeze([...stacks]) };
+}
+function expansionMatches(resource, url) {
+  if (resource.template === void 0) return resource.url === url;
+  let grammar = compiled.get(resource);
+  if (!grammar) {
+    grammar = compile(resource);
+    compiled.set(resource, grammar);
+  }
+  const match = grammar.pattern.exec(url);
+  if (!match) return false;
+  const values = /* @__PURE__ */ new Map();
+  for (let index = 0; index < grammar.names.length; index++) {
+    const name = grammar.names[index];
+    const value = match[index + 1];
+    if (values.has(name) && values.get(name) !== value) return false;
+    values.set(name, value);
+  }
+  const z = values.get("z");
+  if (z !== void 0 && Number(z) > 30) return false;
+  for (const name of ["x", "y"]) {
+    const value = values.get(name);
+    if (value !== void 0 && Number(value) >= 2 ** (z === void 0 ? 30 : Number(z)))
+      return false;
+  }
+  const quadkey = values.get("quadkey");
+  if (quadkey !== void 0 && z !== void 0 && quadkey.length !== Number(z)) return false;
+  const box = values.get("bbox-epsg-3857");
+  if (box !== void 0) {
+    const [west, south, east, north] = box.split(",").map(Number);
+    if ([west, south, east, north].some(
+      (value) => !Number.isFinite(value) || Math.abs(value) > 20037508343e-3
+    ) || west >= east || south >= north)
+      return false;
+  }
+  const range = values.get("range");
+  if (range !== void 0) {
+    const [start, end] = range.split("-").map(Number);
+    if (start % 256 !== 0 || end !== start + 255 || end > 1114111) return false;
+  }
+  const stack = values.get("fontstack");
+  if (stack !== void 0) {
+    try {
+      if (!resource.fontStacks?.includes(decodeURIComponent(stack))) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function matchNativeResource(resources, url) {
+  try {
+    if (url.length > 2048 || resolveTileflowNativeManifestUrl(url) !== url || /[{}]/u.test(url))
+      return void 0;
+  } catch {
+    return void 0;
+  }
+  let found;
+  for (const resource of resources) {
+    if (!expansionMatches(resource, url)) continue;
+    if (found) throw invalid();
+    found = Object.freeze({
+      url,
+      scope: resource.scope,
+      ...resource.tilesetId === void 0 ? {} : { tilesetId: resource.tilesetId }
+    });
+  }
+  return found;
+}
+
+// src/native-admission-url.ts
+var scopes = /* @__PURE__ */ new Set(["style", "tilejson", "tile", "sprite", "glyph", "font"]);
+var isNativeToken = (value) => typeof value === "string" && /^[A-Za-z0-9_.-]{1,96}$/u.test(value) && !value.startsWith("tf_");
+function hasReservedNativeContext(url) {
+  const query = url.indexOf("?");
+  if (query < 0) return false;
+  return url.slice(query + 1).split("&").some((part) => {
+    const key = part.split("=", 1)[0].replace(
+      /%([0-9a-f]{2})/giu,
+      (_, hex) => String.fromCharCode(Number.parseInt(hex, 16))
+    );
+    return key.toLowerCase().startsWith("__tf_native");
+  });
+}
+function nativeResourceOrigin(url) {
+  const match = /^(https:\/\/[^/?#]+)\//u.exec(url);
+  if (!match) throw new Error("Invalid native resource");
+  return match[1];
+}
+function nativeVersionedStyleMatchesMap(url, mapId) {
+  try {
+    const path = url.slice(nativeResourceOrigin(url).length);
+    const match = /^\/maps\/(map_[A-Za-z0-9_-]{16})\/native\/v([1-9][0-9]{0,15})\/([A-Za-z][A-Za-z0-9_-]{0,63})\.json$/u.exec(
+      path
+    );
+    return Boolean(match && match[1] === mapId && Number.isSafeInteger(Number(match[2])));
+  } catch {
+    return false;
+  }
+}
+function styleScopeAllowsMap(url, mapId) {
+  try {
+    const path = url.slice(nativeResourceOrigin(url).length);
+    return !/^\/maps\/[^/?#]+\/native(?:[/?#]|$)/u.test(decodeURIComponent(path)) || nativeVersionedStyleMatchesMap(url, mapId);
+  } catch {
+    return false;
+  }
+}
+function normalizeNativeResources(input) {
+  if (!Array.isArray(input) || input.length > nativeAdmissionLimits.resources)
+    throw new Error("Invalid native resource catalog");
+  const seen = /* @__PURE__ */ new Set();
+  return Object.freeze(
+    input.map((resource) => {
+      if (!resource || typeof resource.url !== "string" || resource.url.length > nativeAdmissionLimits.urlCharacters - 128 || !scopes.has(resource.scope) || hasReservedNativeContext(resource.url) || /[^\x21-\x7e]|[\\#]/u.test(resource.url) || seen.has(resource.url))
+        throw new Error("Invalid native resource");
+      const origin = nativeResourceOrigin(resource.url);
+      const canonical = resource.template === void 0 ? resolveTileflowNativeManifestUrl2(resource.url) : resolveTileflowNativeResourceUrl(resource.url, {
+        documentUrl: `${origin}/`,
+        template: resource.template
+      });
+      if (canonical !== resource.url) throw new Error("Invalid native resource");
+      const decoded = decodeURIComponent(resource.url);
+      if (/tf_native_|tf_public_/iu.test(decoded)) throw new Error("Invalid native resource");
+      if ((resource.scope === "tile" || resource.scope === "tilejson") && resource.tilesetId === void 0)
+        throw new Error("Missing native tileset");
+      if (resource.tilesetId !== void 0 && (!/^[A-Za-z0-9._:-]{1,255}$/u.test(resource.tilesetId) || /tf_native_|tf_public_/iu.test(resource.tilesetId)))
+        throw new Error("Invalid native tileset");
+      const template = normalizeNativeTemplate(resource);
+      seen.add(resource.url);
+      return Object.freeze({
+        url: resource.url,
+        scope: resource.scope,
+        ...resource.tilesetId === void 0 ? {} : { tilesetId: resource.tilesetId },
+        ...template
+      });
+    })
+  );
+}
+function authorityAllowsResource(authority, resource, mapId) {
+  return authority.mapId === mapId && authority.resourceOrigins.includes(nativeResourceOrigin(resource.url)) && authority.resourceScopes.includes(resource.scope) && (resource.scope !== "style" || styleScopeAllowsMap(resource.url, mapId)) && (resource.tilesetId === void 0 || authority.tilesetIds.includes(resource.tilesetId));
+}
+function discriminateNativeResourceForTest(url, context) {
+  if (!isNativeToken(context) || hasReservedNativeContext(url))
+    throw new Error("Invalid native context");
+  const result = `${url}${url.includes("?") ? "&" : "?"}${nativeContextParameter}=${context}`;
+  if (result.length > nativeAdmissionLimits.urlCharacters)
+    throw new Error("Invalid native context");
+  return result;
+}
+
+// src/native-admission-catalog.ts
+function mergeGlyphResource(previous, next) {
+  if (previous.scope !== "glyph" || next.scope !== "glyph" || previous.template !== "glyphs" || next.template !== "glyphs" || previous.tilesetId !== next.tilesetId || !previous.fontStacks || !next.fontStacks)
+    return void 0;
+  const fontStacks = [.../* @__PURE__ */ new Set([...previous.fontStacks, ...next.fontStacks])].sort();
+  if (fontStacks.length > 16) return void 0;
+  return normalizeNativeResources([{ ...previous, fontStacks }])[0];
+}
+function createNativeAdmissionCatalog(initial, context, extendNative) {
+  let resources = normalizeNativeResources(initial);
+  let live = true;
+  let pending;
+  const invalid2 = () => new NativeAdmissionError("NATIVE_ADMISSION_INVALID");
+  const cancelled = () => new NativeAdmissionError("NATIVE_ADMISSION_CANCELLED");
+  return Object.freeze({
+    match(url) {
+      if (!live) return void 0;
+      return matchNativeResource(resources, url);
+    },
+    discriminate(url) {
+      try {
+        if (!live || !resources.some((item) => item.url === url) && !matchNativeResource(resources, url))
+          throw invalid2();
+        return discriminateNativeResourceForTest(url, context);
+      } catch {
+        throw invalid2();
+      }
+    },
+    extend(input) {
+      if (!live) return Promise.reject(cancelled());
+      if (pending) return Promise.reject(new NativeAdmissionError("NATIVE_ADMISSION_UNAVAILABLE"));
+      let next;
+      let additions;
+      try {
+        const requested = normalizeNativeResources(input);
+        const merged = new Map(resources.map((entry) => [entry.url, entry]));
+        const nativeUpdates = [];
+        for (const entry of requested) {
+          const previous = merged.get(entry.url);
+          if (!previous) {
+            merged.set(entry.url, entry);
+            nativeUpdates.push(entry);
+            continue;
+          }
+          if (JSON.stringify(previous) === JSON.stringify(entry)) continue;
+          const union = mergeGlyphResource(previous, entry);
+          if (!union) throw invalid2();
+          merged.set(entry.url, union);
+          nativeUpdates.push(union);
+        }
+        next = normalizeNativeResources([...merged.values()]);
+        additions = Object.freeze(nativeUpdates);
+      } catch {
+        return Promise.reject(invalid2());
+      }
+      if (additions.length === 0) return Promise.resolve(Object.freeze({ resources: next.length }));
+      let resolve;
+      let reject;
+      const result = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+      });
+      void result.catch(() => void 0);
+      const operation = { cancel: () => reject(cancelled()) };
+      pending = operation;
+      void Promise.resolve().then(() => {
+        if (!live || pending !== operation) throw cancelled();
+        return extendNative(additions);
+      }).then((ack) => {
+        if (!live || pending !== operation) return;
+        if (!ack || ack.resources !== next.length) throw invalid2();
+        resources = next;
+        pending = void 0;
+        resolve(Object.freeze({ resources: resources.length }));
+      }).catch(() => {
+        if (!live || pending !== operation) return;
+        pending = void 0;
+        reject(new NativeAdmissionError("NATIVE_ADMISSION_UNAVAILABLE"));
+      });
+      return result;
+    },
+    retire() {
+      if (!live) return;
+      live = false;
+      pending?.cancel();
+      pending = void 0;
+      resources = Object.freeze([]);
+    }
+  });
+}
+
+// src/session-controller.ts
+import { resolveTileflowNativeManifestUrl as resolveTileflowNativeManifestUrl3 } from "@tileflow/core/native";
+var RESPONSE_BYTE_LIMIT = 65536;
+var GRANT_CHARACTER_LIMIT = 24576;
+var MAX_TILESETS = 18;
+var MAX_GRANT_LIFETIME_MS = 15 * 60 * 1e3;
+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 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;
+var COMPACT_ID = /^[A-Za-z0-9._:-]{1,255}$/u;
+var SURFACE_ID = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/u;
+var NATIVE_GRANT = /^tf_native_v1\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/u;
+var EXACT_ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+var ALLOWED_SCOPES = /* @__PURE__ */ new Set([
+  "style",
+  "tilejson",
+  "tile",
+  "sprite",
+  "glyph",
+  "font"
+]);
+var SUCCESS_KEYS = /* @__PURE__ */ new Set([
+  "ok",
+  "kind",
+  "version",
+  "usageMode",
+  "counted",
+  "grant",
+  "mapId",
+  "sessionId",
+  "surfaceId",
+  "credentialId",
+  "credentialRevision",
+  "deliveryPolicyRevision",
+  "issuedAt",
+  "serverTime",
+  "expiresAt",
+  "meterMode",
+  "disposition",
+  "resourceOrigins",
+  "resourceScopes",
+  "tilesetIds"
+]);
+var RESTART_KEYS = /* @__PURE__ */ new Set(["code", "error", "retryWithNewSession", "sessionId"]);
+var ERROR_MESSAGES = {
+  NATIVE_SESSION_INPUT_INVALID: "Native session configuration is invalid.",
+  NATIVE_SESSION_RESPONSE_TOO_LARGE: "Native session response exceeded its byte limit.",
+  NATIVE_SESSION_RESPONSE_UTF8_INVALID: "Native session response was not valid UTF-8.",
+  NATIVE_SESSION_RESPONSE_JSON_INVALID: "Native session response was not valid JSON.",
+  NATIVE_SESSION_RESPONSE_INVALID: "Native session response did not satisfy the expected contract.",
+  NATIVE_SESSION_CREDENTIAL_REJECTED: "Native session credential was rejected.",
+  NATIVE_SESSION_MAP_MISMATCH: "Native session authority does not match the requested Map.",
+  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_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) {
+    super(ERROR_MESSAGES[code]);
+    __publicField(this, "code");
+    __publicField(this, "kind");
+    this.name = "HostedNativeSessionError";
+    this.code = code;
+    this.kind = errorKind(code);
+  }
+};
+function createHostedNativeSessionController(input) {
+  if (!isRecord(input) || typeof input.fetch !== "function" || typeof input.now !== "function" || typeof input.sessionIdFactory !== "function") {
+    throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+  }
+  const fetch = input.fetch;
+  const now = input.now;
+  const sessionIdFactory = input.sessionIdFactory;
+  const issuedSessionIds = /* @__PURE__ */ new Set();
+  let binding = normalizeBinding(input.binding);
+  let lifecycle = "foreground";
+  let disposed = false;
+  let bindingGeneration = 0;
+  const admittedAuthorities = /* @__PURE__ */ new WeakMap();
+  const clock = { lastWall: readWallClock(now), logical: 0, epoch: 0 };
+  let activeSession = binding.kind === "hosted" ? createSession(binding.surfaceId, 0) : null;
+  let state = snapshotIdle(binding, activeSession, lifecycle);
+  const listeners = /* @__PURE__ */ new Set();
+  const operations = /* @__PURE__ */ new Set();
+  function readClock() {
+    const wall = readWallClock(now);
+    if (wall < clock.lastWall) clock.epoch += 1;
+    else clock.logical += wall - clock.lastWall;
+    clock.lastWall = wall;
+    return clock.logical;
+  }
+  function bindingIsDirect() {
+    return binding.kind === "direct";
+  }
+  function createSession(surfaceId, startedAt) {
+    let sessionId;
+    try {
+      sessionId = sessionIdFactory();
+    } catch {
+      throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+    }
+    if (typeof sessionId !== "string" || !COMPACT_ID.test(sessionId) || secretShaped(sessionId) || issuedSessionIds.has(sessionId)) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+    }
+    issuedSessionIds.add(sessionId);
+    return {
+      authority: null,
+      error: null,
+      lastServerTime: null,
+      operation: null,
+      pendingAdmissions: 0,
+      redirect: null,
+      requestCount: 0,
+      requestedSurfaceId: surfaceId,
+      serverStartedAt: null,
+      sessionId,
+      startedAt
+    };
+  }
+  function publish(next) {
+    if (disposed && next.status !== "disposed") return;
+    state = next;
+    for (const listener of [...listeners]) {
+      try {
+        listener(next);
+      } catch {
+      }
+    }
+  }
+  function publishSession(session, status, error) {
+    if (disposed || activeSession !== session || binding.kind !== "hosted") return;
+    if (status === "ready") {
+      if (!session.authority) return;
+      const authority = session.authority.public;
+      publish(
+        Object.freeze({
+          status: "ready",
+          source: "hosted",
+          lifecycle,
+          mapId: binding.mapId,
+          sessionId: session.sessionId,
+          surfaceId: authority.surfaceId,
+          credentialId: authority.credentialId,
+          credentialRevision: authority.credentialRevision,
+          deliveryPolicyRevision: authority.deliveryPolicyRevision
+        })
+      );
+      return;
+    }
+    if (status === "error") {
+      if (!error) return;
+      publish(
+        Object.freeze({
+          status: "error",
+          source: "hosted",
+          lifecycle,
+          mapId: binding.mapId,
+          sessionId: session.sessionId,
+          error: Object.freeze({ ...error })
+        })
+      );
+      return;
+    }
+    publish(
+      Object.freeze({
+        status,
+        source: "hosted",
+        lifecycle,
+        mapId: binding.mapId,
+        sessionId: session.sessionId
+      })
+    );
+  }
+  function rotateIfRequired(at) {
+    if (!activeSession || binding.kind !== "hosted") return;
+    if (at - activeSession.startedAt < ROTATION_AGE_MS && activeSession.requestCount < ROTATION_REQUEST_LIMIT) {
+      return;
+    }
+    const previous = activeSession;
+    activeSession = createSession(
+      previous.authority?.public.surfaceId ?? previous.requestedSurfaceId,
+      at
+    );
+    publishSession(activeSession, "idle");
+  }
+  function redirectSession(session, at) {
+    const replacement = createSession(
+      session.authority?.public.surfaceId ?? session.requestedSurfaceId,
+      at
+    );
+    replacement.requestCount = session.pendingAdmissions;
+    replacement.operation = session.operation;
+    session.redirect = replacement;
+    activeSession = replacement;
+    publishSession(replacement, "loading");
+    return replacement;
+  }
+  function latestSession(session) {
+    const seen = /* @__PURE__ */ new Set();
+    let current = session;
+    while (current.redirect && !seen.has(current.redirect)) {
+      seen.add(current);
+      current = current.redirect;
+    }
+    return current;
+  }
+  async function ensureAuthority(session, at) {
+    if (session.authority && session.authority.clockEpoch === clock.epoch && session.authority.validUntil - at > REFRESH_MARGIN_MS) {
+      return { authority: session.authority, session };
+    }
+    if (session.operation) return session.operation.promise;
+    if (binding.kind !== "hosted") {
+      throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
+    }
+    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 {
+          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 (activeSession === result.session) {
+            publishSession(result.session, "ready");
+            if (abort.signal.aborted) throw abort.error();
+          }
+          return result;
+        } catch (error) {
+          const normalized = abort.signal.aborted ? abort.error() : normalizeError(error);
+          const target = latestSession(session);
+          if (normalized.code !== "NATIVE_SESSION_REPLACED" && normalized.code !== "NATIVE_SESSION_DISPOSED") {
+            target.error = Object.freeze({ code: normalized.code, kind: normalized.kind });
+            publishSession(target, "error", target.error);
+          }
+          throw normalized;
+        } finally {
+          operations.delete(abort);
+          let current = session;
+          const seen = /* @__PURE__ */ new Set();
+          while (current && !seen.has(current)) {
+            seen.add(current);
+            if (current.operation === operation) current.operation = null;
+            current = current.redirect;
+          }
+        }
+      })
+    };
+    session.operation = operation;
+    return operation.promise;
+  }
+  async function bootstrap(session, hostedBinding, abort, allowRestart, allowServerAgeRotation) {
+    const requestStartedAt = readClock();
+    const requestClockEpoch = clock.epoch;
+    const requestBindingGeneration = bindingGeneration;
+    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);
+    let body;
+    try {
+      body = source.length ? JSON.parse(source) : null;
+    } catch {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_JSON_INVALID");
+    }
+    if (response.status === 409 && allowRestart && isExactRestart(body, session.sessionId)) {
+      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 (!hasNoStore(response.headers.get("cache-control"))) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    const payload = parseSuccess(body, hostedBinding, session.sessionId, expectedSurfaceId);
+    if (session.lastServerTime !== null && payload.serverTimeMs < session.lastServerTime) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    if (allowServerAgeRotation && session.serverStartedAt !== null && payload.serverTimeMs - session.serverStartedAt >= ROTATION_AGE_MS) {
+      assertCurrentSession(session, hostedBinding);
+      const replacement = redirectSession(session, readClock());
+      if (abort.signal.aborted) throw abort.error();
+      return bootstrap(replacement, hostedBinding, abort, false, false);
+    }
+    session.serverStartedAt ?? (session.serverStartedAt = payload.serverTimeMs);
+    session.lastServerTime = payload.serverTimeMs;
+    const ttl = payload.expiresAtMs - payload.serverTimeMs;
+    return {
+      authority: Object.freeze({
+        public: payload.authority,
+        validUntil: requestStartedAt + ttl,
+        clockEpoch: requestClockEpoch,
+        bindingGeneration: requestBindingGeneration
+      }),
+      session
+    };
+  }
+  function assertCurrentSession(session, expectedBinding) {
+    if (activeSession !== session || binding.kind !== "hosted" || !sameHostedBinding(binding, expectedBinding)) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
+    }
+  }
+  async function fetchResponse(hostedBinding, session, surfaceId, abort) {
+    const body = JSON.stringify({
+      mapId: hostedBinding.mapId,
+      sessionId: session.sessionId,
+      surfaceId
+    });
+    const init = Object.freeze({
+      body,
+      credentials: "omit",
+      headers: Object.freeze({
+        "Content-Type": "application/json",
+        "X-Tileflow-Mobile-Client": hostedBinding.credential
+      }),
+      method: "POST",
+      signal: abort.signal
+    });
+    let pending;
+    try {
+      pending = Promise.resolve(fetch(`${hostedBinding.apiOrigin}/v1/sessions/start`, init));
+    } catch {
+      if (abort.signal.aborted) throw abort.error();
+      throw new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
+    }
+    pending.then(
+      (response) => {
+        if (abort.signal.aborted) void cancelResponse(response);
+      },
+      () => void 0
+    );
+    try {
+      return await raceWithAbort(pending, abort);
+    } catch (error) {
+      if (abort.signal.aborted) throw abort.error();
+      throw normalizeError(error, "NATIVE_SESSION_UNAVAILABLE");
+    }
+  }
+  function currentSnapshot() {
+    if (disposed) return Object.freeze({ status: "disposed", lifecycle: "disposed" });
+    if (binding.kind === "direct" || !activeSession) {
+      return Object.freeze({ status: "idle", source: "direct", lifecycle });
+    }
+    if (activeSession.operation) {
+      return Object.freeze({
+        status: "loading",
+        source: "hosted",
+        lifecycle,
+        mapId: binding.mapId,
+        sessionId: activeSession.sessionId
+      });
+    }
+    if (activeSession.error) {
+      return Object.freeze({
+        status: "error",
+        source: "hosted",
+        lifecycle,
+        mapId: binding.mapId,
+        sessionId: activeSession.sessionId,
+        error: Object.freeze({ ...activeSession.error })
+      });
+    }
+    if (activeSession.authority) {
+      const authority = activeSession.authority.public;
+      return Object.freeze({
+        status: "ready",
+        source: "hosted",
+        lifecycle,
+        mapId: binding.mapId,
+        sessionId: activeSession.sessionId,
+        surfaceId: authority.surfaceId,
+        credentialId: authority.credentialId,
+        credentialRevision: authority.credentialRevision,
+        deliveryPolicyRevision: authority.deliveryPolicyRevision
+      });
+    }
+    return Object.freeze({
+      status: "idle",
+      source: "hosted",
+      lifecycle,
+      mapId: binding.mapId,
+      sessionId: activeSession.sessionId
+    });
+  }
+  async function acquireAuthority(session, at) {
+    const expectedGeneration = bindingGeneration;
+    let candidate = session;
+    let checkedAt = at;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const resolved = await ensureAuthority(candidate, checkedAt);
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (bindingGeneration !== expectedGeneration) {
+        throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
+      }
+      checkedAt = readClock();
+      if (resolved.authority.clockEpoch === clock.epoch && resolved.authority.validUntil > checkedAt) {
+        admittedAuthorities.set(resolved.authority.public, resolved.authority);
+        return resolved.authority.public;
+      }
+      resolved.session.authority = null;
+      candidate = resolved.session;
+    }
+    const error = new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
+    candidate.error = Object.freeze({ code: error.code, kind: error.kind });
+    publishSession(candidate, "error", candidate.error);
+    throw error;
+  }
+  return Object.freeze({
+    get state() {
+      return state;
+    },
+    async prepare() {
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (bindingIsDirect()) return null;
+      if (lifecycle !== "foreground")
+        throw new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
+      const at = readClock();
+      rotateIfRequired(at);
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (bindingIsDirect() || !activeSession)
+        throw new HostedNativeSessionError("NATIVE_SESSION_REPLACED");
+      const authority = await acquireAuthority(activeSession, at);
+      if (lifecycle !== "foreground")
+        throw new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE");
+      return Object.freeze({
+        mapId: authority.mapId,
+        resourceOrigins: Object.freeze([...authority.resourceOrigins]),
+        resourceScopes: Object.freeze([...authority.resourceScopes]),
+        tilesetIds: Object.freeze([...authority.tilesetIds])
+      });
+    },
+    async acquire() {
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (bindingIsDirect()) return null;
+      const at = readClock();
+      rotateIfRequired(at);
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      if (bindingIsDirect() || !activeSession) return null;
+      const session = activeSession;
+      session.requestCount += 1;
+      session.pendingAdmissions += 1;
+      try {
+        return await acquireAuthority(session, at);
+      } finally {
+        session.pendingAdmissions = Math.max(0, session.pendingAdmissions - 1);
+      }
+    },
+    transportBudget(authority) {
+      if (disposed || lifecycle !== "foreground") return 0;
+      const stored = admittedAuthorities.get(authority);
+      if (!stored || stored.bindingGeneration !== bindingGeneration) return 0;
+      try {
+        const at = readClock();
+        if (stored.clockEpoch !== clock.epoch) return 0;
+        return Math.max(0, Math.floor(stored.validUntil - at));
+      } catch {
+        return 0;
+      }
+    },
+    background() {
+      if (disposed) return;
+      lifecycle = "background";
+      publish(currentSnapshot());
+    },
+    async resume() {
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      lifecycle = "foreground";
+      if (binding.kind === "direct" || !activeSession) {
+        publish(currentSnapshot());
+        return;
+      }
+      const previous = activeSession;
+      const hadAuthority = Boolean(previous.authority || previous.operation);
+      const at = readClock();
+      rotateIfRequired(at);
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      publish(currentSnapshot());
+      if (!hadAuthority || !activeSession) return;
+      if (activeSession !== previous || !activeSession.authority || activeSession.authority.clockEpoch !== clock.epoch || activeSession.authority.validUntil - at <= REFRESH_MARGIN_MS) {
+        await acquireAuthority(activeSession, at);
+      }
+    },
+    replaceBinding(nextBinding) {
+      if (disposed) throw new HostedNativeSessionError("NATIVE_SESSION_DISPOSED");
+      const next = normalizeBinding(nextBinding);
+      if (sameBinding(binding, next)) return;
+      bindingGeneration += 1;
+      for (const operation of operations) operation.abort("NATIVE_SESSION_REPLACED");
+      binding = next;
+      activeSession = next.kind === "hosted" ? createSession(next.surfaceId, readClock()) : null;
+      publish(snapshotIdle(binding, activeSession, lifecycle));
+    },
+    subscribe(listener) {
+      if (typeof listener !== "function") {
+        throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+      }
+      if (disposed) return () => void 0;
+      listeners.add(listener);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        listeners.delete(listener);
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      bindingGeneration += 1;
+      for (const operation of operations) operation.abort("NATIVE_SESSION_DISPOSED");
+      operations.clear();
+      activeSession = null;
+      binding = Object.freeze({ kind: "direct" });
+      publish(Object.freeze({ status: "disposed", lifecycle: "disposed" }));
+      listeners.clear();
+    }
+  });
+}
+function normalizeBinding(value) {
+  try {
+    if (!isRecord(value)) throw new Error();
+    if (value.kind === "direct") {
+      if (Object.keys(value).length !== 1) throw new Error();
+      return Object.freeze({ kind: "direct" });
+    }
+    if (value.kind !== "hosted" || Object.keys(value).some(
+      (key) => !["kind", "apiOrigin", "credential", "mapId", "surfaceId"].includes(key)
+    ) || typeof value.credential !== "string" || !MOBILE_CREDENTIAL.test(value.credential) || typeof value.mapId !== "string" || !MAP_ID.test(value.mapId)) {
+      throw new Error();
+    }
+    return Object.freeze({
+      kind: "hosted",
+      apiOrigin: canonicalOrigin(value.apiOrigin),
+      credential: value.credential,
+      mapId: value.mapId,
+      surfaceId: normalizeSurface(value.surfaceId)
+    });
+  } catch (error) {
+    if (error instanceof HostedNativeSessionError) throw error;
+    throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+  }
+}
+function canonicalOrigin(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048 || value !== value.trim()) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+  }
+  try {
+    const resolved = resolveTileflowNativeManifestUrl3(value);
+    if (!resolved.endsWith("/")) throw new Error();
+    const origin = resolved.slice(0, -1);
+    if (value !== origin) throw new Error();
+    return origin;
+  } catch {
+    throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+  }
+}
+function normalizeSurface(value) {
+  return typeof value === "string" && SURFACE_ID.test(value) && !secretShaped(value) ? value : "default";
+}
+function secretShaped(value) {
+  return MOBILE_CREDENTIAL.test(value) || value.startsWith("tf_native_");
+}
+function sameHostedBinding(left, right) {
+  return left.apiOrigin === right.apiOrigin && left.credential === right.credential && left.mapId === right.mapId;
+}
+function sameBinding(left, right) {
+  if (left.kind !== right.kind) return false;
+  if (left.kind === "direct") return true;
+  return right.kind === "hosted" && sameHostedBinding(left, right);
+}
+function snapshotIdle(binding, session, lifecycle) {
+  return binding.kind === "direct" || !session ? Object.freeze({ status: "idle", source: "direct", lifecycle }) : Object.freeze({
+    status: "idle",
+    source: "hosted",
+    lifecycle,
+    mapId: binding.mapId,
+    sessionId: session.sessionId
+  });
+}
+function parseSuccess(value, binding, expectedSessionId, expectedSurfaceId) {
+  if (!isRecord(value) || Object.keys(value).length !== SUCCESS_KEYS.size || Object.keys(value).some((key) => !SUCCESS_KEYS.has(key)) || value.ok !== true || value.kind !== "native" || value.version !== 1 || value.usageMode !== "session" || value.counted !== false || value.mapId !== binding.mapId || value.sessionId !== expectedSessionId || value.surfaceId !== expectedSurfaceId || typeof value.surfaceId !== "string" || !SURFACE_ID.test(value.surfaceId) || secretShaped(value.surfaceId) || typeof value.credentialId !== "string" || !CREDENTIAL_ID.test(value.credentialId) || !positiveRevision(value.credentialRevision) || !positiveRevision(value.deliveryPolicyRevision) || typeof value.grant !== "string" || value.grant.length === 0 || value.grant.length > GRANT_CHARACTER_LIMIT || !NATIVE_GRANT.test(value.grant) || !["disabled", "shadow", "enforced"].includes(String(value.meterMode)) || !["unmetered", "ordinary", "unbilled_fail_open"].includes(String(value.disposition)) || value.disposition === "unmetered" && value.meterMode !== "disabled") {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  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) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const authority = {
+    mapId: value.mapId,
+    sessionId: value.sessionId,
+    surfaceId: value.surfaceId,
+    credentialId: value.credentialId,
+    credentialRevision: value.credentialRevision,
+    deliveryPolicyRevision: value.deliveryPolicyRevision,
+    issuedAt: value.issuedAt,
+    serverTime: value.serverTime,
+    expiresAt: value.expiresAt,
+    meterMode: value.meterMode,
+    disposition: value.disposition,
+    resourceOrigins: Object.freeze(parseOrigins(value.resourceOrigins)),
+    resourceScopes: Object.freeze(parseScopes(value.resourceScopes)),
+    tilesetIds: Object.freeze(parseTilesets(value.tilesetIds))
+  };
+  const withGrant = Object.defineProperty(authority, "grant", {
+    value: value.grant,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return { authority: Object.freeze(withGrant), serverTimeMs, expiresAtMs };
+}
+function parseOrigins(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 2) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const result = [];
+  for (const item of value) {
+    if (typeof item !== "string") {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    let origin;
+    try {
+      const resolved = resolveTileflowNativeManifestUrl3(item);
+      if (!resolved.endsWith("/")) throw new Error();
+      origin = resolved.slice(0, -1);
+      if (item !== origin) throw new Error();
+    } catch {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    if (result.includes(origin)) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    result.push(origin);
+  }
+  return result;
+}
+function parseScopes(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > ALLOWED_SCOPES.size) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const result = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !ALLOWED_SCOPES.has(item) || result.includes(item)) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    result.push(item);
+  }
+  return result;
+}
+function parseTilesets(value) {
+  if (!Array.isArray(value) || value.length > MAX_TILESETS) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const result = [];
+  for (const item of value) {
+    if (typeof item !== "string" || !COMPACT_ID.test(item) || result.includes(item)) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+    }
+    result.push(item);
+  }
+  return result;
+}
+function parseExactIso(value) {
+  if (typeof value !== "string" || !EXACT_ISO.test(value)) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== value) {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  return parsed;
+}
+function positiveRevision(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isExactRestart(value, expectedSessionId) {
+  return isRecord(value) && Object.keys(value).length === RESTART_KEYS.size && Object.keys(value).every((key) => RESTART_KEYS.has(key)) && value.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && typeof value.error === "string" && value.error.length > 0 && value.error.length <= 500 && value.retryWithNewSession === true && value.sessionId === expectedSessionId;
+}
+async function readBoundedResponse(response, abort) {
+  let reader;
+  try {
+    if (!response || !Number.isSafeInteger(response.status) || !response.headers || typeof response.headers.get !== "function" || !response.body || typeof response.body.getReader !== "function") {
+      throw new Error();
+    }
+    reader = response.body.getReader();
+  } catch {
+    throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+  }
+  const chunks = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      if (abort.signal.aborted) throw abort.error();
+      const next = await raceWithAbort(Promise.resolve(reader.read()), abort);
+      if (next.done) break;
+      if (!(next.value instanceof Uint8Array)) {
+        throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_INVALID");
+      }
+      size += next.value.byteLength;
+      if (size > RESPONSE_BYTE_LIMIT) {
+        throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_TOO_LARGE");
+      }
+      chunks.push(next.value.slice());
+    }
+  } catch (error) {
+    void Promise.resolve(reader.cancel()).catch(() => void 0);
+    if (abort.signal.aborted) throw abort.error();
+    throw normalizeError(error, "NATIVE_SESSION_UNAVAILABLE");
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return decodeUtf8(bytes);
+}
+function decodeUtf8(bytes) {
+  let result = "";
+  for (let index = 0; index < bytes.length; ) {
+    const first = bytes[index++];
+    let codePoint;
+    let remaining;
+    let minimum;
+    if (first <= 127) {
+      codePoint = first;
+      remaining = 0;
+      minimum = 0;
+    } else if (first >= 194 && first <= 223) {
+      codePoint = first & 31;
+      remaining = 1;
+      minimum = 128;
+    } else if (first >= 224 && first <= 239) {
+      codePoint = first & 15;
+      remaining = 2;
+      minimum = 2048;
+    } else if (first >= 240 && first <= 244) {
+      codePoint = first & 7;
+      remaining = 3;
+      minimum = 65536;
+    } else {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_UTF8_INVALID");
+    }
+    if (index + remaining > bytes.length) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_UTF8_INVALID");
+    }
+    for (let count = 0; count < remaining; count += 1) {
+      const byte = bytes[index++];
+      if ((byte & 192) !== 128) {
+        throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_UTF8_INVALID");
+      }
+      codePoint = codePoint << 6 | byte & 63;
+    }
+    if (codePoint < minimum || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343) {
+      throw new HostedNativeSessionError("NATIVE_SESSION_RESPONSE_UTF8_INVALID");
+    }
+    result += String.fromCodePoint(codePoint);
+  }
+  return result;
+}
+function hasNoStore(value) {
+  return typeof value === "string" && value.split(",").some((part) => part.trim().toLowerCase() === "no-store");
+}
+function statusError(status) {
+  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");
+}
+function errorKind(code) {
+  if (code === "NATIVE_SESSION_DISPOSED" || code === "NATIVE_SESSION_REPLACED") return "cancelled";
+  if (code === "NATIVE_SESSION_UNAVAILABLE") return "recoverable";
+  return "terminal";
+}
+function normalizeError(error, fallback = "NATIVE_SESSION_RESPONSE_INVALID") {
+  return error instanceof HostedNativeSessionError ? error : new HostedNativeSessionError(fallback);
+}
+function readWallClock(now) {
+  try {
+    const value = now();
+    if (!(value instanceof Date) || !Number.isFinite(value.getTime())) throw new Error();
+    return value.getTime();
+  } catch {
+    throw new HostedNativeSessionError("NATIVE_SESSION_INPUT_INVALID");
+  }
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+async function cancelResponse(response) {
+  try {
+    await response.body?.getReader().cancel();
+  } catch {
+  }
+}
+var _aborted, _code, _listeners;
+var SessionAbortController = class {
+  constructor() {
+    __publicField(this, "signal");
+    __privateAdd(this, _aborted, false);
+    __privateAdd(this, _code, "NATIVE_SESSION_REPLACED");
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Set());
+    const isAborted = () => __privateGet(this, _aborted);
+    this.signal = Object.freeze({
+      get aborted() {
+        return isAborted();
+      },
+      addEventListener: (type, listener, _options) => {
+        if (type === "abort" && !__privateGet(this, _aborted)) __privateGet(this, _listeners).add(listener);
+      },
+      removeEventListener: (type, listener) => {
+        if (type === "abort") __privateGet(this, _listeners).delete(listener);
+      }
+    });
+  }
+  abort(code) {
+    if (__privateGet(this, _aborted)) return;
+    __privateSet(this, _code, code);
+    __privateSet(this, _aborted, true);
+    for (const listener of [...__privateGet(this, _listeners)]) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+    __privateGet(this, _listeners).clear();
+  }
+  error() {
+    return new HostedNativeSessionError(__privateGet(this, _code));
+  }
+};
+_aborted = new WeakMap();
+_code = new WeakMap();
+_listeners = new WeakMap();
+function raceWithAbort(promise, controller) {
+  if (controller.signal.aborted) return Promise.reject(controller.error());
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(controller.error());
+    };
+    const cleanup = () => controller.signal.removeEventListener("abort", onAbort);
+    controller.signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      () => {
+        cleanup();
+        reject(new HostedNativeSessionError("NATIVE_SESSION_UNAVAILABLE"));
+      }
+    );
+  });
+}
+
+// src/native-admission-owner.ts
+var NativeAdmissionError = class extends Error {
+  constructor(code) {
+    super("Native resource admission failed.");
+    __publicField(this, "code");
+    this.name = "NativeAdmissionError";
+    this.code = code;
+  }
+};
+function createNativeAdmissionOwner(options) {
+  const bridge = options.bridge;
+  const factory = options.createController ?? createHostedNativeSessionController;
+  const contexts = /* @__PURE__ */ new Map();
+  const pendingControllers = /* @__PURE__ */ new Set();
+  let installation = null;
+  let installed;
+  let installResult;
+  let disposed = false;
+  let foreground = true;
+  let contextSequence = 0;
+  let status = "idle";
+  let disposal;
+  function cancel(code = "NATIVE_ADMISSION_CANCELLED") {
+    return new NativeAdmissionError(code);
+  }
+  function install() {
+    if (disposed) return Promise.reject(cancel());
+    if (installResult) return installResult;
+    status = "installing";
+    try {
+      installed = bridge.install().then(
+        (ack) => {
+          if (!ack || !isNativeToken(ack.installation)) throw cancel("NATIVE_ADMISSION_INVALID");
+          installation = ack.installation;
+          return ack.installation;
+        },
+        () => {
+          throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+        }
+      );
+    } catch {
+      installed = Promise.reject(cancel("NATIVE_ADMISSION_UNAVAILABLE"));
+    }
+    const attempt = installed.then(
+      (id) => {
+        if (disposed) throw cancel();
+        status = "ready";
+        return Object.freeze({ installation: id });
+      },
+      () => {
+        if (!disposed) status = "error";
+        throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+      }
+    );
+    installResult = attempt;
+    void attempt.catch(() => {
+      if (!disposed && installation === null && installResult === attempt) {
+        installed = void 0;
+        installResult = void 0;
+      }
+    });
+    return attempt;
+  }
+  function retire(context) {
+    return context.handle.retire();
+  }
+  function failContext(context) {
+    void retire(context).catch(() => void 0);
+  }
+  async function handleBatch(context, event) {
+    if (!context.live || !foreground || event.generation !== context.generation) return;
+    const serial = typeof event.batch === "string" && /^[1-9][0-9]{0,15}$/u.test(event.batch) ? Number(event.batch) : NaN;
+    if (Number.isSafeInteger(serial) && serial <= context.lastBatch) return;
+    if (!Number.isSafeInteger(serial) || context.batch !== null || !Array.isArray(event.tickets) || event.tickets.length === 0 || event.tickets.length > nativeAdmissionLimits.batchSize) {
+      failContext(context);
+      return;
+    }
+    const selected = /* @__PURE__ */ new Map();
+    for (const ticket of event.tickets) {
+      if (!ticket || !isNativeToken(ticket.ticket) || selected.has(ticket.ticket) || typeof ticket.url !== "string") {
+        failContext(context);
+        return;
+      }
+      const resource = context.catalog.match(ticket.url);
+      if (!resource) {
+        failContext(context);
+        return;
+      }
+      selected.set(ticket.ticket, resource);
+    }
+    context.lastBatch = serial;
+    context.batch = event.batch;
+    const tickets = new Map(event.tickets.map((ticket) => [ticket.ticket, { cancelled: false }]));
+    context.tickets = tickets;
+    const acquisitions = event.tickets.map(
+      async (ticket) => {
+        if (!context.live || tickets.get(ticket.ticket)?.cancelled) return false;
+        if (context.mapId === null) return null;
+        try {
+          return await context.controller.acquire();
+        } catch {
+          return false;
+        }
+      }
+    );
+    const authorities = await Promise.all(acquisitions);
+    if (disposed || !context.live || context.batch !== event.batch || installation !== event.installation)
+      return;
+    const results = event.tickets.map((ticket, index) => {
+      const reject = (code) => ({
+        ticket: ticket.ticket,
+        kind: "reject",
+        code
+      });
+      if (!foreground || tickets.get(ticket.ticket)?.cancelled)
+        return reject("NATIVE_ADMISSION_CANCELLED");
+      const authority = authorities[index];
+      if (authority === false) return reject("NATIVE_ADMISSION_DENIED");
+      if (context.mapId === null) return { ticket: ticket.ticket, kind: "delegate" };
+      const resource = selected.get(ticket.ticket);
+      if (!authority || !authorityAllowsResource(authority, resource, context.mapId))
+        return reject("NATIVE_ADMISSION_DENIED");
+      const validForMs = context.controller.transportBudget(authority);
+      if (!Number.isSafeInteger(validForMs) || validForMs <= nativeAdmissionLimits.validitySafetyMs || validForMs > 9e5) {
+        return reject("NATIVE_ADMISSION_EXPIRED");
+      }
+      return {
+        ticket: ticket.ticket,
+        kind: "grant",
+        validForMs,
+        authority: {
+          grant: authority.grant,
+          mapId: authority.mapId,
+          resourceOrigins: [...authority.resourceOrigins],
+          resourceScopes: [...authority.resourceScopes],
+          tilesetIds: [...authority.tilesetIds]
+        }
+      };
+    });
+    if (JSON.stringify(results).length > nativeAdmissionLimits.bridgeBytes) {
+      failContext(context);
+      return;
+    }
+    context.batch = null;
+    context.tickets = /* @__PURE__ */ new Map();
+    try {
+      await bridge.completeBatch(
+        event.installation,
+        context.id,
+        context.generation,
+        event.batch,
+        results
+      );
+    } catch {
+      if (context.live) failContext(context);
+    }
+  }
+  function onEvent(event) {
+    if (disposed || !event || event.installation !== installation) return;
+    if (event.kind === "ownershipLost") {
+      void dispose().catch(() => void 0);
+      return;
+    }
+    if (event.kind === "lifecycle") {
+      foreground = event.foreground === true;
+      for (const context2 of contexts.values()) {
+        if (foreground) void context2.controller.resume().catch(() => void 0);
+        else {
+          context2.controller.background();
+          for (const ticket of context2.tickets.values()) ticket.cancelled = true;
+        }
+      }
+      return;
+    }
+    const context = contexts.get(event.context);
+    if (!context || !context.live || event.generation !== context.generation) return;
+    if (event.kind === "retired") {
+      failContext(context);
+      return;
+    }
+    if (event.kind === "cancel") {
+      if (!Array.isArray(event.tickets) || event.tickets.length > nativeAdmissionLimits.queueDepth) {
+        failContext(context);
+        return;
+      }
+      for (const id of event.tickets) {
+        const ticket = context.tickets.get(id);
+        if (ticket) ticket.cancelled = true;
+      }
+      return;
+    }
+    if (event.kind === "response") {
+      if (Number.isInteger(event.status) && event.status >= 100 && event.status <= 599) {
+        try {
+          options.onObservation?.(Object.freeze({ context: context.id, status: event.status }));
+        } catch {
+        }
+      }
+      return;
+    }
+    if (event.kind === "batch") void handleBatch(context, event).catch(() => failContext(context));
+  }
+  const unsubscribe = bridge.subscribe((event) => {
+    try {
+      onEvent(event);
+    } catch {
+      void dispose().catch(() => void 0);
+    }
+  });
+  async function openMap(input) {
+    if (disposed) throw cancel();
+    let resources;
+    try {
+      resources = normalizeNativeResources(input.resources);
+      if (input.onRetired !== void 0 && typeof input.onRetired !== "function") throw cancel();
+    } catch {
+      throw cancel("NATIVE_ADMISSION_INVALID");
+    }
+    if (input.fetch && options.sessionFetch) throw cancel("NATIVE_ADMISSION_INVALID");
+    const ack = await install();
+    if (disposed) throw cancel();
+    if (contexts.size + pendingControllers.size >= nativeAdmissionLimits.contexts || contextSequence >= Number.MAX_SAFE_INTEGER) {
+      throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+    }
+    const identity = `${ack.installation}.${++contextSequence}`;
+    let sessionSequence = 0;
+    const sessionIdFactory = input.sessionIdFactory ?? (() => {
+      if (sessionSequence >= Number.MAX_SAFE_INTEGER) throw cancel("NATIVE_ADMISSION_INVALID");
+      return `${identity}.${++sessionSequence}`;
+    });
+    let boundFetch;
+    const fetch = options.sessionFetch ? (url, init) => {
+      if (!boundFetch) return Promise.reject(cancel("NATIVE_ADMISSION_CANCELLED"));
+      return boundFetch(url, init);
+    } : input.fetch ?? (input.binding.kind === "direct" ? async () => {
+      throw cancel("NATIVE_ADMISSION_INVALID");
+    } : void 0);
+    if (!fetch) throw cancel("NATIVE_ADMISSION_INVALID");
+    let controller;
+    try {
+      controller = factory({ binding: input.binding, fetch, now: input.now, sessionIdFactory });
+    } catch {
+      throw cancel("NATIVE_ADMISSION_INVALID");
+    }
+    pendingControllers.add(controller);
+    const mapId = input.binding.kind === "hosted" ? input.binding.mapId : null;
+    let orphan;
+    try {
+      const registered = await bridge.registerContext(ack.installation, { mapId, resources });
+      if (!registered || !isNativeToken(registered.context) || !Number.isSafeInteger(registered.generation) || registered.generation < 1 || contexts.has(registered.context)) {
+        void dispose().catch(() => void 0);
+        throw cancel("NATIVE_ADMISSION_INVALID");
+      }
+      orphan = registered.context;
+      if (disposed) throw cancel();
+      if (options.sessionFetch) boundFetch = options.sessionFetch(registered.context);
+      let retirement;
+      let retirementNotified = false;
+      const catalog = createNativeAdmissionCatalog(resources, registered.context, (additions) => {
+        if (!bridge.extendContext) return Promise.reject(cancel("NATIVE_ADMISSION_UNAVAILABLE"));
+        return bridge.extendContext(ack.installation, registered.context, additions);
+      });
+      const context = {
+        id: registered.context,
+        generation: registered.generation,
+        mapId,
+        live: true,
+        lastBatch: 0,
+        batch: null,
+        tickets: /* @__PURE__ */ new Map(),
+        catalog,
+        controller,
+        handle: void 0
+      };
+      context.handle = Object.freeze({
+        context: context.id,
+        generation: context.generation,
+        scope: Object.freeze({ installation: ack.installation, context: context.id }),
+        get state() {
+          return Object.freeze({
+            status: context.live ? "active" : "retired",
+            context: context.id
+          });
+        },
+        async prepare() {
+          if (!context.live || disposed) throw cancel();
+          if (context.mapId === null) return null;
+          if (!foreground || !controller.prepare) throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+          try {
+            const policy = await controller.prepare();
+            if (!context.live || disposed) throw cancel();
+            if (!foreground || !policy || policy.mapId !== context.mapId)
+              throw cancel("NATIVE_ADMISSION_DENIED");
+            return policy;
+          } catch {
+            throw cancel(
+              context.live && !disposed ? "NATIVE_ADMISSION_DENIED" : "NATIVE_ADMISSION_CANCELLED"
+            );
+          }
+        },
+        discriminate: catalog.discriminate,
+        discriminateForTest: catalog.discriminate,
+        extendResources: catalog.extend,
+        retire() {
+          if (retirement) return retirement;
+          context.live = false;
+          context.batch = null;
+          context.tickets.clear();
+          catalog.retire();
+          contexts.delete(context.id);
+          controller.dispose();
+          boundFetch = void 0;
+          const attempt = Promise.resolve().then(async () => {
+            try {
+              const retired = await bridge.retireContext(ack.installation, context.id);
+              if (retired?.retired !== true) throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+              return Object.freeze({ retired: true });
+            } catch {
+              throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+            }
+          });
+          retirement = attempt;
+          void attempt.catch(() => {
+            if (retirement === attempt) retirement = void 0;
+          });
+          if (!retirementNotified) {
+            retirementNotified = true;
+            try {
+              input.onRetired?.();
+            } catch {
+            }
+          }
+          return attempt;
+        }
+      });
+      if (!foreground) controller.background();
+      contexts.set(context.id, context);
+      orphan = void 0;
+      return context.handle;
+    } catch (error) {
+      controller.dispose();
+      boundFetch = void 0;
+      if (orphan) {
+        try {
+          await bridge.retireContext(ack.installation, orphan);
+        } catch {
+          void dispose().catch(() => void 0);
+        }
+      }
+      throw error instanceof NativeAdmissionError ? error : cancel("NATIVE_ADMISSION_UNAVAILABLE");
+    } finally {
+      pendingControllers.delete(controller);
+    }
+  }
+  function dispose() {
+    if (disposal) return disposal;
+    disposed = true;
+    status = "disposed";
+    const retiring = [...contexts.values()].map(
+      (context) => retire(context).catch(() => void 0)
+    );
+    for (const controller of pendingControllers) controller.dispose();
+    const attempt = (async () => {
+      try {
+        let id;
+        try {
+          id = await installed;
+        } catch {
+        }
+        await Promise.all(retiring);
+        if (!id) return Object.freeze({ removed: false, ownershipLost: false });
+        try {
+          const ack = await bridge.remove(id);
+          if (!ack || typeof ack.removed !== "boolean" || typeof ack.ownershipLost !== "boolean")
+            throw cancel("NATIVE_ADMISSION_INVALID");
+          return Object.freeze({ removed: ack.removed, ownershipLost: ack.ownershipLost });
+        } catch {
+          throw cancel("NATIVE_ADMISSION_UNAVAILABLE");
+        }
+      } finally {
+        unsubscribe();
+      }
+    })();
+    disposal = attempt;
+    void attempt.catch(() => {
+      if (disposal === attempt) disposal = void 0;
+    });
+    return attempt;
+  }
+  return Object.freeze({
+    install,
+    openMap,
+    async replaceMap(previous, input) {
+      if (disposed) throw cancel();
+      await previous.retire();
+      return openMap(input);
+    },
+    dispose,
+    get state() {
+      return Object.freeze({
+        status,
+        contexts: contexts.size,
+        pendingRegistrations: pendingControllers.size
+      });
+    }
+  });
+}
+export {
+  NativeAdmissionError,
+  createNativeAdmissionOwner
+};