@tileflow/core 0.1.0-alpha.20 → 0.1.0-alpha.21

package/dist/runtime.js

@@ -0,0 +1,1117 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/portable-identity-rules.ts
+function isTileflowPortableId(value) {
+  return typeof value === "string" && value.length <= tileflowPortableIdMaximumLength && tileflowPortableIdPattern.test(value) && !["constructor", "prototype"].includes(value) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(value);
+}
+function isTileflowThemeName(value) {
+  return isTileflowPortableId(value) && value !== "system";
+}
+var tileflowPortableIdMaximumLength, tileflowPortableIdPattern;
+var init_portable_identity_rules = __esm({
+  "src/portable-identity-rules.ts"() {
+    "use strict";
+    tileflowPortableIdMaximumLength = 64;
+    tileflowPortableIdPattern = /^[a-z][a-z0-9-]{0,63}$/u;
+  }
+});
+
+// src/portable-identity.ts
+import { z } from "zod";
+var tileflowPortableIdSchema, tileflowThemeNameSchema;
+var init_portable_identity = __esm({
+  "src/portable-identity.ts"() {
+    "use strict";
+    init_portable_identity_rules();
+    tileflowPortableIdSchema = z.string().min(1).max(tileflowPortableIdMaximumLength).regex(tileflowPortableIdPattern, {
+      message: "Expected lowercase kebab-case beginning with a letter"
+    }).refine(
+      (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+      "Expected a portable identifier that is not a reserved filename or prototype key"
+    );
+    tileflowThemeNameSchema = tileflowPortableIdSchema.refine(
+      isTileflowThemeName,
+      "Expected a concrete theme name; system is browser-only"
+    );
+  }
+});
+
+// src/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  parseTileflowRuntimeManifest: () => parseTileflowRuntimeManifest,
+  safeParseTileflowRuntimeManifest: () => safeParseTileflowRuntimeManifest,
+  tileflowRuntimeManifestLimits: () => tileflowRuntimeManifestLimits,
+  tileflowRuntimeManifestSchema: () => tileflowRuntimeManifestSchema,
+  tileflowRuntimeManifestVersion: () => tileflowRuntimeManifestVersion
+});
+import { z as z2 } from "zod";
+function parseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.parse(input);
+}
+function safeParseTileflowRuntimeManifest(input) {
+  return tileflowRuntimeManifestSchema.safeParse(input);
+}
+function validateUniqueFontFaces(fontFaces, context) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, fontFace] of fontFaces.entries()) {
+    const identity = `${fontFace.family}\0${fontFace.style ?? "normal"}\0${fontFace.weight ?? "400"}`;
+    const first = seen.get(identity);
+    if (first !== void 0) {
+      context.addIssue({
+        code: "custom",
+        message: `Duplicate font face identity; first declared at index ${first}`,
+        path: [index]
+      });
+      continue;
+    }
+    seen.set(identity, index);
+  }
+}
+function isPublicResourceUrl(value) {
+  if (value.startsWith("//")) return false;
+  if (!value.startsWith("/") && !value.startsWith("./") && !value.startsWith("../") && !isAbsolutePublicUrl(value)) {
+    return false;
+  }
+  return isSafeResolvedPublicUrl(value);
+}
+function isAbsolutePublicUrl(value) {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+  } catch {
+    return false;
+  }
+}
+function isSafeResolvedPublicUrl(value) {
+  try {
+    const url = new URL(value, "https://manifest.invalid/owner/manifest.json");
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash && !hasEncodedPathSeparator(value);
+  } catch {
+    return false;
+  }
+}
+function hasEncodedPathSeparator(value) {
+  return /%(?:2f|5c)/iu.test(value);
+}
+function isApiOrigin(value) {
+  try {
+    const url = new URL(value);
+    return isAbsolutePublicUrl(value) && url.pathname === "/" && !url.search && value.replace(/\/$/u, "") === url.origin;
+  } catch {
+    return false;
+  }
+}
+function findUnsafeManifestStructure(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const pending = [{ path: [], value: input }];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (visited.has(current.value)) continue;
+    visited.add(current.value);
+    if (!Array.isArray(current.value)) {
+      const prototype = Object.getPrototypeOf(current.value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        return { path: current.path, reason: "prototype" };
+      }
+    }
+    for (const key of Object.keys(current.value)) {
+      const path = [...current.path, Array.isArray(current.value) ? Number(key) : key];
+      if (key === "__proto__") return { path, reason: "key" };
+      const descriptor = Object.getOwnPropertyDescriptor(current.value, key);
+      if (descriptor && "value" in descriptor && descriptor.value && typeof descriptor.value === "object") {
+        pending.push({ path, value: descriptor.value });
+      }
+    }
+  }
+  return void 0;
+}
+var tileflowRuntimeManifestVersion, tileflowRuntimeManifestLimits, safeTextSchema, publicResourceUrlSchema, apiOriginSchema, viewSchema, fontFaceSchema, fontFacesSchema, manifestThemeSchema, manifestMapSchema, canonicalManifestSchema, safeManifestInputSchema, tileflowRuntimeManifestSchema;
+var init_manifest = __esm({
+  "src/manifest.ts"() {
+    "use strict";
+    init_portable_identity();
+    tileflowRuntimeManifestVersion = 1;
+    tileflowRuntimeManifestLimits = Object.freeze({ maximumBytes: 1024 * 1024 });
+    safeTextSchema = z2.string().min(1).max(2048).refine((value) => value === value.trim(), "Expected text without surrounding whitespace").refine((value) => !/[\p{Cc}\\]/u.test(value), "Expected safe text");
+    publicResourceUrlSchema = safeTextSchema.refine(isPublicResourceUrl, {
+      message: "Expected an HTTP(S), root-relative, or path-relative public URL"
+    });
+    apiOriginSchema = safeTextSchema.refine(isApiOrigin, {
+      message: "Expected an absolute HTTP(S) origin without path, credentials, query, or fragment"
+    });
+    viewSchema = z2.object({
+      bearing: z2.number().finite().min(-180).max(180).optional(),
+      center: z2.tuple([z2.number().finite().min(-180).max(180), z2.number().finite().min(-90).max(90)]).optional(),
+      pitch: z2.number().finite().min(0).max(85).optional(),
+      zoom: z2.number().finite().min(0).max(24).optional()
+    }).strict();
+    fontFaceSchema = z2.object({
+      family: safeTextSchema.max(100),
+      source: publicResourceUrlSchema,
+      style: z2.enum(["italic", "normal", "oblique"]).optional(),
+      weight: z2.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"]).optional()
+    }).strict();
+    fontFacesSchema = z2.array(fontFaceSchema).max(16).superRefine(validateUniqueFontFaces);
+    manifestThemeSchema = z2.object({
+      colorScheme: z2.enum(["dark", "light"]),
+      fontFaces: fontFacesSchema.optional(),
+      revision: safeTextSchema.max(128).optional(),
+      styleId: safeTextSchema.max(128).optional(),
+      styleUrl: publicResourceUrlSchema
+    }).strict();
+    manifestMapSchema = z2.object({
+      apiUrl: apiOriginSchema.optional(),
+      defaultTheme: tileflowThemeNameSchema,
+      environment: safeTextSchema.max(128).optional(),
+      mapId: safeTextSchema.max(128).optional(),
+      systemThemes: z2.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+      themes: z2.record(tileflowThemeNameSchema, manifestThemeSchema),
+      usageMode: z2.literal("session").optional(),
+      view: viewSchema.optional(),
+      worldGeneration: z2.literal("v1").optional()
+    }).strict().superRefine((entry, context) => {
+      const names = Object.keys(entry.themes);
+      if (names.length === 0) {
+        context.addIssue({ code: "custom", message: "Expected at least one theme", path: ["themes"] });
+      }
+      if (names.length > 64) {
+        context.addIssue({ code: "too_big", maximum: 64, origin: "object", path: ["themes"] });
+      }
+      if (!Object.hasOwn(entry.themes, entry.defaultTheme)) {
+        context.addIssue({
+          code: "custom",
+          message: "defaultTheme must name a declared theme",
+          path: ["defaultTheme"]
+        });
+      }
+      if (entry.systemThemes) {
+        for (const colorScheme of ["light", "dark"]) {
+          const name = entry.systemThemes[colorScheme];
+          const theme = entry.themes[name];
+          if (!theme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must name a declared theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          } else if (theme.colorScheme !== colorScheme) {
+            context.addIssue({
+              code: "custom",
+              message: `systemThemes.${colorScheme} must reference a ${colorScheme} theme`,
+              path: ["systemThemes", colorScheme]
+            });
+          }
+        }
+      }
+      if (entry.usageMode === void 0 !== (entry.worldGeneration === void 0)) {
+        context.addIssue({
+          code: "custom",
+          message: "usageMode and worldGeneration must be declared together"
+        });
+      }
+    });
+    canonicalManifestSchema = z2.object({
+      apiUrl: apiOriginSchema.optional(),
+      maps: z2.record(tileflowPortableIdSchema, manifestMapSchema),
+      version: z2.literal(tileflowRuntimeManifestVersion)
+    }).strict().superRefine((manifest, context) => {
+      const mapCount = Object.keys(manifest.maps).length;
+      if (mapCount === 0) {
+        context.addIssue({ code: "custom", message: "Expected at least one map", path: ["maps"] });
+      }
+      if (mapCount > 1e3) {
+        context.addIssue({ code: "too_big", maximum: 1e3, origin: "object", path: ["maps"] });
+      }
+      if (new TextEncoder().encode(JSON.stringify(manifest)).byteLength > tileflowRuntimeManifestLimits.maximumBytes) {
+        context.addIssue({
+          code: "too_big",
+          maximum: tileflowRuntimeManifestLimits.maximumBytes,
+          origin: "string",
+          message: "Manifest JSON exceeds the 1 MiB limit"
+        });
+      }
+    });
+    safeManifestInputSchema = z2.unknown().superRefine((input, context) => {
+      const unsafe = findUnsafeManifestStructure(input);
+      if (unsafe) {
+        context.addIssue({
+          code: "custom",
+          message: unsafe.reason === "prototype" ? "Expected plain manifest objects" : "Expected no prototype-mutating keys",
+          path: unsafe.path
+        });
+      }
+    });
+    tileflowRuntimeManifestSchema = safeManifestInputSchema.pipe(canonicalManifestSchema);
+  }
+});
+
+// src/runtime.ts
+init_portable_identity_rules();
+var defaultTileflowManifestUrl = "/tileflow/manifest.json";
+var defaultTileflowRuntimeView = Object.freeze({
+  bearing: 0,
+  center: [0, 20],
+  pitch: 0,
+  zoom: 2
+});
+var tileflowStyleFontFacesMetadataKey = "tileflow:fontFaces";
+var tileflowStyleFontFaceLimits = Object.freeze({
+  maximumCount: 16,
+  maximumSourceLength: 2048
+});
+var maxStaticImageDimension = 1280;
+var maxStaticImagePixels = 1280 * 1280;
+var defaultManifestCacheTtlMs = 3e4;
+var maximumManifestBytes = 1024 * 1024;
+var maximumSessionGrantBytes = 64 * 1024;
+var manifestCache = new globalThis.Map();
+var missingStaticMapIdWarnings = /* @__PURE__ */ new Set();
+function shouldLoadTileflowManifest(options) {
+  return options.source.kind === "tileflow";
+}
+function validateTileflowRuntimeSource(source) {
+  if (source === void 0) {
+    return { code: "missing-source", error: "source is required", ok: false };
+  }
+  if (!isPlainRuntimeRecord(source)) {
+    return { code: "invalid-source", error: "source must be an object", ok: false };
+  }
+  if (source.kind === "tileflow") {
+    if (!isTileflowPortableId(source.map) || source.manifestUrl !== void 0 && (typeof source.manifestUrl !== "string" || source.manifestUrl.length === 0)) {
+      return {
+        code: "invalid-source",
+        error: "a tileflow source requires a portable map id and an optional non-empty manifestUrl",
+        ok: false
+      };
+    }
+    return { ok: true };
+  }
+  if (source.kind === "maplibre") {
+    const style = source.style;
+    if ((typeof style !== "string" || style.length === 0) && (!style || typeof style !== "object" || Array.isArray(style))) {
+      return {
+        code: "invalid-source",
+        error: "a maplibre source requires a style object or non-empty style URL",
+        ok: false
+      };
+    }
+    return { ok: true };
+  }
+  return {
+    code: "invalid-source",
+    error: "source.kind must be 'tileflow' or 'maplibre'",
+    ok: false
+  };
+}
+function validateTileflowThemeSelection(value) {
+  return value === "system" || isTileflowThemeName(value);
+}
+function assertValidTileflowRuntimeSource(source) {
+  const validation = validateTileflowRuntimeSource(source);
+  if (!validation.ok) {
+    throw new TypeError(`Invalid Tileflow runtime source: ${validation.error}`);
+  }
+}
+function resolveTileflowRuntimeStyle(options) {
+  assertValidTileflowRuntimeSource(options.source);
+  if (options.source.kind === "maplibre") {
+    if (options.theme !== void 0) {
+      throw new TypeError("The theme option is only valid for a Tileflow map source.");
+    }
+    if (typeof options.source.style !== "string") {
+      return {
+        fontFaces: getTileflowStyleFontFaces(options.source.style),
+        style: options.source.style
+      };
+    }
+    return {
+      analytics: inferTileflowAnalyticsFromStyleUrl(options.source.style),
+      style: options.source.style
+    };
+  }
+  if (options.manifestMap) {
+    const theme = resolveTileflowRuntimeTheme(
+      options.manifestMap,
+      options.theme,
+      options.colorScheme
+    );
+    return {
+      analytics: {
+        apiUrl: options.manifestMap.apiUrl,
+        mapId: options.manifestMap.mapId,
+        styleId: theme.styleId
+      },
+      colorScheme: theme.colorScheme,
+      ...theme.fontFaces === void 0 ? {} : { fontFaces: [...theme.fontFaces] },
+      revision: theme.revision,
+      style: theme.styleUrl,
+      theme: theme.name
+    };
+  }
+  return null;
+}
+function resolveTileflowRuntimeTheme(map, selection, colorScheme) {
+  let name;
+  if (selection === void 0) {
+    name = map.defaultTheme;
+  } else if (selection === "system") {
+    if (!map.systemThemes) {
+      throw new Error(
+        `Tileflow map "${map.name}" does not declare systemThemes; select a concrete theme.`
+      );
+    }
+    if (!colorScheme) {
+      throw new Error('Resolving theme="system" requires an explicit browser color scheme.');
+    }
+    name = map.systemThemes[colorScheme];
+  } else {
+    name = selection;
+  }
+  if (!isTileflowThemeName(name)) {
+    throw new Error(
+      `Tileflow resolved invalid theme ${JSON.stringify(name)} for map "${map.name}"; expected a concrete portable theme name.`
+    );
+  }
+  const theme = Object.hasOwn(map.themes, name) ? map.themes[name] : void 0;
+  if (!theme) {
+    const available = Object.keys(map.themes).sort().join(", ");
+    throw new Error(
+      `Unknown Tileflow theme "${name}" for map "${map.name}". Available themes: ${available}.`
+    );
+  }
+  return { ...theme, name };
+}
+function getTileflowStyleFontFaces(style) {
+  const input = style.metadata?.[tileflowStyleFontFacesMetadataKey];
+  if (input === void 0) return [];
+  if (!Array.isArray(input) || input.length > tileflowStyleFontFaceLimits.maximumCount) {
+    throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return input.map((value) => {
+    if (!isPlainRuntimeRecord(value)) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const keys = Object.keys(value);
+    if (keys.some((key2) => !["family", "source", "style", "weight"].includes(key2))) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const family = value.family;
+    const source = value.source;
+    const fontStyle = value.style;
+    const weight = value.weight;
+    if (typeof family !== "string" || family.length === 0 || family.length > 100 || family !== family.trim() || /[\p{Cc}\\]/u.test(family) || typeof source !== "string" || source.length === 0 || source.length > tileflowStyleFontFaceLimits.maximumSourceLength || source !== source.trim() || /[\p{Cc}\\]/u.test(source) || !isTileflowPublicFontUrl(source) || fontStyle !== void 0 && !["italic", "normal", "oblique"].includes(String(fontStyle)) || weight !== void 0 && !/^[1-9]00$/u.test(String(weight))) {
+      throw new TypeError("Invalid Tileflow style fontFaces metadata.");
+    }
+    const face = {
+      family,
+      source,
+      ...fontStyle === void 0 ? {} : { style: fontStyle },
+      ...weight === void 0 ? {} : { weight }
+    };
+    const key = `${face.family}\0${face.style ?? "normal"}\0${face.weight ?? "400"}`;
+    if (seen.has(key)) throw new TypeError("Invalid duplicate Tileflow style fontFace metadata.");
+    seen.add(key);
+    return face;
+  });
+}
+function normalizeTileflowUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function createTileflowSessionId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+    return `ses_${crypto.randomUUID()}`;
+  }
+  return `ses_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function createTileflowSessionController(input) {
+  const fetchGrant = input.fetch ?? globalThis.fetch;
+  const grantTimeoutMs = validateSessionGrantTimeout(input.grantTimeoutMs);
+  const now = input.now ?? (() => /* @__PURE__ */ new Date());
+  const sessionIdFactory = input.sessionIdFactory ?? createTileflowSessionId;
+  const createSession = (startedAt) => ({
+    binding: null,
+    grant: null,
+    grantPromise: null,
+    pendingGrantRequests: 0,
+    requestCount: 0,
+    sessionId: sessionIdFactory(),
+    startedAt
+  });
+  let activeSession = createSession(now().getTime());
+  async function resolveGrant(session, analytics, at) {
+    if (session.grant && session.grant.expiresAt - at > 3e4) {
+      return { grant: session.grant, session };
+    }
+    session.pendingGrantRequests += 1;
+    try {
+      if (!session.grantPromise) {
+        const pending = (async () => {
+          try {
+            const nextGrant = await requestSessionGrant({
+              analytics,
+              at,
+              fetchGrant,
+              timeoutMs: grantTimeoutMs,
+              sessionId: session.sessionId,
+              source: input.source
+            });
+            session.grant = nextGrant;
+            return { grant: nextGrant, session };
+          } catch (error) {
+            if (!(error instanceof TileflowSessionRestartError)) throw error;
+            const replacement = createSession(at);
+            replacement.binding = session.binding;
+            replacement.requestCount = session.pendingGrantRequests;
+            if (activeSession === session) activeSession = replacement;
+            const replacementPending = requestSessionGrant({
+              analytics,
+              at,
+              fetchGrant,
+              timeoutMs: grantTimeoutMs,
+              sessionId: replacement.sessionId,
+              source: input.source
+            }).then((nextGrant) => {
+              replacement.grant = nextGrant;
+              return { grant: nextGrant, session: replacement };
+            });
+            replacement.grantPromise = replacementPending;
+            try {
+              return await replacementPending;
+            } finally {
+              if (replacement.grantPromise === replacementPending) {
+                replacement.grantPromise = null;
+              }
+            }
+          } finally {
+            session.grantPromise = null;
+          }
+        })();
+        session.grantPromise = pending;
+      }
+      return await session.grantPromise;
+    } finally {
+      session.pendingGrantRequests -= 1;
+    }
+  }
+  return {
+    get sessionId() {
+      return activeSession.sessionId;
+    },
+    async resolveRequestUrl(url, analytics) {
+      if (!analytics || !analytics.mapId) return void 0;
+      const at = now().getTime();
+      if (at - activeSession.startedAt >= 6 * 60 * 60 * 1e3 || activeSession.requestCount >= 1e4) {
+        activeSession = createSession(at);
+      }
+      const apiOrigin = originOf(getTileflowAnalyticsApiUrl(analytics));
+      const binding = JSON.stringify([getTileflowAnalyticsApiUrl(analytics), analytics.mapId]);
+      let session = activeSession;
+      const grantedOrigins = session.binding === binding ? session.grant?.resourceOrigins : void 0;
+      if (!isEligibleResource(url, analytics.mapId, apiOrigin, grantedOrigins)) {
+        return void 0;
+      }
+      if (session.binding !== null && session.binding !== binding) {
+        session = createSession(at);
+        activeSession = session;
+      }
+      session.binding = binding;
+      session.requestCount += 1;
+      const resolved = await resolveGrant(session, analytics, at);
+      const nextUrl = new URL(url);
+      nextUrl.searchParams.set("session", resolved.session.sessionId);
+      nextUrl.searchParams.set("map", analytics.mapId);
+      if (analytics.styleId) nextUrl.searchParams.set("styleId", analytics.styleId);
+      if (resolved.grant.token) nextUrl.searchParams.set("grant", resolved.grant.token);
+      return nextUrl.toString();
+    }
+  };
+}
+async function requestSessionGrant(input) {
+  return runWithinSessionGrantTimeout(input.timeoutMs, async (signal) => {
+    const apiUrl = getTileflowAnalyticsApiUrl(input.analytics);
+    const response = await input.fetchGrant(`${apiUrl}/v1/sessions/start`, {
+      body: JSON.stringify({
+        mapId: input.analytics.mapId,
+        sdkVersion: input.analytics.sdkVersion,
+        sessionId: input.sessionId,
+        source: input.analytics.source ?? input.source,
+        styleId: input.analytics.styleId
+      }),
+      credentials: "omit",
+      headers: { "Content-Type": "application/json" },
+      method: "POST",
+      signal
+    });
+    throwIfSessionGrantAborted(signal);
+    let body = null;
+    try {
+      const source = await readBoundedUtf8Response(response, maximumSessionGrantBytes, {
+        invalidUtf8: "Tileflow session grant response was not valid UTF-8.",
+        tooLarge: "Tileflow session grant response was too large."
+      });
+      body = JSON.parse(source);
+    } catch (error) {
+      if (error instanceof SyntaxError) body = null;
+      else throw error;
+    }
+    throwIfSessionGrantAborted(signal);
+    if (response.status === 409 && isRecord(body) && body.code === "COMMERCIAL_SESSION_RESTART_REQUIRED" && body.ok === false && body.retryWithNewSession === true && body.sessionId === input.sessionId) {
+      throw new TileflowSessionRestartError();
+    }
+    if (!response.ok) {
+      throw new Error(`Tileflow session grant failed: ${response.status}`);
+    }
+    const parsed = parseSessionGrantResponse(body, input.sessionId);
+    if (!parsed) {
+      throw new Error("Tileflow session grant response was invalid.");
+    }
+    const expiresAt = parsed.grant ? Date.parse(parsed.expiresAt) : input.at + 6e4;
+    if (response.status === 201 && (!parsed.grant || !parsed.expiresAt) || parsed.grant && (!Number.isFinite(expiresAt) || expiresAt <= input.at)) {
+      throw new Error("Tileflow session grant response was invalid.");
+    }
+    return {
+      expiresAt,
+      resourceOrigins: new Set(
+        [originOf(apiUrl), ...(parsed.resourceOrigins ?? []).map(originOf)].filter(
+          (value) => Boolean(value)
+        )
+      ),
+      token: parsed.grant ?? null
+    };
+  });
+}
+function validateSessionGrantTimeout(value) {
+  const resolved = value ?? 1e4;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > 12e4) {
+    throw new Error("Tileflow session grantTimeoutMs must be an integer from 1 to 120000");
+  }
+  return resolved;
+}
+async function runWithinSessionGrantTimeout(timeoutMs, operation) {
+  const controller = new AbortController();
+  const timeoutError = new Error(`Tileflow session grant timed out after ${timeoutMs}ms`);
+  const timeout = setTimeout(() => controller.abort(timeoutError), timeoutMs);
+  try {
+    return await raceSessionGrantWithAbort(operation(controller.signal), controller.signal);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function raceSessionGrantWithAbort(operation, signal) {
+  if (signal.aborted) return Promise.reject(sessionGrantAbortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(sessionGrantAbortReason(signal));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function throwIfSessionGrantAborted(signal) {
+  if (signal.aborted) throw sessionGrantAbortReason(signal);
+}
+function sessionGrantAbortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  const error = new Error("Tileflow session grant was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function parseSessionGrantResponse(value, expectedSessionId) {
+  if (!isRecord(value) || value.ok !== true || value.sessionId !== expectedSessionId) return null;
+  if (value.usageMode !== void 0 && value.usageMode !== "session") return null;
+  if (value.billingEnabled !== void 0 && value.billingEnabled !== false) return null;
+  if (value.disposition !== void 0 && value.disposition !== "ordinary" && value.disposition !== "unbilled_fail_open") {
+    return null;
+  }
+  if (value.meterMode !== void 0 && value.meterMode !== "disabled" && value.meterMode !== "shadow" && value.meterMode !== "enforced") {
+    return null;
+  }
+  if (value.grant !== void 0 && (typeof value.grant !== "string" || value.grant.length === 0 || value.grant.length > 8192)) {
+    return null;
+  }
+  if (value.expiresAt !== void 0 && typeof value.expiresAt !== "string") return null;
+  if (value.grant !== void 0 && value.expiresAt === void 0) return null;
+  if (value.resourceOrigins !== void 0 && (!Array.isArray(value.resourceOrigins) || value.resourceOrigins.length > 32 || value.resourceOrigins.some((origin) => !originOf(origin)))) {
+    return null;
+  }
+  return value;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlainRuntimeRecord(value) {
+  if (!isRecord(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isTileflowPublicFontUrl(value) {
+  if (value.startsWith("//")) return false;
+  if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) return true;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+var TileflowSessionRestartError = class extends Error {
+  constructor() {
+    super("Tileflow session must restart");
+    this.name = "TileflowSessionRestartError";
+  }
+};
+function isEligibleResource(value, mapId, apiOrigin, grantedOrigins) {
+  try {
+    const url = new URL(value);
+    if (url.username || url.password) return false;
+    const originAllowed = url.origin === apiOrigin || grantedOrigins?.has(url.origin) || apiOrigin === "https://api.tileflow.dev" && url.origin === "https://cdn.tileflow.dev";
+    if (!originAllowed) return false;
+    return url.pathname === `/maps/${encodeURIComponent(mapId)}/style.json` || url.pathname.startsWith("/tiles/") || url.pathname.startsWith("/v1/tiles/") || url.pathname.startsWith("/fonts/") || url.pathname.startsWith("/sprites/");
+  } catch {
+    return false;
+  }
+}
+function originOf(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) return null;
+    return url.origin;
+  } catch {
+    return null;
+  }
+}
+function resolveTileflowAnalyticsRequestUrl(url, analytics, sessionId) {
+  if (!analytics || analytics.enabled === false) {
+    return void 0;
+  }
+  const apiUrl = getTileflowAnalyticsApiUrl(analytics);
+  if (!apiUrl || !isTileflowTileUrl(url, apiUrl)) {
+    return void 0;
+  }
+  const nextUrl = new URL(url);
+  nextUrl.searchParams.set("session", sessionId);
+  if (analytics.mapId) {
+    nextUrl.searchParams.set("map", analytics.mapId);
+  }
+  if (analytics.styleId) {
+    nextUrl.searchParams.set("styleId", analytics.styleId);
+  }
+  return nextUrl.toString();
+}
+function startTileflowSession(analytics, input) {
+  if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
+    return;
+  }
+  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
+  const payload = JSON.stringify({
+    mapId: input.mapId,
+    metadata: analytics.metadata,
+    referrer: typeof document === "undefined" ? void 0 : document.referrer || "",
+    sdkVersion: analytics.sdkVersion,
+    sessionId: input.sessionId,
+    source: analytics.source ?? input.source,
+    styleId: input.styleId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const blob = new Blob([payload], { type: "application/json" });
+  if (navigator.sendBeacon?.(endpoint, blob)) {
+    return;
+  }
+  void fetch(endpoint, {
+    body: payload,
+    credentials: "omit",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    keepalive: true,
+    method: "POST"
+  }).catch(() => void 0);
+}
+function getTileflowAnalyticsApiUrl(analytics) {
+  if (analytics.apiUrl) {
+    return normalizeTileflowUrl(analytics.apiUrl);
+  }
+  if (analytics.endpoint) {
+    try {
+      const url = new URL(analytics.endpoint, getTileflowLocationOrigin());
+      return url.origin;
+    } catch {
+      return "https://api.tileflow.dev";
+    }
+  }
+  return "https://api.tileflow.dev";
+}
+function mergeTileflowAnalytics(userAnalytics, runtimeAnalytics) {
+  if (!userAnalytics && !runtimeAnalytics?.mapId) {
+    return void 0;
+  }
+  return {
+    ...runtimeAnalytics,
+    ...userAnalytics,
+    apiUrl: userAnalytics?.apiUrl ?? runtimeAnalytics?.apiUrl,
+    mapId: userAnalytics?.mapId ?? runtimeAnalytics?.mapId,
+    styleId: userAnalytics?.styleId ?? runtimeAnalytics?.styleId
+  };
+}
+function resolveTileflowMapMode(options) {
+  return options.mode ?? "interactive";
+}
+function resolveTileflowRuntimeView(options) {
+  const manifestView = options.manifestMap?.view;
+  return {
+    ...options.fallback ?? defaultTileflowRuntimeView,
+    ...manifestView ?? {},
+    ...options.bearing !== void 0 ? { bearing: options.bearing } : {},
+    ...options.center !== void 0 ? { center: options.center } : {},
+    ...options.pitch !== void 0 ? { pitch: options.pitch } : {},
+    ...options.zoom !== void 0 ? { zoom: options.zoom } : {}
+  };
+}
+function normalizeTileflowRuntimeCenter(center, fallback = defaultTileflowRuntimeView.center) {
+  if (!center) return [fallback[0], fallback[1]];
+  let longitude;
+  let latitude;
+  if (Array.isArray(center)) {
+    [longitude, latitude] = center;
+  } else {
+    const objectCenter = center;
+    longitude = objectCenter.lng ?? objectCenter.lon;
+    latitude = objectCenter.lat;
+  }
+  if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) {
+    return [fallback[0], fallback[1]];
+  }
+  return [longitude, latitude];
+}
+function loadTileflowManifest(url, options = {}) {
+  assertSafeManifestRequestUrl(url);
+  const ttl = normalizeManifestCacheTtl(options.cacheTtlMs);
+  const timeoutMs = normalizeManifestTimeout(options.timeoutMs);
+  const cacheable = ttl > 0 && !options.fetch && !options.signal;
+  const now = Date.now();
+  const cached = cacheable ? manifestCache.get(url) : void 0;
+  if (cached && cached.expiresAt > now) return cached.promise;
+  if (cached) manifestCache.delete(url);
+  const fetchManifest = options.fetch ?? globalThis.fetch;
+  const requestSignal = createManifestRequestSignal(options.signal, timeoutMs);
+  const promise = Promise.resolve().then(() => fetchManifest(url, { cache: "no-store", signal: requestSignal.signal })).then(async (response) => {
+    if (response.status === 404) {
+      manifestCache.delete(url);
+      return null;
+    }
+    if (!response.ok) throw new Error(`Tileflow manifest failed: ${response.status}`);
+    const source = await readBoundedManifestResponse(response);
+    let input;
+    try {
+      input = JSON.parse(source);
+    } catch {
+      throw new Error("Tileflow manifest is not valid JSON.");
+    }
+    try {
+      const { parseTileflowRuntimeManifest: parseTileflowRuntimeManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+      return resolveLoadedTileflowManifestUrls(
+        parseTileflowRuntimeManifest2(input),
+        response.url || resolveTileflowLoadedResourceUrl(url, getTileflowLocationBaseUrl())
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "schema validation failed";
+      throw new Error(`Invalid Tileflow manifest: ${message}`);
+    }
+  }).catch((error) => {
+    manifestCache.delete(url);
+    throw error;
+  }).finally(requestSignal.cleanup);
+  if (cacheable) manifestCache.set(url, { expiresAt: now + ttl, promise });
+  return promise;
+}
+function resolveLoadedTileflowManifestUrls(manifest, manifestUrl) {
+  return {
+    ...manifest,
+    maps: Object.fromEntries(
+      Object.entries(manifest.maps).map(([mapName, entry]) => [
+        mapName,
+        {
+          ...entry,
+          themes: Object.fromEntries(
+            Object.entries(entry.themes).map(([themeName, theme]) => {
+              const styleUrl = resolveTileflowLoadedResourceUrl(theme.styleUrl, manifestUrl);
+              return [
+                themeName,
+                {
+                  ...theme,
+                  styleUrl,
+                  ...theme.fontFaces ? {
+                    fontFaces: theme.fontFaces.map((definition) => ({
+                      ...definition,
+                      source: resolveTileflowLoadedResourceUrl(definition.source, styleUrl)
+                    }))
+                  } : {}
+                }
+              ];
+            })
+          )
+        }
+      ])
+    )
+  };
+}
+function resolveTileflowLoadedResourceUrl(value, baseUrl) {
+  let url;
+  try {
+    url = new URL(value, baseUrl);
+  } catch {
+    throw new TypeError("Tileflow manifest resource URL is invalid.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.hash || /%(?:2f|5c)/iu.test(value)) {
+    throw new TypeError("Tileflow manifest resource URL is invalid.");
+  }
+  return url.toString();
+}
+function clearTileflowManifestCache(url) {
+  if (url === void 0) manifestCache.clear();
+  else manifestCache.delete(url);
+}
+function resolveTileflowManifestMap(manifest, mapName) {
+  if (!Object.hasOwn(manifest.maps, mapName)) return null;
+  const entry = manifest.maps[mapName];
+  const defaultStyleUrl = entry.themes[entry.defaultTheme]?.styleUrl;
+  const analytics = defaultStyleUrl ? inferTileflowAnalyticsFromStyleUrl(defaultStyleUrl) : void 0;
+  return {
+    apiUrl: entry.apiUrl ?? manifest.apiUrl ?? analytics?.apiUrl,
+    mapId: entry.mapId ?? analytics?.mapId,
+    name: mapName,
+    defaultTheme: entry.defaultTheme,
+    ...entry.environment ? { environment: entry.environment } : {},
+    ...entry.systemThemes ? { systemThemes: { ...entry.systemThemes } } : {},
+    themes: entry.themes,
+    usageMode: entry.usageMode,
+    view: entry.view,
+    worldGeneration: entry.worldGeneration
+  };
+}
+function resolveTileflowStaticImageUrl(input) {
+  if (!input.manifestMap?.mapId) {
+    warnMissingStaticMapId(input.manifestMap);
+    return void 0;
+  }
+  if (!input.imageSize) {
+    return void 0;
+  }
+  const apiUrl = normalizeTileflowUrl(input.manifestMap.apiUrl ?? "https://api.tileflow.dev");
+  const mapId = encodeURIComponent(input.manifestMap.mapId);
+  const url = new URL(`/maps/${mapId}/static.png`, apiUrl);
+  const theme = resolveTileflowRuntimeTheme(input.manifestMap, input.theme, input.colorScheme);
+  url.searchParams.set("center", input.center.join(","));
+  url.searchParams.set("theme", theme.name);
+  url.searchParams.set("zoom", String(input.zoom));
+  url.searchParams.set("width", String(input.imageSize.width));
+  url.searchParams.set("height", String(input.imageSize.height));
+  return url.toString();
+}
+function warnMissingStaticMapId(manifestMap) {
+  const styleUrl = manifestMap ? manifestMap.themes[manifestMap.defaultTheme]?.styleUrl : void 0;
+  if (!styleUrl || missingStaticMapIdWarnings.has(styleUrl) || typeof console === "undefined") {
+    return;
+  }
+  missingStaticMapIdWarnings.add(styleUrl);
+  console.warn(
+    `Tileflow image mode requires a deployed manifest entry with mapId. The manifest style URL "${styleUrl}" cannot be converted to a static image URL.`
+  );
+}
+function normalizeTileflowStaticImageSize(input) {
+  let width = clampTileflowImageDimension(input.width);
+  let height = clampTileflowImageDimension(input.height);
+  const pixelCount = width * height;
+  if (pixelCount > maxStaticImagePixels) {
+    const scale = Math.sqrt(maxStaticImagePixels / pixelCount);
+    width = clampTileflowImageDimension(width * scale);
+    height = clampTileflowImageDimension(height * scale);
+  }
+  return { height, width };
+}
+async function readBoundedManifestResponse(response) {
+  return readBoundedUtf8Response(response, maximumManifestBytes, {
+    invalidUtf8: "Tileflow manifest is not valid UTF-8.",
+    tooLarge: "Tileflow manifest is too large."
+  });
+}
+async function readBoundedUtf8Response(response, maximumBytes, errors) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength !== null) {
+    const declaredBytes = Number(contentLength);
+    if (Number.isFinite(declaredBytes) && declaredBytes > maximumBytes) {
+      throw new Error(errors.tooLarge);
+    }
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  while (true) {
+    const next = await reader.read();
+    if (next.done) break;
+    byteLength += next.value.byteLength;
+    if (byteLength > maximumBytes) {
+      await reader.cancel();
+      throw new Error(errors.tooLarge);
+    }
+    chunks.push(next.value);
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error(errors.invalidUtf8);
+  }
+}
+function normalizeManifestCacheTtl(value) {
+  if (value === void 0) return defaultManifestCacheTtlMs;
+  if (!Number.isFinite(value) || value < 0 || value > 5 * 6e4) {
+    throw new TypeError("cacheTtlMs must be between 0 and 300000 milliseconds.");
+  }
+  return value;
+}
+function normalizeManifestTimeout(value) {
+  if (value === void 0) return 1e4;
+  if (!Number.isFinite(value) || value < 1 || value > 6e4) {
+    throw new TypeError("timeoutMs must be between 1 and 60000 milliseconds.");
+  }
+  return value;
+}
+function createManifestRequestSignal(external, timeoutMs) {
+  const controller = new AbortController();
+  const abortFromExternal = () => controller.abort(external?.reason);
+  if (external?.aborted) abortFromExternal();
+  else external?.addEventListener("abort", abortFromExternal, { once: true });
+  const timeout = setTimeout(
+    () => controller.abort(new DOMException("Timed out", "TimeoutError")),
+    timeoutMs
+  );
+  return {
+    cleanup() {
+      clearTimeout(timeout);
+      external?.removeEventListener("abort", abortFromExternal);
+    },
+    signal: controller.signal
+  };
+}
+function assertSafeManifestRequestUrl(value) {
+  if (value.length < 1 || value.length > 2048 || /[\p{Cc}\\]/u.test(value) || value.startsWith("//") || /%(?:2f|5c)/iu.test(value)) {
+    throw new TypeError("Tileflow manifest URL must be a safe HTTP(S) or relative URL.");
+  }
+  try {
+    const url = new URL(value, getTileflowLocationOrigin());
+    if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password || url.hash) {
+      throw new Error("unsafe");
+    }
+  } catch {
+    throw new TypeError("Tileflow manifest URL must be a safe HTTP(S) or relative URL.");
+  }
+}
+function inferTileflowAnalyticsFromStyleUrl(styleUrl) {
+  try {
+    const url = new URL(styleUrl, getTileflowLocationOrigin());
+    const match = url.pathname.match(/^\/maps\/([^/]+)\/style\.json$/);
+    if (!match?.[1]) {
+      return void 0;
+    }
+    return {
+      apiUrl: url.origin,
+      mapId: match[1],
+      styleId: url.toString()
+    };
+  } catch {
+    return void 0;
+  }
+}
+function isTileflowTileUrl(url, apiUrl) {
+  try {
+    const parsedUrl = new URL(url);
+    const parsedApiUrl = new URL(apiUrl);
+    return parsedUrl.origin === parsedApiUrl.origin && isTilePath(parsedUrl);
+  } catch {
+    return false;
+  }
+}
+function isTilePath(url) {
+  return url.pathname.startsWith("/tiles/") || url.pathname.startsWith("/v1/tiles/");
+}
+function clampTileflowImageDimension(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 640;
+  }
+  return Math.max(64, Math.min(maxStaticImageDimension, Math.round(value)));
+}
+function getTileflowLocationOrigin() {
+  if (typeof window === "undefined") {
+    return "http://localhost";
+  }
+  return window.location.origin;
+}
+function getTileflowLocationBaseUrl() {
+  if (typeof document !== "undefined" && document.baseURI) return document.baseURI;
+  if (typeof window !== "undefined" && window.location.href) return window.location.href;
+  return `${getTileflowLocationOrigin().replace(/\/+$/u, "")}/`;
+}
+export {
+  assertValidTileflowRuntimeSource,
+  clearTileflowManifestCache,
+  createTileflowSessionController,
+  createTileflowSessionId,
+  defaultTileflowManifestUrl,
+  defaultTileflowRuntimeView,
+  getTileflowAnalyticsApiUrl,
+  getTileflowStyleFontFaces,
+  inferTileflowAnalyticsFromStyleUrl,
+  loadTileflowManifest,
+  mergeTileflowAnalytics,
+  normalizeTileflowRuntimeCenter,
+  normalizeTileflowStaticImageSize,
+  normalizeTileflowUrl,
+  resolveTileflowAnalyticsRequestUrl,
+  resolveTileflowManifestMap,
+  resolveTileflowMapMode,
+  resolveTileflowRuntimeStyle,
+  resolveTileflowRuntimeTheme,
+  resolveTileflowRuntimeView,
+  resolveTileflowStaticImageUrl,
+  shouldLoadTileflowManifest,
+  startTileflowSession,
+  tileflowStyleFontFaceLimits,
+  tileflowStyleFontFacesMetadataKey,
+  validateTileflowRuntimeSource,
+  validateTileflowThemeSelection
+};