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

package/dist/{chunk-QCR76BUO.js → chunk-MSQ4OLKA.js}

@@ -1,15 +1,19 @@
 import {
+  StaticMapRequestError,
+  staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-ROBEGDDY.js";
+} from "./chunk-EMCKSFZV.js";
 import {
   isSafeHttpUrl,
+  jsonByteLength,
   stableStringify
-} from "./chunk-YUG3PBK2.js";
+} from "./chunk-NM2JSFUF.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_V2_MEDIA_TYPE = "application/vnd.tileflow.static-map-result+json;version=2";
 var preparedStaticMapRequestBodies = /* @__PURE__ */ new WeakMap();
 var staticMapReadyResultSchema = z.object({
   cached: z.boolean(),
@@ -20,6 +24,39 @@ var staticMapReadyResultSchema = z.object({
   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 = staticMapReadyResultSchema.extend({
+  attribution: staticMapAttributionResultSchema,
+  resultVersion: z.literal(2)
+}).strict();
 var staticMapProcessingResultSchema = z.object({
   operationId: z.string().min(20).max(68),
   retryAfterMs: z.number().int().min(0).max(5e3),
@@ -44,6 +81,10 @@ function createStaticMapIdempotencyKey() {
 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({
@@ -86,6 +127,7 @@ async function requestStaticMapUntilReady(request, options) {
   const fetcher = options.fetch ?? fetch;
   const createUrl = normalizeStaticMapEndpointUrl(options.createUrl);
   const headers = {
+    Accept: STATIC_MAP_RESULT_V2_MEDIA_TYPE,
     "Content-Type": "application/json",
     "Idempotency-Key": idempotency.key
   };
@@ -103,14 +145,17 @@ async function requestStaticMapUntilReady(request, options) {
       });
       throwIfAborted(signal);
       if (!response.ok) {
-        await discardBoundedResponse(response, 8 * 1024);
+        const requestError = response.status === 422 ? await readStaticMapRequestErrorResponse(response, 8 * 1024) : await discardBoundedResponse(response, 8 * 1024);
         throwIfAborted(signal);
+        if (requestError) {
+          throw new StaticMapRequestError(requestError, response.status);
+        }
         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);
+        const parsed = staticMapHostedResultSchema.safeParse(json);
         if (!parsed.success) {
           throw new Error(
             `Tileflow static map returned an invalid response: ${parsed.error.message}`
@@ -131,6 +176,12 @@ async function requestStaticMapUntilReady(request, options) {
     }
   });
 }
+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) {
@@ -148,11 +199,26 @@ async function readJsonResponse(response) {
     throw new Error("Tileflow static map returned an invalid response: expected JSON");
   }
 }
+async function readStaticMapRequestErrorResponse(response, maximumBytes) {
+  try {
+    const source = await readBoundedResponseText(response, maximumBytes, `${maximumBytes} bytes`);
+    const parsed = staticMapRequestErrorResponseSchema.safeParse(JSON.parse(source));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
 async function discardBoundedResponse(response, maximumBytes) {
   try {
     await readBoundedResponseText(response, maximumBytes, `${maximumBytes} bytes`);
   } 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 "";
@@ -293,7 +359,11 @@ function hasControlCharacter(value) {
 }
 
 export {
+  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
   staticMapReadyResultSchema,
+  staticMapAttributionEntrySchema,
+  staticMapAttributionResultSchema,
+  staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
   validateStaticMapIdempotencyKey,
   createStaticMapIdempotencyKey,

package/dist/{chunk-YUG3PBK2.js → chunk-NM2JSFUF.js}

@@ -49,17 +49,24 @@ function base64Url(bytes) {
 // src/scene-contract.ts
 import { z } from "zod";
 var staticSceneSchemaVersion = 1;
+var MAX_OVERLAY_LATITUDE = 85.051129;
 var staticSceneLimits = {
-  maxDimension: 1280,
+  maxDimension: 2048,
   maxGeoJsonBytes: 96e3,
   maxOverlays: 24,
   maxPathCoordinates: 2e3,
-  maxPhysicalPixels: 1280 * 1280,
+  maxPhysicalPixels: 2048 * 2048 * 4,
   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 overlayCoordinateSchema = coordinateSchema.refine(
+  ([, latitude]) => Math.abs(latitude) <= MAX_OVERLAY_LATITUDE,
+  {
+    message: `Static overlay latitude must be within \xB1${MAX_OVERLAY_LATITUDE}\xB0`
+  }
+);
 var colorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, {
   message: "Expected a hex color like #C6A15B"
 });
@@ -72,12 +79,32 @@ var portableIdSchema = z.string().min(1).max(64).regex(/^[a-z][a-z0-9-]{0,63}$/u
 var concreteThemeSchema = portableIdSchema.refine((value) => value !== "system", {
   message: 'Static maps require a concrete theme; "system" is browser-only'
 });
+var staticMapFormatSchema = z.enum(["png", "jpeg", "webp"]);
+var staticAttributionPositionSchema = z.enum([
+  "auto",
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+]);
+var staticAttributionRequestSchema = z.union([
+  z.object({
+    mode: z.literal("embedded").optional(),
+    position: staticAttributionPositionSchema.optional()
+  }).strict(),
+  z.object({
+    mode: z.literal("external")
+  }).strict()
+]);
 var sizeSchema = z.object({
-  dpr: z.literal(1).optional(),
+  dpr: z.union([z.literal(1), z.literal(2)]).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,
+  (size) => {
+    const dpr = size.dpr ?? 1;
+    return size.width * size.height * dpr * dpr <= staticSceneLimits.maxPhysicalPixels;
+  },
   {
     message: "Static map exceeds the maximum render pixel budget"
   }
@@ -99,9 +126,30 @@ var boundsCameraSchema = z.object({
 }).refine((camera) => camera.bounds[3] > camera.bounds[1], {
   message: "Bounds north must be greater than south"
 });
+var staticPaddingSchema = z.object({
+  bottom: z.number().int().nonnegative(),
+  left: z.number().int().nonnegative(),
+  right: z.number().int().nonnegative(),
+  top: z.number().int().nonnegative()
+}).strict();
+var autoPaddingInputSchema = z.union([
+  z.number().int().nonnegative(),
+  z.object({
+    bottom: z.number().int().nonnegative().optional(),
+    left: z.number().int().nonnegative().optional(),
+    right: z.number().int().nonnegative().optional(),
+    top: z.number().int().nonnegative().optional()
+  }).strict()
+]);
+var autoCameraSchema = z.object({
+  bearing: z.number().finite().min(-180).max(180).optional(),
+  maxZoom: z.number().finite().min(0).max(22).optional(),
+  padding: autoPaddingInputSchema.optional(),
+  type: z.literal("auto")
+});
 var lineOverlaySchema = z.object({
   color: colorSchema.default("#C6A15B"),
-  coordinates: z.array(coordinateSchema).min(2).max(staticSceneLimits.maxPathCoordinates),
+  coordinates: z.array(overlayCoordinateSchema).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"),
@@ -109,7 +157,7 @@ var lineOverlaySchema = z.object({
 });
 var circleOverlaySchema = z.object({
   color: colorSchema.default("#C6A15B"),
-  coordinate: coordinateSchema,
+  coordinate: overlayCoordinateSchema,
   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),
@@ -119,14 +167,14 @@ var circleOverlaySchema = z.object({
 });
 var markerOverlaySchema = z.object({
   color: colorSchema.default("#C6A15B"),
-  coordinate: coordinateSchema,
+  coordinate: overlayCoordinateSchema,
   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(
+var polygonRingSchema = z.array(overlayCoordinateSchema).min(4).max(staticSceneLimits.maxPathCoordinates).refine(
   (ring) => {
     const first = ring[0];
     const last = ring[ring.length - 1];
@@ -150,7 +198,9 @@ var staticOverlaySchema = z.discriminatedUnion("type", [
   polygonOverlaySchema
 ]);
 var staticSceneSchema = z.object({
-  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema]),
+  attribution: staticAttributionRequestSchema.optional(),
+  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema, autoCameraSchema]),
+  format: staticMapFormatSchema.optional(),
   map: portableIdSchema,
   overlays: z.array(staticOverlaySchema).max(staticSceneLimits.maxOverlays).default([]),
   size: sizeSchema,
@@ -190,7 +240,11 @@ export {
   hashStableValue,
   isSafeHttpUrl,
   staticSceneSchemaVersion,
+  MAX_OVERLAY_LATITUDE,
   staticSceneLimits,
+  staticAttributionPositionSchema,
+  staticAttributionRequestSchema,
+  staticPaddingSchema,
   staticOverlaySchema,
   staticSceneSchema,
   normalizeStaticOverlay,

package/dist/chunk-TQMKOTBE.js

@@ -0,0 +1,287 @@
+import {
+  analyzeStaticAutoFit,
+  normalizeStaticScene,
+  staticAutoFitPlanSchema,
+  validateStaticScene
+} from "./chunk-EMCKSFZV.js";
+import {
+  hashStableValue,
+  isSafeHttpUrl,
+  jsonByteLength,
+  stableStringify,
+  staticSceneSchema,
+  stripUndefined
+} from "./chunk-NM2JSFUF.js";
+
+// src/manifest.ts
+import { z } from "zod";
+var staticRendererSchemaVersionV1 = 1;
+var staticRendererSchemaVersion = 2;
+var staticAttributionPlanSchemaVersion = 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 staticAttributionPlanSchemaV1 = 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 staticRenderManifestBaseShape = {
+  autoFit: staticAutoFitPlanSchema.optional(),
+  mapId: z.string().trim().min(1).max(128),
+  rendererVersion: z.string().trim().min(1).max(64),
+  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
+]);
+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) {
+    return { error: "manifest.schemaVersion: Unsupported renderer schema version", ok: false };
+  }
+  const rawScene = input.scene;
+  const sceneValidation = validateVersionedScene(rawScene, schemaVersion);
+  if (!sceneValidation.ok) return sceneValidation;
+  const schema = schemaVersion === staticRendererSchemaVersionV1 ? staticRenderManifestV1Schema : staticRenderManifestV2Schema;
+  const parsed = schema.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 (schemaVersion === staticRendererSchemaVersion && (!("attribution" in parsed.data) || !attributionMatchesScene(parsed.data.attribution, sceneValidation.scene))) {
+    return {
+      error: "manifest.attribution: Expected the exact request resolved from scene",
+      ok: false
+    };
+  }
+  return {
+    manifest: {
+      ...parsed.data,
+      ...autoFit === void 0 ? {} : { autoFit },
+      scene: sceneValidation.scene
+    },
+    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) {
+  const scene = normalizeStaticScene(input.scene);
+  const autoFit = expectedAutoFit(scene);
+  return staticRenderManifestV2Schema.parse(
+    stripUndefined({
+      attribution: input.attribution,
+      autoFit,
+      mapId: input.mapId,
+      rendererVersion: input.rendererVersion,
+      schemaVersion: staticRendererSchemaVersion,
+      scene,
+      styleId: input.styleId,
+      styleRevision: input.styleRevision,
+      styleUrl: input.styleUrl
+    })
+  );
+}
+async function hashRenderManifest(manifest) {
+  const validation = validateStaticRenderManifest(manifest);
+  if (!validation.ok) throw new Error(`Invalid Tileflow render manifest: ${validation.error}`);
+  return hashStableValue(validation.manifest);
+}
+async function hashStaticSceneRequest(scene) {
+  const validation = validateStaticScene(scene);
+  if (!validation.ok) throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
+  return hashStableValue(validation.scene);
+}
+function 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 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 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 {
+  staticRendererSchemaVersionV1,
+  staticRendererSchemaVersion,
+  staticAttributionPlanSchemaVersion,
+  staticAttributionLimits,
+  staticAttributionSegmentSchema,
+  staticAttributionProvenanceSchema,
+  staticAttributionEntrySchema,
+  staticAttributionPlanSchemaV1,
+  staticRenderManifestV1Schema,
+  staticRenderManifestV2Schema,
+  staticRenderManifestSchema,
+  validateStaticRenderManifest,
+  createRenderManifestV1,
+  createRenderManifest,
+  createRenderManifestV2,
+  hashRenderManifest,
+  hashStaticSceneRequest
+};