@tileflow/core 0.1.0-alpha.32 → 0.1.0-alpha.33

package/dist/build.js

@@ -4211,6 +4211,38 @@ function isTileflowThemeName(value) {
   return isTileflowPortableId(value) && value !== "system";
 }
 
+// src/sun.ts
+var tileflowSunMetadataKey = "tileflow:sun";
+var tileflowDefaultSunPreset = Object.freeze({
+  azimuth: 210,
+  altitude: 60,
+  color: "#ffffff",
+  intensity: 0.5,
+  shadowIntensity: 1,
+  ambient: Object.freeze({ color: "#ffffff", intensity: 0.5 })
+});
+var degrees = Math.PI / 180;
+function normalizeTileflowAzimuth(azimuth) {
+  const turned = azimuth % 360;
+  return turned < 0 ? turned + 360 : turned === 0 ? 0 : turned;
+}
+function tileflowSunMetadata(preset) {
+  return Object.freeze({ version: 1, ...preset });
+}
+function tileflowSunLight(direction, base) {
+  const radial = base?.position?.[0] ?? 1.15;
+  return {
+    ...base ?? {},
+    anchor: "map",
+    position: [
+      radial,
+      Number(normalizeTileflowAzimuth(direction.azimuth).toFixed(3)),
+      // MapLibre lights the extrusions from above the horizon only.
+      Number(Math.min(90, Math.max(0, 90 - direction.altitude)).toFixed(3))
+    ]
+  };
+}
+
 // src/themes/visual-semantics.ts
 var visualNumberProperties = /* @__PURE__ */ new Set([
   "angle",
@@ -4369,7 +4401,9 @@ var themeTypographyKeys = [
   "water"
 ];
 var themeTypographyDomains = ["places", "poi", "roads", "water"];
-var themeLightingKeys = ["anchor", "color", "intensity", "position"];
+var themeLightingKeys = ["ambient", "anchor", "color", "intensity", "position", "sun"];
+var themeSunKeys = ["altitude", "azimuth", "color", "intensity", "shadowIntensity"];
+var themeAmbientKeys = ["color", "intensity"];
 function resolveTileflowTheme(theme) {
   assertThemeDocument(theme);
   const resolver = new ThemeValueResolver(theme);
@@ -4380,11 +4414,12 @@ function resolveTileflowTheme(theme) {
     number: resolver.resolveCategory("number")
   };
   const typography = resolver.resolveTypography(theme.typography);
-  const lighting = resolver.resolveLighting(theme.lighting);
+  const { light: lighting, sun } = resolver.resolveLighting(theme.lighting);
   return {
     colorScheme: theme.colorScheme,
     id: theme.id,
     lighting,
+    ...sun ? { sun } : {},
     tokens,
     typography,
     version: theme.version
@@ -4902,6 +4937,65 @@ var ThemeValueResolver = class {
     };
   }
   resolveLighting(lighting) {
+    const { ambient, sun, ...flat } = lighting;
+    const light = this.#resolveFlatLight(flat);
+    if (sun === void 0 && ambient === void 0) return { light };
+    const resolvedSun = this.resolveTree(sun ?? {}, "theme.lighting.sun");
+    const resolvedAmbient = this.resolveTree(ambient ?? {}, "theme.lighting.ambient");
+    const defaults4 = tileflowDefaultSunPreset;
+    const number = (value, path, fallback, range2) => {
+      if (value === void 0) return fallback;
+      assertFiniteNumber(value, path);
+      if (range2 && (value < range2[0] || value > range2[1])) {
+        throw new Error(`Tileflow ${path} must be between ${range2[0]} and ${range2[1]}.`);
+      }
+      return value;
+    };
+    const colour = (value, path, fallback) => {
+      if (value === void 0) return fallback;
+      assertColor(value, path);
+      return value;
+    };
+    const preset = {
+      azimuth: normalizeTileflowAzimuth(
+        number(resolvedSun.azimuth, "theme.lighting.sun.azimuth", defaults4.azimuth)
+      ),
+      altitude: number(
+        resolvedSun.altitude,
+        "theme.lighting.sun.altitude",
+        defaults4.altitude,
+        [-90, 90]
+      ),
+      color: colour(resolvedSun.color, "theme.lighting.sun.color", defaults4.color),
+      intensity: number(
+        resolvedSun.intensity,
+        "theme.lighting.sun.intensity",
+        defaults4.intensity,
+        [0, 1]
+      ),
+      shadowIntensity: number(
+        resolvedSun.shadowIntensity,
+        "theme.lighting.sun.shadowIntensity",
+        defaults4.shadowIntensity,
+        [0, 1]
+      ),
+      ambient: {
+        color: colour(
+          resolvedAmbient.color,
+          "theme.lighting.ambient.color",
+          defaults4.ambient.color
+        ),
+        intensity: number(
+          resolvedAmbient.intensity,
+          "theme.lighting.ambient.intensity",
+          defaults4.ambient.intensity,
+          [0, 1]
+        )
+      }
+    };
+    return { light: sun === void 0 ? light : tileflowSunLight(preset, light), sun: preset };
+  }
+  #resolveFlatLight(lighting) {
     const result = this.resolveTree(lighting, "theme.lighting");
     if (result.anchor !== void 0 && result.anchor !== "map" && result.anchor !== "viewport") {
       throw themeTypeError("theme.lighting.anchor", "map or viewport", result.anchor);
@@ -5078,6 +5172,24 @@ function assertThemeTypographyStyleFields(style, path) {
 function assertThemeLighting(value, path) {
   const lighting = assertPlainThemeRecord(value, path);
   assertExactThemeKeys(lighting, path, themeLightingKeys);
+  if (Object.hasOwn(lighting, "sun")) {
+    const sun = assertPlainThemeRecord(lighting.sun, `${path}.sun`);
+    assertExactThemeKeys(sun, `${path}.sun`, themeSunKeys);
+    for (const key of ["altitude", "azimuth", "intensity", "shadowIntensity"]) {
+      if (Object.hasOwn(sun, key))
+        assertThemeCategoryValue(sun[key], "number", `${path}.sun.${key}`);
+    }
+    if (Object.hasOwn(sun, "color"))
+      assertThemeCategoryValue(sun.color, "color", `${path}.sun.color`);
+  }
+  if (Object.hasOwn(lighting, "ambient")) {
+    const ambient = assertPlainThemeRecord(lighting.ambient, `${path}.ambient`);
+    assertExactThemeKeys(ambient, `${path}.ambient`, themeAmbientKeys);
+    if (Object.hasOwn(ambient, "intensity"))
+      assertThemeCategoryValue(ambient.intensity, "number", `${path}.ambient.intensity`);
+    if (Object.hasOwn(ambient, "color"))
+      assertThemeCategoryValue(ambient.color, "color", `${path}.ambient.color`);
+  }
   if (Object.hasOwn(lighting, "anchor") && lighting.anchor !== "map" && lighting.anchor !== "viewport") {
     throw themeTypeError(`${path}.anchor`, "map or viewport", lighting.anchor);
   }
@@ -5244,6 +5356,7 @@ function inferThemeCategoryFromPath(path) {
   const tokenCategory = path.match(/^theme\.tokens\.(color|font|image|number)(?:\.|$)/u)?.[1];
   if (isThemeTokenCategory(tokenCategory)) return tokenCategory;
   if (/^theme\.lighting\.position(?:\[\d+\])?$/u.test(path)) return "number";
+  if (/^theme\.lighting\.sun\.(?:altitude|azimuth|shadowIntensity)$/u.test(path)) return "number";
   const segments = path.replace(/\[\d+\]/g, "").split(".");
   return [...segments].reverse().map((segment) => classifyTileflowVisualProperty(segment)).find((category) => category !== void 0);
 }
@@ -6217,7 +6330,7 @@ function compileRoads(request, context) {
       });
     }
   }
-  compileSidewalks(request?.sidewalks, context, contributions);
+  compileSidewalks(request?.sidewalks, areaStyles.pedestrian?.fill?.color, context, contributions);
   compileRoundabouts(request?.roundabouts, context, contributions);
   compileCrossings(request?.crossings, context, contributions);
   if (semantics.oneWayMarkers && visible.size > 0) {
@@ -6286,15 +6399,15 @@ function roadPhysicalCohort(roadClass) {
   if (roadClass === "minor" || roadClass === "service" || roadClass === "track") return "local";
   return "path";
 }
-function compileSidewalks(request, context, contributions) {
+function compileSidewalks(request, pedestrianAreaColor, context, contributions) {
   const { fields, layers } = context.data.schema;
   if (!layers.sidewalk) return;
   const config = mergeTileflowDesign(
     {
       surface: {
-        color: context.colors.roads.casing,
+        color: pedestrianAreaColor ?? context.colors.road,
         minZoom: 17,
-        opacity: 0.96
+        opacity: 1
       }
     },
     request
@@ -6946,10 +7059,10 @@ function roadWidth(roadClass, scale) {
       [16, 3.4]
     ]
   };
-  return zoom.linear(stops[roadClass].map(([z15, value]) => [z15, value * scale]));
+  return zoom.linear(stops[roadClass].map(([z16, value]) => [z16, value * scale]));
 }
 function widen(value, addition) {
-  return zoom.linear(value.stops.map(([z15, width]) => [z15, width + addition]));
+  return zoom.linear(value.stops.map(([z16, width]) => [z16, width + addition]));
 }
 function structureFilter(field2, structure) {
   if (structure === "surface") {
@@ -8462,24 +8575,39 @@ function validateStops(stops, api) {
   }
 }
 function validateOperandCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxOperands) {
-    throw new Error(
-      `${api} supports at most ${tileflowDataExpressionLimits.maxOperands} operands.`
+  const limit = tileflowDataExpressionLimits.maxOperands;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} operands; it supports at most ${limit}. Nest ${api} calls of at most ${limit} operands each.`
     );
   }
 }
 function validateBranchCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxBranches) {
-    throw new Error(
-      `${api} supports at most ${tileflowDataExpressionLimits.maxBranches} branches.`
+  const limit = tileflowDataExpressionLimits.maxBranches;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} branches; it supports at most ${limit}. Split the lookup into nested ${api} groups of at most ${limit} branches, or reduce the mapping.`
     );
   }
 }
 function validateStopCount(count, api) {
-  if (count > tileflowDataExpressionLimits.maxStops) {
-    throw new Error(`${api} supports at most ${tileflowDataExpressionLimits.maxStops} stops.`);
+  const limit = tileflowDataExpressionLimits.maxStops;
+  if (count > limit) {
+    throw limitError(
+      `${api} received ${count} stops; it supports at most ${limit}. Remove stops the curve can interpolate.`
+    );
   }
 }
+function limitError(message) {
+  const site = authoringCallSite(new Error().stack);
+  return new Error(site ? `${message} Called at ${site}.` : message);
+}
+function authoringCallSite(stack) {
+  const locations = (stack ?? "").split("\n").slice(1).map((line) => /\(?([^()\s]+?):(\d+):(\d+)\)?$/.exec(line.trim())).filter((match2) => match2 !== null).map(([, file, line, column]) => ({ file: file.replace(/^file:\/\//, ""), line, column }));
+  const own = locations[0]?.file;
+  const site = locations.find(({ file }) => file !== own && !file.startsWith("node:"));
+  return site ? `${site.file}:${site.line}:${site.column}` : void 0;
+}
 function node(value) {
   if (isTileflowExpression(value)) return cloneJson19(value.value);
   if (isDataFieldReference(value)) return ["get", cloneJson19(value)];
@@ -8673,7 +8801,11 @@ function visitExpression(value, path, variables, issues) {
         return;
       }
       if ((value.length - 2) / 2 > branchLimit) {
-        addExpressionIssue(issues, path, `Expression case exceeds ${branchLimit} branches.`);
+        addExpressionIssue(
+          issues,
+          path,
+          `Expression case has ${(value.length - 2) / 2} branches and exceeds ${branchLimit}.`
+        );
         return;
       }
       for (let index = 1; index < value.length; index += 1) visit(value[index], index);
@@ -8689,7 +8821,11 @@ function visitExpression(value, path, variables, issues) {
         return;
       }
       if ((value.length - 3) / 2 > branchLimit) {
-        addExpressionIssue(issues, path, `Expression match exceeds ${branchLimit} branches.`);
+        addExpressionIssue(
+          issues,
+          path,
+          `Expression match has ${(value.length - 3) / 2} branches and exceeds ${branchLimit}.`
+        );
         return;
       }
       visit(value[1], 1);
@@ -10616,7 +10752,7 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     if (!parsed.success || parsed.data.category !== expectedCategory) {
       context.addIssue({
         code: "custom",
-        message: expectedCategory === void 0 ? "Structural expressions cannot contain theme-token references" : `Expected a ${expectedCategory} theme-token reference`,
+        message: expectedCategory === void 0 ? `Structural expressions cannot contain theme-token references. ${structuralThemeValueHint}` : parsed.success ? `Expected a ${expectedCategory} theme-token reference, received ${parsed.data.category} token "${parsed.data.token}". ${expressionOperandHint(expectedCategory)}` : `Expected a ${expectedCategory} theme-token reference`,
         path
       });
     }
@@ -10625,9 +10761,11 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
   if (candidate.kind === "theme-fixed") {
     const parsed = expectedCategory === "number" ? z5.union([fixedNumberSchema, fixedNumberArraySchema]).safeParse(candidate) : expectedCategory === "color" || expectedCategory === "image" ? fixedStringSchema.safeParse(candidate) : void 0;
     if (!parsed?.success) {
+      const received = fixedValueKind(candidate.value);
+      const literal2 = JSON.stringify(candidate.value);
       context.addIssue({
         code: "custom",
-        message: expectedCategory === void 0 ? "Structural expressions cannot contain theme-fixed values" : `Expected a fixed ${expectedCategory} value`,
+        message: expectedCategory === void 0 ? `Structural expressions cannot contain theme-fixed values. ${structuralThemeValueHint}` : received !== void 0 && received !== expectedCategoryKind(expectedCategory) ? `Expected a fixed ${expectedCategory} value, received a fixed ${received}. ${expressionOperandHint(expectedCategory)} Write ${literal2} instead of fixed(${literal2}).` : `Expected a fixed ${expectedCategory} value`,
         path
       });
     }
@@ -10647,6 +10785,20 @@ function validateExpressionThemeValues(value, expectedCategory, context, path) {
     validateExpressionThemeValues(entry, expectedCategory, context, [...path, key]);
   }
 }
+var structuralThemeValueHint = "fixed() and theme tokens apply only to visual properties such as colours, sizes, and images; write structural values directly.";
+function expressionOperandHint(category) {
+  return `In ${category === "image" ? "an" : "a"} ${category} expression, fixed() and theme tokens belong in its ${category} results; conditions and other operands take plain values.`;
+}
+function fixedValueKind(value) {
+  if (typeof value === "number") return "number";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "array";
+  return void 0;
+}
+function expectedCategoryKind(category) {
+  return category === "number" ? "number" : "string";
+}
 var numberExpressionSchema = expressionSchemaFor("number");
 var colorExpressionSchema = expressionSchemaFor("color");
 var imageExpressionSchema = expressionSchemaFor("image");
@@ -10759,10 +10911,21 @@ var themeTypographySchema = themeTypographyStyleSchema.extend({
   water: themeTypographyStyleSchema.optional()
 });
 var themeLightingSchema = z5.object({
+  ambient: z5.object({
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional()
+  }).strict().optional(),
   anchor: z5.enum(["map", "viewport"]).optional(),
   color: themeColorValueSchema.optional(),
   intensity: themeNumberValueSchema.optional(),
-  position: z5.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional()
+  position: z5.tuple([themeNumberValueSchema, themeNumberValueSchema, themeNumberValueSchema]).optional(),
+  sun: z5.object({
+    altitude: themeNumberValueSchema.optional(),
+    azimuth: themeNumberValueSchema.optional(),
+    color: themeColorValueSchema.optional(),
+    intensity: themeNumberValueSchema.optional(),
+    shadowIntensity: themeNumberValueSchema.optional()
+  }).strict().optional()
 }).strict();
 var tileflowThemeSchema = z5.object({
   colorScheme: z5.enum(["light", "dark"]),
@@ -12117,9 +12280,43 @@ function parseOrThrow(schema, input, name) {
   if (result.success) return result.data;
   throw new TileflowResolvedMapValidationError(
     name,
-    validationMessagesFromIssues(result.error.issues)
+    validationMessagesFromIssues(expandUnionIssues(result.error.issues, [], input))
   );
 }
+function expandUnionIssues(issues, base, input) {
+  return issues.flatMap((issue) => {
+    const path = [...base, ...issue.path];
+    if (issue.code !== "invalid_union" || issue.errors.length === 0) return [{ ...issue, path }];
+    const candidates = issue.errors.filter((branch) => !branch.some(isUnionBranchMismatch));
+    if (candidates.length === 0) {
+      return [{ ...issue, path, message: unmatchedUnionMessage(valueAtPath(input, path)) }];
+    }
+    const fewest = Math.min(...candidates.map((branch) => branch.length));
+    const best = candidates.filter((branch) => branch.length === fewest);
+    return best.length === 1 ? expandUnionIssues(best[0], path, input) : [{ ...issue, path }];
+  });
+}
+function isUnionBranchMismatch(issue) {
+  if (issue.path.length === 0)
+    return issue.code === "invalid_type" || issue.code === "invalid_value";
+  return issue.path.length === 1 && (issue.code === "invalid_value" || issue.code === "invalid_union" && issue.errors.length === 0);
+}
+function unmatchedUnionMessage(value) {
+  const kind = value !== null && typeof value === "object" ? value.kind : void 0;
+  if (kind === "theme-fixed" || kind === "theme-token") {
+    return `This property is structural. ${structuralThemeValueHint}`;
+  }
+  const received = value === null ? "null" : Array.isArray(value) ? "an array" : typeof value;
+  return `Invalid input: no accepted form takes ${received === "object" ? "this object" : received}`;
+}
+function valueAtPath(input, path) {
+  let value = input;
+  for (const key of path) {
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, key)) return void 0;
+    value = value[key];
+  }
+  return value;
+}
 function validationMessagesFromIssues(issues) {
   return issues.flatMap((issue) => {
     const basePath = issue.path.join(".");
@@ -12183,6 +12380,71 @@ function findUnsafeObjectStructure(input) {
   return void 0;
 }
 
+// src/route-inks.ts
+var tileflowRouteMetadataKey = "tileflow:route";
+var tileflowRouteTokens = Object.freeze({
+  color: Object.freeze({
+    line: "route.line",
+    casing: "route.casing",
+    core: "route.core",
+    glow: "route.glow",
+    alternative: "route.alternative"
+  }),
+  number: Object.freeze({
+    glowOpacity: "route.glow.opacity",
+    coreOpacity: "route.core.opacity"
+  })
+});
+var tileflowDefaultRouteInks = Object.freeze({
+  light: Object.freeze({
+    line: "#2563eb",
+    casing: "#1e3a8a",
+    core: "#dbeafe",
+    glow: "#2563eb",
+    alternative: "#94a3b8",
+    glowOpacity: 0.16,
+    coreOpacity: 0
+  }),
+  dark: Object.freeze({
+    line: "#60a5fa",
+    casing: "#0b1220",
+    core: "#eff6ff",
+    glow: "#60a5fa",
+    alternative: "#64748b",
+    glowOpacity: 0.4,
+    coreOpacity: 0.7
+  })
+});
+var colourKeys = Object.keys(
+  tileflowRouteTokens.color
+);
+var numberKeys = Object.keys(
+  tileflowRouteTokens.number
+);
+function resolveTileflowRouteInks(theme) {
+  const defaults4 = tileflowDefaultRouteInks[theme.colorScheme];
+  const inks = { ...defaults4 };
+  for (const key of colourKeys) {
+    const value = theme.tokens.color[tileflowRouteTokens.color[key]];
+    if (value !== void 0) inks[key] = value;
+  }
+  for (const key of numberKeys) {
+    const token = tileflowRouteTokens.number[key];
+    const value = theme.tokens.number[token];
+    if (value === void 0) continue;
+    if (!(value >= 0 && value <= 1)) {
+      throw new Error(
+        `Tileflow theme "${theme.id}" sets number token "${token}" to ${value}; route opacities run from 0 to 1.`
+      );
+    }
+    inks[key] = value;
+  }
+  return Object.freeze(inks);
+}
+function tileflowRouteMetadata(inks) {
+  return Object.freeze({ version: 1, ...inks });
+}
+
 // src/terrain/index.ts
 function resolveTerrain(terrain, apiBaseUrl) {
   if (!terrain || terrain === "none") return void 0;
@@ -12851,6 +13113,47 @@ function isSafeArtifactName(value) {
   });
 }
 
+// src/cartography/layout-zoom-diagnostics.ts
+function diagnoseFractionalLayoutZoomSteps(layers) {
+  const diagnostics = [];
+  for (const layer of layers) {
+    const layout = layer.layout;
+    if (layout === null || typeof layout !== "object") continue;
+    for (const [property, value] of Object.entries(layout)) {
+      const stops = fractionalZoomSteps(value);
+      if (stops.length === 0) continue;
+      const [origin] = readTileflowCompilerProvenance(layer);
+      const listed = stops.map((stop) => String(stop)).join(", ");
+      diagnostics.push({
+        code: "TF_LAYOUT_FRACTIONAL_ZOOM_STEP",
+        ...origin ? { domain: origin.owner } : {},
+        message: `${property} steps at zoom ${listed}; layout properties are evaluated at each tile's integer zoom, so the step takes effect at zoom ${stops.map(Math.ceil).join(", ")}.`,
+        path: `layers.${String(layer.id)}.layout.${property}`,
+        phase: "lowering",
+        severity: "warning",
+        suggestion: "Step at whole zooms, or move the change to a paint property or a zoom range.",
+        ...origin ? { target: origin.target } : {}
+      });
+    }
+  }
+  return diagnostics;
+}
+function fractionalZoomSteps(value) {
+  if (!Array.isArray(value)) return [];
+  const stops = [];
+  if (value[0] === "step" && isZoom(value[1])) {
+    for (let index = 3; index < value.length; index += 2) {
+      const stop = value[index];
+      if (typeof stop === "number" && !Number.isInteger(stop)) stops.push(stop);
+    }
+  }
+  for (const entry of value) stops.push(...fractionalZoomSteps(entry));
+  return stops;
+}
+function isZoom(value) {
+  return Array.isArray(value) && value.length === 1 && value[0] === "zoom";
+}
+
 // src/cartography/overlay-placement-manifest.ts
 var tileflowOverlayPlacementManifestMetadataKey = "tileflow:overlay-placement-manifest";
 var tileflowOverlayPlacementManifestSchemaVersion = 1;
@@ -14055,6 +14358,8 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
       ...atmosphere ? { [tileflowAtmosphereMetadataKey]: { version: 1, ...atmosphere } } : {},
       "tileflow:theme": selected.name,
       "tileflow:colorScheme": resolvedTheme.colorScheme,
+      [tileflowRouteMetadataKey]: tileflowRouteMetadata(resolveTileflowRouteInks(resolvedTheme)),
+      ...resolvedTheme.sun ? { [tileflowSunMetadataKey]: tileflowSunMetadata(resolvedTheme.sun) } : {},
       "tileflow:data": data.identity,
       "tileflow:sources": sourceIdentities,
       ...Object.keys(loweredOverlays.identities).length > 0 ? { "tileflow:overlays": loweredOverlays.identities } : {},
@@ -14081,7 +14386,16 @@ function compileSemanticStyleInternal(input, options, inspect, onReport) {
   runCompilationPhase("assets", () => assertTextAssets(style, config));
   runCompilationPhase("assets", () => assertGlyphFontStacks(style, config));
   runCompilationPhase("validation", () => assertMapLibreStyle(style, config.id));
-  return { diagnostics, report, style, ...inspection ? { inspection } : {} };
+  const layoutDiagnostics = runCompilationPhase(
+    "validation",
+    () => diagnoseFractionalLayoutZoomSteps(plannedLayers)
+  );
+  return {
+    diagnostics: [...diagnostics, ...layoutDiagnostics],
+    report,
+    style,
+    ...inspection ? { inspection } : {}
+  };
 }
 function finalizeTileflowLayers(input) {
   const ids = /* @__PURE__ */ new Set();
@@ -14726,6 +15040,97 @@ function hasControlCharacter(value) {
   return false;
 }
 
+// src/capture-shot.ts
+import { z as z9 } from "zod";
+var tileflowCaptureShotLimits = Object.freeze({
+  blendThemes: Object.freeze({ maximum: 8, minimum: 2 }),
+  defaultFps: 30,
+  durationMs: Object.freeze({ maximum: 6e4 }),
+  fps: Object.freeze([24, 25, 30, 50, 60]),
+  keyframes: Object.freeze({ maximum: 64, minimum: 2 }),
+  maximumFrames: 3600
+});
+var tileflowCaptureShotBlendSchema = z9.object({
+  themes: z9.array(tileflowThemeNameSchema).min(tileflowCaptureShotLimits.blendThemes.minimum).max(tileflowCaptureShotLimits.blendThemes.maximum),
+  position: z9.number().finite().min(0)
+}).strict().superRefine((blend, context) => {
+  if (new Set(blend.themes).size !== blend.themes.length) {
+    context.addIssue({ code: "custom", message: "Expected distinct themes", path: ["themes"] });
+  }
+  if (blend.position > blend.themes.length - 1) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected a position from 0 to ${blend.themes.length - 1}`,
+      path: ["position"]
+    });
+  }
+});
+var tileflowCaptureShotKeyframeSchema = z9.object({
+  at: z9.number().int().min(0).max(tileflowCaptureShotLimits.durationMs.maximum),
+  camera: tileflowCaptureCenterCameraSchema,
+  blend: tileflowCaptureShotBlendSchema.optional()
+}).strict();
+var tileflowCaptureShotFields = {
+  theme: tileflowThemeNameSchema,
+  viewport: tileflowCaptureViewportSchema,
+  fps: z9.literal(tileflowCaptureShotLimits.fps).optional(),
+  keyframes: z9.array(tileflowCaptureShotKeyframeSchema).min(tileflowCaptureShotLimits.keyframes.minimum).max(tileflowCaptureShotLimits.keyframes.maximum),
+  easing: z9.enum(["smooth", "linear"]).optional()
+};
+var tileflowCaptureShotSchema = z9.object({ map: tileflowPortableIdSchema, ...tileflowCaptureShotFields }).strict().superRefine(checkShotTiming);
+var tileflowMapShotSchema = z9.object(tileflowCaptureShotFields).strict().superRefine(checkShotTiming);
+function tileflowCaptureShotFrameCount(shot) {
+  const fps = shot.fps ?? tileflowCaptureShotLimits.defaultFps;
+  const duration = shot.keyframes.at(-1)?.at ?? 0;
+  return Math.floor(duration * fps / 1e3 + 1e-9) + 1;
+}
+function checkShotTiming(shot, context) {
+  const { keyframes } = shot;
+  if (keyframes[0] && keyframes[0].at !== 0) {
+    context.addIssue({
+      code: "custom",
+      message: "Expected the first keyframe at 0 milliseconds",
+      path: ["keyframes", 0, "at"]
+    });
+  }
+  for (let index = 1; index < keyframes.length; index += 1) {
+    if (keyframes[index].at <= keyframes[index - 1].at) {
+      context.addIssue({
+        code: "custom",
+        message: "Expected a time after the previous keyframe",
+        path: ["keyframes", index, "at"]
+      });
+    }
+  }
+  const blended = keyframes.filter((keyframe) => keyframe.blend !== void 0);
+  if (blended.length > 0) {
+    const themes = JSON.stringify(blended[0].blend.themes);
+    keyframes.forEach((keyframe, index) => {
+      if (!keyframe.blend) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected a blend on every keyframe when one keyframe blends themes",
+          path: ["keyframes", index, "blend"]
+        });
+      } else if (JSON.stringify(keyframe.blend.themes) !== themes) {
+        context.addIssue({
+          code: "custom",
+          message: "Expected the same themes, in the same order, on every keyframe",
+          path: ["keyframes", index, "blend", "themes"]
+        });
+      }
+    });
+  }
+  const frames = tileflowCaptureShotFrameCount(shot);
+  if (frames > tileflowCaptureShotLimits.maximumFrames) {
+    context.addIssue({
+      code: "custom",
+      message: `Expected at most ${tileflowCaptureShotLimits.maximumFrames} frames; this shot renders ${frames}`,
+      path: ["keyframes", keyframes.length - 1, "at"]
+    });
+  }
+}
+
 // src/maps/operations.ts
 var resetValue = deepFreeze({ $tileflow: "reset" });
 var disableValue = deepFreeze({ op: "disable" });
@@ -14778,6 +15183,7 @@ var tileflowMapMergeStrategies = {
   overlays: "keyed-resources",
   projection: "atomic",
   scenes: "leaf",
+  shots: "leaf",
   sources: "keyed-resources",
   systemThemes: "atomic",
   terrain: "atomic",
@@ -15154,6 +15560,7 @@ function parseTileflowMap(map) {
   for (const node2 of lineage.reverse()) {
     const resolved = node2 === map ? resolvedLeaf : resolveMap(node2);
     validateMapScenes(node2, resolved.id);
+    validateMapShots(node2, resolved.id);
     const parsed = parseResolvedTileflowMap(resolved);
     if (node2 === map) parsedLeaf = parsed;
   }
@@ -15161,40 +15568,53 @@ function parseTileflowMap(map) {
   return parsedLeaf;
 }
 function validateMapScenes(map, mapId) {
-  if (map.scenes === void 0) return;
-  if (!isPlainRecord5(map.scenes)) {
-    throw new Error(`Invalid Tileflow map "${map.id}". scenes: Expected a plain object.`);
+  validateMapCaptureEntries(map, mapId, "scenes", (input) => {
+    const result = tileflowCaptureSceneSchema.safeParse(input);
+    return result.success ? tileflowCaptureSceneFitIssue(result.data) : result.error.issues[0];
+  });
+}
+function validateMapShots(map, mapId) {
+  validateMapCaptureEntries(map, mapId, "shots", (input) => {
+    const result = tileflowCaptureShotSchema.safeParse(input);
+    return result.success ? void 0 : result.error.issues[0];
+  });
+}
+function validateMapCaptureEntries(map, mapId, key, findIssue) {
+  const entries = map[key];
+  if (entries === void 0) return;
+  if (!isPlainRecord5(entries)) {
+    throw new Error(`Invalid Tileflow map "${map.id}". ${key}: Expected a plain object.`);
   }
+  const label = key === "scenes" ? "scene" : "shot";
   const namesByCaseFold = /* @__PURE__ */ new Map();
-  for (const [sceneName, input] of Object.entries(map.scenes)) {
-    const nameResult = tileflowCaptureSceneNameSchema.safeParse(sceneName);
+  for (const [name, input] of Object.entries(entries)) {
+    const nameResult = tileflowCaptureSceneNameSchema.safeParse(name);
     if (!nameResult.success) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}: ${nameResult.error.issues[0]?.message ?? "Invalid scene name"}`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}: ${nameResult.error.issues[0]?.message ?? `Invalid ${label} name`}`
       );
     }
-    const normalizedSceneName = nameResult.data;
-    const folded = normalizedSceneName.toLowerCase();
+    const normalizedName = nameResult.data;
+    const folded = normalizedName.toLowerCase();
     const existing = namesByCaseFold.get(folded);
     if (existing) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}: Expected an id that does not normalize to "${existing}".`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}: Expected an id that does not normalize to "${existing}".`
       );
     }
-    namesByCaseFold.set(folded, normalizedSceneName);
+    namesByCaseFold.set(folded, normalizedName);
     if (!isPlainRecord5(input)) {
-      throw new Error(`Invalid Tileflow map "${map.id}". scenes.${sceneName}: Expected an object.`);
+      throw new Error(`Invalid Tileflow map "${map.id}". ${key}.${name}: Expected an object.`);
     }
     if (Object.hasOwn(input, "map")) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}.map: Unrecognized key; a singular map scene inherits its map id.`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}.map: Unrecognized key; a singular map ${label} inherits its map id.`
       );
     }
-    const result = tileflowCaptureSceneSchema.safeParse({ ...input, map: mapId });
-    const issue = result.success ? tileflowCaptureSceneFitIssue(result.data) : result.error.issues[0];
-    if (!result.success || issue) {
+    const issue = findIssue({ ...input, map: mapId });
+    if (issue) {
       throw new Error(
-        `Invalid Tileflow map "${map.id}". scenes.${sceneName}${issue?.path.length ? `.${issue.path.join(".")}` : ""}: ${issue?.message ?? "Invalid scene"}`
+        `Invalid Tileflow map "${map.id}". ${key}.${name}${issue.path.length ? `.${issue.path.join(".")}` : ""}: ${issue.message}`
       );
     }
   }
@@ -15206,10 +15626,10 @@ function isPlainRecord5(value) {
 }
 
 // src/icon-composition.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/icon-package.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var tileflowIconIdPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 var tileflowIconPackageLimits = {
   decodeConcurrency: 4,
@@ -15228,19 +15648,19 @@ var tileflowHostedAlphaCompatibility = {
   },
   maxMapsPerDeploy: 20
 };
-var sha256Schema = z9.string().regex(/^[a-f0-9]{64}$/);
+var sha256Schema = z10.string().regex(/^[a-f0-9]{64}$/);
 var tileflowIconPackageContentHashSchema = sha256Schema;
-var tileflowIconIdSchema = z9.string().max(64).regex(tileflowIconIdPattern);
-var tileflowRenderedIconManifestEntrySchema = z9.object({
+var tileflowIconIdSchema = z10.string().max(64).regex(tileflowIconIdPattern);
+var tileflowRenderedIconManifestEntrySchema = z10.object({
   name: tileflowIconIdSchema,
   appearance: tileflowIconAppearanceSchema.optional(),
   layout: tileflowIconLayoutSchema.optional(),
-  pixelSha256: z9.object({
+  pixelSha256: z10.object({
     oneX: sha256Schema,
     twoX: sha256Schema
   }).strict()
 }).strict();
-var tileflowIconPackageLabelSchema = z9.string().superRefine((value, context) => {
+var tileflowIconPackageLabelSchema = z10.string().superRefine((value, context) => {
   if (value !== value.trim() || value.length === 0) {
     context.addIssue({
       code: "custom",
@@ -15260,32 +15680,32 @@ var tileflowIconPackageLabelSchema = z9.string().superRefine((value, context) =>
     });
   }
 });
-var spriteDimensionsSchema = z9.object({
-  height: z9.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
-  pixelRatio: z9.union([z9.literal(1), z9.literal(2)]),
-  width: z9.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
+var spriteDimensionsSchema = z10.object({
+  height: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension),
+  pixelRatio: z10.union([z10.literal(1), z10.literal(2)]),
+  width: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension)
 }).strict();
 function iconPackageFileSchema(name, contentType) {
-  return z9.object({
-    byteLength: z9.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
-    contentType: z9.literal(contentType),
-    name: z9.literal(name),
+  return z10.object({
+    byteLength: z10.number().int().nonnegative().max(tileflowIconPackageLimits.maxGeneratedFileBytes),
+    contentType: z10.literal(contentType),
+    name: z10.literal(name),
     sha256: sha256Schema
   }).strict();
 }
-var tileflowIconPackageManifestSchema = z9.object({
-  files: z9.tuple([
+var tileflowIconPackageManifestSchema = z10.object({
+  files: z10.tuple([
     iconPackageFileSchema("sprite.json", "application/json"),
     iconPackageFileSchema("sprite.png", "image/png"),
     iconPackageFileSchema("sprite@2x.json", "application/json"),
     iconPackageFileSchema("sprite@2x.png", "image/png")
   ]),
-  format: z9.enum(["tileflow-icon-package-v1", "tileflow-icon-package-v2"]),
-  iconNames: z9.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  renderedIcons: z9.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
-  sprites: z9.object({
-    oneX: spriteDimensionsSchema.extend({ pixelRatio: z9.literal(1) }),
-    twoX: spriteDimensionsSchema.extend({ pixelRatio: z9.literal(2) })
+  format: z10.enum(["tileflow-icon-package-v1", "tileflow-icon-package-v2"]),
+  iconNames: z10.array(tileflowIconIdSchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  renderedIcons: z10.array(tileflowRenderedIconManifestEntrySchema).min(1).max(tileflowIconPackageLimits.maxIconCount),
+  sprites: z10.object({
+    oneX: spriteDimensionsSchema.extend({ pixelRatio: z10.literal(1) }),
+    twoX: spriteDimensionsSchema.extend({ pixelRatio: z10.literal(2) })
   }).strict()
 }).strict().superRefine((manifest, context) => {
   if (manifest.renderedIcons.some(
@@ -15384,57 +15804,57 @@ function containsControlCharacter(value) {
 
 // src/icon-composition.ts
 var tileflowIconCompositionMaximumBytes = 1024 * 1024;
-var idsSchema = z10.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
+var idsSchema = z11.array(tileflowIconIdSchema).max(tileflowIconPackageLimits.maxIconCount).refine(
   (ids) => new Set(ids).size === ids.length && ids.every((id2, index) => index === 0 || compareCodeUnits8(ids[index - 1], id2) < 0),
   "Icon exports must be unique and sorted by code unit"
 );
-var localContributorSchema = z10.object({ kind: z10.literal("local"), iconIds: idsSchema }).strict();
-var packageContributorSchema = z10.object({
-  kind: z10.literal("package"),
-  package: z10.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
+var localContributorSchema = z11.object({ kind: z11.literal("local"), iconIds: idsSchema }).strict();
+var packageContributorSchema = z11.object({
+  kind: z11.literal("package"),
+  package: z11.string().max(214).regex(/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u),
   iconIds: idsSchema
 }).strict();
-var setContributorSchema = z10.object({
-  kind: z10.literal("icon-set"),
+var setContributorSchema = z11.object({
+  kind: z11.literal("icon-set"),
   reference: tileflowIconSetReferenceSchema,
   teamId: tileflowIconSetTeamIdSchema,
   setId: tileflowIconSetIdSchema,
   versionId: tileflowIconSetVersionIdSchema,
-  version: z10.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  version: z11.number().int().positive().max(Number.MAX_SAFE_INTEGER),
   packageId: tileflowIconSetPackageIdSchema,
   contentHash: tileflowIconPackageContentHashSchema,
   iconIds: idsSchema.min(1)
 }).strict();
-var tileflowRenderedIconIdentitySchema = z10.object({
-  kind: z10.literal("rendered-icon"),
+var tileflowRenderedIconIdentitySchema = z11.object({
+  kind: z11.literal("rendered-icon"),
   id: tileflowIconIdSchema,
   appearance: tileflowIconAppearanceSchema.optional(),
   layout: tileflowIconLayoutSchema.optional(),
-  width: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  height: z10.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
-  pixelSha256: z10.object({
+  width: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  height: z11.number().int().positive().max(tileflowIconPackageLimits.maxAtlasDimension / 2),
+  pixelSha256: z11.object({
     oneX: tileflowIconPackageContentHashSchema,
     twoX: tileflowIconPackageContentHashSchema
   }).strict()
 }).strict();
-var tileflowIconCompositionSchema = z10.object({
+var tileflowIconCompositionSchema = z11.object({
   // An explicit map keeps declaration order independent of TypeScript's literal cache.
-  format: z10.enum({
+  format: z11.enum({
     "tileflow-icon-composition-v1": "tileflow-icon-composition-v1",
     "tileflow-icon-composition-v2": "tileflow-icon-composition-v2"
   }),
-  compositionVersion: z10.union([z10.literal(1), z10.literal(2)]),
+  compositionVersion: z11.union([z11.literal(1), z11.literal(2)]),
   packageHash: tileflowIconPackageContentHashSchema,
-  contributors: z10.array(
-    z10.discriminatedUnion("kind", [
+  contributors: z11.array(
+    z11.discriminatedUnion("kind", [
       localContributorSchema,
       packageContributorSchema,
       setContributorSchema
     ])
   ).min(1).max(tileflowIconSourceLimit),
-  winners: z10.array(
+  winners: z11.array(
     tileflowRenderedIconIdentitySchema.omit({ kind: true }).extend({
-      contributor: z10.number().int().min(0).max(tileflowIconSourceLimit - 1)
+      contributor: z11.number().int().min(0).max(tileflowIconSourceLimit - 1)
     })
   ).min(1).max(tileflowIconPackageLimits.maxIconCount)
 }).strict().superRefine((receipt, context) => {
@@ -15786,23 +16206,23 @@ function compileTileflowMapWithInspection(config, options) {
 }
 
 // src/renderer-deployment.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/native-build-record.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/native-profile-definition.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var tileflowNativeProfileSchema = strictNativeObject({
-  id: z11.literal("native-v1"),
-  renderer: z11.literal("native"),
-  schemaVersion: z11.literal(1),
-  styleVersion: z11.literal(8),
-  validatorStyleSpec: z11.literal("24.8.5"),
-  reactNativeStyleSpec: z11.literal("26.2.1"),
-  maplibreReactNative: z11.literal("11.3.10"),
-  android: z11.literal("13.2.0"),
-  ios: z11.literal("6.26.0")
+  id: z12.literal("native-v1"),
+  renderer: z12.literal("native"),
+  schemaVersion: z12.literal(1),
+  styleVersion: z12.literal(8),
+  validatorStyleSpec: z12.literal("24.8.5"),
+  reactNativeStyleSpec: z12.literal("26.2.1"),
+  maplibreReactNative: z12.literal("11.3.10"),
+  android: z12.literal("13.2.0"),
+  ios: z12.literal("6.26.0")
 });
 var tileflowNativeProfile = Object.freeze({
   id: "native-v1",
@@ -15815,8 +16235,8 @@ var tileflowNativeProfile = Object.freeze({
   android: "13.2.0",
   ios: "6.26.0"
 });
-var tileflowNativeProfileIdSchema = z11.literal("native-v1");
-var tileflowRendererSchema = z11.enum(["web", "native"]);
+var tileflowNativeProfileIdSchema = z12.literal("native-v1");
+var tileflowRendererSchema = z12.enum(["web", "native"]);
 
 // src/native-profile-helpers.ts
 var tileflowNativeProfileLimits = Object.freeze({
@@ -15897,20 +16317,20 @@ function isBoundedNativeJson(input, stage = "input") {
 }
 
 // src/native-build-record.ts
-var hashSchema = z12.string().regex(/^[a-f0-9]{64}$/u);
-var layerCountSchema = z12.number().int().min(0).max(tileflowNativeProfileLimits.maximumLayers);
+var hashSchema = z13.string().regex(/^[a-f0-9]{64}$/u);
+var layerCountSchema = z13.number().int().min(0).max(tileflowNativeProfileLimits.maximumLayers);
 var layerTransformationSchema = strictNativeObject({
   inputLayer: layerCountSchema,
   outputStart: layerCountSchema,
-  outputCount: z12.number().int().min(1).max(32),
-  properties: z12.array(z12.enum(["line-cap", "line-dasharray"])).min(1).max(2).refine(
+  outputCount: z13.number().int().min(1).max(32),
+  properties: z13.array(z13.enum(["line-cap", "line-dasharray"])).min(1).max(2).refine(
     (properties2) => properties2.length === 1 || properties2[0] === "line-cap" && properties2[1] === "line-dasharray",
     "Expected unique, ordered properties"
   )
 });
 var symbolOverlapTransformationSchema = strictNativeObject({
   inputLayer: layerCountSchema,
-  properties: z12.array(z12.enum(["icon-overlap", "text-overlap"])).min(1).max(2).refine(
+  properties: z13.array(z13.enum(["icon-overlap", "text-overlap"])).min(1).max(2).refine(
     (properties2) => properties2.length === 1 || properties2[0] === "icon-overlap" && properties2[1] === "text-overlap",
     "Expected unique, ordered properties"
   )
@@ -15922,9 +16342,9 @@ var tileflowNativeStyleTransformationSchema = strictNativeObject({
   loweredStyleSha256: hashSchema,
   inputLayers: layerCountSchema,
   outputLayers: layerCountSchema,
-  projection: z12.enum(["none", "mercator-to-implicit", "globe-to-mercator"]),
-  layers: z12.array(layerTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers),
-  symbolOverlap: z12.array(symbolOverlapTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers)
+  projection: z13.enum(["none", "mercator-to-implicit", "globe-to-mercator"]),
+  layers: z13.array(layerTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers),
+  symbolOverlap: z13.array(symbolOverlapTransformationSchema).max(tileflowNativeProfileLimits.maximumLayers)
 }).superRefine((style, context) => {
   let previous = -1;
   let added = 0;
@@ -15960,14 +16380,14 @@ var tileflowNativeStyleTransformationSchema = strictNativeObject({
   }
 });
 var tileflowNativeBuildRecordSchema = strictNativeObject({
-  schemaVersion: z12.literal(2),
-  renderer: z12.literal("native"),
-  profile: z12.literal("native-v1"),
-  validation: z12.literal("static-artifacts"),
-  preparationVersion: z12.literal("native-lowering-v1"),
-  engines: strictNativeObject({ android: z12.literal("13.2.0"), ios: z12.literal("6.26.0") }),
+  schemaVersion: z13.literal(2),
+  renderer: z13.literal("native"),
+  profile: z13.literal("native-v1"),
+  validation: z13.literal("static-artifacts"),
+  preparationVersion: z13.literal("native-lowering-v1"),
+  engines: strictNativeObject({ android: z13.literal("13.2.0"), ios: z13.literal("6.26.0") }),
   buildManifestSha256: hashSchema,
-  transformations: z12.array(tileflowNativeStyleTransformationSchema).max(4096)
+  transformations: z13.array(tileflowNativeStyleTransformationSchema).max(4096)
 }).superRefine((record3, context) => {
   let previous = "";
   for (const [index, item] of record3.transformations.entries()) {
@@ -24423,7 +24843,7 @@ var latest_default = {
 };
 
 // src/native-profile.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/native-url-policy.ts
 var tileflowNativeUrlLimits = Object.freeze({ maximumLength: 2048 });
@@ -24578,7 +24998,7 @@ var { resolveTileflowNativeResourceUrl } = createNativeUrlPolicy(
 );
 
 // src/native-profile.ts
-var tileflowNativeDiagnosticCodeSchema = z13.enum([
+var tileflowNativeDiagnosticCodeSchema = z14.enum([
   "NATIVE_UNSUPPORTED_STYLE",
   "NATIVE_UNSUPPORTED_SOURCE",
   "NATIVE_FONT_UNAVAILABLE",
@@ -24587,13 +25007,13 @@ var tileflowNativeDiagnosticCodeSchema = z13.enum([
 ]);
 var tileflowNativeDiagnosticSchema = strictNativeObject({
   code: tileflowNativeDiagnosticCodeSchema,
-  phase: z13.literal("native-compatibility"),
-  severity: z13.literal("error"),
-  path: z13.string().max(300).regex(/^(?:\/(?:[^~]|~[01])*)?$/u),
-  renderer: z13.literal("native"),
+  phase: z14.literal("native-compatibility"),
+  severity: z14.literal("error"),
+  path: z14.string().max(300).regex(/^(?:\/(?:[^~]|~[01])*)?$/u),
+  renderer: z14.literal("native"),
   profile: tileflowNativeProfileIdSchema,
-  message: z13.string().max(300),
-  suggestion: z13.string().max(300)
+  message: z14.string().max(300),
+  suggestion: z14.string().max(300)
 });
 var descriptions = {
   NATIVE_UNSUPPORTED_STYLE: [
@@ -24973,24 +25393,24 @@ var tileflowRendererDeploymentLimits = Object.freeze({
   maximumNativeFamilyBytes: tileflowNativeProfileLimits.maximumStyleBytes,
   maximumThemes: 64
 });
-var hashSchema2 = z14.string().regex(/^[a-f0-9]{64}$/u);
-var recordSchema = z14.record(z14.string().min(1).max(256), z14.unknown());
-var positive = z14.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-var sourceAssetsSchema = z14.object({
-  fonts: z14.array(
-    z14.object({
-      family: z14.string().min(1).max(128),
+var hashSchema2 = z15.string().regex(/^[a-f0-9]{64}$/u);
+var recordSchema = z15.record(z15.string().min(1).max(256), z15.unknown());
+var positive = z15.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var sourceAssetsSchema = z15.object({
+  fonts: z15.array(
+    z15.object({
+      family: z15.string().min(1).max(128),
       sha256: hashSchema2,
-      style: z14.enum(["italic", "normal", "oblique"]),
-      weight: z14.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
+      style: z15.enum(["italic", "normal", "oblique"]),
+      weight: z15.enum(["100", "200", "300", "400", "500", "600", "700", "800", "900"])
     }).strict()
   ).max(64),
-  icons: z14.array(
-    z14.union([
-      z14.object({
-        format: z14.enum(["jpeg", "png", "svg", "webp"]),
+  icons: z15.array(
+    z15.union([
+      z15.object({
+        format: z15.enum(["jpeg", "png", "svg", "webp"]),
         id: tileflowPortableIdSchema,
-        kind: z14.enum(["icon", "pattern"]),
+        kind: z15.enum(["icon", "pattern"]),
         sha256: hashSchema2
       }).strict(),
       tileflowRenderedIconIdentitySchema
@@ -24998,44 +25418,44 @@ var sourceAssetsSchema = z14.object({
   ).max(512),
   iconComposition: tileflowIconCompositionSchema.optional()
 }).strict();
-var themeBuildSchema = z14.object({
-  colorScheme: z14.enum(["dark", "light"]),
+var themeBuildSchema = z15.object({
+  colorScheme: z15.enum(["dark", "light"]),
   dataRequirements: recordSchema,
   sourceRequirements: recordSchema,
   styleSha256: hashSchema2,
   themeId: tileflowPortableIdSchema,
   themeVersion: positive
 }).strict();
-var mapBuildSchema = z14.object({
+var mapBuildSchema = z15.object({
   assetSetSha256: hashSchema2,
   defaultTheme: tileflowThemeNameSchema,
-  lineage: z14.array(z14.object({ id: tileflowPortableIdSchema, mapVersion: positive }).strict()).min(1).max(64),
+  lineage: z15.array(z15.object({ id: tileflowPortableIdSchema, mapVersion: positive }).strict()).min(1).max(64),
   mapRevisionSha256: hashSchema2,
-  mapRevisionSchemaVersion: z14.literal(2).optional(),
+  mapRevisionSchemaVersion: z15.literal(2).optional(),
   mapVersion: positive,
-  semanticCompiler: z14.object({ name: z14.literal("tileflow-semantic"), version: z14.literal(1) }).strict(),
+  semanticCompiler: z15.object({ name: z15.literal("tileflow-semantic"), version: z15.literal(1) }).strict(),
   sourceAssets: sourceAssetsSchema,
-  systemThemes: z14.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
-  themes: z14.record(tileflowThemeNameSchema, themeBuildSchema)
+  systemThemes: z15.object({ dark: tileflowThemeNameSchema, light: tileflowThemeNameSchema }).strict().optional(),
+  themes: z15.record(tileflowThemeNameSchema, themeBuildSchema)
 }).strict();
-var buildManifestSchema = z14.object({
-  schemaVersion: z14.literal(1),
-  maps: z14.record(tileflowPortableIdSchema, mapBuildSchema),
-  provenance: z14.object({
-    schemaVersion: z14.literal(1),
-    lockfile: z14.object({ format: z14.enum(["bun", "npm", "pnpm", "yarn"]), sha256: hashSchema2 }).strict().optional(),
-    packages: z14.record(z14.string().min(1).max(128), z14.string().min(1).max(128))
+var buildManifestSchema = z15.object({
+  schemaVersion: z15.literal(1),
+  maps: z15.record(tileflowPortableIdSchema, mapBuildSchema),
+  provenance: z15.object({
+    schemaVersion: z15.literal(1),
+    lockfile: z15.object({ format: z15.enum(["bun", "npm", "pnpm", "yarn"]), sha256: hashSchema2 }).strict().optional(),
+    packages: z15.record(z15.string().min(1).max(128), z15.string().min(1).max(128))
   }).strict().optional()
 }).strict();
 var familyShape = {
   buildManifest: buildManifestSchema,
-  styles: z14.record(tileflowThemeNameSchema, recordSchema)
+  styles: z15.record(tileflowThemeNameSchema, recordSchema)
 };
-var teamSourcesSchema = z14.record(
+var teamSourcesSchema = z15.record(
   tileflowPortableIdSchema,
-  z14.object({
-    tileset: z14.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
-    type: z14.enum(["raster", "vector"])
+  z15.object({
+    tileset: z15.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
+    type: z15.enum(["raster", "vector"])
   }).strict()
 ).superRefine((sources, context) => {
   const entries = Object.entries(sources);
@@ -25047,21 +25467,21 @@ var teamSourcesSchema = z14.record(
     tilesets.add(value.tileset);
   }
 });
-var viewSchema2 = z14.object({
-  center: z14.tuple([z14.number().min(-180).max(180), z14.number().min(-90).max(90)]).optional(),
-  zoom: z14.number().min(0).max(24).optional(),
-  bearing: z14.number().finite().optional(),
-  pitch: z14.number().min(0).max(85).optional()
+var viewSchema2 = z15.object({
+  center: z15.tuple([z15.number().min(-180).max(180), z15.number().min(-90).max(90)]).optional(),
+  zoom: z15.number().min(0).max(24).optional(),
+  bearing: z15.number().finite().optional(),
+  pitch: z15.number().min(0).max(85).optional()
 }).strict();
-var tileflowRendererDeploymentArtifactSchema = z14.object({
-  kind: z14.literal("tileflow-map-deployment"),
-  schemaVersion: z14.literal(2),
+var tileflowRendererDeploymentArtifactSchema = z15.object({
+  kind: z15.literal("tileflow-map-deployment"),
+  schemaVersion: z15.literal(2),
   mapId: tileflowPortableIdSchema,
   teamSources: teamSourcesSchema,
   view: viewSchema2.optional(),
-  renderers: z14.object({
-    web: z14.object(familyShape).strict(),
-    native: z14.object({ ...familyShape, buildRecord: tileflowNativeBuildRecordSchema }).strict()
+  renderers: z15.object({
+    web: z15.object(familyShape).strict(),
+    native: z15.object({ ...familyShape, buildRecord: tileflowNativeBuildRecordSchema }).strict()
   }).strict()
 }).strict().superRefine((artifact, context) => {
   const fail = () => context.addIssue({
@@ -25186,30 +25606,30 @@ function object(value) {
 function equal(left, right) {
   return left === void 0 || right === void 0 ? left === right : serializeCanonicalJson(left) === serializeCanonicalJson(right);
 }
-var artifactName = z14.string().min(1).max(256).refine(
+var artifactName = z15.string().min(1).max(256).refine(
   (value) => [...value].every((char) => {
     const code = char.codePointAt(0);
     return code >= 32 && code !== 127;
   })
 );
-var semanticSchema = z14.object({
-  version: z14.literal(2),
-  domains: z14.object({
-    poi: z14.object({
-      deduplication: z14.object({
-        identity: z14.tuple([
-          z14.literal("source"),
-          z14.literal("source-layer"),
-          z14.literal("feature-id")
+var semanticSchema = z15.object({
+  version: z15.literal(2),
+  domains: z15.object({
+    poi: z15.object({
+      deduplication: z15.object({
+        identity: z15.tuple([
+          z15.literal("source"),
+          z15.literal("source-layer"),
+          z15.literal("feature-id")
         ]),
-        representationPriority: z14.tuple([
-          z14.literal("marker"),
-          z14.literal("icon"),
-          z14.literal("combined"),
-          z14.literal("label")
+        representationPriority: z15.tuple([
+          z15.literal("marker"),
+          z15.literal("icon"),
+          z15.literal("combined"),
+          z15.literal("label")
         ])
       }).strict(),
-      fields: z14.object({
+      fields: z15.object({
         category: artifactName,
         filterRank: artifactName,
         icon: artifactName,
@@ -25217,18 +25637,18 @@ var semanticSchema = z14.object({
         sizeRank: artifactName,
         type: artifactName
       }).strict(),
-      hitTesting: z14.object({
-        frequency: z14.literal("animation-frame"),
-        order: z14.literal("rendered-topmost")
+      hitTesting: z15.object({
+        frequency: z15.literal("animation-frame"),
+        order: z15.literal("rendered-topmost")
       }).strict(),
-      identity: z14.literal("maplibre-feature-id-if-present"),
-      layers: z14.array(
-        z14.object({
-          anchor: z14.literal("pointer-coordinate"),
-          category: z14.enum(tileflowPoiCategories),
+      identity: z15.literal("maplibre-feature-id-if-present"),
+      layers: z15.array(
+        z15.object({
+          anchor: z15.literal("pointer-coordinate"),
+          category: z15.enum(tileflowPoiCategories),
           layerId: artifactName,
-          priority: z14.number().int().min(0).max(4095),
-          representation: z14.enum(["combined", "icon", "label", "marker"]),
+          priority: z15.number().int().min(0).max(4095),
+          representation: z15.enum(["combined", "icon", "label", "marker"]),
           source: artifactName,
           sourceLayer: artifactName
         }).strict()
@@ -25254,8 +25674,8 @@ function semanticIdentity(style) {
   const poi2 = manifest.domains.poi;
   return poi2 ? { ...poi2, layers: poi2.layers.map(({ priority: _priority, ...identity }) => identity) } : manifest;
 }
-var mapIdSchema = z14.string().regex(/^map_[A-Za-z0-9_-]{16}$/u);
-var publicUrlSchema = z14.string().min(1).max(2048).refine((value) => {
+var mapIdSchema = z15.string().regex(/^map_[A-Za-z0-9_-]{16}$/u);
+var publicUrlSchema = z15.string().min(1).max(2048).refine((value) => {
   try {
     const url = new URL(value);
     return url.protocol === "https:" && !url.username && !url.password && !url.search && !url.hash && url.toString() === value && !/tf_(?:public|native|live)_/u.test(value);
@@ -25263,22 +25683,22 @@ var publicUrlSchema = z14.string().min(1).max(2048).refine((value) => {
     return false;
   }
 });
-var webResponseTheme = z14.object({ styleId: z14.string().min(1).max(128).optional(), styleUrl: publicUrlSchema }).strict();
-var nativeResponseTheme = z14.object({ styleUrl: publicUrlSchema, revision: hashSchema2 }).strict();
-var tileflowRendererDeploymentResponseSchema = z14.object({
-  kind: z14.literal("tileflow-map-deployment-result"),
-  schemaVersion: z14.literal(2),
-  changed: z14.boolean(),
+var webResponseTheme = z15.object({ styleId: z15.string().min(1).max(128).optional(), styleUrl: publicUrlSchema }).strict();
+var nativeResponseTheme = z15.object({ styleUrl: publicUrlSchema, revision: hashSchema2 }).strict();
+var tileflowRendererDeploymentResponseSchema = z15.object({
+  kind: z15.literal("tileflow-map-deployment-result"),
+  schemaVersion: z15.literal(2),
+  changed: z15.boolean(),
   mapId: mapIdSchema,
-  deploymentId: z14.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  deploymentId: z15.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/u),
   version: positive,
-  worldConversionId: z14.string().min(1).max(128).optional(),
-  renderers: z14.object({
-    web: z14.object({ themes: z14.record(tileflowThemeNameSchema, webResponseTheme) }).strict(),
-    native: z14.object({
-      profile: z14.literal("native-v1"),
+  worldConversionId: z15.string().min(1).max(128).optional(),
+  renderers: z15.object({
+    web: z15.object({ themes: z15.record(tileflowThemeNameSchema, webResponseTheme) }).strict(),
+    native: z15.object({
+      profile: z15.literal("native-v1"),
       manifestUrl: publicUrlSchema,
-      themes: z14.record(tileflowThemeNameSchema, nativeResponseTheme)
+      themes: z15.record(tileflowThemeNameSchema, nativeResponseTheme)
     }).strict()
   }).strict()
 }).strict().superRefine((value, context) => {