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

package/README.md

@@ -20,19 +20,67 @@ import {
 const scene = validateStaticScene({
   map: 'madrid',
   theme: 'dark',
+  format: 'webp',
   camera: {type: 'auto', padding: 24},
-  size: {width: 1200, height: 800},
+  size: {width: 600, height: 400, dpr: 2},
   overlays: [marker({coordinate: [-3.7038, 40.4168]})],
 });
 
 if (!scene.ok) throw new Error(scene.error);
 
-await precacheStaticMap(scene.scene, {
+const result = await precacheStaticMap(scene.scene, {
   apiKey: process.env.TILEFLOW_API_KEY,
   idempotencyKey: createStaticMapIdempotencyKey(),
 });
+
+console.log(result.attribution.entries);
 ```
 
+`width` and `height` are logical CSS pixels. `dpr` accepts 1 or 2 and defaults to 1, so a 600 by
+400 scene at DPR 2 produces a 1200 by 800 image without changing camera, padding, or overlay paint
+sizes. Logical dimensions may reach 2048 per axis; the physical budget permits 4096 by 4096 output,
+or 16,777,216 total pixels.
+
+`format` accepts `png`, `jpeg`, or `webp` and defaults to PNG. PNG's canonical default stays omitted,
+so explicit and omitted PNG requests share identity. JPEG and WebP use a fixed encoder quality;
+there is no public quality option.
+
+## Attribution
+
+New renders default to `attribution: {mode: 'embedded', position: 'auto'}` without adding that
+omitted default to the normalized scene. Hosted derives notices from the sources referenced by the
+exact selected Style and embeds a safe, compact block. Automatic placement prefers an unobstructed
+corner, then the least interfering corner among declared request overlays. Explicit center and
+bounds cameras never move.
+
+Choose a corner when composition requires it:
+
+```ts
+attribution: {mode: 'embedded', position: 'bottom-left'}
+```
+
+Or request structured external attribution:
+
+```ts
+const result = await createStaticMap(
+  {...scene.scene, attribution: {mode: 'external'}},
+  {
+    apiKey: process.env.TILEFLOW_API_KEY,
+    idempotencyKey: createStaticMapIdempotencyKey(),
+  },
+);
+
+for (const entry of result.attribution.entries) {
+  renderAttributionText(entry.text, entry.links);
+}
+```
+
+External mode leaves the image unchanged and returns `position: null`. The caller must retain and
+display every returned entry beside the image. Entries contain bounded plain text, safe HTTP(S)
+links, and `platform-notice` or `team-declared` authority; they never contain source HTML or private
+resource IDs. Embedded results return the resolved corner. Changing mode or requested position
+changes scene and artifact identity.
+
 ## Automatic framing
 
 `camera.type: 'auto'` fits the complete nominal footprint of every declared marker, circle, line,
@@ -68,7 +116,8 @@ reason, and bounded details. `validateStaticScene` returns that document; reques
 `StaticMapRequestError` either locally or from the Hosted response. The reasons distinguish an empty
 scene, an ambiguous antimeridian path, an out-of-range overlay latitude, an insufficient viewport,
 a Globe visibility conflict, an unresolvable camera, and failed post-fit containment. Correct the
-scene; do not retry it unchanged.
+scene; do not retry it unchanged. Unsupported attribution grammar or glyphs, excessive attribution,
+and a block that cannot fit use the same non-retryable `422` boundary.
 
 The package has four deliberately separate surfaces, all available from the root for compatibility:
 
@@ -76,24 +125,28 @@ The package has four deliberately separate surfaces, all available from the root
   `normalizeStaticScene`;
 - overlay authoring and MapLibre compilation: `line`, `circle`, `marker`, `polygon`, and
   `compileStaticOverlays`;
-- renderer identity: `createRenderManifest`, `validateStaticRenderManifest`,
-  `hashRenderManifest`, and `hashStaticSceneRequest`;
+- renderer identity: `createRenderManifestV1`, `createRenderManifestV2`,
+  `validateStaticRenderManifest`, `hashRenderManifest`, and `hashStaticSceneRequest`;
 - bounded Hosted transport: `prepareStaticMapRequest`, `createStaticMap`, `precacheStaticMap`, and
   `requestStaticMapUntilReady`.
 
 Applications that need only one surface can use `@tileflow/static/scene`, `/overlays`, `/manifest`,
 or `/client`. The root remains a compatibility entry point.
 
-`StaticRenderManifest` is the immutable input contract between a resolved Hosted style and a Static
-Maps renderer. Its top-level `mapId` identifies that resolved destination while `scene.map` retains
-the portable map name supplied by the application. It is unrelated to the runtime delivery manifest
-generated by application build or deploy workflows.
+`StaticRenderManifest` is the versioned immutable input contract between a resolved Hosted style and
+a Static Maps renderer. Manifest v1 remains the exact historical no-attribution contract; new Hosted
+work uses strict v2 with resolved safe entries and immutable provenance. `createRenderManifest`
+remains the v1 compatibility alias. Its top-level `mapId` identifies the resolved destination while
+`scene.map` retains the portable map name supplied by the application. It is unrelated to the
+runtime delivery manifest generated by application build or deploy workflows.
 
 Create one idempotency key per intentional create/precache action and retain it across network
 retries. Reusing the key with the same normalized scene returns the stored result; reusing it with a
 different scene returns 409. A successful paid operation reports `unitCost: 15`, shared
 `remainingUnits`, its durable `operationId`, cache reuse, hash, and immutable image URL. An
-unbounded Starter service reports `remainingUnits: null`. A live
+unbounded Starter service reports `remainingUnits: null`. Creation helpers request strict result v2,
+including `resultVersion: 2` and required attribution. They reject a legacy success rather than
+claiming notices that were never produced. A live
 equal-hash render may return `202`; the helper polls with the same body/key within its bounded wait.
 `maxWaitMs` is the total client completion budget, including network, response parsing, and polling
 delays; `signal` cancels the same complete operation. The helper aborts in-flight work when either
@@ -106,7 +159,7 @@ the same normalized scene for its `sceneKey` and HTTP body, so equivalent omitte
 deduplicate consistently without duplicating the polling implementation.
 
 Free cannot initiate Static Maps work. Starter consumes 15 shared API units for each successful
-logical operation, including a distinct-key cache reuse. Downloading the immutable PNG consumes
-zero units.
+logical operation, including a distinct-key cache reuse. Downloading an immutable PNG, JPEG, or WebP
+consumes zero units.
 
 Docs: https://tileflow.dev/docs

package/dist/{chunk-NHQK5UZ2.js → chunk-EMCKSFZV.js}

@@ -8,7 +8,7 @@ import {
   staticSceneLimits,
   staticSceneSchema,
   stripUndefined
-} from "./chunk-MGQCHCU3.js";
+} from "./chunk-NM2JSFUF.js";
 
 // src/auto-fit.ts
 import { z } from "zod";
@@ -67,6 +67,21 @@ var staticMapRequestErrorResponseSchema = z.discriminatedUnion("code", [
     code: z.literal("STATIC_OVERLAY_INVALID"),
     details: staticOverlayInvalidDetailsSchema,
     reason: z.literal("OVERLAY_LATITUDE_OUT_OF_RANGE")
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("STATIC_MAP_ATTRIBUTION_UNSUPPORTED"),
+    reason: z.enum(["UNSUPPORTED_DECLARATION", "UNSUPPORTED_GLYPH"])
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("STATIC_MAP_ATTRIBUTION_TOO_LARGE"),
+    reason: z.literal("CONTENT_LIMIT_EXCEEDED")
+  }).strict(),
+  z.object({
+    ...autoFitErrorBase,
+    code: z.literal("STATIC_MAP_ATTRIBUTION_DOES_NOT_FIT"),
+    reason: z.literal("BLOCK_DOES_NOT_FIT")
   }).strict()
 ]);
 var StaticMapRequestError = class extends Error {
@@ -398,6 +413,12 @@ function normalizeStaticScene(scene) {
 }
 function normalizeParsedStaticScene(parsed) {
   return stripUndefined({
+    ...parsed.attribution && Object.keys(parsed.attribution).length > 0 ? {
+      attribution: parsed.attribution.mode === "external" ? { mode: "external" } : stripUndefined({
+        mode: parsed.attribution.mode,
+        position: parsed.attribution.position
+      })
+    } : {},
     camera: parsed.camera.type === "center" ? {
       bearing: roundNumber(parsed.camera.bearing ?? 0),
       center: normalizeStaticCoordinate(parsed.camera.center),
@@ -414,6 +435,7 @@ function normalizeParsedStaticScene(parsed) {
       padding: normalizeAutoPadding(parsed.camera.padding, parsed.size),
       type: "auto"
     },
+    ...parsed.format && parsed.format !== "png" ? { format: parsed.format } : {},
     map: parsed.map,
     overlays: parsed.overlays.map(
       (overlay, index) => normalizeStaticOverlay({

package/dist/{chunk-KPT7PASB.js → chunk-EPOYQNNT.js}

@@ -1,7 +1,7 @@
 import {
   normalizeStaticOverlay,
   roundNumber
-} from "./chunk-MGQCHCU3.js";
+} from "./chunk-NM2JSFUF.js";
 
 // src/overlays.ts
 function line(input) {

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

@@ -2,16 +2,18 @@ import {
   StaticMapRequestError,
   staticMapRequestErrorResponseSchema,
   validateStaticScene
-} from "./chunk-NHQK5UZ2.js";
+} from "./chunk-EMCKSFZV.js";
 import {
   isSafeHttpUrl,
+  jsonByteLength,
   stableStringify
-} from "./chunk-MGQCHCU3.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(),
@@ -22,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),
@@ -92,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
   };
@@ -119,7 +155,7 @@ async function requestStaticMapUntilReady(request, options) {
       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}`
@@ -140,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) {
@@ -317,7 +359,11 @@ function hasControlCharacter(value) {
 }
 
 export {
+  STATIC_MAP_RESULT_V2_MEDIA_TYPE,
   staticMapReadyResultSchema,
+  staticMapAttributionEntrySchema,
+  staticMapAttributionResultSchema,
+  staticMapHostedResultSchema,
   staticMapProcessingResultSchema,
   validateStaticMapIdempotencyKey,
   createStaticMapIdempotencyKey,

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

@@ -51,11 +51,11 @@ 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, {
@@ -79,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"
   }
@@ -178,7 +198,9 @@ var staticOverlaySchema = z.discriminatedUnion("type", [
   polygonOverlaySchema
 ]);
 var staticSceneSchema = z.object({
+  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,
@@ -220,6 +242,8 @@ export {
   staticSceneSchemaVersion,
   MAX_OVERLAY_LATITUDE,
   staticSceneLimits,
+  staticAttributionPositionSchema,
+  staticAttributionRequestSchema,
   staticPaddingSchema,
   staticOverlaySchema,
   staticSceneSchema,

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
+};