@tileflow/core 0.1.0-alpha.17 → 0.1.0-alpha.18

package/README.md

@@ -272,6 +272,19 @@ their frame scheduler plus MapLibre event and marker operations after mount. The
 is documented in
 [`docs/contracts/framework-browser-runtime.md`](../../docs/contracts/framework-browser-runtime.md).
 
+## Hosted session authorization
+
+The framework adapters use `createTileflowSessionController` to obtain one short-lived session
+grant before eligible hosted style, tile, font, or sprite requests. Concurrent resources share the
+same preflight, grants are attached only to reviewed HTTP(S) origins, and an expired unused session
+rotates once when the server requests it. A controller also rotates after six hours or 10,000
+eligible requests. The preflight has a 10-second client timeout by default; direct controller users
+can set `grantTimeoutMs` from 1 to 120,000 milliseconds.
+
+`analytics.enabled: false` disables only the optional analytics beacon. It does not disable this
+server-owned commercial authorization. User `transformRequest` callbacks still run first; Tileflow
+then decorates only the resulting eligible URL and preserves the other request options.
+
 Other subpaths under `src/`, `themes/`, `templates/`, and `modules/` are internal implementation
 details and can change during alpha releases.
 

package/dist/browser.d.ts

@@ -1,4 +1,4 @@
-import { T as TileflowAnalytics } from './runtime-BMZ_tuba.js';
+import { T as TileflowAnalytics, a as TileflowSessionController } from './runtime-Bg--GMWM.js';
 import 'zod';
 
 type TileflowMapReadinessState = 'error' | 'idle' | 'loading';
@@ -35,6 +35,7 @@ type TileflowMarkerController<TMap, TDefinition, TMarker> = {
     replace: (map: TMap, definitions: readonly TDefinition[]) => void;
 };
 declare function createTileflowSessionStarter(options: {
+    getSessionId?: () => string;
     sessionId: string;
     source: string;
     startSession?: TileflowSessionSender;
@@ -55,6 +56,7 @@ declare function createTileflowTransformRequest<TRequest extends TileflowTransfo
     always: true;
     asyncAnalyticsTiming?: TileflowAsyncAnalyticsTiming;
     getAnalytics: () => TileflowAnalytics | undefined;
+    sessionController?: TileflowSessionController;
     sessionId: string;
     transformRequest?: TileflowUserTransformRequest<TRequest, TResourceType>;
 }): TileflowTransformRequest<TRequest, TResourceType>;
@@ -62,6 +64,7 @@ declare function createTileflowTransformRequest<TRequest extends TileflowTransfo
     always?: boolean;
     asyncAnalyticsTiming?: TileflowAsyncAnalyticsTiming;
     getAnalytics: () => TileflowAnalytics | undefined;
+    sessionController?: TileflowSessionController;
     sessionId: string;
     transformRequest?: TileflowUserTransformRequest<TRequest, TResourceType>;
 }): TileflowTransformRequest<TRequest, TResourceType> | undefined;

package/dist/browser.js

@@ -26,7 +26,7 @@ function startTileflowSession(analytics, input) {
   if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
     return;
   }
-  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/start`;
+  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
   const payload = JSON.stringify({
     mapId: input.mapId,
     metadata: analytics.metadata,
@@ -49,7 +49,7 @@ function startTileflowSession(analytics, input) {
     },
     keepalive: true,
     method: "POST"
-  });
+  }).catch(() => void 0);
 }
 function getTileflowAnalyticsApiUrl(analytics) {
   if (analytics.apiUrl) {
@@ -94,17 +94,18 @@ function createTileflowSessionStarter(options) {
     },
     start(analytics, styleId) {
       const mapId = analytics?.mapId;
+      const sessionId = options.getSessionId?.() ?? options.sessionId;
       if (!mapId) {
         return false;
       }
-      const key = `${options.sessionId}:${mapId}:${styleId ?? ""}`;
+      const key = `${sessionId}:${mapId}:${styleId ?? ""}`;
       if (starts.has(key)) {
         return false;
       }
       starts.add(key);
       send(analytics, {
         mapId,
-        sessionId: options.sessionId,
+        sessionId,
         source: options.source,
         styleId
       });
@@ -216,7 +217,8 @@ function attachTileflowMapLifecycle(options) {
 function createTileflowTransformRequest(options) {
   if (!options.always && !options.transformRequest) {
     const analytics = options.getAnalytics();
-    if (!analytics || analytics.enabled === false) {
+    const requiresCommercialSession = Boolean(options.sessionController && analytics?.mapId);
+    if (!requiresCommercialSession && (!analytics || analytics.enabled === false)) {
       return void 0;
     }
   }
@@ -226,19 +228,21 @@ function createTileflowTransformRequest(options) {
     const analyticsAtRequest = asyncAnalyticsTiming === "request" ? options.getAnalytics() : void 0;
     if (isPromiseLike(request)) {
       return request.then(
-        (resolvedRequest) => applyTileflowAnalyticsRequest(
+        (resolvedRequest) => applyTileflowRequest(
           url,
           resolvedRequest,
           asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
-          options.sessionId
+          options.sessionId,
+          options.sessionController
         ) ?? resolvedRequest
       );
     }
-    return applyTileflowAnalyticsRequest(
+    return applyTileflowRequest(
       url,
       request,
       asyncAnalyticsTiming === "resolution" ? options.getAnalytics() : analyticsAtRequest,
-      options.sessionId
+      options.sessionId,
+      options.sessionController
     );
   };
 }
@@ -272,10 +276,23 @@ function createTileflowMarkerController(options) {
     }
   };
 }
-function applyTileflowAnalyticsRequest(url, request, analytics, sessionId) {
-  const nextUrl = resolveTileflowAnalyticsRequestUrl(request?.url ?? url, analytics, sessionId);
+function applyTileflowRequest(url, request, analytics, sessionId, sessionController) {
+  const requestUrl = request?.url ?? url;
+  if (sessionController) {
+    return sessionController.resolveRequestUrl(requestUrl, analytics).then(
+      (nextUrl) => composeTileflowRequest(url, request, nextUrl, true) ?? { url }
+    );
+  }
+  return composeTileflowRequest(
+    url,
+    request,
+    resolveTileflowAnalyticsRequestUrl(requestUrl, analytics, sessionId),
+    false
+  );
+}
+function composeTileflowRequest(originalUrl, request, nextUrl, ensureRequest) {
   if (!nextUrl) {
-    return request;
+    return request ?? (ensureRequest ? { url: originalUrl } : void 0);
   }
   return request ? { ...request, url: nextUrl } : { url: nextUrl };
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { a as TileflowConfig, b as TileflowProjectConfig, V as ValidationResult, c as TileflowOsmBasemapOptions, d as TileflowOsmBasemapConfig, e as TileflowRoadsModuleOptions, f as TileflowRoadsModuleConfig, g as TileflowLabelsModuleOptions, h as TileflowLabelsModuleConfig, i as TileflowPoiModuleOptions, j as TileflowPoiModuleConfig, k as TileflowStyleOverrideOptions, l as TileflowStyleOverrideModuleConfig } from './runtime-BMZ_tuba.js';
-export { M as MapLibreSprite, m as MapLibreStyle, N as NormalizedTileflowCaptureScene, R as ResolvedTileflowTypography, n as TileflowAdvancedColorConfig, T as TileflowAnalytics, o as TileflowBaseColors, p as TileflowBasemapConfig, q as TileflowBoundaryColorConfig, r as TileflowBuildingColorConfig, s as TileflowBuildingStyleConfig, t as TileflowBuildings, u as TileflowCaptureApplicationTarget, v as TileflowCaptureBoundsCamera, w as TileflowCaptureCamera, x as TileflowCaptureCenterCamera, y as TileflowCaptureMapTarget, z as TileflowCaptureScene, A as TileflowCaptureTarget, B as TileflowCaptureViewport, C as TileflowColor, D as TileflowColorConfig, E as TileflowColors, F as TileflowDensity, G as TileflowFontWeight, H as TileflowFonts, I as TileflowHostedNotoSansWeight, J as TileflowHydroColorConfig, K as TileflowIconSet, L as TileflowIconSetConfig, O as TileflowLabelColorConfig, P as TileflowLabelDetail, Q as TileflowLabelLanguage, S as TileflowLabels, U as TileflowLandcoverColorConfig, W as TileflowLanduseColorConfig, X as TileflowManifest, Y as TileflowManifestLoadOptions, Z as TileflowMapConfig, _ as TileflowMapMarker, $ as TileflowMapMode, a0 as TileflowMapModeOptions, a1 as TileflowModuleConfig, a2 as TileflowPoi, a3 as TileflowPoiCategory, a4 as TileflowPoiClassMapping, a5 as TileflowPoiColorConfig, a6 as TileflowPoiColorMode, a7 as TileflowPoiDensity, a8 as TileflowPoiIcons, a9 as TileflowPoiLabels, aa as TileflowProjectIconSets, ab as TileflowProjectThemes, ac as TileflowRenderer, ad as TileflowRoadClass, ae as TileflowRoadColorConfig, af as TileflowRoadDetail, ag as TileflowRoadExtras, ah as TileflowRoadHierarchy, ai as TileflowRoadLabelDetail, aj as TileflowRoadOutline, ak as TileflowRoadWeight, al as TileflowRoads, am as TileflowRuntimeManifest, an as TileflowRuntimeManifestMap, ao as TileflowRuntimeManifestMapEntry, ap as TileflowRuntimeStyle, aq as TileflowRuntimeStyleOptions, ar as TileflowSourceLayers, as as TileflowStyleLayerOverride, at as TileflowStyleOptions, au as TileflowTerrain, av as TileflowTerrainConfig, aw as TileflowTerrainEncoding, ax as TileflowTerrainMode, ay as TileflowTheme, az as TileflowThemeConfig, aA as TileflowThemeMode, aB as TileflowThemeModulesConfig, aC as TileflowThemeName, aD as TileflowTiles, aE as TileflowTilesetConfig, aF as TileflowTypography, aG as TileflowTypographyDomain, aH as TileflowTypographyStyle, aI as TileflowViewConfig, aJ as ValidationMessage, aK as createManifest, aL as createStyle, aM as createStyleFromProject, aN as createTileflowSessionId, aO as defaultTileflowManifestUrl, aP as defaultTileflowStyleBaseUrl, aQ as getDefaultColors, aR as getDefaultTileflowStyleBaseUrl, aS as getTileflowAnalyticsApiUrl, aT as inferTileflowAnalyticsFromStyleUrl, aU as isTileflowLocalDevHost, aV as loadTileflowManifest, aW as mergeTileflowAnalytics, aX as normalizeTileflowCaptureId, aY as normalizeTileflowCaptureScene, aZ as normalizeTileflowStaticImageSize, a_ as normalizeTileflowUrl, a$ as resolveTileflowAnalyticsRequestUrl, b0 as resolveTileflowManifestMap, b1 as resolveTileflowMapMode, b2 as resolveTileflowRuntimeStyle, b3 as resolveTileflowStaticImageUrl, b4 as resolveTileflowStyleUrl, b5 as shouldLoadTileflowManifest, b6 as startTileflowSession, b7 as tileflowCaptureApplicationTargetSchema, b8 as tileflowCaptureBoundsCameraSchema, b9 as tileflowCaptureCameraSchema, ba as tileflowCaptureCenterCameraSchema, bb as tileflowCaptureIdSchema, bc as tileflowCaptureMapTargetSchema, bd as tileflowCaptureSceneLimits, be as tileflowCaptureSceneNameSchema, bf as tileflowCaptureSceneSchema, bg as tileflowCaptureSceneSchemaVersion, bh as tileflowCaptureTargetSchema, bi as tileflowCaptureViewportSchema, bj as tileflowHostedNotoSansWeights } from './runtime-BMZ_tuba.js';
+import { b as TileflowConfig, c as TileflowProjectConfig, V as ValidationResult, d as TileflowOsmBasemapOptions, e as TileflowOsmBasemapConfig, f as TileflowRoadsModuleOptions, g as TileflowRoadsModuleConfig, h as TileflowLabelsModuleOptions, i as TileflowLabelsModuleConfig, j as TileflowPoiModuleOptions, k as TileflowPoiModuleConfig, l as TileflowStyleOverrideOptions, m as TileflowStyleOverrideModuleConfig } from './runtime-Bg--GMWM.js';
+export { M as MapLibreSprite, n as MapLibreStyle, N as NormalizedTileflowCaptureScene, R as ResolvedTileflowTypography, o as TileflowAdvancedColorConfig, T as TileflowAnalytics, p as TileflowBaseColors, q as TileflowBasemapConfig, r as TileflowBoundaryColorConfig, s as TileflowBuildingColorConfig, t as TileflowBuildingStyleConfig, u as TileflowBuildings, v as TileflowCaptureApplicationTarget, w as TileflowCaptureBoundsCamera, x as TileflowCaptureCamera, y as TileflowCaptureCenterCamera, z as TileflowCaptureMapTarget, A as TileflowCaptureScene, B as TileflowCaptureTarget, C as TileflowCaptureViewport, D as TileflowColor, E as TileflowColorConfig, F as TileflowColors, G as TileflowDensity, H as TileflowFontWeight, I as TileflowFonts, J as TileflowHostedNotoSansWeight, K as TileflowHydroColorConfig, L as TileflowIconSet, O as TileflowIconSetConfig, P as TileflowLabelColorConfig, Q as TileflowLabelDetail, S as TileflowLabelLanguage, U as TileflowLabels, W as TileflowLandcoverColorConfig, X as TileflowLanduseColorConfig, Y as TileflowManifest, Z as TileflowManifestLoadOptions, _ as TileflowMapConfig, $ as TileflowMapMarker, a0 as TileflowMapMode, a1 as TileflowMapModeOptions, a2 as TileflowModuleConfig, a3 as TileflowPoi, a4 as TileflowPoiCategory, a5 as TileflowPoiClassMapping, a6 as TileflowPoiColorConfig, a7 as TileflowPoiColorMode, a8 as TileflowPoiDensity, a9 as TileflowPoiIcons, aa as TileflowPoiLabels, ab as TileflowProjectIconSets, ac as TileflowProjectThemes, ad as TileflowRenderer, ae as TileflowRoadClass, af as TileflowRoadColorConfig, ag as TileflowRoadDetail, ah as TileflowRoadExtras, ai as TileflowRoadHierarchy, aj as TileflowRoadLabelDetail, ak as TileflowRoadOutline, al as TileflowRoadWeight, am as TileflowRoads, an as TileflowRuntimeManifest, ao as TileflowRuntimeManifestMap, ap as TileflowRuntimeManifestMapEntry, aq as TileflowRuntimeStyle, ar as TileflowRuntimeStyleOptions, a as TileflowSessionController, as as TileflowSessionGrantResponse, at as TileflowSourceLayers, au as TileflowStyleLayerOverride, av as TileflowStyleOptions, aw as TileflowTerrain, ax as TileflowTerrainConfig, ay as TileflowTerrainEncoding, az as TileflowTerrainMode, aA as TileflowTheme, aB as TileflowThemeConfig, aC as TileflowThemeMode, aD as TileflowThemeModulesConfig, aE as TileflowThemeName, aF as TileflowTiles, aG as TileflowTilesetConfig, aH as TileflowTypography, aI as TileflowTypographyDomain, aJ as TileflowTypographyStyle, aK as TileflowViewConfig, aL as ValidationMessage, aM as createManifest, aN as createStyle, aO as createStyleFromProject, aP as createTileflowSessionController, aQ as createTileflowSessionId, aR as defaultTileflowManifestUrl, aS as defaultTileflowStyleBaseUrl, aT as getDefaultColors, aU as getDefaultTileflowStyleBaseUrl, aV as getTileflowAnalyticsApiUrl, aW as inferTileflowAnalyticsFromStyleUrl, aX as isTileflowLocalDevHost, aY as loadTileflowManifest, aZ as mergeTileflowAnalytics, a_ as normalizeTileflowCaptureId, a$ as normalizeTileflowCaptureScene, b0 as normalizeTileflowStaticImageSize, b1 as normalizeTileflowUrl, b2 as resolveTileflowAnalyticsRequestUrl, b3 as resolveTileflowManifestMap, b4 as resolveTileflowMapMode, b5 as resolveTileflowRuntimeStyle, b6 as resolveTileflowStaticImageUrl, b7 as resolveTileflowStyleUrl, b8 as shouldLoadTileflowManifest, b9 as startTileflowSession, ba as tileflowCaptureApplicationTargetSchema, bb as tileflowCaptureBoundsCameraSchema, bc as tileflowCaptureCameraSchema, bd as tileflowCaptureCenterCameraSchema, be as tileflowCaptureIdSchema, bf as tileflowCaptureMapTargetSchema, bg as tileflowCaptureSceneLimits, bh as tileflowCaptureSceneNameSchema, bi as tileflowCaptureSceneSchema, bj as tileflowCaptureSceneSchemaVersion, bk as tileflowCaptureTargetSchema, bl as tileflowCaptureViewportSchema, bm as tileflowHostedNotoSansWeights } from './runtime-Bg--GMWM.js';
 import { z } from 'zod';
 
 declare const tileflowThemeSchema: z.ZodObject<{

package/dist/index.js

@@ -6821,6 +6821,250 @@ function createTileflowSessionId() {
   }
   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);
+    const body = await response.json().catch(() => null);
+    throwIfSessionGrantAborted(signal);
+    if (response.status === 409 && isRecord6(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 (!isRecord6(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 isRecord6(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+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;
@@ -6843,7 +7087,7 @@ function startTileflowSession(analytics, input) {
   if (!analytics || analytics.enabled === false || !input.mapId || typeof navigator === "undefined") {
     return;
   }
-  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/start`;
+  const endpoint = analytics.endpoint ?? `${getTileflowAnalyticsApiUrl(analytics)}/v1/sessions/analytics`;
   const payload = JSON.stringify({
     mapId: input.mapId,
     metadata: analytics.metadata,
@@ -6866,7 +7110,7 @@ function startTileflowSession(analytics, input) {
     },
     keepalive: true,
     method: "POST"
-  });
+  }).catch(() => void 0);
 }
 function getTileflowAnalyticsApiUrl(analytics) {
   if (analytics.apiUrl) {
@@ -6883,9 +7127,6 @@ function getTileflowAnalyticsApiUrl(analytics) {
   return "https://api.tileflow.dev";
 }
 function mergeTileflowAnalytics(userAnalytics, runtimeAnalytics) {
-  if (userAnalytics?.enabled === false) {
-    return userAnalytics;
-  }
   if (!userAnalytics && !runtimeAnalytics?.mapId) {
     return void 0;
   }
@@ -6994,7 +7235,7 @@ function normalizeTileflowStaticImageSize(input) {
 function inferTileflowAnalyticsFromStyleUrl(styleUrl) {
   try {
     const url = new URL(styleUrl, getTileflowLocationOrigin());
-    const match = url.pathname.match(/\/(?:v1\/)?maps\/([^/]+)\/style\.json$/);
+    const match = url.pathname.match(/^\/maps\/([^/]+)\/style\.json$/);
     if (!match?.[1]) {
       return void 0;
     }
@@ -7037,6 +7278,7 @@ export {
   createManifest,
   createStyle,
   createStyleFromProject,
+  createTileflowSessionController,
   createTileflowSessionId,
   defaultTileflowManifestUrl,
   defaultTileflowStyleBaseUrl,

package/dist/{runtime-BMZ_tuba.d.ts → runtime-Bg--GMWM.d.ts}

@@ -558,6 +558,23 @@ type TileflowAnalytics = {
     source?: string;
     styleId?: string;
 };
+type TileflowSessionGrantResponse = {
+    billingEnabled?: false;
+    disposition?: 'ordinary' | 'unbilled_fail_open';
+    expiresAt?: string;
+    grant?: string;
+    meterMode?: 'disabled' | 'shadow' | 'enforced';
+    ok: boolean;
+    resourceOrigins?: string[];
+    sessionId: string;
+    usageMode?: 'session';
+    code?: string;
+    retryWithNewSession?: boolean;
+};
+type TileflowSessionController = {
+    readonly sessionId: string;
+    resolveRequestUrl(url: string, analytics: TileflowAnalytics | undefined): Promise<string | undefined>;
+};
 type TileflowMapMarker = {
     id: string;
     coordinates: [number, number];
@@ -622,6 +639,13 @@ declare function resolveTileflowStyleUrl(mapName: string, styleBaseUrl?: string)
 declare function getDefaultTileflowStyleBaseUrl(): string;
 declare function normalizeTileflowUrl(value: string): string;
 declare function createTileflowSessionId(): string;
+declare function createTileflowSessionController(input: {
+    fetch?: typeof fetch;
+    grantTimeoutMs?: number;
+    now?: () => Date;
+    sessionIdFactory?: () => string;
+    source: string;
+}): TileflowSessionController;
 declare function resolveTileflowAnalyticsRequestUrl(url: string, analytics: TileflowAnalytics | undefined, sessionId: string): string | undefined;
 declare function startTileflowSession(analytics: TileflowAnalytics | undefined, input: {
     mapId?: string;
@@ -653,4 +677,4 @@ declare function normalizeTileflowStaticImageSize(input: {
 };
 declare function inferTileflowAnalyticsFromStyleUrl(styleUrl: string): TileflowAnalytics | undefined;
 
-export { type TileflowMapMode as $, type TileflowCaptureTarget as A, type TileflowCaptureViewport as B, type TileflowColor as C, type TileflowColorConfig as D, type TileflowColors as E, type TileflowDensity as F, type TileflowFontWeight as G, type TileflowFonts as H, type TileflowHostedNotoSansWeight as I, type TileflowHydroColorConfig as J, type TileflowIconSet as K, type TileflowIconSetConfig as L, type MapLibreSprite as M, type NormalizedTileflowCaptureScene as N, type TileflowLabelColorConfig as O, type TileflowLabelDetail as P, type TileflowLabelLanguage as Q, type ResolvedTileflowTypography as R, type TileflowLabels as S, type TileflowAnalytics as T, type TileflowLandcoverColorConfig as U, type ValidationResult as V, type TileflowLanduseColorConfig as W, type TileflowManifest as X, type TileflowManifestLoadOptions as Y, type TileflowMapConfig as Z, type TileflowMapMarker as _, type TileflowConfig as a, resolveTileflowAnalyticsRequestUrl as a$, type TileflowMapModeOptions as a0, type TileflowModuleConfig as a1, type TileflowPoi as a2, type TileflowPoiCategory as a3, type TileflowPoiClassMapping as a4, type TileflowPoiColorConfig as a5, type TileflowPoiColorMode as a6, type TileflowPoiDensity as a7, type TileflowPoiIcons as a8, type TileflowPoiLabels as a9, type TileflowThemeMode as aA, type TileflowThemeModulesConfig as aB, type TileflowThemeName as aC, type TileflowTiles as aD, type TileflowTilesetConfig as aE, type TileflowTypography as aF, type TileflowTypographyDomain as aG, type TileflowTypographyStyle as aH, type TileflowViewConfig as aI, type ValidationMessage as aJ, createManifest as aK, createStyle as aL, createStyleFromProject as aM, createTileflowSessionId as aN, defaultTileflowManifestUrl as aO, defaultTileflowStyleBaseUrl as aP, getDefaultColors as aQ, getDefaultTileflowStyleBaseUrl as aR, getTileflowAnalyticsApiUrl as aS, inferTileflowAnalyticsFromStyleUrl as aT, isTileflowLocalDevHost as aU, loadTileflowManifest as aV, mergeTileflowAnalytics as aW, normalizeTileflowCaptureId as aX, normalizeTileflowCaptureScene as aY, normalizeTileflowStaticImageSize as aZ, normalizeTileflowUrl as a_, type TileflowProjectIconSets as aa, type TileflowProjectThemes as ab, type TileflowRenderer as ac, type TileflowRoadClass as ad, type TileflowRoadColorConfig as ae, type TileflowRoadDetail as af, type TileflowRoadExtras as ag, type TileflowRoadHierarchy as ah, type TileflowRoadLabelDetail as ai, type TileflowRoadOutline as aj, type TileflowRoadWeight as ak, type TileflowRoads as al, type TileflowRuntimeManifest as am, type TileflowRuntimeManifestMap as an, type TileflowRuntimeManifestMapEntry as ao, type TileflowRuntimeStyle as ap, type TileflowRuntimeStyleOptions as aq, type TileflowSourceLayers as ar, type TileflowStyleLayerOverride as as, type TileflowStyleOptions as at, type TileflowTerrain as au, type TileflowTerrainConfig as av, type TileflowTerrainEncoding as aw, type TileflowTerrainMode as ax, type TileflowTheme as ay, type TileflowThemeConfig as az, type TileflowProjectConfig as b, resolveTileflowManifestMap as b0, resolveTileflowMapMode as b1, resolveTileflowRuntimeStyle as b2, resolveTileflowStaticImageUrl as b3, resolveTileflowStyleUrl as b4, shouldLoadTileflowManifest as b5, startTileflowSession as b6, tileflowCaptureApplicationTargetSchema as b7, tileflowCaptureBoundsCameraSchema as b8, tileflowCaptureCameraSchema as b9, tileflowCaptureCenterCameraSchema as ba, tileflowCaptureIdSchema as bb, tileflowCaptureMapTargetSchema as bc, tileflowCaptureSceneLimits as bd, tileflowCaptureSceneNameSchema as be, tileflowCaptureSceneSchema as bf, tileflowCaptureSceneSchemaVersion as bg, tileflowCaptureTargetSchema as bh, tileflowCaptureViewportSchema as bi, tileflowHostedNotoSansWeights as bj, type TileflowOsmBasemapOptions as c, type TileflowOsmBasemapConfig as d, type TileflowRoadsModuleOptions as e, type TileflowRoadsModuleConfig as f, type TileflowLabelsModuleOptions as g, type TileflowLabelsModuleConfig as h, type TileflowPoiModuleOptions as i, type TileflowPoiModuleConfig as j, type TileflowStyleOverrideOptions as k, type TileflowStyleOverrideModuleConfig as l, type MapLibreStyle as m, type TileflowAdvancedColorConfig as n, type TileflowBaseColors as o, type TileflowBasemapConfig as p, type TileflowBoundaryColorConfig as q, type TileflowBuildingColorConfig as r, type TileflowBuildingStyleConfig as s, type TileflowBuildings as t, type TileflowCaptureApplicationTarget as u, type TileflowCaptureBoundsCamera as v, type TileflowCaptureCamera as w, type TileflowCaptureCenterCamera as x, type TileflowCaptureMapTarget as y, type TileflowCaptureScene as z };
+export { type TileflowMapMarker as $, type TileflowCaptureScene as A, type TileflowCaptureTarget as B, type TileflowCaptureViewport as C, type TileflowColor as D, type TileflowColorConfig as E, type TileflowColors as F, type TileflowDensity as G, type TileflowFontWeight as H, type TileflowFonts as I, type TileflowHostedNotoSansWeight as J, type TileflowHydroColorConfig as K, type TileflowIconSet as L, type MapLibreSprite as M, type NormalizedTileflowCaptureScene as N, type TileflowIconSetConfig as O, type TileflowLabelColorConfig as P, type TileflowLabelDetail as Q, type ResolvedTileflowTypography as R, type TileflowLabelLanguage as S, type TileflowAnalytics as T, type TileflowLabels as U, type ValidationResult as V, type TileflowLandcoverColorConfig as W, type TileflowLanduseColorConfig as X, type TileflowManifest as Y, type TileflowManifestLoadOptions as Z, type TileflowMapConfig as _, type TileflowSessionController as a, normalizeTileflowCaptureScene as a$, type TileflowMapMode as a0, type TileflowMapModeOptions as a1, type TileflowModuleConfig as a2, type TileflowPoi as a3, type TileflowPoiCategory as a4, type TileflowPoiClassMapping as a5, type TileflowPoiColorConfig as a6, type TileflowPoiColorMode as a7, type TileflowPoiDensity as a8, type TileflowPoiIcons as a9, type TileflowTheme as aA, type TileflowThemeConfig as aB, type TileflowThemeMode as aC, type TileflowThemeModulesConfig as aD, type TileflowThemeName as aE, type TileflowTiles as aF, type TileflowTilesetConfig as aG, type TileflowTypography as aH, type TileflowTypographyDomain as aI, type TileflowTypographyStyle as aJ, type TileflowViewConfig as aK, type ValidationMessage as aL, createManifest as aM, createStyle as aN, createStyleFromProject as aO, createTileflowSessionController as aP, createTileflowSessionId as aQ, defaultTileflowManifestUrl as aR, defaultTileflowStyleBaseUrl as aS, getDefaultColors as aT, getDefaultTileflowStyleBaseUrl as aU, getTileflowAnalyticsApiUrl as aV, inferTileflowAnalyticsFromStyleUrl as aW, isTileflowLocalDevHost as aX, loadTileflowManifest as aY, mergeTileflowAnalytics as aZ, normalizeTileflowCaptureId as a_, type TileflowPoiLabels as aa, type TileflowProjectIconSets as ab, type TileflowProjectThemes as ac, type TileflowRenderer as ad, type TileflowRoadClass as ae, type TileflowRoadColorConfig as af, type TileflowRoadDetail as ag, type TileflowRoadExtras as ah, type TileflowRoadHierarchy as ai, type TileflowRoadLabelDetail as aj, type TileflowRoadOutline as ak, type TileflowRoadWeight as al, type TileflowRoads as am, type TileflowRuntimeManifest as an, type TileflowRuntimeManifestMap as ao, type TileflowRuntimeManifestMapEntry as ap, type TileflowRuntimeStyle as aq, type TileflowRuntimeStyleOptions as ar, type TileflowSessionGrantResponse as as, type TileflowSourceLayers as at, type TileflowStyleLayerOverride as au, type TileflowStyleOptions as av, type TileflowTerrain as aw, type TileflowTerrainConfig as ax, type TileflowTerrainEncoding as ay, type TileflowTerrainMode as az, type TileflowConfig as b, normalizeTileflowStaticImageSize as b0, normalizeTileflowUrl as b1, resolveTileflowAnalyticsRequestUrl as b2, resolveTileflowManifestMap as b3, resolveTileflowMapMode as b4, resolveTileflowRuntimeStyle as b5, resolveTileflowStaticImageUrl as b6, resolveTileflowStyleUrl as b7, shouldLoadTileflowManifest as b8, startTileflowSession as b9, tileflowCaptureApplicationTargetSchema as ba, tileflowCaptureBoundsCameraSchema as bb, tileflowCaptureCameraSchema as bc, tileflowCaptureCenterCameraSchema as bd, tileflowCaptureIdSchema as be, tileflowCaptureMapTargetSchema as bf, tileflowCaptureSceneLimits as bg, tileflowCaptureSceneNameSchema as bh, tileflowCaptureSceneSchema as bi, tileflowCaptureSceneSchemaVersion as bj, tileflowCaptureTargetSchema as bk, tileflowCaptureViewportSchema as bl, tileflowHostedNotoSansWeights as bm, type TileflowProjectConfig as c, type TileflowOsmBasemapOptions as d, type TileflowOsmBasemapConfig as e, type TileflowRoadsModuleOptions as f, type TileflowRoadsModuleConfig as g, type TileflowLabelsModuleOptions as h, type TileflowLabelsModuleConfig as i, type TileflowPoiModuleOptions as j, type TileflowPoiModuleConfig as k, type TileflowStyleOverrideOptions as l, type TileflowStyleOverrideModuleConfig as m, type MapLibreStyle as n, type TileflowAdvancedColorConfig as o, type TileflowBaseColors as p, type TileflowBasemapConfig as q, type TileflowBoundaryColorConfig as r, type TileflowBuildingColorConfig as s, type TileflowBuildingStyleConfig as t, type TileflowBuildings as u, type TileflowCaptureApplicationTarget as v, type TileflowCaptureBoundsCamera as w, type TileflowCaptureCamera as x, type TileflowCaptureCenterCamera as y, type TileflowCaptureMapTarget as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/core",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.18",
   "description": "Typed Tileflow config and MapLibre style compiler.",
   "type": "module",
   "sideEffects": false,