@tileflow/static 0.1.0-alpha.22 → 0.1.0-alpha.24

package/dist/scene.d.ts

@@ -1,16 +1,18 @@
 import { z } from 'zod';
-import { i as StaticSceneInput, h as StaticScene } from './scene-contract-OMIOisSB.js';
-export { M as MAX_OVERLAY_LATITUDE, S as StaticAttributionMode, a as StaticAttributionPosition, b as StaticAttributionRequest, c as StaticCoordinate, d as StaticMapFormat, g as StaticPadding, s as staticAttributionPositionSchema, j as staticAttributionRequestSchema, l as staticSceneLimits, m as staticSceneSchema, n as staticSceneSchemaVersion } from './scene-contract-OMIOisSB.js';
+import { S as StaticMapError } from './errors-B9rwehK0.js';
+import { j as StaticSceneInput, i as StaticScene } from './scene-contract-Cr6BNLz0.js';
+export { M as MAX_OVERLAY_LATITUDE, S as StaticAttributionMode, a as StaticAttributionPosition, b as StaticAttributionRequest, c as StaticCoordinate, d as StaticMapFormat, g as StaticOverlayPlacement, h as StaticPadding, k as StaticSymbolAnchor, l as StaticSymbolCollision, m as StaticSymbolLabelAppearance, n as StaticSymbolLabelPosition, o as StaticSymbolLanguage, p as isSupportedStaticSymbolCodePoint, s as staticAttributionPositionSchema, q as staticAttributionRequestSchema, r as staticOverlayPlacements, u as staticSceneLimits, v as staticSceneSchema, w as staticSceneSchemaVersion, x as staticSymbolAnchors, y as staticSymbolCollisions, z as staticSymbolLabelAppearances, A as staticSymbolLabelPositions, B as staticSymbolLanguages } from './scene-contract-Cr6BNLz0.js';
 
 declare const autoFitDetailsSchema: z.ZodObject<{
     overlay: z.ZodOptional<z.ZodObject<{
         id: z.ZodString;
         index: z.ZodNumber;
         type: z.ZodEnum<{
-            line: "line";
             circle: "circle";
+            line: "line";
             marker: "marker";
             polygon: "polygon";
+            symbol: "symbol";
         }>;
     }, z.core.$strict>>;
     padding: z.ZodOptional<z.ZodObject<{
@@ -44,14 +46,41 @@ declare const staticOverlayInvalidDetailsSchema: z.ZodObject<{
         id: z.ZodString;
         index: z.ZodNumber;
         type: z.ZodEnum<{
-            line: "line";
             circle: "circle";
+            line: "line";
             marker: "marker";
             polygon: "polygon";
+            symbol: "symbol";
         }>;
     }, z.core.$strict>;
 }, z.core.$strict>;
-type StaticMapRequestErrorDetails = StaticAutoFitDetails | z.infer<typeof staticOverlayInvalidDetailsSchema>;
+declare const staticLabelUnsupportedDetailsSchema: z.ZodObject<{
+    codePoint: z.ZodNumber;
+    overlay: z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodNumber;
+        type: z.ZodLiteral<"symbol">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const staticIconUnavailableDetailsSchema: z.ZodObject<{
+    icon: z.ZodString;
+    overlay: z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodNumber;
+        type: z.ZodLiteral<"symbol">;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const staticSymbolTooLargeDetailsSchema: z.ZodObject<{
+    height: z.ZodNumber;
+    limit: z.ZodLiteral<2048>;
+    overlay: z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodNumber;
+        type: z.ZodLiteral<"symbol">;
+    }, z.core.$strict>;
+    width: z.ZodNumber;
+}, z.core.$strict>;
+type StaticMapRequestErrorDetails = StaticAutoFitDetails | z.infer<typeof staticIconUnavailableDetailsSchema> | z.infer<typeof staticOverlayInvalidDetailsSchema> | z.infer<typeof staticLabelUnsupportedDetailsSchema> | z.infer<typeof staticSymbolTooLargeDetailsSchema>;
 declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     code: z.ZodLiteral<"AUTO_FIT_EMPTY">;
     reason: z.ZodLiteral<"NO_FITTABLE_OVERLAYS">;
@@ -64,10 +93,11 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
             id: z.ZodString;
             index: z.ZodNumber;
             type: z.ZodEnum<{
-                line: "line";
                 circle: "circle";
+                line: "line";
                 marker: "marker";
                 polygon: "polygon";
+                symbol: "symbol";
             }>;
         }, z.core.$strict>>;
         padding: z.ZodOptional<z.ZodObject<{
@@ -103,10 +133,11 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
             id: z.ZodString;
             index: z.ZodNumber;
             type: z.ZodEnum<{
-                line: "line";
                 circle: "circle";
+                line: "line";
                 marker: "marker";
                 polygon: "polygon";
+                symbol: "symbol";
             }>;
         }, z.core.$strict>>;
         padding: z.ZodOptional<z.ZodObject<{
@@ -133,9 +164,9 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     reason: z.ZodEnum<{
+        CAMERA_UNRESOLVABLE: "CAMERA_UNRESOLVABLE";
         GLOBE_NOT_SIMULTANEOUSLY_VISIBLE: "GLOBE_NOT_SIMULTANEOUSLY_VISIBLE";
         INSUFFICIENT_VIEWPORT: "INSUFFICIENT_VIEWPORT";
-        CAMERA_UNRESOLVABLE: "CAMERA_UNRESOLVABLE";
         PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT: "PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT";
     }>;
     error: z.ZodString;
@@ -149,16 +180,66 @@ declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.Zo
             id: z.ZodString;
             index: z.ZodNumber;
             type: z.ZodEnum<{
-                line: "line";
                 circle: "circle";
+                line: "line";
                 marker: "marker";
                 polygon: "polygon";
+                symbol: "symbol";
             }>;
         }, z.core.$strict>;
     }, z.core.$strict>;
     reason: z.ZodLiteral<"OVERLAY_LATITUDE_OUT_OF_RANGE">;
     error: z.ZodString;
     retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_LABEL_UNSUPPORTED">;
+    details: z.ZodObject<{
+        codePoint: z.ZodNumber;
+        overlay: z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodLiteral<"symbol">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reason: z.ZodLiteral<"UNSUPPORTED_GLYPH">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_ICON_UNAVAILABLE">;
+    details: z.ZodObject<{
+        icon: z.ZodString;
+        overlay: z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodLiteral<"symbol">;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    reason: z.ZodEnum<{
+        ICON_NOT_FOUND: "ICON_NOT_FOUND";
+        MANAGED_SPRITE_REQUIRED: "MANAGED_SPRITE_REQUIRED";
+    }>;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_PLACEMENT_UNAVAILABLE">;
+    reason: z.ZodLiteral<"MAP_REDEPLOY_REQUIRED">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_SYMBOL_TOO_LARGE">;
+    details: z.ZodObject<{
+        height: z.ZodNumber;
+        limit: z.ZodLiteral<2048>;
+        overlay: z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodLiteral<"symbol">;
+        }, z.core.$strict>;
+        width: z.ZodNumber;
+    }, z.core.$strict>;
+    reason: z.ZodLiteral<"COMPOSED_IMAGE_TOO_LARGE">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
 }, z.core.$strict>, z.ZodObject<{
     code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_UNSUPPORTED">;
     reason: z.ZodEnum<{
@@ -182,7 +263,7 @@ type StaticMapRequestErrorResponse = z.infer<typeof staticMapRequestErrorRespons
 type StaticAutoFitErrorResponse = Extract<StaticMapRequestErrorResponse, {
     code: `AUTO_FIT_${string}`;
 }>;
-declare class StaticMapRequestError extends Error {
+declare class StaticMapRequestError extends StaticMapError {
     readonly code: StaticMapRequestErrorResponse['code'];
     readonly details?: StaticMapRequestErrorDetails;
     readonly reason: StaticMapRequestErrorResponse['reason'];

package/dist/scene.js

@@ -3,24 +3,38 @@ import {
   normalizeStaticScene,
   staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-EMCKSFZV.js";
+} from "./chunk-TBI5AED6.js";
 import {
   MAX_OVERLAY_LATITUDE,
+  isSupportedStaticSymbolCodePoint,
   staticAttributionPositionSchema,
   staticAttributionRequestSchema,
+  staticOverlayPlacements,
   staticSceneLimits,
   staticSceneSchema,
-  staticSceneSchemaVersion
-} from "./chunk-NM2JSFUF.js";
+  staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages
+} from "./chunk-6DWVCK64.js";
 export {
   MAX_OVERLAY_LATITUDE,
   StaticMapRequestError,
+  isSupportedStaticSymbolCodePoint,
   normalizeStaticScene,
   staticAttributionPositionSchema,
   staticAttributionRequestSchema,
   staticMapRequestErrorResponseSchema,
+  staticOverlayPlacements,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages,
   validateStaticScene
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/static",
-  "version": "0.1.0-alpha.22",
+  "version": "0.1.0-alpha.24",
   "license": "Apache-2.0",
   "description": "Static map request schemas and helpers for Tileflow.",
   "type": "module",
@@ -25,10 +25,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist",
-    "LICENSE",
-    "NOTICE",
-    "GENERATED_OUTPUT_LICENSE.md",
-    "TRADEMARKS.md"
+    "LICENSE"
   ],
   "exports": {
     ".": {
@@ -64,8 +61,8 @@
     "zod": "^4.4.3"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/scene.ts src/overlays.ts src/manifest.ts src/client.ts --format esm --dts --clean --splitting",
-    "verify": "tsx --test test/*.test.ts",
+    "build": "tsup src/index.ts src/scene.ts src/overlays.ts src/manifest.ts src/client.ts --format esm --dts --clean --splitting && node ../../scripts/canonicalize-zod-enums.mjs dist",
+    "verify": "pnpm --silent --dir ../.. static-text:check && tsx --test test/*.test.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "tsc -p tsconfig.json --noEmit"
   }

package/GENERATED_OUTPUT_LICENSE.md

@@ -1,21 +0,0 @@
-# Tileflow generated-output grant
-
-In addition to the rights granted by the Apache License, Version 2.0, Tileflow.dev contributors
-grant recipients a perpetual, worldwide, non-exclusive, no-charge, royalty-free right to use,
-reproduce, modify, display, perform, distribute, sublicense, and commercialize the Tileflow-owned
-parts of output generated by this SDK.
-
-Covered output includes compiled map styles, manifests, receipts, sprites, glyph artifacts, static
-render descriptions, and other build artifacts produced from Tileflow maps or application maps.
-Original Tileflow map definitions, icons, and patterns distributed by `@tileflow/maps` may likewise
-be used, modified, embedded, deployed, and redistributed as part of personal or commercial maps and
-applications.
-
-This grant does not relicense third-party software, fonts, icons, map data, datasets, imagery, or
-other input material. Their licenses, attribution requirements, notices, and use restrictions
-continue to apply to the relevant source and generated output. You are responsible for having the
-rights necessary to process and distribute your own inputs.
-
-This grant does not provide access to Tileflow hosted services or grant rights in Tileflow names,
-logos, or marks. The SDK and generated output are provided without warranties or conditions beyond
-those required by applicable law.

package/NOTICE

@@ -1,9 +0,0 @@
-Tileflow SDK
-Copyright 2026 Tileflow.dev contributors
-
-This product includes software and original map artwork developed by Tileflow.dev contributors.
-
-Third-party materials distributed with a package remain subject to their own license and notice
-files. See THIRD_PARTY_NOTICES.md and asset-adjacent license files where present.
-
-The Tileflow names and marks are not licensed under the Apache License 2.0. See TRADEMARKS.md.

package/TRADEMARKS.md

@@ -1,10 +0,0 @@
-# Tileflow trademarks
-
-The Apache License, Version 2.0, and the Tileflow generated-output grant do not grant permission to
-use the Tileflow name, `tileflow.dev`, logos, service marks, product names, or other Tileflow brand
-features except for reasonable and customary use that truthfully describes the origin of the SDK or
-compatibility with Tileflow, and for reproducing required notices.
-
-You may not use Tileflow brand features in a way that suggests sponsorship, endorsement, or an
-official Tileflow product when none exists. Third-party names and marks remain the property of their
-respective owners.

package/dist/chunk-EPOYQNNT.js

@@ -1,122 +0,0 @@
-import {
-  normalizeStaticOverlay,
-  roundNumber
-} from "./chunk-NM2JSFUF.js";
-
-// src/overlays.ts
-function line(input) {
-  return normalizeStaticOverlay({ ...input, type: "line" });
-}
-function circle(input) {
-  return normalizeStaticOverlay({ ...input, type: "circle" });
-}
-function marker(input) {
-  return normalizeStaticOverlay({ ...input, type: "marker" });
-}
-function polygon(input) {
-  return normalizeStaticOverlay({ ...input, type: "polygon" });
-}
-function compileStaticOverlays(overlays, options = {}) {
-  if (options.longitudeOffsets !== void 0 && (options.longitudeOffsets.length !== overlays.length || options.longitudeOffsets.some(
-    (offset) => !Number.isInteger(offset) || Math.abs(offset) > 360 || offset % 360 !== 0
-  ))) {
-    throw new Error(
-      "Static overlay longitude offsets must contain one -360, 0, or 360 per overlay"
-    );
-  }
-  const sources = {};
-  const layers = [];
-  for (const [index, overlay] of overlays.entries()) {
-    const longitudeOffset = options.longitudeOffsets?.[index] ?? 0;
-    const id = safeLayerId(`overlay-${index + 1}-${overlay.id ?? overlay.type}`);
-    const sourceId = `${id}-source`;
-    if (overlay.type === "line") {
-      sources[sourceId] = {
-        data: feature("LineString", shiftLongitudes(overlay.coordinates, longitudeOffset)),
-        type: "geojson"
-      };
-      layers.push({
-        id,
-        layout: { "line-cap": "round", "line-join": "round" },
-        paint: {
-          "line-color": overlay.color,
-          "line-opacity": overlay.opacity,
-          "line-width": overlay.width
-        },
-        source: sourceId,
-        type: "line"
-      });
-      continue;
-    }
-    if (overlay.type === "polygon") {
-      sources[sourceId] = {
-        data: feature("Polygon", shiftLongitudes(overlay.coordinates, longitudeOffset)),
-        type: "geojson"
-      };
-      layers.push({
-        id,
-        paint: {
-          "fill-color": overlay.fill,
-          "fill-opacity": overlay.opacity
-        },
-        source: sourceId,
-        type: "fill"
-      });
-      if (overlay.stroke && overlay.strokeWidth > 0) {
-        layers.push({
-          id: `${id}-stroke`,
-          layout: { "line-cap": "round", "line-join": "round" },
-          paint: {
-            "line-color": overlay.stroke,
-            "line-width": overlay.strokeWidth
-          },
-          source: sourceId,
-          type: "line"
-        });
-      }
-      continue;
-    }
-    sources[sourceId] = {
-      data: feature("Point", shiftLongitudes(overlay.coordinate, longitudeOffset)),
-      type: "geojson"
-    };
-    layers.push({
-      id,
-      paint: {
-        "circle-color": overlay.color,
-        "circle-opacity": overlay.type === "circle" ? overlay.opacity : 1,
-        "circle-radius": overlay.radius,
-        "circle-stroke-color": overlay.strokeColor ?? overlay.color,
-        "circle-stroke-width": overlay.strokeWidth
-      },
-      source: sourceId,
-      type: "circle"
-    });
-  }
-  return { layers, sources };
-}
-function shiftLongitudes(value, offset) {
-  if (!Array.isArray(value)) return value;
-  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
-    return [roundNumber(value[0] + offset), value[1]];
-  }
-  return value.map((entry) => shiftLongitudes(entry, offset));
-}
-function feature(type, coordinates) {
-  return {
-    geometry: { coordinates, type },
-    properties: {},
-    type: "Feature"
-  };
-}
-function safeLayerId(value) {
-  return value.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
-}
-
-export {
-  line,
-  circle,
-  marker,
-  polygon,
-  compileStaticOverlays
-};

package/dist/chunk-NM2JSFUF.js

@@ -1,252 +0,0 @@
-// src/canonical.ts
-function stableStringify(value) {
-  return JSON.stringify(sortJson(value));
-}
-function roundNumber(value) {
-  return Number(value.toFixed(6));
-}
-function stripUndefined(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return value;
-  }
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function jsonByteLength(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).length;
-}
-async function hashStableValue(value) {
-  const bytes = new TextEncoder().encode(stableStringify(value));
-  const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return base64Url(new Uint8Array(digest));
-}
-function isSafeHttpUrl(value) {
-  try {
-    const url = new URL(value);
-    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash;
-  } catch {
-    return false;
-  }
-}
-function sortJson(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortJson(entry)])
-    );
-  }
-  return value;
-}
-function base64Url(bytes) {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-}
-
-// src/scene-contract.ts
-import { z } from "zod";
-var staticSceneSchemaVersion = 1;
-var MAX_OVERLAY_LATITUDE = 85.051129;
-var staticSceneLimits = {
-  maxDimension: 2048,
-  maxGeoJsonBytes: 96e3,
-  maxOverlays: 24,
-  maxPathCoordinates: 2e3,
-  maxPhysicalPixels: 2048 * 2048 * 4,
-  minDimension: 64
-};
-var coordinateSchema = z.tuple([z.number().finite(), z.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
-  message: "Expected [lng, lat] within world bounds"
-});
-var overlayCoordinateSchema = coordinateSchema.refine(
-  ([, latitude]) => Math.abs(latitude) <= MAX_OVERLAY_LATITUDE,
-  {
-    message: `Static overlay latitude must be within \xB1${MAX_OVERLAY_LATITUDE}\xB0`
-  }
-);
-var colorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, {
-  message: "Expected a hex color like #C6A15B"
-});
-var portableIdSchema = z.string().min(1).max(64).regex(/^[a-z][a-z0-9-]{0,63}$/u, {
-  message: "Expected lowercase kebab-case beginning with a letter"
-}).refine(
-  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
-  "Expected a portable identifier that is not a reserved filename or prototype key"
-);
-var concreteThemeSchema = portableIdSchema.refine((value) => value !== "system", {
-  message: 'Static maps require a concrete theme; "system" is browser-only'
-});
-var staticMapFormatSchema = z.enum(["png", "jpeg", "webp"]);
-var staticAttributionPositionSchema = z.enum([
-  "auto",
-  "top-left",
-  "top-right",
-  "bottom-left",
-  "bottom-right"
-]);
-var staticAttributionRequestSchema = z.union([
-  z.object({
-    mode: z.literal("embedded").optional(),
-    position: staticAttributionPositionSchema.optional()
-  }).strict(),
-  z.object({
-    mode: z.literal("external")
-  }).strict()
-]);
-var sizeSchema = z.object({
-  dpr: z.union([z.literal(1), z.literal(2)]).optional(),
-  height: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension),
-  width: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension)
-}).refine(
-  (size) => {
-    const dpr = size.dpr ?? 1;
-    return size.width * size.height * dpr * dpr <= staticSceneLimits.maxPhysicalPixels;
-  },
-  {
-    message: "Static map exceeds the maximum render pixel budget"
-  }
-);
-var centerCameraSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  center: coordinateSchema,
-  type: z.literal("center"),
-  zoom: z.number().finite().min(0).max(22)
-});
-var boundsCameraSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  bounds: z.tuple([z.number().finite(), z.number().finite(), z.number().finite(), z.number().finite()]).refine(
-    ([west, south, east, north]) => west >= -180 && west <= 180 && east >= -180 && east <= 180 && south >= -90 && south <= 90 && north >= -90 && north <= 90 && west !== east && south !== north,
-    { message: "Expected bounds as [west, south, east, north]" }
-  ),
-  padding: z.number().int().min(0).max(256).optional(),
-  type: z.literal("bounds")
-}).refine((camera) => camera.bounds[3] > camera.bounds[1], {
-  message: "Bounds north must be greater than south"
-});
-var staticPaddingSchema = z.object({
-  bottom: z.number().int().nonnegative(),
-  left: z.number().int().nonnegative(),
-  right: z.number().int().nonnegative(),
-  top: z.number().int().nonnegative()
-}).strict();
-var autoPaddingInputSchema = z.union([
-  z.number().int().nonnegative(),
-  z.object({
-    bottom: z.number().int().nonnegative().optional(),
-    left: z.number().int().nonnegative().optional(),
-    right: z.number().int().nonnegative().optional(),
-    top: z.number().int().nonnegative().optional()
-  }).strict()
-]);
-var autoCameraSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  maxZoom: z.number().finite().min(0).max(22).optional(),
-  padding: autoPaddingInputSchema.optional(),
-  type: z.literal("auto")
-});
-var lineOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinates: z.array(overlayCoordinateSchema).min(2).max(staticSceneLimits.maxPathCoordinates),
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(1),
-  type: z.literal("line"),
-  width: z.number().finite().min(0.5).max(32).default(4)
-});
-var circleOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinate: overlayCoordinateSchema,
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(1),
-  radius: z.number().finite().min(1).max(64).default(6),
-  strokeColor: colorSchema.optional(),
-  strokeWidth: z.number().finite().min(0).max(16).default(0),
-  type: z.literal("circle")
-});
-var markerOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinate: overlayCoordinateSchema,
-  id: z.string().trim().min(1).max(64).optional(),
-  radius: z.number().finite().min(2).max(64).default(8),
-  strokeColor: colorSchema.default("#ffffff"),
-  strokeWidth: z.number().finite().min(0).max(16).default(2),
-  type: z.literal("marker")
-});
-var polygonRingSchema = z.array(overlayCoordinateSchema).min(4).max(staticSceneLimits.maxPathCoordinates).refine(
-  (ring) => {
-    const first = ring[0];
-    const last = ring[ring.length - 1];
-    return Boolean(first && last && first[0] === last[0] && first[1] === last[1]);
-  },
-  { message: "Polygon rings must end at their starting coordinate" }
-);
-var polygonOverlaySchema = z.object({
-  coordinates: z.array(polygonRingSchema).min(1).max(16),
-  fill: colorSchema.default("#C6A15B"),
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(0.28),
-  stroke: colorSchema.optional(),
-  strokeWidth: z.number().finite().min(0).max(16).default(0),
-  type: z.literal("polygon")
-});
-var staticOverlaySchema = z.discriminatedUnion("type", [
-  lineOverlaySchema,
-  circleOverlaySchema,
-  markerOverlaySchema,
-  polygonOverlaySchema
-]);
-var staticSceneSchema = z.object({
-  attribution: staticAttributionRequestSchema.optional(),
-  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema, autoCameraSchema]),
-  format: staticMapFormatSchema.optional(),
-  map: portableIdSchema,
-  overlays: z.array(staticOverlaySchema).max(staticSceneLimits.maxOverlays).default([]),
-  size: sizeSchema,
-  theme: concreteThemeSchema
-});
-
-// src/overlay-normalization.ts
-function normalizeStaticOverlay(overlay) {
-  const parsed = staticOverlaySchema.parse(overlay);
-  const normalized = stripUndefined({ ...parsed });
-  if ("coordinate" in normalized) {
-    normalized.coordinate = normalizeStaticCoordinate(normalized.coordinate);
-  }
-  if ("coordinates" in normalized) {
-    normalized.coordinates = normalizeStaticCoordinates(normalized.coordinates);
-  }
-  return normalized;
-}
-function normalizeStaticCoordinate(coordinate) {
-  return [roundNumber(coordinate[0]), roundNumber(coordinate[1])];
-}
-function normalizeStaticCoordinates(value) {
-  if (!Array.isArray(value)) {
-    return value;
-  }
-  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
-    return normalizeStaticCoordinate(value);
-  }
-  return value.map(normalizeStaticCoordinates);
-}
-
-export {
-  stableStringify,
-  roundNumber,
-  stripUndefined,
-  jsonByteLength,
-  hashStableValue,
-  isSafeHttpUrl,
-  staticSceneSchemaVersion,
-  MAX_OVERLAY_LATITUDE,
-  staticSceneLimits,
-  staticAttributionPositionSchema,
-  staticAttributionRequestSchema,
-  staticPaddingSchema,
-  staticOverlaySchema,
-  staticSceneSchema,
-  normalizeStaticOverlay,
-  normalizeStaticCoordinate
-};