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

package/dist/chunk-XMT7VJL5.js

@@ -0,0 +1,297 @@
+import {
+  analyzeStaticAutoFit,
+  normalizeStaticScene,
+  staticAutoFitPlanSchema,
+  validateStaticScene
+} from "./chunk-TBI5AED6.js";
+import {
+  hashStableValue,
+  isSafeHttpUrl,
+  jsonByteLength,
+  stableStringify,
+  staticOverlayPlacements,
+  staticSceneSchema,
+  stripUndefined
+} from "./chunk-6DWVCK64.js";
+
+// src/manifest.ts
+import { z } from "zod";
+var staticRendererSchemaVersion = 1;
+var staticAttributionPlanSchemaVersion = 1;
+var staticRenderCompositionSchemaVersion = 1;
+var staticAttributionLimits = {
+  maxBytes: 32 * 1024,
+  maxEntries: 18,
+  maxLinksPerEntry: 8,
+  maxTextLength: 16384,
+  maxUrlLength: 2048
+};
+var sha256HexSchema = z.string().regex(/^[0-9a-f]{64}$/u);
+var sourceIdSchema = z.string().min(1).max(128);
+var boundedIdentitySchema = z.string().min(1).max(512).refine(hasNoControlCharacters, {
+  message: "Expected no control characters"
+});
+var staticResolvedAttributionPositionSchema = z.enum([
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+]);
+var staticAttributionSegmentSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("text"),
+    text: z.string().min(1).max(staticAttributionLimits.maxTextLength).refine(hasNoControlCharacters, { message: "Attribution text contains control characters" })
+  }).strict(),
+  z.object({
+    kind: z.literal("link"),
+    label: z.string().min(1).max(staticAttributionLimits.maxTextLength).refine(hasNoControlCharacters, {
+      message: "Attribution link label contains control characters"
+    }),
+    url: z.string().trim().url().max(staticAttributionLimits.maxUrlLength).refine(isSafeHttpUrl, {
+      message: "Expected an http(s) URL without credentials or a fragment"
+    })
+  }).strict()
+]);
+var attributionSourceSchema = z.object({
+  sourceId: sourceIdSchema,
+  sourceSelectionIdentity: boundedIdentitySchema
+}).strict();
+var attributionSourcesSchema = z.array(attributionSourceSchema).min(1).max(18).refine(isUniqueSortedSources, {
+  message: "Attribution sources must be unique and sorted"
+});
+var staticAttributionProvenanceSchema = z.discriminatedUnion("authority", [
+  z.object({
+    authority: z.literal("platform-notice"),
+    noticeId: boundedIdentitySchema,
+    noticeSha256: sha256HexSchema,
+    resource: z.enum(["terrain", "world"]),
+    sources: attributionSourcesSchema
+  }).strict(),
+  z.object({
+    authority: z.literal("team-declared"),
+    sources: z.array(
+      attributionSourceSchema.extend({
+        mapRevision: boundedIdentitySchema,
+        resourceId: boundedIdentitySchema
+      }).strict()
+    ).min(1).max(18).refine(isUniqueSortedSources, {
+      message: "Attribution sources must be unique and sorted"
+    })
+  }).strict()
+]);
+var staticAttributionEntrySchema = z.object({
+  authority: z.enum(["platform-notice", "team-declared"]),
+  provenance: staticAttributionProvenanceSchema,
+  segments: z.array(staticAttributionSegmentSchema).min(1).max(17)
+}).strict().superRefine((entry, context) => {
+  if (entry.authority !== entry.provenance.authority) {
+    context.addIssue({
+      code: "custom",
+      message: "Attribution entry authority must match its provenance",
+      path: ["authority"]
+    });
+  }
+  const links = entry.segments.filter((segment) => segment.kind === "link").length;
+  if (links > staticAttributionLimits.maxLinksPerEntry) {
+    context.addIssue({
+      code: "custom",
+      message: `Attribution entries can contain at most ${staticAttributionLimits.maxLinksPerEntry} links`,
+      path: ["segments"]
+    });
+  }
+});
+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()]),
+  schemaVersion: z.literal(staticAttributionPlanSchemaVersion)
+}).strict().superRefine((plan, context) => {
+  if (plan.mode === "external" && plan.position !== null || plan.mode === "embedded" && plan.position === null) {
+    context.addIssue({
+      code: "custom",
+      message: "Attribution position must match its mode",
+      path: ["position"]
+    });
+  }
+  if (jsonByteLength(plan) > staticAttributionLimits.maxBytes) {
+    context.addIssue({
+      code: "custom",
+      message: `Attribution plan exceeds ${staticAttributionLimits.maxBytes} bytes`
+    });
+  }
+});
+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 staticRenderManifestSchema = z.object(staticRenderManifestBaseShape).strict();
+function validateStaticRenderManifest(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { error: "manifest: Expected an object", ok: false };
+  }
+  if (input.schemaVersion !== staticRendererSchemaVersion) {
+    return { error: "manifest.schemaVersion: Unsupported renderer schema version", ok: false };
+  }
+  const rawScene = input.scene;
+  const sceneValidation = validateStaticScene(rawScene);
+  if (!sceneValidation.ok) return sceneValidation;
+  const parsed = staticRenderManifestSchema.safeParse({
+    ...input,
+    scene: sceneValidation.scene
+  });
+  if (!parsed.success) return zodFailure(parsed.error);
+  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 };
+  }
+  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,
+      ...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({
+      attribution: input.attribution,
+      autoFit,
+      composition: input.composition,
+      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 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;
+    return codePoint <= 31 || codePoint === 127;
+  });
+}
+function isUniqueSortedSources(values) {
+  return values.every(
+    (value, index) => index === 0 || compareCodeUnits(values[index - 1].sourceId, value.sourceId) < 0
+  );
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function zodFailure(error) {
+  return {
+    error: error.issues.map((issue) => `${issue.path.join(".") || "manifest"}: ${issue.message}`).join("; "),
+    ok: false
+  };
+}
+
+export {
+  staticRendererSchemaVersion,
+  staticAttributionPlanSchemaVersion,
+  staticRenderCompositionSchemaVersion,
+  staticAttributionLimits,
+  staticAttributionSegmentSchema,
+  staticAttributionProvenanceSchema,
+  staticAttributionEntrySchema,
+  staticAttributionPlanSchema,
+  staticRenderCompositionSchema,
+  staticRenderManifestSchema,
+  validateStaticRenderManifest,
+  createRenderManifest,
+  hashRenderManifest,
+  hashStaticSceneRequest
+};

package/dist/client.d.ts

@@ -1,17 +1,42 @@
 import { z } from 'zod';
-import { e as StaticSceneInput } from './scene-contract-DZMhLDnf.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;
 
-type StaticMapResult = {
+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<{
+        label: string;
+        url: string;
+    }>[];
+    text: string;
+}>;
+type StaticMapAttributionResult = Readonly<{
+    entries: readonly StaticMapAttributionEntry[];
+    mode: 'embedded' | 'external';
+    position: Exclude<StaticAttributionPosition, 'auto'> | null;
+}>;
+type StaticMapResultBase = Readonly<{
     cached: boolean;
     hash: string;
     imageUrl: string;
-    operationId: string | null;
     remainingUnits: number | null;
     status: 'ready';
-    unitCost: 0 | 15;
-};
+}>;
+type StaticMapImageResult = StaticMapResultBase & Readonly<{
+    operationId: null;
+    unitCost: 0;
+}>;
+type StaticMapHostedResult = StaticMapResultBase & Readonly<{
+    attribution: StaticMapAttributionResult;
+    operationId: string;
+    resultVersion: 1;
+    unitCost: 15;
+}>;
+type StaticMapResult = StaticMapImageResult | StaticMapHostedResult;
 type StaticMapCreateOptions = {
     apiKey?: string;
     apiUrl?: string;
@@ -27,7 +52,41 @@ type StaticMapEndpointRequestOptions = Omit<StaticMapCreateOptions, 'apiUrl'> &
 type PreparedStaticMapRequest = Readonly<{
     sceneKey: string;
 }>;
-declare const staticMapReadyResultSchema: z.ZodObject<{
+declare const staticMapAttributionEntrySchema: z.ZodObject<{
+    authority: z.ZodEnum<{
+        "platform-notice": "platform-notice";
+        "team-declared": "team-declared";
+    }>;
+    links: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        url: z.ZodString;
+    }, z.core.$strict>>;
+    text: z.ZodString;
+}, z.core.$strict>;
+declare const staticMapAttributionResultSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        authority: z.ZodEnum<{
+            "platform-notice": "platform-notice";
+            "team-declared": "team-declared";
+        }>;
+        links: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+    mode: z.ZodEnum<{
+        embedded: "embedded";
+        external: "external";
+    }>;
+    position: z.ZodNullable<z.ZodEnum<{
+        "top-left": "top-left";
+        "top-right": "top-right";
+        "bottom-left": "bottom-left";
+        "bottom-right": "bottom-right";
+    }>>;
+}, z.core.$strict>;
+declare const staticMapHostedResultSchema: z.ZodObject<{
     cached: z.ZodBoolean;
     hash: z.ZodString;
     imageUrl: z.ZodString;
@@ -35,6 +94,30 @@ declare const staticMapReadyResultSchema: z.ZodObject<{
     remainingUnits: z.ZodNullable<z.ZodNumber>;
     status: z.ZodLiteral<"ready">;
     unitCost: z.ZodLiteral<15>;
+    attribution: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            authority: z.ZodEnum<{
+                "platform-notice": "platform-notice";
+                "team-declared": "team-declared";
+            }>;
+            links: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                url: z.ZodString;
+            }, z.core.$strict>>;
+            text: z.ZodString;
+        }, z.core.$strict>>;
+        mode: z.ZodEnum<{
+            embedded: "embedded";
+            external: "external";
+        }>;
+        position: z.ZodNullable<z.ZodEnum<{
+            "top-left": "top-left";
+            "top-right": "top-right";
+            "bottom-left": "bottom-left";
+            "bottom-right": "bottom-right";
+        }>>;
+    }, z.core.$strict>;
+    resultVersion: z.ZodLiteral<1>;
 }, z.core.$strict>;
 declare const staticMapProcessingResultSchema: z.ZodObject<{
     operationId: z.ZodString;
@@ -51,8 +134,8 @@ declare function validateStaticMapIdempotencyKey(value: unknown): {
 };
 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>;
+declare function createStaticMap(scene: StaticSceneInput, options: StaticMapCreateOptions): Promise<StaticMapHostedResult>;
+declare function precacheStaticMap(scene: StaticSceneInput, options: StaticMapCreateOptions): Promise<StaticMapHostedResult>;
+declare function requestStaticMapUntilReady(request: PreparedStaticMapRequest, options: StaticMapEndpointRequestOptions): Promise<StaticMapHostedResult>;
 
-export { type PreparedStaticMapRequest, type StaticMapCreateOptions, type StaticMapEndpointRequestOptions, type StaticMapResult, createStaticMap, createStaticMapIdempotencyKey, precacheStaticMap, prepareStaticMapRequest, requestStaticMapUntilReady, stableStringify, 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,25 +1,36 @@
 import {
+  STATIC_MAP_RESULT_MEDIA_TYPE,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
   prepareStaticMapRequest,
   requestStaticMapUntilReady,
+  staticMapAttributionEntrySchema,
+  staticMapAttributionResultSchema,
+  staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-A23RC4BE.js";
-import "./chunk-NHQK5UZ2.js";
+} from "./chunk-N63IFMFM.js";
+import {
+  StaticMapError,
+  staticMapErrorResponseSchema
+} from "./chunk-TBI5AED6.js";
 import {
   stableStringify
-} from "./chunk-MGQCHCU3.js";
+} from "./chunk-6DWVCK64.js";
 export {
+  STATIC_MAP_RESULT_MEDIA_TYPE,
+  StaticMapError,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
   prepareStaticMapRequest,
   requestStaticMapUntilReady,
   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 { 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 { 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';
+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,44 +1,69 @@
 import {
+  STATIC_MAP_RESULT_MEDIA_TYPE,
   createStaticMap,
   createStaticMapIdempotencyKey,
   precacheStaticMap,
   prepareStaticMapRequest,
   requestStaticMapUntilReady,
+  staticMapAttributionEntrySchema,
+  staticMapAttributionResultSchema,
+  staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   validateStaticMapIdempotencyKey
-} from "./chunk-A23RC4BE.js";
+} from "./chunk-N63IFMFM.js";
 import {
   createRenderManifest,
   hashRenderManifest,
   hashStaticSceneRequest,
+  staticAttributionEntrySchema,
+  staticAttributionLimits,
+  staticAttributionPlanSchema,
+  staticAttributionPlanSchemaVersion,
+  staticAttributionProvenanceSchema,
+  staticAttributionSegmentSchema,
+  staticRenderCompositionSchema,
+  staticRenderCompositionSchemaVersion,
   staticRenderManifestSchema,
   staticRendererSchemaVersion,
   validateStaticRenderManifest
-} from "./chunk-S3WXE5P4.js";
+} from "./chunk-XMT7VJL5.js";
 import {
   circle,
   compileStaticOverlays,
   line,
   marker,
-  polygon
-} from "./chunk-KPT7PASB.js";
+  polygon,
+  symbol
+} from "./chunk-HVVIAOBE.js";
 import {
+  StaticMapError,
   StaticMapRequestError,
   normalizeStaticScene,
+  staticMapErrorResponseSchema,
   staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-NHQK5UZ2.js";
+} from "./chunk-TBI5AED6.js";
 import {
   MAX_OVERLAY_LATITUDE,
+  isSupportedStaticSymbolCodePoint,
   stableStringify,
+  staticAttributionPositionSchema,
+  staticAttributionRequestSchema,
+  staticOverlayPlacements,
   staticOverlaySchema,
   staticSceneLimits,
   staticSceneSchema,
-  staticSceneSchemaVersion
-} from "./chunk-MGQCHCU3.js";
+  staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages
+} from "./chunk-6DWVCK64.js";
 export {
   MAX_OVERLAY_LATITUDE,
+  STATIC_MAP_RESULT_MEDIA_TYPE,
+  StaticMapError,
   StaticMapRequestError,
   circle,
   compileStaticOverlays,
@@ -47,6 +72,7 @@ export {
   createStaticMapIdempotencyKey,
   hashRenderManifest,
   hashStaticSceneRequest,
+  isSupportedStaticSymbolCodePoint,
   line,
   marker,
   normalizeStaticScene,
@@ -55,15 +81,35 @@ export {
   prepareStaticMapRequest,
   requestStaticMapUntilReady,
   stableStringify,
+  staticAttributionEntrySchema,
+  staticAttributionLimits,
+  staticAttributionPlanSchema,
+  staticAttributionPlanSchemaVersion,
+  staticAttributionPositionSchema,
+  staticAttributionProvenanceSchema,
+  staticAttributionRequestSchema,
+  staticAttributionSegmentSchema,
+  staticMapAttributionEntrySchema,
+  staticMapAttributionResultSchema,
+  staticMapErrorResponseSchema,
+  staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
-  staticMapReadyResultSchema,
   staticMapRequestErrorResponseSchema,
+  staticOverlayPlacements,
   staticOverlaySchema,
+  staticRenderCompositionSchema,
+  staticRenderCompositionSchemaVersion,
   staticRenderManifestSchema,
   staticRendererSchemaVersion,
   staticSceneLimits,
   staticSceneSchema,
   staticSceneSchemaVersion,
+  staticSymbolAnchors,
+  staticSymbolCollisions,
+  staticSymbolLabelAppearances,
+  staticSymbolLabelPositions,
+  staticSymbolLanguages,
+  symbol,
   validateStaticMapIdempotencyKey,
   validateStaticRenderManifest,
   validateStaticScene