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

package/dist/{chunk-TQMKOTBE.js → chunk-XMT7VJL5.js}

@@ -3,21 +3,22 @@ import {
   normalizeStaticScene,
   staticAutoFitPlanSchema,
   validateStaticScene
-} from "./chunk-EMCKSFZV.js";
+} from "./chunk-TBI5AED6.js";
 import {
   hashStableValue,
   isSafeHttpUrl,
   jsonByteLength,
   stableStringify,
+  staticOverlayPlacements,
   staticSceneSchema,
   stripUndefined
-} from "./chunk-NM2JSFUF.js";
+} from "./chunk-6DWVCK64.js";
 
 // src/manifest.ts
 import { z } from "zod";
-var staticRendererSchemaVersionV1 = 1;
-var staticRendererSchemaVersion = 2;
+var staticRendererSchemaVersion = 1;
 var staticAttributionPlanSchemaVersion = 1;
+var staticRenderCompositionSchemaVersion = 1;
 var staticAttributionLimits = {
   maxBytes: 32 * 1024,
   maxEntries: 18,
@@ -99,7 +100,7 @@ var staticAttributionEntrySchema = z.object({
     });
   }
 });
-var staticAttributionPlanSchemaV1 = z.object({
+var staticAttributionPlanSchema = z.object({
   entries: z.array(staticAttributionEntrySchema).max(staticAttributionLimits.maxEntries),
   mode: z.enum(["embedded", "external"]),
   position: z.union([z.literal("auto"), staticResolvedAttributionPositionSchema, z.null()]),
@@ -119,45 +120,58 @@ var staticAttributionPlanSchemaV1 = z.object({
     });
   }
 });
+var placementAnchorsSchema = z.object({
+  "above-water": z.string().min(1).max(256).nullable(),
+  "below-roads": z.string().min(1).max(256).nullable(),
+  "above-roads": z.string().min(1).max(256).nullable(),
+  "above-buildings": z.string().min(1).max(256).nullable(),
+  "below-labels": z.string().min(1).max(256).nullable(),
+  "above-labels": z.null()
+}).strict().refine(anchorsHaveTerminalNulls, {
+  message: "Placement anchors may become null only at the end of semantic order"
+});
+var resolvedIconSchema = z.object({
+  height: z.number().int().positive().max(2048),
+  icon: z.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+  overlayIndex: z.number().int().min(0).max(23),
+  width: z.number().int().positive().max(2048)
+}).strict();
+var staticRenderCompositionSchema = z.object({
+  anchors: placementAnchorsSchema,
+  icons: z.array(resolvedIconSchema).max(24),
+  schemaVersion: z.literal(staticRenderCompositionSchemaVersion)
+}).strict().refine(
+  (composition) => composition.icons.every(
+    (icon, index) => index === 0 || composition.icons[index - 1].overlayIndex < icon.overlayIndex
+  ),
+  { message: "Resolved symbol icons must be unique and sorted by overlay index" }
+);
 var staticRenderManifestBaseShape = {
+  attribution: staticAttributionPlanSchema,
   autoFit: staticAutoFitPlanSchema.optional(),
+  composition: staticRenderCompositionSchema,
   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"
   })
 };
-var staticSceneSchemaV1 = staticSceneSchema.omit({ attribution: true });
-var staticRenderManifestV1Schema = z.object({
-  ...staticRenderManifestBaseShape,
-  schemaVersion: z.literal(staticRendererSchemaVersionV1),
-  scene: staticSceneSchemaV1
-});
-var staticRenderManifestV2Schema = z.object({
-  ...staticRenderManifestBaseShape,
-  attribution: staticAttributionPlanSchemaV1,
-  schemaVersion: z.literal(staticRendererSchemaVersion),
-  scene: staticSceneSchema
-}).strict();
-var staticRenderManifestSchema = z.discriminatedUnion("schemaVersion", [
-  staticRenderManifestV1Schema,
-  staticRenderManifestV2Schema
-]);
+var staticRenderManifestSchema = z.object(staticRenderManifestBaseShape).strict();
 function validateStaticRenderManifest(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     return { error: "manifest: Expected an object", ok: false };
   }
-  const schemaVersion = input.schemaVersion;
-  if (schemaVersion !== staticRendererSchemaVersionV1 && schemaVersion !== staticRendererSchemaVersion) {
+  if (input.schemaVersion !== staticRendererSchemaVersion) {
     return { error: "manifest.schemaVersion: Unsupported renderer schema version", ok: false };
   }
   const rawScene = input.scene;
-  const sceneValidation = validateVersionedScene(rawScene, schemaVersion);
+  const sceneValidation = validateStaticScene(rawScene);
   if (!sceneValidation.ok) return sceneValidation;
-  const schema = schemaVersion === staticRendererSchemaVersionV1 ? staticRenderManifestV1Schema : staticRenderManifestV2Schema;
-  const parsed = schema.safeParse({
+  const parsed = staticRenderManifestSchema.safeParse({
     ...input,
     scene: sceneValidation.scene
   });
@@ -166,12 +180,18 @@ function validateStaticRenderManifest(input) {
   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 };
   }
-  if (schemaVersion === staticRendererSchemaVersion && (!("attribution" in parsed.data) || !attributionMatchesScene(parsed.data.attribution, sceneValidation.scene))) {
+  if (!attributionMatchesScene(parsed.data.attribution, sceneValidation.scene)) {
     return {
       error: "manifest.attribution: Expected the exact request resolved from scene",
       ok: false
     };
   }
+  if (!compositionMatchesScene(parsed.data.composition, sceneValidation.scene)) {
+    return {
+      error: "manifest.composition: Expected exact resolved symbol icon references",
+      ok: false
+    };
+  }
   return {
     manifest: {
       ...parsed.data,
@@ -181,31 +201,14 @@ function validateStaticRenderManifest(input) {
     ok: true
   };
 }
-function createRenderManifestV1(input) {
-  const rawScene = staticSceneSchemaV1.parse(input.scene);
-  const scene = normalizeStaticScene(rawScene);
-  const autoFit = expectedAutoFit(scene);
-  return staticRenderManifestV1Schema.parse(
-    stripUndefined({
-      autoFit,
-      mapId: input.mapId,
-      rendererVersion: input.rendererVersion,
-      schemaVersion: staticRendererSchemaVersionV1,
-      scene,
-      styleId: input.styleId,
-      styleRevision: input.styleRevision,
-      styleUrl: input.styleUrl
-    })
-  );
-}
-var createRenderManifest = createRenderManifestV1;
-function createRenderManifestV2(input) {
+function createRenderManifest(input) {
   const scene = normalizeStaticScene(input.scene);
   const autoFit = expectedAutoFit(scene);
-  return staticRenderManifestV2Schema.parse(
+  return staticRenderManifestSchema.parse(
     stripUndefined({
       attribution: input.attribution,
       autoFit,
+      composition: input.composition,
       mapId: input.mapId,
       rendererVersion: input.rendererVersion,
       schemaVersion: staticRendererSchemaVersion,
@@ -226,25 +229,35 @@ async function hashStaticSceneRequest(scene) {
   if (!validation.ok) throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
   return hashStableValue(validation.scene);
 }
-function validateVersionedScene(input, version) {
-  if (version === 1 && input && typeof input === "object" && !Array.isArray(input)) {
-    const { attribution: _attribution, ...legacy } = input;
-    return validateStaticScene(legacy);
-  }
-  return validateStaticScene(input);
-}
 function attributionMatchesScene(plan, scene) {
   const request = scene.attribution;
   const expectedMode = request?.mode === "external" ? "external" : "embedded";
   const expectedPosition = expectedMode === "external" ? null : request && "position" in request ? request.position ?? "auto" : "auto";
   return plan.mode === expectedMode && plan.position === expectedPosition;
 }
+function compositionMatchesScene(composition, scene) {
+  const expected = scene.overlays.flatMap(
+    (overlay, overlayIndex) => overlay.type === "symbol" && overlay.icon ? [{ icon: overlay.icon, overlayIndex }] : []
+  );
+  return expected.length === composition.icons.length && expected.every(
+    (icon, index) => composition.icons[index]?.icon === icon.icon && composition.icons[index]?.overlayIndex === icon.overlayIndex
+  );
+}
 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;
 }
+function anchorsHaveTerminalNulls(anchors) {
+  let sawNull = false;
+  for (const placement of staticOverlayPlacements) {
+    const anchor = anchors[placement];
+    if (anchor === null) sawNull = true;
+    else if (sawNull) return false;
+  }
+  return true;
+}
 function hasNoControlCharacters(value) {
   return !Array.from(value).some((character) => {
     const codePoint = character.codePointAt(0) ?? 0;
@@ -267,21 +280,18 @@ function zodFailure(error) {
 }
 
 export {
-  staticRendererSchemaVersionV1,
   staticRendererSchemaVersion,
   staticAttributionPlanSchemaVersion,
+  staticRenderCompositionSchemaVersion,
   staticAttributionLimits,
   staticAttributionSegmentSchema,
   staticAttributionProvenanceSchema,
   staticAttributionEntrySchema,
-  staticAttributionPlanSchemaV1,
-  staticRenderManifestV1Schema,
-  staticRenderManifestV2Schema,
+  staticAttributionPlanSchema,
+  staticRenderCompositionSchema,
   staticRenderManifestSchema,
   validateStaticRenderManifest,
-  createRenderManifestV1,
   createRenderManifest,
-  createRenderManifestV2,
   hashRenderManifest,
   hashStaticSceneRequest
 };

package/dist/client.d.ts

@@ -1,9 +1,11 @@
 import { z } from 'zod';
-import { a as StaticAttributionPosition, i as StaticSceneInput } from './scene-contract-OMIOisSB.js';
+export { S as StaticMapError, a as StaticMapErrorResponse, s as staticMapErrorResponseSchema } from './errors-B9rwehK0.js';
+import { a as StaticAttributionPosition, j as StaticSceneInput } from './scene-contract-Cr6BNLz0.js';
 
 declare function stableStringify(value: unknown): string;
 
-declare const STATIC_MAP_RESULT_V2_MEDIA_TYPE = "application/vnd.tileflow.static-map-result+json;version=2";
+declare const STATIC_MAP_RESULT_MEDIA_TYPE = "application/vnd.tileflow.static-map-result+json;version=1";
+
 type StaticMapAttributionEntry = Readonly<{
     authority: 'platform-notice' | 'team-declared';
     links: readonly Readonly<{
@@ -17,23 +19,24 @@ type StaticMapAttributionResult = Readonly<{
     mode: 'embedded' | 'external';
     position: Exclude<StaticAttributionPosition, 'auto'> | null;
 }>;
-type StaticMapResult = {
-    attribution?: StaticMapAttributionResult;
+type StaticMapResultBase = Readonly<{
     cached: boolean;
     hash: string;
     imageUrl: string;
-    operationId: string | null;
     remainingUnits: number | null;
-    resultVersion?: 2;
     status: 'ready';
-    unitCost: 0 | 15;
-};
-type StaticMapHostedResult = StaticMapResult & Readonly<{
+}>;
+type StaticMapImageResult = StaticMapResultBase & Readonly<{
+    operationId: null;
+    unitCost: 0;
+}>;
+type StaticMapHostedResult = StaticMapResultBase & Readonly<{
     attribution: StaticMapAttributionResult;
     operationId: string;
-    resultVersion: 2;
+    resultVersion: 1;
     unitCost: 15;
 }>;
+type StaticMapResult = StaticMapImageResult | StaticMapHostedResult;
 type StaticMapCreateOptions = {
     apiKey?: string;
     apiUrl?: string;
@@ -49,15 +52,6 @@ type StaticMapEndpointRequestOptions = Omit<StaticMapCreateOptions, 'apiUrl'> &
 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 staticMapAttributionEntrySchema: z.ZodObject<{
     authority: z.ZodEnum<{
         "platform-notice": "platform-notice";
@@ -86,10 +80,10 @@ declare const staticMapAttributionResultSchema: z.ZodObject<{
         external: "external";
     }>;
     position: z.ZodNullable<z.ZodEnum<{
-        "top-left": "top-left";
-        "top-right": "top-right";
         "bottom-left": "bottom-left";
         "bottom-right": "bottom-right";
+        "top-left": "top-left";
+        "top-right": "top-right";
     }>>;
 }, z.core.$strict>;
 declare const staticMapHostedResultSchema: z.ZodObject<{
@@ -117,13 +111,13 @@ declare const staticMapHostedResultSchema: z.ZodObject<{
             external: "external";
         }>;
         position: z.ZodNullable<z.ZodEnum<{
-            "top-left": "top-left";
-            "top-right": "top-right";
             "bottom-left": "bottom-left";
             "bottom-right": "bottom-right";
+            "top-left": "top-left";
+            "top-right": "top-right";
         }>>;
     }, z.core.$strict>;
-    resultVersion: z.ZodLiteral<2>;
+    resultVersion: z.ZodLiteral<1>;
 }, z.core.$strict>;
 declare const staticMapProcessingResultSchema: z.ZodObject<{
     operationId: z.ZodString;
@@ -144,4 +138,4 @@ declare function createStaticMap(scene: StaticSceneInput, options: StaticMapCrea
 declare function precacheStaticMap(scene: StaticSceneInput, options: StaticMapCreateOptions): Promise<StaticMapHostedResult>;
 declare function requestStaticMapUntilReady(request: PreparedStaticMapRequest, options: StaticMapEndpointRequestOptions): Promise<StaticMapHostedResult>;
 
-export { type PreparedStaticMapRequest, STATIC_MAP_RESULT_V2_MEDIA_TYPE, type StaticMapAttributionEntry, type StaticMapAttributionResult, type StaticMapCreateOptions, type StaticMapEndpointRequestOptions, type StaticMapHostedResult, type StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapAttributionEntrySchema, staticMapAttributionResultSchema, staticMapHostedResultSchema, staticMapProcessingResultSchema, staticMapReadyResultSchema, validateStaticMapIdempotencyKey };
+export { type PreparedStaticMapRequest, STATIC_MAP_RESULT_MEDIA_TYPE, type StaticMapAttributionEntry, type StaticMapAttributionResult, type StaticMapCreateOptions, type StaticMapEndpointRequestOptions, type StaticMapHostedResult, type StaticMapImageResult, type StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapAttributionEntrySchema, staticMapAttributionResultSchema, staticMapHostedResultSchema, staticMapProcessingResultSchema, validateStaticMapIdempotencyKey };

package/dist/client.js

@@ -1,5 +1,5 @@
 import {
-  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
+  STATIC_MAP_RESULT_MEDIA_TYPE,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
@@ -9,15 +9,18 @@ import {
   staticMapAttributionResultSchema,
   staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-MSQ4OLKA.js";
-import "./chunk-EMCKSFZV.js";
+} from "./chunk-N63IFMFM.js";
+import {
+  StaticMapError,
+  staticMapErrorResponseSchema
+} from "./chunk-TBI5AED6.js";
 import {
   stableStringify
-} from "./chunk-NM2JSFUF.js";
+} from "./chunk-6DWVCK64.js";
 export {
-  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
+  STATIC_MAP_RESULT_MEDIA_TYPE,
+  StaticMapError,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
@@ -26,8 +29,8 @@ export {
   stableStringify,
   staticMapAttributionEntrySchema,
   staticMapAttributionResultSchema,
+  staticMapErrorResponseSchema,
   staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
 };

package/dist/errors-B9rwehK0.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+declare const staticMapErrorResponseSchema: z.ZodObject<{
+    code: z.ZodOptional<z.ZodString>;
+    error: z.ZodString;
+    remainingUnits: z.ZodOptional<z.ZodNumber>;
+    requestId: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type StaticMapErrorResponse = z.infer<typeof staticMapErrorResponseSchema>;
+declare class StaticMapError extends Error {
+    readonly code: string | null;
+    readonly remainingUnits: number | null;
+    readonly requestId: string | null;
+    readonly response: StaticMapErrorResponse;
+    readonly retryable: boolean | null;
+    readonly status: number;
+    constructor(response: StaticMapErrorResponse, status: number);
+}
+
+export { StaticMapError as S, type StaticMapErrorResponse as a, staticMapErrorResponseSchema as s };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { StaticAutoFitErrorResponse, StaticAutoFitFailure, StaticMapRequestError, StaticMapRequestErrorResponse, StaticMapRequestFailure, normalizeStaticScene, staticMapRequestErrorResponseSchema, validateStaticScene } from './scene.js';
-export { circle, compileStaticOverlays, line, marker, polygon } from './overlays.js';
-export { StaticAttributionEntry, StaticAttributionPlanV1, StaticAttributionProvenance, StaticAttributionSegment, StaticRenderManifest, StaticRenderManifestV1, StaticRenderManifestV2, StaticResolvedAttributionPosition, createRenderManifest, createRenderManifestV1, createRenderManifestV2, hashRenderManifest, hashStaticSceneRequest, staticAttributionEntrySchema, staticAttributionLimits, staticAttributionPlanSchemaV1, staticAttributionPlanSchemaVersion, staticAttributionProvenanceSchema, staticAttributionSegmentSchema, staticRenderManifestSchema, staticRenderManifestV1Schema, staticRenderManifestV2Schema, staticRendererSchemaVersion, staticRendererSchemaVersionV1, validateStaticRenderManifest } from './manifest.js';
-export { PreparedStaticMapRequest, STATIC_MAP_RESULT_V2_MEDIA_TYPE, StaticMapAttributionEntry, StaticMapAttributionResult, StaticMapCreateOptions, StaticMapEndpointRequestOptions, StaticMapHostedResult, StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapAttributionEntrySchema, staticMapAttributionResultSchema, staticMapHostedResultSchema, staticMapProcessingResultSchema, staticMapReadyResultSchema, validateStaticMapIdempotencyKey } from './client.js';
-export { M as MAX_OVERLAY_LATITUDE, S as StaticAttributionMode, a as StaticAttributionPosition, b as StaticAttributionRequest, c as StaticCoordinate, d as StaticMapFormat, e as StaticOverlay, f as StaticOverlayInput, g as StaticPadding, h as StaticScene, i as StaticSceneInput, s as staticAttributionPositionSchema, j as staticAttributionRequestSchema, k as staticOverlaySchema, l as staticSceneLimits, m as staticSceneSchema, n as staticSceneSchemaVersion } from './scene-contract-OMIOisSB.js';
+export { circle, compileStaticOverlays, line, marker, polygon, symbol } from './overlays.js';
+export { StaticAttributionEntry, StaticAttributionPlan, StaticAttributionProvenance, StaticAttributionSegment, StaticRenderComposition, StaticRenderManifest, StaticResolvedAttributionPosition, createRenderManifest, hashRenderManifest, hashStaticSceneRequest, staticAttributionEntrySchema, staticAttributionLimits, staticAttributionPlanSchema, staticAttributionPlanSchemaVersion, staticAttributionProvenanceSchema, staticAttributionSegmentSchema, staticRenderCompositionSchema, staticRenderCompositionSchemaVersion, staticRenderManifestSchema, staticRendererSchemaVersion, validateStaticRenderManifest } from './manifest.js';
+export { PreparedStaticMapRequest, STATIC_MAP_RESULT_MEDIA_TYPE, StaticMapAttributionEntry, StaticMapAttributionResult, StaticMapCreateOptions, StaticMapEndpointRequestOptions, StaticMapHostedResult, StaticMapImageResult, StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, staticMapAttributionEntrySchema, staticMapAttributionResultSchema, staticMapHostedResultSchema, staticMapProcessingResultSchema, validateStaticMapIdempotencyKey } from './client.js';
+export { M as MAX_OVERLAY_LATITUDE, S as StaticAttributionMode, a as StaticAttributionPosition, b as StaticAttributionRequest, c as StaticCoordinate, d as StaticMapFormat, e as StaticOverlay, f as StaticOverlayInput, g as StaticOverlayPlacement, h as StaticPadding, i as StaticScene, j as StaticSceneInput, 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, t as staticOverlaySchema, 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';
+export { S as StaticMapError, a as StaticMapErrorResponse, s as staticMapErrorResponseSchema } from './errors-B9rwehK0.js';
 import 'zod';

package/dist/index.js

@@ -1,5 +1,5 @@
 import {
-  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
+  STATIC_MAP_RESULT_MEDIA_TYPE,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
@@ -9,64 +9,70 @@ import {
   staticMapAttributionResultSchema,
   staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-MSQ4OLKA.js";
+} from "./chunk-N63IFMFM.js";
 import {
   createRenderManifest,
-  createRenderManifestV1,
-  createRenderManifestV2,
   hashRenderManifest,
   hashStaticSceneRequest,
   staticAttributionEntrySchema,
   staticAttributionLimits,
-  staticAttributionPlanSchemaV1,
+  staticAttributionPlanSchema,
   staticAttributionPlanSchemaVersion,
   staticAttributionProvenanceSchema,
   staticAttributionSegmentSchema,
+  staticRenderCompositionSchema,
+  staticRenderCompositionSchemaVersion,
   staticRenderManifestSchema,
-  staticRenderManifestV1Schema,
-  staticRenderManifestV2Schema,
   staticRendererSchemaVersion,
-  staticRendererSchemaVersionV1,
   validateStaticRenderManifest
-} from "./chunk-TQMKOTBE.js";
+} from "./chunk-XMT7VJL5.js";
 import {
   circle,
   compileStaticOverlays,
   line,
   marker,
-  polygon
-} from "./chunk-EPOYQNNT.js";
+  polygon,
+  symbol
+} from "./chunk-HVVIAOBE.js";
 import {
+  StaticMapError,
   StaticMapRequestError,
   normalizeStaticScene,
+  staticMapErrorResponseSchema,
   staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-EMCKSFZV.js";
+} from "./chunk-TBI5AED6.js";
 import {
   MAX_OVERLAY_LATITUDE,
+  isSupportedStaticSymbolCodePoint,
   stableStringify,
   staticAttributionPositionSchema,
   staticAttributionRequestSchema,
+  staticOverlayPlacements,
   staticOverlaySchema,
   staticSceneLimits,
   staticSceneSchema,
-  staticSceneSchemaVersion
-} from "./chunk-NM2JSFUF.js";
+  staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages
+} from "./chunk-6DWVCK64.js";
 export {
   MAX_OVERLAY_LATITUDE,
-  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
+  STATIC_MAP_RESULT_MEDIA_TYPE,
+  StaticMapError,
   StaticMapRequestError,
   circle,
   compileStaticOverlays,
   createRenderManifest,
-  createRenderManifestV1,
-  createRenderManifestV2,
   createStaticMap,
   createStaticMapIdempotencyKey,
   hashRenderManifest,
   hashStaticSceneRequest,
+  isSupportedStaticSymbolCodePoint,
   line,
   marker,
   normalizeStaticScene,
@@ -77,7 +83,7 @@ export {
   stableStringify,
   staticAttributionEntrySchema,
   staticAttributionLimits,
-  staticAttributionPlanSchemaV1,
+  staticAttributionPlanSchema,
   staticAttributionPlanSchemaVersion,
   staticAttributionPositionSchema,
   staticAttributionProvenanceSchema,
@@ -85,19 +91,25 @@ export {
   staticAttributionSegmentSchema,
   staticMapAttributionEntrySchema,
   staticMapAttributionResultSchema,
+  staticMapErrorResponseSchema,
   staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   staticMapRequestErrorResponseSchema,
+  staticOverlayPlacements,
   staticOverlaySchema,
+  staticRenderCompositionSchema,
+  staticRenderCompositionSchemaVersion,
   staticRenderManifestSchema,
-  staticRenderManifestV1Schema,
-  staticRenderManifestV2Schema,
   staticRendererSchemaVersion,
-  staticRendererSchemaVersionV1,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages,
+  symbol,
   validateStaticMapIdempotencyKey,
   validateStaticRenderManifest,
   validateStaticScene