@tileflow/capture 0.1.0-alpha.28 → 0.1.0-alpha.30

package/README.md

@@ -106,6 +106,66 @@ The equivalent CLI command is `tileflow setup capture`. These settings control b
 not the network access required by a map's remote resources. Tileflow never deletes the shared
 per-user browser cache.
 
+## Render a timed shot
+
+A [capture shot](https://github.com/tileflow/tileflow-sdk/blob/main/packages/core/docs/capture-shots.md)
+is a committed camera move with keyframes and an optional theme blend. This module assumes a
+`dusk-flyover` shot in `tileflow.config.ts` and writes its WebM video and receipt:
+
+<!-- docs:check -->
+
+```ts
+import {mkdir, writeFile} from 'node:fs/promises';
+import {captureTileflowShot, serializeTileflowShotReceipt} from '@tileflow/capture';
+
+const shot = await captureTileflowShot({shot: 'dusk-flyover', allowBrowserInstall: true});
+if (!shot.video) throw new Error('The shot produced no video.');
+
+await mkdir('.tileflow/captures/shots', {recursive: true});
+await writeFile('.tileflow/captures/shots/dusk-flyover.webm', shot.video);
+await writeFile(
+  '.tileflow/captures/shots/dusk-flyover.receipt.json',
+  serializeTileflowShotReceipt(shot.receipt),
+);
+console.log(shot.frameCount, shot.codec, shot.framesSha256);
+```
+
+Every frame moves the camera with MapLibre `jumpTo`, moves the blend position, and waits for
+MapLibre `idle` and two animation frames before its screenshot, exactly as a scene does. A slow
+machine or network makes the render take longer; the video keeps its frame rate and shows every
+frame. `timeoutMs` bounds page setup and each frame separately.
+
+The pinned browser encodes the captured PNGs with WebCodecs: VP9, or VP8 where VP9 is unavailable.
+A browser that supports neither fails before the first frame with `VIDEO_ENCODER_UNAVAILABLE`.
+Use `format: 'frames'` to receive the PNG frames through `onFrame` instead of a video; frames are
+delivered in order and are not kept in memory:
+
+<!-- docs:check -->
+
+```ts
+import {mkdir, writeFile} from 'node:fs/promises';
+import {createTileflowCaptureSession} from '@tileflow/capture';
+
+await mkdir('frames', {recursive: true});
+const session = createTileflowCaptureSession({allowBrowserInstall: true});
+try {
+  const shot = await session.captureShot('dusk-flyover', {
+    format: 'frames',
+    onFrame: (frame) =>
+      writeFile(`frames/frame-${String(frame.index).padStart(4, '0')}.png`, frame.png),
+  });
+  console.log(shot.frameCount, shot.framesSha256);
+} finally {
+  await session.close();
+}
+```
+
+`captureShots` and `captureAllShots` render several shots from one compiled snapshot. A shot
+receipt records the shot, theme and blend styles, timing, dimensions, renderer, data identity, and
+`frames.sha256`, a digest of every frame's PNG SHA-256. Frames are reproducible under the same
+conditions as scene captures; encoder bytes may differ between runs, so `output.sha256` identifies
+the written video while `frames.sha256` identifies its pixels.
+
 ## Capture the running application
 
 Application capture uses the app's normal loopback server; it does not start a server or discover a
@@ -195,9 +255,9 @@ validation, browser startup, resource loading, MapLibre readiness, and screensho
 Resource diagnostics contain safe classification and origin/status information, not credentials,
 query strings, response bodies, raw browser stacks, or DOM contents.
 
-New receipts use schema version 4. Version-2 and version-3 receipts remain readable as historical
-evidence, not as newly verified version-4 captures. Import `@tileflow/capture/receipt` for receipt-only
-tooling without loading the capture runtime. World selectors resolve once per capture session to
+Receipts use schema version 4; parsing rejects any other version. Shot receipts use their own
+schema version 1. Import
+`@tileflow/capture/receipt` for receipt-only tooling without loading the capture runtime. World selectors resolve once per capture session to
 an immutable release. Capture retains the complete resolved TileJSON, including its zoom range,
 bounds, attribution and vector-layer metadata. Above the data's maximum zoom, MapLibre enlarges
 available tiles while preserving the scene camera. Retries reuse the same frozen metadata.

package/THIRD_PARTY_NOTICES.md

@@ -18,7 +18,7 @@ the platform-specific headless shell into its versioned per-user browser cache;
 distribution carries Chromium's license and credits. Chromium source and license information are
 available at https://www.chromium.org/chromium-projects/.
 
-## MapLibre GL JS 6.9.0
+## MapLibre GL JS 6.13.0
 
 Copyright (c) 2023 MapLibre contributors. Licensed under BSD-3-Clause. The installed `maplibre-gl`
 package includes `LICENSE.txt`, including notices for code derived from Mapbox GL JS and other

package/dist/{chunk-BSTB4FN6.js → chunk-BI5PWIH4.js}

@@ -4,9 +4,9 @@ import { types as nodeUtilTypes } from "util";
 import {
   isTileflowWorldReleaseId,
   serializeCanonicalJson,
-  tileflowCaptureIdSchema,
   tileflowCaptureSceneLimits,
   tileflowCaptureSceneNameSchema,
+  tileflowCaptureShotLimits,
   tileflowPortableIdSchema,
   tileflowThemeNameSchema
 } from "@tileflow/core";
@@ -132,11 +132,10 @@ function parseTileflowCaptureReceipt(source) {
 function validateTileflowCaptureReceipt(value) {
   assertPlainReceiptData(value);
   const receipt = requireRecord(value, "receipt");
-  const schemaVersion = receipt.schemaVersion;
-  if (schemaVersion !== 2 && schemaVersion !== 3 && schemaVersion !== tileflowCaptureReceiptSchemaVersion) {
+  if (receipt.schemaVersion !== tileflowCaptureReceiptSchemaVersion) {
     throw invalidReceipt("The baseline receipt schema version is unsupported.");
   }
-  const commonKeys = [
+  requireExactKeys(receipt, [
     "schemaVersion",
     "scene",
     "style",
@@ -144,18 +143,14 @@ function validateTileflowCaptureReceipt(value) {
     "renderer",
     "platform",
     "data",
-    ...schemaVersion === 2 && receipt.verification === void 0 ? [] : ["verification"],
+    "verification",
     "networkDependent"
-  ];
-  requireExactKeys(receipt, commonKeys);
+  ]);
   const scene = requireRecord(receipt.scene, "scene");
-  requireExactKeys(
-    scene,
-    schemaVersion === tileflowCaptureReceiptSchemaVersion ? ["name", "map", "theme", "target", "sha256"] : ["name", "map", "target", "sha256"]
-  );
+  requireExactKeys(scene, ["name", "map", "theme", "target", "sha256"]);
   const name = requireSceneName(scene.name);
-  const map = schemaVersion === tileflowCaptureReceiptSchemaVersion ? requirePortableIdentifier(scene.map, "scene.map") : requireIdentifier(scene.map, "scene.map");
-  const theme = schemaVersion === tileflowCaptureReceiptSchemaVersion ? requireConcreteTheme(scene.theme) : void 0;
+  const map = requirePortableIdentifier(scene.map, "scene.map");
+  const theme = requireConcreteTheme(scene.theme);
   if (scene.target !== "map" && scene.target !== "application") {
     throw invalidReceipt("The baseline receipt has an invalid scene target.");
   }
@@ -197,13 +192,13 @@ function validateTileflowCaptureReceipt(value) {
   if (typeof receipt.networkDependent !== "boolean") {
     throw invalidReceipt("The baseline receipt has an invalid network dependency flag.");
   }
-  const data = schemaVersion === 2 ? validateDataIdentityV2(receipt.data) : validateDataIdentityV3(receipt.data);
+  const data = validateDataIdentity(receipt.data);
   const normalized = {
-    schemaVersion,
+    schemaVersion: tileflowCaptureReceiptSchemaVersion,
     scene: {
       name,
       map,
-      ...theme === void 0 ? {} : { theme },
+      theme,
       target: scene.target,
       sha256: requireHash(scene.sha256, "scene.sha256")
     },
@@ -237,61 +232,220 @@ function validateTileflowCaptureReceipt(value) {
   assertCanonicalReceiptByteLimit(normalized);
   return normalized;
 }
-function validateDataIdentityV2(value) {
-  const data = requireRecord(value, "data");
-  if (data.url !== void 0 && data.source !== void 0) {
-    throw invalidReceipt(
-      "The baseline receipt data identity must not mix legacy and safe sources."
-    );
+var tileflowShotReceiptSchemaVersion = 1;
+var tileflowShotReceiptLimits = Object.freeze({ maximumBytes: 64 * 1024 });
+function createTileflowShotReceipt(input) {
+  return validateTileflowShotReceipt({
+    schemaVersion: tileflowShotReceiptSchemaVersion,
+    kind: "shot",
+    shot: { name: input.shot, map: input.map, theme: input.theme, sha256: input.shotSha256 },
+    style: { sha256: input.styleSha256 },
+    ...input.blend ? { blend: { themes: input.blend } } : {},
+    timing: { fps: input.fps, frameCount: input.frameCount, durationMs: input.durationMs },
+    image: {
+      cssWidth: input.width,
+      cssHeight: input.height,
+      physicalWidth: input.width * input.dpr,
+      physicalHeight: input.height * input.dpr,
+      dpr: input.dpr
+    },
+    frames: { sha256: input.framesSha256 },
+    output: input.output,
+    renderer: input.renderer,
+    platform: { os: process.platform, architecture: process.arch },
+    data: normalizeCaptureDataInput(input.data),
+    verification: { data: "rendered", style: "rendered" },
+    networkDependent: input.networkDependent
+  });
+}
+function serializeTileflowShotReceipt(receipt) {
+  const serialized = `${serializeCanonicalJson(validateTileflowShotReceipt(receipt))}
+`;
+  if (new TextEncoder().encode(serialized).byteLength > tileflowShotReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The shot receipt exceeds the supported byte limit.");
   }
-  requireExactKeys(data, [
-    ...data.bindings === void 0 ? [] : ["bindings"],
-    ...data.capabilities === void 0 ? [] : ["capabilities"],
-    "kind",
-    ...data.generation === void 0 ? [] : ["generation"],
-    ...data.revision === void 0 ? [] : ["revision"],
-    "schema",
+  return serialized;
+}
+function parseTileflowShotReceipt(source) {
+  const byteLength = typeof source === "string" ? new TextEncoder().encode(source).byteLength : source.byteLength;
+  if (byteLength > tileflowShotReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The shot receipt exceeds the supported byte limit.");
+  }
+  let value;
+  let text;
+  try {
+    text = typeof source === "string" ? source : new TextDecoder("utf-8", { fatal: true }).decode(source);
+    value = JSON.parse(text);
+  } catch (error) {
+    throw invalidReceipt("The shot receipt is not valid UTF-8 JSON.", error);
+  }
+  const receipt = validateTileflowShotReceipt(value);
+  if (text.trim() !== serializeCanonicalJson(value)) {
+    throw invalidReceipt("The shot receipt is not canonical JSON.");
+  }
+  return receipt;
+}
+function validateTileflowShotReceipt(value) {
+  assertPlainReceiptData(value, "receipt", {
+    allowArrays: true,
+    ancestors: /* @__PURE__ */ new WeakSet(),
+    nodes: 0
+  });
+  const receipt = requireRecord(value, "receipt");
+  if (receipt.schemaVersion !== tileflowShotReceiptSchemaVersion || receipt.kind !== "shot") {
+    throw invalidReceipt("The shot receipt schema version is unsupported.");
+  }
+  requireExactKeys(receipt, [
     "schemaVersion",
-    ...data.semantics === void 0 ? [] : ["semantics"],
-    "sourceId",
-    ...data.source === void 0 ? [] : ["source"],
-    ...data.url === void 0 ? [] : ["url"]
+    "kind",
+    "shot",
+    "style",
+    ...receipt.blend === void 0 ? [] : ["blend"],
+    "timing",
+    "image",
+    "frames",
+    "output",
+    "renderer",
+    "platform",
+    "data",
+    "verification",
+    "networkDependent"
   ]);
-  if (data.kind !== "tileflow-world" && data.kind !== "vector-tiles") {
-    throw invalidReceipt("The baseline receipt has an invalid data.kind.");
+  const shot = requireRecord(receipt.shot, "shot");
+  requireExactKeys(shot, ["name", "map", "theme", "sha256"]);
+  const style = requireRecord(receipt.style, "style");
+  requireExactKeys(style, ["sha256"]);
+  const blend = receipt.blend === void 0 ? void 0 : validateShotBlend(receipt.blend);
+  const timing = requireRecord(receipt.timing, "timing");
+  requireExactKeys(timing, ["fps", "frameCount", "durationMs"]);
+  const fps = timing.fps;
+  if (fps !== 24 && fps !== 25 && fps !== 30 && fps !== 50 && fps !== 60) {
+    throw invalidReceipt("The shot receipt has an invalid timing.fps.");
+  }
+  const frameCount = requirePositiveInteger(timing.frameCount, "timing.frameCount");
+  const durationMs = requirePositiveInteger(timing.durationMs, "timing.durationMs");
+  if (durationMs > tileflowCaptureShotLimits.durationMs.maximum || frameCount > tileflowCaptureShotLimits.maximumFrames || frameCount !== Math.floor(durationMs * fps / 1e3 + 1e-9) + 1) {
+    throw invalidReceipt("The shot receipt timing is inconsistent.");
   }
-  if (data.schema !== "openmaptiles" || data.sourceId !== "tileflow") {
-    throw invalidReceipt("The baseline receipt has an unsupported data contract.");
+  const image = requireRecord(receipt.image, "image");
+  requireExactKeys(image, ["cssWidth", "cssHeight", "physicalWidth", "physicalHeight", "dpr"]);
+  const cssWidth = requirePositiveInteger(image.cssWidth, "image.cssWidth");
+  const cssHeight = requirePositiveInteger(image.cssHeight, "image.cssHeight");
+  const physicalWidth = requirePositiveInteger(image.physicalWidth, "image.physicalWidth");
+  const physicalHeight = requirePositiveInteger(image.physicalHeight, "image.physicalHeight");
+  if (image.dpr !== 1 && image.dpr !== 2) {
+    throw invalidReceipt("The shot receipt has an invalid image DPR.");
   }
-  if (data.kind === "tileflow-world") {
-    const hasGeneration = data.generation !== void 0;
-    const hasLegacyRevision = data.revision !== void 0;
-    if (hasGeneration === hasLegacyRevision) {
-      throw invalidReceipt(
-        "The baseline receipt must identify World by one generation or one legacy revision."
-      );
+  if (cssWidth * image.dpr !== physicalWidth || cssHeight * image.dpr !== physicalHeight) {
+    throw invalidReceipt("The shot receipt image dimensions are inconsistent.");
+  }
+  if (physicalWidth > tileflowCaptureSceneLimits.viewport.maximum || physicalHeight > tileflowCaptureSceneLimits.viewport.maximum || physicalWidth * physicalHeight > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+    throw invalidReceipt("The shot receipt image exceeds the supported pixel limit.");
+  }
+  const frames = requireRecord(receipt.frames, "frames");
+  requireExactKeys(frames, ["sha256"]);
+  const framesSha256 = requireHash(frames.sha256, "frames.sha256");
+  const output = requireRecord(receipt.output, "output");
+  if (output.kind === "webm") {
+    requireExactKeys(output, ["kind", "codec", "sha256"]);
+    if (output.codec !== "vp8" && output.codec !== "vp9") {
+      throw invalidReceipt("The shot receipt has an invalid output.codec.");
     }
-  } else if (data.generation !== void 0) {
-    throw invalidReceipt("The baseline receipt has an invalid data.generation.");
+  } else if (output.kind === "frames") {
+    requireExactKeys(output, ["kind", "sha256"]);
+    if (output.sha256 !== framesSha256) {
+      throw invalidReceipt("The shot receipt frame output does not match its frames.");
+    }
+  } else {
+    throw invalidReceipt("The shot receipt has an invalid output.kind.");
   }
-  const bindings = data.bindings === void 0 ? void 0 : validateDataBindings(data.bindings, "data.bindings");
-  const capabilities = data.capabilities === void 0 ? void 0 : validateDataCapabilities(data.capabilities, "data.capabilities");
-  const source = data.source === void 0 ? data.url === void 0 ? void 0 : fingerprintLegacyDataUrl(data.url) : validateDataSource(data.source, "data.source");
-  const semantics = data.semantics === void 0 ? void 0 : validateDataSemantics(data.semantics, "data.semantics");
-  return {
-    ...bindings ? { bindings } : {},
-    ...capabilities ? { capabilities } : {},
-    ...data.generation === void 0 ? {} : { generation: requireWorldGeneration(data.generation) },
-    kind: data.kind,
-    ...data.revision === void 0 ? {} : { revision: requireSourceRevision(data.revision) },
-    schema: data.schema,
-    schemaVersion: requirePositiveInteger(data.schemaVersion, "data.schemaVersion"),
-    ...semantics ? { semantics } : {},
-    sourceId: data.sourceId,
-    ...source ? { source } : {}
+  const renderer = requireRecord(receipt.renderer, "renderer");
+  requireExactKeys(renderer, [
+    "tileflow",
+    "maplibre",
+    "playwright",
+    "chromiumRevision",
+    "chromiumVersion"
+  ]);
+  const platform = requireRecord(receipt.platform, "platform");
+  requireExactKeys(platform, ["os", "architecture"]);
+  const verification = requireRecord(receipt.verification, "verification");
+  requireExactKeys(verification, ["data", "style"]);
+  if (verification.data !== "rendered" || verification.style !== "rendered") {
+    throw invalidReceipt("The shot receipt verification must record rendered style and data.");
+  }
+  if (typeof receipt.networkDependent !== "boolean") {
+    throw invalidReceipt("The shot receipt has an invalid network dependency flag.");
+  }
+  const normalized = {
+    schemaVersion: tileflowShotReceiptSchemaVersion,
+    kind: "shot",
+    shot: {
+      name: requireSceneName(shot.name),
+      map: requirePortableIdentifier(shot.map, "shot.map"),
+      theme: requireShotTheme(shot.theme, "shot.theme"),
+      sha256: requireHash(shot.sha256, "shot.sha256")
+    },
+    style: { sha256: requireHash(style.sha256, "style.sha256") },
+    ...blend ? { blend } : {},
+    timing: { fps, frameCount, durationMs },
+    image: { cssWidth, cssHeight, physicalWidth, physicalHeight, dpr: image.dpr },
+    frames: { sha256: framesSha256 },
+    output: output.kind === "webm" ? {
+      kind: "webm",
+      codec: output.codec,
+      sha256: requireHash(output.sha256, "output.sha256")
+    } : { kind: "frames", sha256: framesSha256 },
+    renderer: {
+      tileflow: requireBoundedString(renderer.tileflow, "renderer.tileflow"),
+      maplibre: requireBoundedString(renderer.maplibre, "renderer.maplibre"),
+      playwright: requireBoundedString(renderer.playwright, "renderer.playwright"),
+      chromiumRevision: requireBoundedString(
+        renderer.chromiumRevision,
+        "renderer.chromiumRevision"
+      ),
+      chromiumVersion: requireBoundedString(renderer.chromiumVersion, "renderer.chromiumVersion")
+    },
+    platform: {
+      os: requireBoundedString(platform.os, "platform.os"),
+      architecture: requireBoundedString(platform.architecture, "platform.architecture")
+    },
+    data: validateDataIdentity(receipt.data),
+    verification: { data: "rendered", style: "rendered" },
+    networkDependent: receipt.networkDependent
   };
+  const serialized = `${serializeCanonicalJson(normalized)}
+`;
+  if (new TextEncoder().encode(serialized).byteLength > tileflowShotReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The shot receipt exceeds the supported byte limit.");
+  }
+  return normalized;
 }
-function validateDataIdentityV3(value) {
+function requireShotTheme(value, field) {
+  const result = tileflowThemeNameSchema.safeParse(value);
+  if (!result.success) throw invalidReceipt(`The shot receipt has an invalid ${field}.`);
+  return result.data;
+}
+function validateShotBlend(value) {
+  const blend = requireRecord(value, "blend");
+  requireExactKeys(blend, ["themes"]);
+  if (!Array.isArray(blend.themes) || blend.themes.length < tileflowCaptureShotLimits.blendThemes.minimum || blend.themes.length > tileflowCaptureShotLimits.blendThemes.maximum) {
+    throw invalidReceipt("The shot receipt has an invalid blend.themes list.");
+  }
+  const themes = blend.themes.map((entry, index) => {
+    const theme = requireRecord(entry, `blend.themes.${index}`);
+    requireExactKeys(theme, ["name", "styleSha256"]);
+    return {
+      name: requireShotTheme(theme.name, `blend.themes.${index}.name`),
+      styleSha256: requireHash(theme.styleSha256, `blend.themes.${index}.styleSha256`)
+    };
+  });
+  if (new Set(themes.map((theme) => theme.name)).size !== themes.length) {
+    throw invalidReceipt("The shot receipt blends a theme more than once.");
+  }
+  return { themes };
+}
+function validateDataIdentity(value) {
   const data = requireRecord(value, "data");
   if (data.kind === "tileflow-world") {
     requireExactKeys(data, [
@@ -304,13 +458,12 @@ function validateDataIdentityV3(value) {
       "releaseId",
       "schema",
       "schemaVersion",
-      ...data.semantics === void 0 ? [] : ["semantics"],
+      "semantics",
       "sourceId"
     ]);
     if (data.product !== "world-v1" || data.schema !== "openmaptiles" || data.sourceId !== "tileflow") {
       throw invalidReceipt("The baseline receipt has an unsupported World data contract.");
     }
-    const semantics2 = data.semantics === void 0 ? void 0 : validateDataSemantics(data.semantics, "data.semantics");
     return {
       archiveSha256: requireHash(data.archiveSha256, "data.archiveSha256"),
       contractSha256: requireHash(data.contractSha256, "data.contractSha256"),
@@ -321,7 +474,7 @@ function validateDataIdentityV3(value) {
       releaseId: requireWorldReleaseId(data.releaseId),
       schema: "openmaptiles",
       schemaVersion: requirePositiveInteger(data.schemaVersion, "data.schemaVersion"),
-      ...semantics2 ? { semantics: semantics2 } : {},
+      semantics: validateDataSemantics(data.semantics, "data.semantics"),
       sourceId: "tileflow"
     };
   }
@@ -329,41 +482,35 @@ function validateDataIdentityV3(value) {
     throw invalidReceipt("The baseline receipt has an invalid data.kind.");
   }
   requireExactKeys(data, [
-    ...data.bindings === void 0 ? [] : ["bindings"],
-    ...data.capabilities === void 0 ? [] : ["capabilities"],
+    "bindings",
+    "capabilities",
     "kind",
     ...data.revision === void 0 ? [] : ["revision"],
     "schema",
     "schemaVersion",
-    ...data.semantics === void 0 ? [] : ["semantics"],
-    "sourceId",
-    ...data.source === void 0 ? [] : ["source"]
+    "semantics",
+    "source",
+    "sourceId"
   ]);
   if (data.schema !== "openmaptiles" || data.sourceId !== "tileflow") {
     throw invalidReceipt("The baseline receipt has an unsupported data contract.");
   }
-  const bindings = data.bindings === void 0 ? void 0 : validateDataBindings(data.bindings, "data.bindings");
-  const capabilities = data.capabilities === void 0 ? void 0 : validateDataCapabilities(data.capabilities, "data.capabilities");
-  const semantics = data.semantics === void 0 ? void 0 : validateDataSemantics(data.semantics, "data.semantics");
   return {
-    ...bindings ? { bindings } : {},
-    ...capabilities ? { capabilities } : {},
+    bindings: validateDataBindings(data.bindings, "data.bindings"),
+    capabilities: validateDataCapabilities(data.capabilities, "data.capabilities"),
     kind: "vector-tiles",
     ...data.revision === void 0 ? {} : { revision: requireSourceRevision(data.revision) },
     schema: "openmaptiles",
     schemaVersion: requirePositiveInteger(data.schemaVersion, "data.schemaVersion"),
-    ...semantics ? { semantics } : {},
-    sourceId: "tileflow",
-    ...data.source === void 0 ? {} : { source: validateDataSource(data.source, "data.source") }
+    semantics: validateDataSemantics(data.semantics, "data.semantics"),
+    source: validateDataSource(data.source, "data.source"),
+    sourceId: "tileflow"
   };
 }
 function normalizeCaptureDataInput(input) {
   if (input.kind === "tileflow-world") return input;
   const { url, ...identity } = input;
-  return {
-    ...identity,
-    ...url === void 0 ? {} : { source: fingerprintLegacyDataUrl(url) }
-  };
+  return { ...identity, source: fingerprintDataUrl(url) };
 }
 function validateDataSemantics(value, field) {
   const semantics = requireRecord(value, field);
@@ -410,16 +557,18 @@ function validateDataCapabilities(value, field) {
   const capabilities = requireRecord(value, field);
   requireExactKeys(capabilities, [
     "businessCorridor",
-    ...capabilities.bathymetry === void 0 ? [] : ["bathymetry"],
+    "bathymetry",
+    "canopy",
     "globalLandcover",
     "tree"
   ]);
-  if (typeof capabilities.businessCorridor !== "boolean" || capabilities.bathymetry !== void 0 && typeof capabilities.bathymetry !== "boolean" || typeof capabilities.globalLandcover !== "boolean" || typeof capabilities.tree !== "boolean") {
+  if (typeof capabilities.businessCorridor !== "boolean" || typeof capabilities.bathymetry !== "boolean" || typeof capabilities.canopy !== "boolean" || typeof capabilities.globalLandcover !== "boolean" || typeof capabilities.tree !== "boolean") {
     throw invalidReceipt(`The baseline receipt has an invalid ${field} object.`);
   }
   return {
     businessCorridor: capabilities.businessCorridor,
-    ...capabilities.bathymetry === void 0 ? {} : { bathymetry: capabilities.bathymetry },
+    bathymetry: capabilities.bathymetry,
+    canopy: capabilities.canopy,
     globalLandcover: capabilities.globalLandcover,
     tree: capabilities.tree
   };
@@ -434,7 +583,6 @@ function validateDataSource(value, field) {
 }
 function validateVerification(value, target) {
   const expected = verificationForTarget(target);
-  if (value === void 0) return expected;
   const verification = requireRecord(value, "verification");
   requireExactKeys(verification, ["data", "style"]);
   if (verification.data !== expected.data || verification.style !== expected.style) {
@@ -456,12 +604,17 @@ function assertCanonicalReceiptByteLimit(receipt) {
   }
 }
 function assertPlainReceiptData(value, path = "receipt", state = {
+  allowArrays: false,
   ancestors: /* @__PURE__ */ new WeakSet(),
   nodes: 0
 }, depth = 0) {
   if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
     return;
   }
+  if (typeof value === "object" && Array.isArray(value) && state.allowArrays) {
+    assertPlainReceiptArray(value, path, state, depth);
+    return;
+  }
   if (typeof value !== "object" || Array.isArray(value)) {
     throw invalidReceipt(`The baseline receipt has an executable or non-plain ${path} value.`);
   }
@@ -500,6 +653,35 @@ function assertPlainReceiptData(value, path = "receipt", state = {
     state.ancestors.delete(value);
   }
 }
+function assertPlainReceiptArray(value, path, state, depth) {
+  if (nodeUtilTypes.isProxy(value)) {
+    throw invalidReceipt(`The baseline receipt has an executable proxy at ${path}.`);
+  }
+  if (Object.getPrototypeOf(value) !== Array.prototype) {
+    throw invalidReceipt(`The baseline receipt has a non-plain ${path} array.`);
+  }
+  if (depth > 32 || ++state.nodes > 4096 || value.length > 4096) {
+    throw invalidReceipt("The baseline receipt exceeds the supported structural limit.");
+  }
+  if (state.ancestors.has(value)) {
+    throw invalidReceipt("The baseline receipt must not contain cyclic data.");
+  }
+  if (Reflect.ownKeys(value).length !== value.length + 1) {
+    throw invalidReceipt(`The baseline receipt has a sparse or extended ${path} array.`);
+  }
+  state.ancestors.add(value);
+  try {
+    for (let index = 0; index < value.length; index += 1) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, index);
+      if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+        throw invalidReceipt("The baseline receipt contains an accessor or non-enumerable field.");
+      }
+      assertPlainReceiptData(descriptor.value, `${path}.${index}`, state, depth + 1);
+    }
+  } finally {
+    state.ancestors.delete(value);
+  }
+}
 function requireRecord(value, field) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw invalidReceipt(`The baseline receipt has an invalid ${field} object.`);
@@ -513,11 +695,6 @@ function requireExactKeys(value, expected) {
     throw invalidReceipt("The baseline receipt contains missing or unsupported fields.");
   }
 }
-function requireIdentifier(value, field) {
-  const result = tileflowCaptureIdSchema.safeParse(value);
-  if (!result.success) throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
-  return result.data;
-}
 function requirePortableIdentifier(value, field) {
   const result = tileflowPortableIdSchema.safeParse(value);
   if (!result.success) throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
@@ -566,7 +743,7 @@ function requireSourceRevision(value) {
   }
   return value;
 }
-function fingerprintLegacyDataUrl(value) {
+function fingerprintDataUrl(value) {
   if (typeof value !== "string" || value.length < 1 || value.length > 2048) {
     throw invalidReceipt("The baseline receipt has an invalid data.url.");
   }
@@ -594,12 +771,6 @@ function isLoopbackHostname(value) {
   const hostname = value.toLowerCase().replace(/^\[|\]$/g, "");
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 }
-function requireWorldGeneration(value) {
-  if (value !== "v1") {
-    throw invalidReceipt("The baseline receipt has an invalid data.generation.");
-  }
-  return value;
-}
 function requireWorldReleaseId(value) {
   if (!isTileflowWorldReleaseId(value)) {
     throw invalidReceipt("The baseline receipt has an invalid data.releaseId.");
@@ -621,5 +792,11 @@ export {
   createTileflowCaptureReceipt,
   serializeTileflowCaptureReceipt,
   parseTileflowCaptureReceipt,
-  validateTileflowCaptureReceipt
+  validateTileflowCaptureReceipt,
+  tileflowShotReceiptSchemaVersion,
+  tileflowShotReceiptLimits,
+  createTileflowShotReceipt,
+  serializeTileflowShotReceipt,
+  parseTileflowShotReceipt,
+  validateTileflowShotReceipt
 };