@tileflow/static 0.1.0-alpha.2 → 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-S3WXE5P4.js

@@ -0,0 +1,99 @@
+import {
+  analyzeStaticAutoFit,
+  normalizeStaticScene,
+  staticAutoFitPlanSchema,
+  validateStaticScene
+} from "./chunk-NHQK5UZ2.js";
+import {
+  hashStableValue,
+  isSafeHttpUrl,
+  stableStringify,
+  staticSceneSchema,
+  stripUndefined
+} 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),
+  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 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 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,
+      styleId: input.styleId,
+      styleRevision: input.styleRevision,
+      styleUrl: input.styleUrl
+    })
+  );
+}
+async function hashRenderManifest(manifest) {
+  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,
+  staticRenderManifestSchema,
+  validateStaticRenderManifest,
+  createRenderManifest,
+  hashRenderManifest,
+  hashStaticSceneRequest
+};

package/dist/client.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { e as StaticSceneInput } from './scene-contract-DZMhLDnf.js';
+
+declare function stableStringify(value: unknown): string;
+
+type StaticMapResult = {
+    cached: boolean;
+    hash: string;
+    imageUrl: string;
+    operationId: string | null;
+    remainingUnits: number | null;
+    status: 'ready';
+    unitCost: 0 | 15;
+};
+type StaticMapCreateOptions = {
+    apiKey?: string;
+    apiUrl?: string;
+    fetch?: typeof fetch;
+    idempotencyKey: string;
+    maxWaitMs?: number;
+    pollIntervalMs?: number;
+    signal?: AbortSignal;
+};
+type StaticMapEndpointRequestOptions = Omit<StaticMapCreateOptions, 'apiUrl'> & {
+    createUrl: string;
+};
+type PreparedStaticMapRequest = Readonly<{
+    sceneKey: string;
+}>;
+declare const staticMapReadyResultSchema: z.ZodObject<{
+    cached: z.ZodBoolean;
+    hash: z.ZodString;
+    imageUrl: z.ZodString;
+    operationId: z.ZodString;
+    remainingUnits: z.ZodNullable<z.ZodNumber>;
+    status: z.ZodLiteral<"ready">;
+    unitCost: z.ZodLiteral<15>;
+}, z.core.$strict>;
+declare const staticMapProcessingResultSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    retryAfterMs: z.ZodNumber;
+    status: z.ZodLiteral<"processing">;
+}, z.core.$strict>;
+
+declare function validateStaticMapIdempotencyKey(value: unknown): {
+    key: string;
+    ok: true;
+} | {
+    error: string;
+    ok: false;
+};
+declare function createStaticMapIdempotencyKey(): string;
+declare function prepareStaticMapRequest(scene: StaticSceneInput): PreparedStaticMapRequest;
+declare function createStaticMap(scene: StaticSceneInput, options: StaticMapCreateOptions): Promise<StaticMapResult>;
+declare function precacheStaticMap(scene: StaticSceneInput, options: StaticMapCreateOptions): Promise<StaticMapResult>;
+declare function requestStaticMapUntilReady(request: PreparedStaticMapRequest, options: StaticMapEndpointRequestOptions): Promise<StaticMapResult>;
+
+export { type PreparedStaticMapRequest, type StaticMapCreateOptions, type StaticMapEndpointRequestOptions, type StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapProcessingResultSchema, staticMapReadyResultSchema, validateStaticMapIdempotencyKey };

package/dist/client.js

@@ -0,0 +1,25 @@
+import {
+  createStaticMap,
+  createStaticMapIdempotencyKey,
+  precacheStaticMap,
+  prepareStaticMapRequest,
+  requestStaticMapUntilReady,
+  staticMapProcessingResultSchema,
+  staticMapReadyResultSchema,
+  validateStaticMapIdempotencyKey
+} from "./chunk-A23RC4BE.js";
+import "./chunk-NHQK5UZ2.js";
+import {
+  stableStringify
+} from "./chunk-MGQCHCU3.js";
+export {
+  createStaticMap,
+  createStaticMapIdempotencyKey,
+  precacheStaticMap,
+  prepareStaticMapRequest,
+  requestStaticMapUntilReady,
+  stableStringify,
+  staticMapProcessingResultSchema,
+  staticMapReadyResultSchema,
+  validateStaticMapIdempotencyKey
+};