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

package/dist/chunk-QCR76BUO.js

@@ -0,0 +1,304 @@
+import {
+  validateStaticScene
+} from "./chunk-ROBEGDDY.js";
+import {
+  isSafeHttpUrl,
+  stableStringify
+} from "./chunk-YUG3PBK2.js";
+
+// src/client.ts
+import { z } from "zod";
+var maxStaticMapResponseBytes = 64 * 1024;
+var staticMapIdempotencyKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
+var preparedStaticMapRequestBodies = /* @__PURE__ */ new WeakMap();
+var staticMapReadyResultSchema = z.object({
+  cached: z.boolean(),
+  hash: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+  imageUrl: z.string().trim().url().max(2048).refine(isSafeHttpUrl, { message: "Expected an http(s) URL without credentials" }),
+  operationId: z.string().min(20).max(68),
+  remainingUnits: z.number().int().nonnegative().nullable(),
+  status: z.literal("ready"),
+  unitCost: z.literal(15)
+}).strict();
+var staticMapProcessingResultSchema = z.object({
+  operationId: z.string().min(20).max(68),
+  retryAfterMs: z.number().int().min(0).max(5e3),
+  status: z.literal("processing")
+}).strict();
+function validateStaticMapIdempotencyKey(value) {
+  if (typeof value !== "string" || !staticMapIdempotencyKeyPattern.test(value)) {
+    return {
+      error: "Idempotency key must contain 8-128 ASCII letters, digits, dot, underscore, colon, or hyphen and start with a letter or digit",
+      ok: false
+    };
+  }
+  return { key: value, ok: true };
+}
+function createStaticMapIdempotencyKey() {
+  const key = `static_${crypto.randomUUID()}`;
+  if (!validateStaticMapIdempotencyKey(key).ok) {
+    throw new Error("Unable to create a valid Tileflow Static Maps idempotency key");
+  }
+  return key;
+}
+function prepareStaticMapRequest(scene) {
+  const validation = validateStaticScene(scene);
+  if (!validation.ok) {
+    throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
+  }
+  const prepared = Object.freeze({
+    sceneKey: stableStringify(validation.scene)
+  });
+  preparedStaticMapRequestBodies.set(prepared, JSON.stringify(validation.scene));
+  return prepared;
+}
+async function createStaticMap(scene, options) {
+  return requestStaticMap(scene, options, "/v1/static/maps");
+}
+async function precacheStaticMap(scene, options) {
+  return requestStaticMap(scene, options, "/v1/static/maps/precache");
+}
+async function requestStaticMap(scene, options, path) {
+  const preparedRequest = prepareStaticMapRequest(scene);
+  const { apiUrl = "https://api.tileflow.dev", ...requestOptions } = options;
+  return requestStaticMapUntilReady(preparedRequest, {
+    ...requestOptions,
+    createUrl: `${normalizeUrl(apiUrl)}${path}`
+  });
+}
+async function requestStaticMapUntilReady(request, options) {
+  const body = preparedStaticMapRequestBodies.get(request);
+  if (body === void 0) {
+    throw new Error("Tileflow static map request must be created with prepareStaticMapRequest");
+  }
+  const idempotency = validateStaticMapIdempotencyKey(options.idempotencyKey);
+  if (!idempotency.ok) {
+    throw new Error(`Invalid Tileflow Static Maps idempotency key: ${idempotency.error}`);
+  }
+  const maxWaitMs = boundedClientDuration(options.maxWaitMs, 3e4, 100, 12e4, "maxWaitMs");
+  const pollIntervalMs = boundedClientDuration(
+    options.pollIntervalMs,
+    500,
+    0,
+    5e3,
+    "pollIntervalMs"
+  );
+  const fetcher = options.fetch ?? fetch;
+  const createUrl = normalizeStaticMapEndpointUrl(options.createUrl);
+  const headers = {
+    "Content-Type": "application/json",
+    "Idempotency-Key": idempotency.key
+  };
+  if (options.apiKey) {
+    headers.Authorization = `Bearer ${options.apiKey}`;
+  }
+  return runWithinStaticMapBudget(maxWaitMs, options.signal, async (signal) => {
+    let operationId = null;
+    while (true) {
+      const response = await fetcher(createUrl, {
+        body,
+        headers,
+        method: "POST",
+        signal
+      });
+      throwIfAborted(signal);
+      if (!response.ok) {
+        await discardBoundedResponse(response, 8 * 1024);
+        throwIfAborted(signal);
+        throw new Error(`Tileflow static map failed (${response.status}).`);
+      }
+      const json = await readJsonResponse(response);
+      throwIfAborted(signal);
+      if (response.status !== 202) {
+        const parsed = staticMapReadyResultSchema.safeParse(json);
+        if (!parsed.success) {
+          throw new Error(
+            `Tileflow static map returned an invalid response: ${parsed.error.message}`
+          );
+        }
+        assertStaticMapOperationIdentity(operationId, parsed.data.operationId);
+        return parsed.data;
+      }
+      const pending = staticMapProcessingResultSchema.safeParse(json);
+      if (!pending.success) {
+        throw new Error(
+          `Tileflow static map returned an invalid response: ${pending.error.message}`
+        );
+      }
+      assertStaticMapOperationIdentity(operationId, pending.data.operationId);
+      operationId ??= pending.data.operationId;
+      await delay(Math.max(pollIntervalMs, pending.data.retryAfterMs), signal);
+    }
+  });
+}
+function boundedClientDuration(value, fallback, minimum, maximum, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < minimum || resolved > maximum) {
+    throw new Error(
+      `Tileflow Static Maps ${name} must be an integer from ${minimum} to ${maximum}`
+    );
+  }
+  return resolved;
+}
+async function readJsonResponse(response) {
+  const source = await readBoundedResponseText(response, maxStaticMapResponseBytes, "64 KiB");
+  try {
+    return JSON.parse(source);
+  } catch {
+    throw new Error("Tileflow static map returned an invalid response: expected JSON");
+  }
+}
+async function discardBoundedResponse(response, maximumBytes) {
+  try {
+    await readBoundedResponseText(response, maximumBytes, `${maximumBytes} bytes`);
+  } catch {
+  }
+}
+async function readBoundedResponseText(response, maximumBytes, displayLimit) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let byteLength = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    byteLength += value.byteLength;
+    if (byteLength > maximumBytes) {
+      await reader.cancel();
+      throw new Error(
+        `Tileflow static map returned an invalid response: response exceeded ${displayLimit}`
+      );
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error("Tileflow static map returned an invalid response: expected UTF-8 JSON");
+  }
+}
+async function runWithinStaticMapBudget(maxWaitMs, externalSignal, operation) {
+  const controller = new AbortController();
+  const timeoutError = new Error(`Tileflow static map timed out after ${maxWaitMs}ms`);
+  const abortFromCaller = () => controller.abort(externalSignal?.reason);
+  if (externalSignal?.aborted) {
+    abortFromCaller();
+  } else {
+    externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
+  }
+  const timeout = setTimeout(() => controller.abort(timeoutError), maxWaitMs);
+  try {
+    throwIfAborted(controller.signal);
+    const pending = operation(controller.signal);
+    return await raceWithAbort(pending, controller.signal);
+  } finally {
+    clearTimeout(timeout);
+    externalSignal?.removeEventListener("abort", abortFromCaller);
+  }
+}
+function delay(milliseconds, signal) {
+  if (milliseconds === 0) {
+    throwIfAborted(signal);
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, milliseconds);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      reject(abortReason(signal));
+    };
+    if (signal.aborted) {
+      onAbort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function raceWithAbort(operation, signal) {
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(abortReason(signal));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function throwIfAborted(signal) {
+  if (signal.aborted) throw abortReason(signal);
+}
+function abortReason(signal) {
+  if (signal.reason instanceof Error) return signal.reason;
+  const error = new Error("Tileflow static map request was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function assertStaticMapOperationIdentity(expected, actual) {
+  if (expected !== null && actual !== expected) {
+    throw new Error("Tileflow static map changed operation identity while polling");
+  }
+}
+function normalizeUrl(value) {
+  const url = new URL(value);
+  if (!isSafeHttpUrl(value) || url.search) {
+    throw new TypeError(
+      "Tileflow Static Maps apiUrl must be HTTP(S) without credentials, query, or fragment"
+    );
+  }
+  return url.toString().replace(/\/+$/, "");
+}
+function normalizeStaticMapEndpointUrl(value) {
+  if (value.startsWith("/")) {
+    if (value.startsWith("//") || value.length > 2048 || /[\\?#]/u.test(value) || hasControlCharacter(value)) {
+      throw new TypeError(
+        "Tileflow Static Maps createUrl must be HTTP(S) without credentials, query, or fragment or a safe root-relative path"
+      );
+    }
+    return value;
+  }
+  const url = new URL(value);
+  if (!isSafeHttpUrl(value) || url.search) {
+    throw new TypeError(
+      "Tileflow Static Maps createUrl must be HTTP(S) without credentials, query, or fragment or a safe root-relative path"
+    );
+  }
+  return url.toString();
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const codePoint = value.charCodeAt(index);
+    if (codePoint <= 31 || codePoint === 127) return true;
+  }
+  return false;
+}
+
+export {
+  staticMapReadyResultSchema,
+  staticMapProcessingResultSchema,
+  validateStaticMapIdempotencyKey,
+  createStaticMapIdempotencyKey,
+  prepareStaticMapRequest,
+  createStaticMap,
+  precacheStaticMap,
+  requestStaticMapUntilReady
+};

package/dist/chunk-ROBEGDDY.js

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

package/dist/chunk-YUG3PBK2.js

@@ -0,0 +1,198 @@
+// src/canonical.ts
+function stableStringify(value) {
+  return JSON.stringify(sortJson(value));
+}
+function roundNumber(value) {
+  return Number(value.toFixed(6));
+}
+function stripUndefined(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function jsonByteLength(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).length;
+}
+async function hashStableValue(value) {
+  const bytes = new TextEncoder().encode(stableStringify(value));
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return base64Url(new Uint8Array(digest));
+}
+function isSafeHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password && !url.hash;
+  } catch {
+    return false;
+  }
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortJson(entry)])
+    );
+  }
+  return value;
+}
+function base64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+// src/scene-contract.ts
+import { z } from "zod";
+var staticSceneSchemaVersion = 1;
+var staticSceneLimits = {
+  maxDimension: 1280,
+  maxGeoJsonBytes: 96e3,
+  maxOverlays: 24,
+  maxPathCoordinates: 2e3,
+  maxPhysicalPixels: 1280 * 1280,
+  minDimension: 64
+};
+var coordinateSchema = z.tuple([z.number().finite(), z.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
+  message: "Expected [lng, lat] within world bounds"
+});
+var colorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, {
+  message: "Expected a hex color like #C6A15B"
+});
+var portableIdSchema = z.string().min(1).max(64).regex(/^[a-z][a-z0-9-]{0,63}$/u, {
+  message: "Expected lowercase kebab-case beginning with a letter"
+}).refine(
+  (name) => !["constructor", "prototype"].includes(name) && !/^(?:AUX|CON|NUL|PRN|COM[1-9]|LPT[1-9])$/i.test(name),
+  "Expected a portable identifier that is not a reserved filename or prototype key"
+);
+var concreteThemeSchema = portableIdSchema.refine((value) => value !== "system", {
+  message: 'Static maps require a concrete theme; "system" is browser-only'
+});
+var sizeSchema = z.object({
+  dpr: z.literal(1).optional(),
+  height: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension),
+  width: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension)
+}).refine(
+  (size) => size.width * size.height * (size.dpr ?? 1) <= staticSceneLimits.maxPhysicalPixels,
+  {
+    message: "Static map exceeds the maximum render pixel budget"
+  }
+);
+var centerCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  center: coordinateSchema,
+  type: z.literal("center"),
+  zoom: z.number().finite().min(0).max(22)
+});
+var boundsCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  bounds: z.tuple([z.number().finite(), z.number().finite(), z.number().finite(), z.number().finite()]).refine(
+    ([west, south, east, north]) => west >= -180 && west <= 180 && east >= -180 && east <= 180 && south >= -90 && south <= 90 && north >= -90 && north <= 90 && west !== east && south !== north,
+    { message: "Expected bounds as [west, south, east, north]" }
+  ),
+  padding: z.number().int().min(0).max(256).optional(),
+  type: z.literal("bounds")
+}).refine((camera) => camera.bounds[3] > camera.bounds[1], {
+  message: "Bounds north must be greater than south"
+});
+var lineOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinates: z.array(coordinateSchema).min(2).max(staticSceneLimits.maxPathCoordinates),
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(1),
+  type: z.literal("line"),
+  width: z.number().finite().min(0.5).max(32).default(4)
+});
+var circleOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinate: coordinateSchema,
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(1),
+  radius: z.number().finite().min(1).max(64).default(6),
+  strokeColor: colorSchema.optional(),
+  strokeWidth: z.number().finite().min(0).max(16).default(0),
+  type: z.literal("circle")
+});
+var markerOverlaySchema = z.object({
+  color: colorSchema.default("#C6A15B"),
+  coordinate: coordinateSchema,
+  id: z.string().trim().min(1).max(64).optional(),
+  radius: z.number().finite().min(2).max(64).default(8),
+  strokeColor: colorSchema.default("#ffffff"),
+  strokeWidth: z.number().finite().min(0).max(16).default(2),
+  type: z.literal("marker")
+});
+var polygonRingSchema = z.array(coordinateSchema).min(4).max(staticSceneLimits.maxPathCoordinates).refine(
+  (ring) => {
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    return Boolean(first && last && first[0] === last[0] && first[1] === last[1]);
+  },
+  { message: "Polygon rings must end at their starting coordinate" }
+);
+var polygonOverlaySchema = z.object({
+  coordinates: z.array(polygonRingSchema).min(1).max(16),
+  fill: colorSchema.default("#C6A15B"),
+  id: z.string().trim().min(1).max(64).optional(),
+  opacity: z.number().finite().min(0).max(1).default(0.28),
+  stroke: colorSchema.optional(),
+  strokeWidth: z.number().finite().min(0).max(16).default(0),
+  type: z.literal("polygon")
+});
+var staticOverlaySchema = z.discriminatedUnion("type", [
+  lineOverlaySchema,
+  circleOverlaySchema,
+  markerOverlaySchema,
+  polygonOverlaySchema
+]);
+var staticSceneSchema = z.object({
+  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema]),
+  map: portableIdSchema,
+  overlays: z.array(staticOverlaySchema).max(staticSceneLimits.maxOverlays).default([]),
+  size: sizeSchema,
+  theme: concreteThemeSchema
+});
+
+// src/overlay-normalization.ts
+function normalizeStaticOverlay(overlay) {
+  const parsed = staticOverlaySchema.parse(overlay);
+  const normalized = stripUndefined({ ...parsed });
+  if ("coordinate" in normalized) {
+    normalized.coordinate = normalizeStaticCoordinate(normalized.coordinate);
+  }
+  if ("coordinates" in normalized) {
+    normalized.coordinates = normalizeStaticCoordinates(normalized.coordinates);
+  }
+  return normalized;
+}
+function normalizeStaticCoordinate(coordinate) {
+  return [roundNumber(coordinate[0]), roundNumber(coordinate[1])];
+}
+function normalizeStaticCoordinates(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
+    return normalizeStaticCoordinate(value);
+  }
+  return value.map(normalizeStaticCoordinates);
+}
+
+export {
+  stableStringify,
+  roundNumber,
+  stripUndefined,
+  jsonByteLength,
+  hashStableValue,
+  isSafeHttpUrl,
+  staticSceneSchemaVersion,
+  staticSceneLimits,
+  staticOverlaySchema,
+  staticSceneSchema,
+  normalizeStaticOverlay,
+  normalizeStaticCoordinate
+};

package/dist/client.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { d as StaticSceneInput } from './scene-contract-DzsUeJ_V.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-QCR76BUO.js";
+import "./chunk-ROBEGDDY.js";
+import {
+  stableStringify
+} from "./chunk-YUG3PBK2.js";
+export {
+  createStaticMap,
+  createStaticMapIdempotencyKey,
+  precacheStaticMap,
+  prepareStaticMapRequest,
+  requestStaticMapUntilReady,
+  stableStringify,
+  staticMapProcessingResultSchema,
+  staticMapReadyResultSchema,
+  validateStaticMapIdempotencyKey
+};