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

package/dist/internal/session.js

@@ -0,0 +1,887 @@
+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/session-controller.ts
+import { resolveTileflowNativeManifestUrl } 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 = resolveTileflowNativeManifestUrl(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 = resolveTileflowNativeManifestUrl(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"));
+      }
+    );
+  });
+}
+export {
+  HostedNativeSessionError,
+  createHostedNativeSessionController
+};