@tileflow/static 0.1.0-alpha.26 → 0.1.0-alpha.28

package/dist/chunk-RGXE4HDY.js

@@ -1,380 +0,0 @@
-import {
-  StaticMapError,
-  StaticMapRequestError,
-  staticMapErrorResponseSchema,
-  staticMapRequestErrorResponseSchema,
-  validateStaticScene
-} from "./chunk-TBI5AED6.js";
-import {
-  isSafeHttpUrl,
-  jsonByteLength,
-  stableStringify
-} from "./chunk-6DWVCK64.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 STATIC_MAP_RESULT_MEDIA_TYPE = "application/vnd.tileflow.static-map-result+json;version=1";
-var preparedStaticMapRequestBodies = /* @__PURE__ */ new WeakMap();
-var staticMapReadyResultBaseSchema = 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 safeAttributionTextSchema = z.string().min(1).max(16384).refine(hasNoControlCharacters, { message: "Attribution text contains control characters" });
-var staticMapAttributionEntrySchema = z.object({
-  authority: z.enum(["platform-notice", "team-declared"]),
-  links: z.array(
-    z.object({
-      label: safeAttributionTextSchema,
-      url: z.string().trim().url().max(2048).refine(isSafeHttpUrl, {
-        message: "Expected an http(s) URL without credentials or a fragment"
-      })
-    }).strict()
-  ).max(8),
-  text: safeAttributionTextSchema
-}).strict();
-var staticMapAttributionResultSchema = z.object({
-  entries: z.array(staticMapAttributionEntrySchema).max(18),
-  mode: z.enum(["embedded", "external"]),
-  position: z.enum(["top-left", "top-right", "bottom-left", "bottom-right"]).nullable()
-}).strict().superRefine((result, context) => {
-  if (result.mode === "external" && result.position !== null || result.mode === "embedded" && result.position === null) {
-    context.addIssue({
-      code: "custom",
-      message: "Attribution position must match its mode",
-      path: ["position"]
-    });
-  }
-  if (jsonByteLength(result) > 32 * 1024) {
-    context.addIssue({ code: "custom", message: "Attribution result exceeds 32 KiB" });
-  }
-});
-var staticMapHostedResultSchema = staticMapReadyResultBaseSchema.extend({
-  attribution: staticMapAttributionResultSchema,
-  resultVersion: z.literal(1)
-}).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) {
-    if (isStaticMapRequestFailure(validation)) {
-      const { ok: _ok, ...response } = validation;
-      throw new StaticMapRequestError(response);
-    }
-    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 = {
-    Accept: STATIC_MAP_RESULT_MEDIA_TYPE,
-    "Content-Type": "application/json",
-    "Idempotency-Key": idempotency.key
-  };
-  if (options.apiKey) {
-    headers.Authorization = `Bearer ${options.apiKey}`;
-  }
-  if (options.mapId !== void 0) {
-    if (!/^map_[A-Za-z0-9_-]{16}$/u.test(options.mapId)) {
-      throw new Error("Invalid Tileflow Map ID.");
-    }
-    headers["X-Tileflow-Map-Id"] = options.mapId;
-  }
-  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) {
-        const errorBody = await readStaticMapErrorBody(response, 8 * 1024);
-        throwIfAborted(signal);
-        if (response.status === 422) {
-          const requestError = staticMapRequestErrorResponseSchema.safeParse(errorBody);
-          if (requestError.success) {
-            throw new StaticMapRequestError(requestError.data, response.status);
-          }
-        }
-        const structured = staticMapErrorResponseSchema.safeParse(errorBody);
-        if (structured.success) {
-          throw new StaticMapError(structured.data, response.status);
-        }
-        throw new Error(`Tileflow static map failed (${response.status}).`);
-      }
-      const json = await readJsonResponse(response);
-      throwIfAborted(signal);
-      if (response.status !== 202) {
-        const parsed = staticMapHostedResultSchema.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 hasNoControlCharacters(value) {
-  return !Array.from(value).some((character) => {
-    const codePoint = character.codePointAt(0) ?? 0;
-    return codePoint <= 31 || codePoint === 127;
-  });
-}
-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 readStaticMapErrorBody(response, maximumBytes) {
-  try {
-    const source = await readBoundedResponseText(response, maximumBytes, `${maximumBytes} bytes`);
-    return JSON.parse(source);
-  } catch {
-    return null;
-  }
-}
-function isStaticMapRequestFailure(value) {
-  if (!("code" in value)) return false;
-  const { ok: _ok, ...response } = value;
-  return staticMapRequestErrorResponseSchema.safeParse(response).success;
-}
-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 {
-  STATIC_MAP_RESULT_MEDIA_TYPE,
-  staticMapAttributionEntrySchema,
-  staticMapAttributionResultSchema,
-  staticMapHostedResultSchema,
-  staticMapProcessingResultSchema,
-  validateStaticMapIdempotencyKey,
-  createStaticMapIdempotencyKey,
-  prepareStaticMapRequest,
-  createStaticMap,
-  precacheStaticMap,
-  requestStaticMapUntilReady
-};

package/dist/chunk-XMT7VJL5.js

@@ -1,297 +0,0 @@
-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/index.d.ts

@@ -1,7 +0,0 @@
-export { StaticAutoFitErrorResponse, StaticAutoFitFailure, StaticMapRequestError, StaticMapRequestErrorResponse, StaticMapRequestFailure, normalizeStaticScene, staticMapRequestErrorResponseSchema, validateStaticScene } from './scene.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';