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

package/dist/chunk-NHQK5UZ2.js

@@ -0,0 +1,455 @@
+import {
+  MAX_OVERLAY_LATITUDE,
+  jsonByteLength,
+  normalizeStaticCoordinate,
+  normalizeStaticOverlay,
+  roundNumber,
+  staticPaddingSchema,
+  staticSceneLimits,
+  staticSceneSchema,
+  stripUndefined
+} from "./chunk-MGQCHCU3.js";
+
+// src/auto-fit.ts
+import { z } from "zod";
+var autoFitOverlayReferenceSchema = z.object({
+  id: z.string().min(1).max(64),
+  index: z.number().int().min(0).max(23),
+  type: z.enum(["circle", "line", "marker", "polygon"])
+}).strict();
+var autoFitViewportSchema = z.object({
+  height: z.number().int().min(64).max(1280),
+  width: z.number().int().min(64).max(1280)
+}).strict();
+var autoFitDetailsSchema = z.object({
+  overlay: autoFitOverlayReferenceSchema.optional(),
+  padding: staticPaddingSchema.optional(),
+  projection: z.enum(["globe", "mercator"]).optional(),
+  requiredInsets: staticPaddingSchema.optional(),
+  ringIndex: z.number().int().min(0).max(15).optional(),
+  segmentIndex: z.number().int().min(0).max(1999).optional(),
+  viewport: autoFitViewportSchema.optional()
+}).strict();
+var staticOverlayInvalidDetailsSchema = z.object({
+  latitude: z.number().finite(),
+  limit: z.literal(MAX_OVERLAY_LATITUDE),
+  overlay: autoFitOverlayReferenceSchema
+}).strict();
+var autoFitErrorBase = {
+  error: z.string().min(1).max(512),
+  retryable: z.literal(false)
+};
+var staticMapRequestErrorResponseSchema = z.discriminatedUnion("code", [
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("AUTO_FIT_EMPTY"),
+    reason: z.literal("NO_FITTABLE_OVERLAYS")
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("AUTO_FIT_AMBIGUOUS"),
+    details: autoFitDetailsSchema,
+    reason: z.literal("ANTIMERIDIAN_WRAP_REQUIRED")
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("AUTO_FIT_IMPOSSIBLE"),
+    details: autoFitDetailsSchema.optional(),
+    reason: z.enum([
+      "GLOBE_NOT_SIMULTANEOUSLY_VISIBLE",
+      "INSUFFICIENT_VIEWPORT",
+      "CAMERA_UNRESOLVABLE",
+      "PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT"
+    ])
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("STATIC_OVERLAY_INVALID"),
+    details: staticOverlayInvalidDetailsSchema,
+    reason: z.literal("OVERLAY_LATITUDE_OUT_OF_RANGE")
+  }).strict()
+]);
+var StaticMapRequestError = class extends Error {
+  code;
+  details;
+  reason;
+  retryable = false;
+  status;
+  constructor(response, status = 422) {
+    super(response.error);
+    this.name = "StaticMapRequestError";
+    this.code = response.code;
+    this.details = "details" in response ? response.details : void 0;
+    this.reason = response.reason;
+    this.status = status;
+  }
+};
+var staticAutoFitPlanSchema = z.object({
+  bounds: z.tuple([
+    z.number().finite(),
+    z.number().finite().min(-90).max(90),
+    z.number().finite(),
+    z.number().finite().min(-90).max(90)
+  ]),
+  longitudeOffsets: z.array(z.number().int().min(-360).max(360)).max(24),
+  nominalInsets: staticPaddingSchema,
+  requiredInsets: staticPaddingSchema
+}).strict();
+function analyzeStaticAutoFit(scene) {
+  if (scene.camera.type !== "auto") {
+    throw new Error("Static auto-fit analysis requires an auto camera");
+  }
+  if (scene.overlays.length === 0) {
+    return failure({
+      code: "AUTO_FIT_EMPTY",
+      error: "Auto-fit requires at least one overlay",
+      reason: "NO_FITTABLE_OVERLAYS",
+      retryable: false
+    });
+  }
+  const components = [];
+  let south = Number.POSITIVE_INFINITY;
+  let north = Number.NEGATIVE_INFINITY;
+  let nominalExpansion = 0;
+  for (const [overlayIndex, overlay] of scene.overlays.entries()) {
+    const coordinates = overlayCoordinates(overlay);
+    const ambiguity = findAmbiguousSegment(overlay);
+    if (ambiguity) {
+      return failure({
+        code: "AUTO_FIT_AMBIGUOUS",
+        details: {
+          overlay: {
+            id: overlay.id ?? `overlay-${overlayIndex + 1}`,
+            index: overlayIndex,
+            type: overlay.type
+          },
+          ...ambiguity.ringIndex === void 0 ? {} : { ringIndex: ambiguity.ringIndex },
+          segmentIndex: ambiguity.segmentIndex
+        },
+        error: `Overlay overlays.${overlayIndex} requires an explicit antimeridian wrap decision`,
+        reason: "ANTIMERIDIAN_WRAP_REQUIRED",
+        retryable: false
+      });
+    }
+    const longitudes = coordinates.map(([longitude]) => longitude);
+    components.push({
+      east: Math.max(...longitudes),
+      overlayIndex,
+      west: Math.min(...longitudes)
+    });
+    for (const [, latitude] of coordinates) {
+      south = Math.min(south, latitude);
+      north = Math.max(north, latitude);
+    }
+    nominalExpansion = Math.max(nominalExpansion, nominalOverlayExpansion(overlay));
+  }
+  const longitudePlan = fitLongitudeComponents(components);
+  const nominalInset = Math.ceil(nominalExpansion);
+  const nominalInsets = allSides(nominalInset);
+  const padding = normalizedPadding(scene.camera.padding, scene.size);
+  if ([padding.bottom, padding.left, padding.right, padding.top].some(
+    (value) => !Number.isSafeInteger(value + nominalInset)
+  )) {
+    return failure({
+      code: "AUTO_FIT_IMPOSSIBLE",
+      details: {
+        padding,
+        viewport: { height: scene.size.height, width: scene.size.width }
+      },
+      error: "Auto-fit nominal footprint leaves no usable viewport",
+      reason: "INSUFFICIENT_VIEWPORT",
+      retryable: false
+    });
+  }
+  const requiredInsets = {
+    bottom: padding.bottom + nominalInset,
+    left: padding.left + nominalInset,
+    right: padding.right + nominalInset,
+    top: padding.top + nominalInset
+  };
+  if (requiredInsets.left + requiredInsets.right >= scene.size.width || requiredInsets.top + requiredInsets.bottom >= scene.size.height) {
+    return failure({
+      code: "AUTO_FIT_IMPOSSIBLE",
+      details: {
+        padding,
+        requiredInsets,
+        viewport: { height: scene.size.height, width: scene.size.width }
+      },
+      error: "Auto-fit nominal footprint leaves no usable viewport",
+      reason: "INSUFFICIENT_VIEWPORT",
+      retryable: false
+    });
+  }
+  return {
+    ok: true,
+    plan: {
+      bounds: [
+        roundNumber(longitudePlan.west),
+        roundNumber(south),
+        roundNumber(longitudePlan.east),
+        roundNumber(north)
+      ],
+      longitudeOffsets: longitudePlan.offsets,
+      nominalInsets,
+      requiredInsets
+    }
+  };
+}
+function failure(response) {
+  return { ...response, ok: false };
+}
+function overlayCoordinates(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker") {
+    return [overlay.coordinate];
+  }
+  if (overlay.type === "line") {
+    return overlay.coordinates;
+  }
+  return overlay.coordinates.flat();
+}
+function findAmbiguousSegment(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker") return null;
+  const paths = overlay.type === "line" ? [overlay.coordinates] : overlay.coordinates;
+  for (const [ringIndex, path] of paths.entries()) {
+    for (let segmentIndex = 0; segmentIndex < path.length - 1; segmentIndex += 1) {
+      const start = path[segmentIndex];
+      const end = path[segmentIndex + 1];
+      if (start && end && Math.abs(end[0] - start[0]) >= 180) {
+        return {
+          ...overlay.type === "polygon" ? { ringIndex } : {},
+          segmentIndex
+        };
+      }
+    }
+  }
+  return null;
+}
+function nominalOverlayExpansion(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker") {
+    return overlay.radius + overlay.strokeWidth;
+  }
+  if (overlay.type === "line") {
+    return overlay.width / 2 + 0.5;
+  }
+  return overlay.stroke && overlay.strokeWidth > 0 ? overlay.strokeWidth / 2 + 0.5 : 0;
+}
+function fitLongitudeComponents(components) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    candidates.add(toCircle(component.west));
+    candidates.add(toCircle(component.east));
+  }
+  let best;
+  for (const cut of [...candidates].sort((left, right) => left - right)) {
+    const assignedStarts = [];
+    let west = Number.POSITIVE_INFINITY;
+    let east = Number.NEGATIVE_INFINITY;
+    let valid = true;
+    for (const component of components) {
+      const width = component.east - component.west;
+      let start = toCircle(component.west);
+      if (start < cut) start += 360;
+      const end = start + width;
+      if (end > cut + 360 + 1e-9) {
+        valid = false;
+        break;
+      }
+      assignedStarts.push(start);
+      west = Math.min(west, start);
+      east = Math.max(east, end);
+    }
+    if (!valid) continue;
+    const span = east - west;
+    const canonicalWest2 = canonicalLongitude(west - 180);
+    const bestCanonicalWest = best ? canonicalLongitude(best.west - 180) : Number.POSITIVE_INFINITY;
+    if (!best || span < best.span - 1e-9 || Math.abs(span - best.span) <= 1e-9 && canonicalWest2 < bestCanonicalWest) {
+      best = { assignedStarts, east, span, west };
+    }
+  }
+  if (!best) {
+    const west = Math.min(...components.map((component) => component.west));
+    const east = Math.max(...components.map((component) => component.east));
+    return { east, offsets: components.map(() => 0), west };
+  }
+  const unshiftedWest = best.west - 180;
+  const canonicalWest = canonicalLongitude(unshiftedWest);
+  const globalOffset = canonicalWest - unshiftedWest;
+  const offsets = components.map((component, index) => {
+    const assignedLongitude = (best?.assignedStarts[index] ?? 0) - 180 + globalOffset;
+    return Math.round(assignedLongitude - component.west);
+  });
+  return {
+    east: canonicalWest + best.span,
+    offsets,
+    west: canonicalWest
+  };
+}
+function toCircle(longitude) {
+  const value = (longitude + 180) % 360;
+  return value < 0 ? value + 360 : value;
+}
+function canonicalLongitude(longitude) {
+  const value = ((longitude + 180) % 360 + 360) % 360;
+  return value - 180;
+}
+function allSides(value) {
+  return { bottom: value, left: value, right: value, top: value };
+}
+function normalizedPadding(padding, size) {
+  if (padding === void 0) {
+    return allSides(Math.min(32, Math.ceil(Math.min(size.width, size.height) * 0.05)));
+  }
+  if (typeof padding === "number") return allSides(padding);
+  return {
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0,
+    right: padding.right ?? 0,
+    top: padding.top ?? 0
+  };
+}
+function autoFitErrorResponse(failure2) {
+  const { ok: _ok, ...response } = failure2;
+  return response;
+}
+function findStaticOverlayLatitudeFailure(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const overlays = input.overlays;
+  if (!Array.isArray(overlays)) return null;
+  for (const [index, candidate] of overlays.entries()) {
+    if (index >= staticSceneLimits.maxOverlays) break;
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const overlay = candidate;
+    const type = overlay.type;
+    if (!["circle", "line", "marker", "polygon"].includes(String(type))) continue;
+    const coordinates = type === "circle" || type === "marker" ? [overlay.coordinate] : overlayCoordinateCandidates(type, overlay.coordinates);
+    for (const coordinate of coordinates) {
+      if (!Array.isArray(coordinate) || coordinate.length !== 2 || typeof coordinate[1] !== "number" || !Number.isFinite(coordinate[1]) || Math.abs(coordinate[1]) <= MAX_OVERLAY_LATITUDE) {
+        continue;
+      }
+      const id = typeof overlay.id === "string" && overlay.id.trim() ? overlay.id.trim() : `overlay-${index + 1}`;
+      const response = {
+        code: "STATIC_OVERLAY_INVALID",
+        details: {
+          latitude: coordinate[1],
+          limit: MAX_OVERLAY_LATITUDE,
+          overlay: {
+            id: id.slice(0, 64),
+            index,
+            type
+          }
+        },
+        error: `Overlay overlays.${index} latitude ${coordinate[1]} exceeds the supported \xB1${MAX_OVERLAY_LATITUDE}\xB0 range`,
+        reason: "OVERLAY_LATITUDE_OUT_OF_RANGE",
+        retryable: false
+      };
+      return { ...response, ok: false };
+    }
+  }
+  return null;
+}
+function overlayCoordinateCandidates(type, value) {
+  if (!Array.isArray(value)) return [];
+  if (type === "line") {
+    return value.slice(0, staticSceneLimits.maxPathCoordinates);
+  }
+  return value.slice(0, 16).flatMap(
+    (ring) => Array.isArray(ring) ? ring.slice(0, staticSceneLimits.maxPathCoordinates) : []
+  );
+}
+
+// src/scene.ts
+function validateStaticScene(input) {
+  const overlayLatitudeFailure = findStaticOverlayLatitudeFailure(input);
+  if (overlayLatitudeFailure) return overlayLatitudeFailure;
+  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
+    };
+  }
+  const scene = normalizeParsedStaticScene(parsed.data);
+  if (scene.camera.type === "auto") {
+    const analysis = analyzeStaticAutoFit(scene);
+    if (!analysis.ok) return analysis;
+  }
+  return { ok: true, scene };
+}
+function normalizeStaticScene(scene) {
+  const overlayLatitudeFailure = findStaticOverlayLatitudeFailure(scene);
+  if (overlayLatitudeFailure) {
+    const { ok: _ok, ...response } = overlayLatitudeFailure;
+    throw new StaticMapRequestError(response);
+  }
+  const normalized = normalizeParsedStaticScene(staticSceneSchema.parse(scene));
+  if (normalized.camera.type === "auto") {
+    const analysis = analyzeStaticAutoFit(normalized);
+    if (!analysis.ok) {
+      throw new StaticMapRequestError(autoFitErrorResponse(analysis));
+    }
+  }
+  return normalized;
+}
+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)
+    } : parsed.camera.type === "bounds" ? {
+      bearing: roundNumber(parsed.camera.bearing ?? 0),
+      bounds: parsed.camera.bounds.map(roundNumber),
+      padding: parsed.camera.padding ?? 32,
+      type: "bounds"
+    } : {
+      bearing: roundNumber(parsed.camera.bearing ?? 0),
+      maxZoom: roundNumber(parsed.camera.maxZoom ?? 16),
+      padding: normalizeAutoPadding(parsed.camera.padding, parsed.size),
+      type: "auto"
+    },
+    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
+  });
+}
+function normalizeAutoPadding(padding, size) {
+  if (padding === void 0) {
+    const value = Math.min(32, Math.ceil(Math.min(size.width, size.height) * 0.05));
+    return { bottom: value, left: value, right: value, top: value };
+  }
+  if (typeof padding === "number") {
+    return { bottom: padding, left: padding, right: padding, top: padding };
+  }
+  return {
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0,
+    right: padding.right ?? 0,
+    top: padding.top ?? 0
+  };
+}
+
+export {
+  staticMapRequestErrorResponseSchema,
+  StaticMapRequestError,
+  staticAutoFitPlanSchema,
+  analyzeStaticAutoFit,
+  validateStaticScene,
+  normalizeStaticScene
+};

package/dist/{chunk-HKYA7ZIU.js → chunk-S3WXE5P4.js}

@@ -1,18 +1,22 @@
 import {
+  analyzeStaticAutoFit,
   normalizeStaticScene,
+  staticAutoFitPlanSchema,
   validateStaticScene
-} from "./chunk-ROBEGDDY.js";
+} from "./chunk-NHQK5UZ2.js";
 import {
   hashStableValue,
   isSafeHttpUrl,
+  stableStringify,
   staticSceneSchema,
   stripUndefined
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-MGQCHCU3.js";
 
 // src/manifest.ts
 import { z } from "zod";
 var staticRendererSchemaVersion = 1;
 var staticRenderManifestSchema = z.object({
+  autoFit: staticAutoFitPlanSchema.optional(),
   mapId: z.string().trim().min(1).max(128),
   rendererVersion: z.string().trim().min(1).max(64),
   schemaVersion: z.literal(staticRendererSchemaVersion),
@@ -24,32 +28,44 @@ var staticRenderManifestSchema = z.object({
   })
 });
 function validateStaticRenderManifest(input) {
-  const parsed = staticRenderManifestSchema.safeParse(input);
+  const rawScene = input && typeof input === "object" && !Array.isArray(input) && "scene" in input ? input.scene : void 0;
+  const sceneValidation = validateStaticScene(rawScene);
+  if (!sceneValidation.ok) {
+    return sceneValidation;
+  }
+  const parsed = staticRenderManifestSchema.safeParse({
+    ...input,
+    scene: sceneValidation.scene
+  });
   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;
+  const autoFit = expectedAutoFit(sceneValidation.scene);
+  if (autoFit === void 0 !== (parsed.data.autoFit === void 0) || autoFit !== void 0 && stableStringify(autoFit) !== stableStringify(parsed.data.autoFit)) {
+    return { error: "manifest.autoFit: Expected the exact plan derived from scene", ok: false };
   }
   return {
     manifest: {
       ...parsed.data,
+      ...autoFit === void 0 ? {} : { autoFit },
       scene: sceneValidation.scene
     },
     ok: true
   };
 }
 function createRenderManifest(input) {
+  const scene = normalizeStaticScene(input.scene);
+  const autoFit = expectedAutoFit(scene);
   return staticRenderManifestSchema.parse(
     stripUndefined({
+      autoFit,
       mapId: input.mapId,
       rendererVersion: input.rendererVersion,
       schemaVersion: staticRendererSchemaVersion,
-      scene: normalizeStaticScene(input.scene),
+      scene,
       styleId: input.styleId,
       styleRevision: input.styleRevision,
       styleUrl: input.styleUrl
@@ -57,17 +73,21 @@ function createRenderManifest(input) {
   );
 }
 async function hashRenderManifest(manifest) {
-  const normalized = staticRenderManifestSchema.parse({
-    ...manifest,
-    scene: normalizeStaticScene(manifest.scene)
-  });
-  return hashStableValue(normalized);
+  const validation = validateStaticRenderManifest(manifest);
+  if (!validation.ok) throw new Error(`Invalid Tileflow render manifest: ${validation.error}`);
+  return hashStableValue(validation.manifest);
 }
 async function hashStaticSceneRequest(scene) {
   const validation = validateStaticScene(scene);
   if (!validation.ok) throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
   return hashStableValue(validation.scene);
 }
+function expectedAutoFit(scene) {
+  if (scene.camera.type !== "auto") return void 0;
+  const analysis = analyzeStaticAutoFit(scene);
+  if (!analysis.ok) throw new Error(`Invalid Tileflow auto-fit scene: ${analysis.error}`);
+  return analysis.plan;
+}
 
 export {
   staticRendererSchemaVersion,

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { d as StaticSceneInput } from './scene-contract-DzsUeJ_V.js';
+import { e as StaticSceneInput } from './scene-contract-DZMhLDnf.js';
 
 declare function stableStringify(value: unknown): string;
 

package/dist/client.js

@@ -7,11 +7,11 @@ import {
   staticMapProcessingResultSchema,
   staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-QCR76BUO.js";
-import "./chunk-ROBEGDDY.js";
+} from "./chunk-A23RC4BE.js";
+import "./chunk-NHQK5UZ2.js";
 import {
   stableStringify
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-MGQCHCU3.js";
 export {
   createStaticMap,
   createStaticMapIdempotencyKey,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { normalizeStaticScene, validateStaticScene } from './scene.js';
+export { StaticAutoFitErrorResponse, StaticAutoFitFailure, StaticMapRequestError, StaticMapRequestErrorResponse, StaticMapRequestFailure, normalizeStaticScene, staticMapRequestErrorResponseSchema, validateStaticScene } from './scene.js';
 export { circle, compileStaticOverlays, line, marker, polygon } from './overlays.js';
 export { StaticRenderManifest, createRenderManifest, hashRenderManifest, hashStaticSceneRequest, staticRenderManifestSchema, staticRendererSchemaVersion, validateStaticRenderManifest } from './manifest.js';
 export { PreparedStaticMapRequest, StaticMapCreateOptions, StaticMapEndpointRequestOptions, StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapProcessingResultSchema, staticMapReadyResultSchema, validateStaticMapIdempotencyKey } from './client.js';
-export { S as StaticCoordinate, a as StaticOverlay, b as StaticOverlayInput, c as StaticScene, d as StaticSceneInput, s as staticOverlaySchema, e as staticSceneLimits, f as staticSceneSchema, g as staticSceneSchemaVersion } from './scene-contract-DzsUeJ_V.js';
+export { M as MAX_OVERLAY_LATITUDE, S as StaticCoordinate, a as StaticOverlay, b as StaticOverlayInput, c as StaticPadding, d as StaticScene, e as StaticSceneInput, s as staticOverlaySchema, f as staticSceneLimits, g as staticSceneSchema, h as staticSceneSchemaVersion } from './scene-contract-DZMhLDnf.js';
 import 'zod';

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   staticMapProcessingResultSchema,
   staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-QCR76BUO.js";
+} from "./chunk-A23RC4BE.js";
 import {
   createRenderManifest,
   hashRenderManifest,
@@ -15,26 +15,31 @@ import {
   staticRenderManifestSchema,
   staticRendererSchemaVersion,
   validateStaticRenderManifest
-} from "./chunk-HKYA7ZIU.js";
+} from "./chunk-S3WXE5P4.js";
 import {
   circle,
   compileStaticOverlays,
   line,
   marker,
   polygon
-} from "./chunk-LGEYA6FQ.js";
+} from "./chunk-KPT7PASB.js";
 import {
+  StaticMapRequestError,
   normalizeStaticScene,
+  staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-ROBEGDDY.js";
+} from "./chunk-NHQK5UZ2.js";
 import {
+  MAX_OVERLAY_LATITUDE,
   stableStringify,
   staticOverlaySchema,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-MGQCHCU3.js";
 export {
+  MAX_OVERLAY_LATITUDE,
+  StaticMapRequestError,
   circle,
   compileStaticOverlays,
   createRenderManifest,
@@ -52,6 +57,7 @@ export {
   stableStringify,
   staticMapProcessingResultSchema,
   staticMapReadyResultSchema,
+  staticMapRequestErrorResponseSchema,
   staticOverlaySchema,
   staticRenderManifestSchema,
   staticRendererSchemaVersion,

package/dist/manifest.d.ts

@@ -1,8 +1,24 @@
 import { z } from 'zod';
-import { d as StaticSceneInput } from './scene-contract-DzsUeJ_V.js';
+import { e as StaticSceneInput } from './scene-contract-DZMhLDnf.js';
 
 declare const staticRendererSchemaVersion = 1;
 declare const staticRenderManifestSchema: z.ZodObject<{
+    autoFit: z.ZodOptional<z.ZodObject<{
+        bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        longitudeOffsets: z.ZodArray<z.ZodNumber>;
+        nominalInsets: z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>;
+        requiredInsets: z.ZodObject<{
+            bottom: z.ZodNumber;
+            left: z.ZodNumber;
+            right: z.ZodNumber;
+            top: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
     mapId: z.ZodString;
     rendererVersion: z.ZodString;
     schemaVersion: z.ZodLiteral<1>;
@@ -17,6 +33,16 @@ declare const staticRenderManifestSchema: 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">;
         map: z.ZodString;
         overlays: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{