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

package/dist/overlays.d.ts

@@ -1,12 +1,14 @@
 import { z } from 'zod';
-import { h as circleOverlaySchema, a as StaticOverlay, l as lineOverlaySchema, m as markerOverlaySchema, p as polygonOverlaySchema } from './scene-contract-DzsUeJ_V.js';
-export { b as StaticOverlayInput, s as staticOverlaySchema } from './scene-contract-DzsUeJ_V.js';
+import { o as circleOverlaySchema, e as StaticOverlay, p as lineOverlaySchema, q as markerOverlaySchema, r as polygonOverlaySchema } from './scene-contract-OMIOisSB.js';
+export { f as StaticOverlayInput, k as staticOverlaySchema } from './scene-contract-OMIOisSB.js';
 
 declare function line(input: Omit<z.input<typeof lineOverlaySchema>, 'type'>): StaticOverlay;
 declare function circle(input: Omit<z.input<typeof circleOverlaySchema>, 'type'>): StaticOverlay;
 declare function marker(input: Omit<z.input<typeof markerOverlaySchema>, 'type'>): StaticOverlay;
 declare function polygon(input: Omit<z.input<typeof polygonOverlaySchema>, 'type'>): StaticOverlay;
-declare function compileStaticOverlays(overlays: StaticOverlay[]): {
+declare function compileStaticOverlays(overlays: StaticOverlay[], options?: {
+    longitudeOffsets?: readonly number[];
+}): {
     layers: Record<string, unknown>[];
     sources: Record<string, Record<string, unknown>>;
 };

package/dist/overlays.js

@@ -4,10 +4,10 @@ import {
   line,
   marker,
   polygon
-} from "./chunk-LGEYA6FQ.js";
+} from "./chunk-EPOYQNNT.js";
 import {
   staticOverlaySchema
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-NM2JSFUF.js";
 export {
   circle,
   compileStaticOverlays,

package/dist/{scene-contract-DzsUeJ_V.d.ts → scene-contract-OMIOisSB.d.ts}

@@ -1,8 +1,9 @@
 import { z } from 'zod';
 
 declare const staticSceneSchemaVersion = 1;
+declare const MAX_OVERLAY_LATITUDE = 85.051129;
 declare const staticSceneLimits: {
-    readonly maxDimension: 1280;
+    readonly maxDimension: 2048;
     readonly maxGeoJsonBytes: 96000;
     readonly maxOverlays: 24;
     readonly maxPathCoordinates: 2000;
@@ -10,6 +11,36 @@ declare const staticSceneLimits: {
     readonly minDimension: 64;
 };
 declare const coordinateSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+declare const staticMapFormatSchema: z.ZodEnum<{
+    png: "png";
+    jpeg: "jpeg";
+    webp: "webp";
+}>;
+declare const staticAttributionPositionSchema: z.ZodEnum<{
+    auto: "auto";
+    "top-left": "top-left";
+    "top-right": "top-right";
+    "bottom-left": "bottom-left";
+    "bottom-right": "bottom-right";
+}>;
+declare const staticAttributionRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    mode: z.ZodOptional<z.ZodLiteral<"embedded">>;
+    position: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        "top-left": "top-left";
+        "top-right": "top-right";
+        "bottom-left": "bottom-left";
+        "bottom-right": "bottom-right";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"external">;
+}, z.core.$strict>]>;
+declare const staticPaddingSchema: z.ZodObject<{
+    bottom: z.ZodNumber;
+    left: z.ZodNumber;
+    right: z.ZodNumber;
+    top: z.ZodNumber;
+}, z.core.$strict>;
 declare const lineOverlaySchema: z.ZodObject<{
     color: z.ZodDefault<z.ZodString>;
     coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
@@ -80,6 +111,18 @@ declare const staticOverlaySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"polygon">;
 }, z.core.$strip>], "type">;
 declare const staticSceneSchema: z.ZodObject<{
+    attribution: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        mode: z.ZodOptional<z.ZodLiteral<"embedded">>;
+        position: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            "top-left": "top-left";
+            "top-right": "top-right";
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"external">;
+    }, z.core.$strict>]>>;
     camera: z.ZodDiscriminatedUnion<[z.ZodObject<{
         bearing: z.ZodOptional<z.ZodNumber>;
         center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
@@ -90,7 +133,22 @@ declare const staticSceneSchema: z.ZodObject<{
         bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
         padding: z.ZodOptional<z.ZodNumber>;
         type: z.ZodLiteral<"bounds">;
+    }, z.core.$strip>, z.ZodObject<{
+        bearing: z.ZodOptional<z.ZodNumber>;
+        maxZoom: z.ZodOptional<z.ZodNumber>;
+        padding: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+            bottom: z.ZodOptional<z.ZodNumber>;
+            left: z.ZodOptional<z.ZodNumber>;
+            right: z.ZodOptional<z.ZodNumber>;
+            top: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        type: z.ZodLiteral<"auto">;
     }, z.core.$strip>], "type">;
+    format: z.ZodOptional<z.ZodEnum<{
+        png: "png";
+        jpeg: "jpeg";
+        webp: "webp";
+    }>>;
     map: z.ZodString;
     overlays: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         color: z.ZodDefault<z.ZodString>;
@@ -126,16 +184,21 @@ declare const staticSceneSchema: z.ZodObject<{
         type: z.ZodLiteral<"polygon">;
     }, z.core.$strip>], "type">>>;
     size: z.ZodObject<{
-        dpr: z.ZodOptional<z.ZodLiteral<1>>;
+        dpr: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
         height: z.ZodNumber;
         width: z.ZodNumber;
     }, z.core.$strip>;
     theme: z.ZodString;
 }, z.core.$strip>;
 type StaticCoordinate = z.infer<typeof coordinateSchema>;
+type StaticAttributionMode = 'embedded' | 'external';
+type StaticAttributionPosition = z.infer<typeof staticAttributionPositionSchema>;
+type StaticAttributionRequest = z.infer<typeof staticAttributionRequestSchema>;
+type StaticMapFormat = z.infer<typeof staticMapFormatSchema>;
+type StaticPadding = z.infer<typeof staticPaddingSchema>;
 type StaticSceneInput = z.input<typeof staticSceneSchema>;
 type StaticScene = z.infer<typeof staticSceneSchema>;
 type StaticOverlayInput = z.input<typeof staticOverlaySchema>;
 type StaticOverlay = z.infer<typeof staticOverlaySchema>;
 
-export { type StaticCoordinate as S, type StaticOverlay as a, type StaticOverlayInput as b, type StaticScene as c, type StaticSceneInput as d, staticSceneLimits as e, staticSceneSchema as f, staticSceneSchemaVersion as g, circleOverlaySchema as h, lineOverlaySchema as l, markerOverlaySchema as m, polygonOverlaySchema as p, staticOverlaySchema as s };
+export { MAX_OVERLAY_LATITUDE as M, type StaticAttributionMode as S, type StaticAttributionPosition as a, type StaticAttributionRequest as b, type StaticCoordinate as c, type StaticMapFormat as d, type StaticOverlay as e, type StaticOverlayInput as f, type StaticPadding as g, type StaticScene as h, type StaticSceneInput as i, staticAttributionRequestSchema as j, staticOverlaySchema as k, staticSceneLimits as l, staticSceneSchema as m, staticSceneSchemaVersion as n, circleOverlaySchema as o, lineOverlaySchema as p, markerOverlaySchema as q, polygonOverlaySchema as r, staticAttributionPositionSchema as s };

package/dist/scene.d.ts

@@ -1,6 +1,201 @@
-import { d as StaticSceneInput, c as StaticScene } from './scene-contract-DzsUeJ_V.js';
-export { S as StaticCoordinate, e as staticSceneLimits, f as staticSceneSchema, g as staticSceneSchemaVersion } from './scene-contract-DzsUeJ_V.js';
-import 'zod';
+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';
+
+declare const autoFitDetailsSchema: z.ZodObject<{
+    overlay: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodNumber;
+        type: z.ZodEnum<{
+            line: "line";
+            circle: "circle";
+            marker: "marker";
+            polygon: "polygon";
+        }>;
+    }, z.core.$strict>>;
+    padding: z.ZodOptional<z.ZodObject<{
+        bottom: z.ZodNumber;
+        left: z.ZodNumber;
+        right: z.ZodNumber;
+        top: z.ZodNumber;
+    }, z.core.$strict>>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        globe: "globe";
+        mercator: "mercator";
+    }>>;
+    requiredInsets: z.ZodOptional<z.ZodObject<{
+        bottom: z.ZodNumber;
+        left: z.ZodNumber;
+        right: z.ZodNumber;
+        top: z.ZodNumber;
+    }, z.core.$strict>>;
+    ringIndex: z.ZodOptional<z.ZodNumber>;
+    segmentIndex: z.ZodOptional<z.ZodNumber>;
+    viewport: z.ZodOptional<z.ZodObject<{
+        height: z.ZodNumber;
+        width: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type StaticAutoFitDetails = z.infer<typeof autoFitDetailsSchema>;
+declare const staticOverlayInvalidDetailsSchema: z.ZodObject<{
+    latitude: z.ZodNumber;
+    limit: z.ZodLiteral<85.051129>;
+    overlay: z.ZodObject<{
+        id: z.ZodString;
+        index: z.ZodNumber;
+        type: z.ZodEnum<{
+            line: "line";
+            circle: "circle";
+            marker: "marker";
+            polygon: "polygon";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type StaticMapRequestErrorDetails = StaticAutoFitDetails | z.infer<typeof staticOverlayInvalidDetailsSchema>;
+declare const staticMapRequestErrorResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    code: z.ZodLiteral<"AUTO_FIT_EMPTY">;
+    reason: z.ZodLiteral<"NO_FITTABLE_OVERLAYS">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"AUTO_FIT_AMBIGUOUS">;
+    details: z.ZodObject<{
+        overlay: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodEnum<{
+                line: "line";
+                circle: "circle";
+                marker: "marker";
+                polygon: "polygon";
+            }>;
+        }, z.core.$strict>>;
+        padding: z.ZodOptional<z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>>;
+        projection: z.ZodOptional<z.ZodEnum<{
+            globe: "globe";
+            mercator: "mercator";
+        }>>;
+        requiredInsets: z.ZodOptional<z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>>;
+        ringIndex: z.ZodOptional<z.ZodNumber>;
+        segmentIndex: z.ZodOptional<z.ZodNumber>;
+        viewport: z.ZodOptional<z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    reason: z.ZodLiteral<"ANTIMERIDIAN_WRAP_REQUIRED">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"AUTO_FIT_IMPOSSIBLE">;
+    details: z.ZodOptional<z.ZodObject<{
+        overlay: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodEnum<{
+                line: "line";
+                circle: "circle";
+                marker: "marker";
+                polygon: "polygon";
+            }>;
+        }, z.core.$strict>>;
+        padding: z.ZodOptional<z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>>;
+        projection: z.ZodOptional<z.ZodEnum<{
+            globe: "globe";
+            mercator: "mercator";
+        }>>;
+        requiredInsets: z.ZodOptional<z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>>;
+        ringIndex: z.ZodOptional<z.ZodNumber>;
+        segmentIndex: z.ZodOptional<z.ZodNumber>;
+        viewport: z.ZodOptional<z.ZodObject<{
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    reason: z.ZodEnum<{
+        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;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_OVERLAY_INVALID">;
+    details: z.ZodObject<{
+        latitude: z.ZodNumber;
+        limit: z.ZodLiteral<85.051129>;
+        overlay: z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            type: z.ZodEnum<{
+                line: "line";
+                circle: "circle";
+                marker: "marker";
+                polygon: "polygon";
+            }>;
+        }, 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_ATTRIBUTION_UNSUPPORTED">;
+    reason: z.ZodEnum<{
+        UNSUPPORTED_DECLARATION: "UNSUPPORTED_DECLARATION";
+        UNSUPPORTED_GLYPH: "UNSUPPORTED_GLYPH";
+    }>;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_TOO_LARGE">;
+    reason: z.ZodLiteral<"CONTENT_LIMIT_EXCEEDED">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    code: z.ZodLiteral<"STATIC_MAP_ATTRIBUTION_DOES_NOT_FIT">;
+    reason: z.ZodLiteral<"BLOCK_DOES_NOT_FIT">;
+    error: z.ZodString;
+    retryable: z.ZodLiteral<false>;
+}, z.core.$strict>], "code">;
+type StaticMapRequestErrorResponse = z.infer<typeof staticMapRequestErrorResponseSchema>;
+type StaticAutoFitErrorResponse = Extract<StaticMapRequestErrorResponse, {
+    code: `AUTO_FIT_${string}`;
+}>;
+declare class StaticMapRequestError extends Error {
+    readonly code: StaticMapRequestErrorResponse['code'];
+    readonly details?: StaticMapRequestErrorDetails;
+    readonly reason: StaticMapRequestErrorResponse['reason'];
+    readonly retryable = false;
+    readonly status: number;
+    constructor(response: StaticMapRequestErrorResponse, status?: number);
+}
+type StaticAutoFitFailure = StaticAutoFitErrorResponse & {
+    ok: false;
+};
+type StaticMapRequestFailure = StaticMapRequestErrorResponse & {
+    ok: false;
+};
 
 declare function validateStaticScene(input: unknown): {
     ok: true;
@@ -8,7 +203,7 @@ declare function validateStaticScene(input: unknown): {
 } | {
     error: string;
     ok: false;
-};
+} | StaticMapRequestFailure;
 declare function normalizeStaticScene(scene: StaticSceneInput): StaticScene;
 
-export { StaticScene, StaticSceneInput, normalizeStaticScene, validateStaticScene };
+export { type StaticAutoFitErrorResponse, type StaticAutoFitFailure, StaticMapRequestError, type StaticMapRequestErrorResponse, type StaticMapRequestFailure, StaticScene, StaticSceneInput, normalizeStaticScene, staticMapRequestErrorResponseSchema, validateStaticScene };

package/dist/scene.js

@@ -1,14 +1,24 @@
 import {
+  StaticMapRequestError,
   normalizeStaticScene,
+  staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-ROBEGDDY.js";
+} from "./chunk-EMCKSFZV.js";
 import {
+  MAX_OVERLAY_LATITUDE,
+  staticAttributionPositionSchema,
+  staticAttributionRequestSchema,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-NM2JSFUF.js";
 export {
+  MAX_OVERLAY_LATITUDE,
+  StaticMapRequestError,
   normalizeStaticScene,
+  staticAttributionPositionSchema,
+  staticAttributionRequestSchema,
+  staticMapRequestErrorResponseSchema,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tileflow/static",
-  "version": "0.1.0-alpha.20",
+  "version": "0.1.0-alpha.22",
   "license": "Apache-2.0",
   "description": "Static map request schemas and helpers for Tileflow.",
   "type": "module",

package/dist/chunk-HKYA7ZIU.js

@@ -1,79 +0,0 @@
-import {
-  normalizeStaticScene,
-  validateStaticScene
-} from "./chunk-ROBEGDDY.js";
-import {
-  hashStableValue,
-  isSafeHttpUrl,
-  staticSceneSchema,
-  stripUndefined
-} from "./chunk-YUG3PBK2.js";
-
-// src/manifest.ts
-import { z } from "zod";
-var staticRendererSchemaVersion = 1;
-var staticRenderManifestSchema = z.object({
-  mapId: z.string().trim().min(1).max(128),
-  rendererVersion: z.string().trim().min(1).max(64),
-  schemaVersion: z.literal(staticRendererSchemaVersion),
-  scene: staticSceneSchema,
-  styleId: z.string().trim().min(1).max(128).optional(),
-  styleRevision: z.string().trim().min(1).max(128),
-  styleUrl: z.string().trim().url().max(512).refine(isSafeHttpUrl, {
-    message: "Expected an http(s) style URL without credentials or a fragment"
-  })
-});
-function validateStaticRenderManifest(input) {
-  const parsed = staticRenderManifestSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      error: parsed.error.issues.map((issue) => `${issue.path.join(".") || "manifest"}: ${issue.message}`).join("; "),
-      ok: false
-    };
-  }
-  const sceneValidation = validateStaticScene(parsed.data.scene);
-  if (!sceneValidation.ok) {
-    return sceneValidation;
-  }
-  return {
-    manifest: {
-      ...parsed.data,
-      scene: sceneValidation.scene
-    },
-    ok: true
-  };
-}
-function createRenderManifest(input) {
-  return staticRenderManifestSchema.parse(
-    stripUndefined({
-      mapId: input.mapId,
-      rendererVersion: input.rendererVersion,
-      schemaVersion: staticRendererSchemaVersion,
-      scene: normalizeStaticScene(input.scene),
-      styleId: input.styleId,
-      styleRevision: input.styleRevision,
-      styleUrl: input.styleUrl
-    })
-  );
-}
-async function hashRenderManifest(manifest) {
-  const normalized = staticRenderManifestSchema.parse({
-    ...manifest,
-    scene: normalizeStaticScene(manifest.scene)
-  });
-  return hashStableValue(normalized);
-}
-async function hashStaticSceneRequest(scene) {
-  const validation = validateStaticScene(scene);
-  if (!validation.ok) throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
-  return hashStableValue(validation.scene);
-}
-
-export {
-  staticRendererSchemaVersion,
-  staticRenderManifestSchema,
-  validateStaticRenderManifest,
-  createRenderManifest,
-  hashRenderManifest,
-  hashStaticSceneRequest
-};

package/dist/chunk-ROBEGDDY.js

@@ -1,63 +0,0 @@
-import {
-  jsonByteLength,
-  normalizeStaticCoordinate,
-  normalizeStaticOverlay,
-  roundNumber,
-  staticSceneLimits,
-  staticSceneSchema,
-  stripUndefined
-} from "./chunk-YUG3PBK2.js";
-
-// src/scene.ts
-function validateStaticScene(input) {
-  const parsed = staticSceneSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      error: parsed.error.issues.map((issue) => `${issue.path.join(".") || "scene"}: ${issue.message}`).join("; "),
-      ok: false
-    };
-  }
-  if (jsonByteLength(parsed.data.overlays) > staticSceneLimits.maxGeoJsonBytes) {
-    return {
-      error: `overlays exceed ${staticSceneLimits.maxGeoJsonBytes} bytes`,
-      ok: false
-    };
-  }
-  return { ok: true, scene: normalizeParsedStaticScene(parsed.data) };
-}
-function normalizeStaticScene(scene) {
-  return normalizeParsedStaticScene(staticSceneSchema.parse(scene));
-}
-function normalizeParsedStaticScene(parsed) {
-  return stripUndefined({
-    camera: parsed.camera.type === "center" ? {
-      bearing: roundNumber(parsed.camera.bearing ?? 0),
-      center: normalizeStaticCoordinate(parsed.camera.center),
-      type: "center",
-      zoom: roundNumber(parsed.camera.zoom)
-    } : {
-      bearing: roundNumber(parsed.camera.bearing ?? 0),
-      bounds: parsed.camera.bounds.map(roundNumber),
-      padding: parsed.camera.padding ?? 32,
-      type: "bounds"
-    },
-    map: parsed.map,
-    overlays: parsed.overlays.map(
-      (overlay, index) => normalizeStaticOverlay({
-        ...overlay,
-        id: overlay.id ?? `overlay-${index + 1}`
-      })
-    ),
-    size: {
-      dpr: parsed.size.dpr ?? 1,
-      height: parsed.size.height,
-      width: parsed.size.width
-    },
-    theme: parsed.theme
-  });
-}
-
-export {
-  validateStaticScene,
-  normalizeStaticScene
-};