@tileflow/capture 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/chunk-BSTB4FN6.js

@@ -0,0 +1,625 @@
+// src/receipt.ts
+import { createHash } from "crypto";
+import { types as nodeUtilTypes } from "util";
+import {
+  isTileflowWorldReleaseId,
+  serializeCanonicalJson,
+  tileflowCaptureIdSchema,
+  tileflowCaptureSceneLimits,
+  tileflowCaptureSceneNameSchema,
+  tileflowPortableIdSchema,
+  tileflowThemeNameSchema
+} from "@tileflow/core";
+
+// src/errors.ts
+var TileflowCaptureError = class extends Error {
+  code;
+  details;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "TileflowCaptureError";
+    this.code = code;
+    this.details = normalizeDetails(options?.details);
+  }
+};
+function captureErrorMessage(error, fallback) {
+  if (error instanceof TileflowCaptureError) {
+    return error.message;
+  }
+  return fallback;
+}
+function normalizeDetails(details) {
+  if (!details) return void 0;
+  const diagnostics = (details.diagnostics ?? []).map((diagnostic) => ({
+    message: boundText(diagnostic.message.replace(/[\r\n]+/g, " ").trim(), 300),
+    path: boundText(diagnostic.path.replaceAll("\\", "/"), 300)
+  })).sort((left, right) => {
+    const leftKey = `${left.path}\0${left.message}`;
+    const rightKey = `${right.path}\0${right.message}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+  }).slice(0, 32);
+  const resources = (details.resources ?? []).map(normalizeResource).filter((resource) => resource !== void 0).sort((left, right) => {
+    const leftKey = `${left.kind}\0${left.origin}\0${left.status ?? ""}\0${left.context ?? ""}`;
+    const rightKey = `${right.kind}\0${right.origin}\0${right.status ?? ""}\0${right.context ?? ""}`;
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+  }).filter(
+    (resource, index, values) => index === 0 || JSON.stringify(resource) !== JSON.stringify(values[index - 1])
+  ).slice(0, 8);
+  const normalized = {
+    ...details.phase ? { phase: details.phase } : {},
+    ...diagnostics.length > 0 ? { diagnostics } : {},
+    ...resources.length > 0 ? { resources } : {}
+  };
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeResource(resource) {
+  let origin;
+  try {
+    origin = new URL(resource.origin).origin;
+  } catch {
+    return void 0;
+  }
+  const status = resource.status !== void 0 && Number.isInteger(resource.status) && resource.status >= 100 && resource.status <= 599 ? resource.status : void 0;
+  const context = resource.context ? boundText(resource.context.replace(/[^A-Za-z0-9 _.,:@+-]/g, "").trim(), 128) : void 0;
+  return {
+    ...context ? { context } : {},
+    kind: resource.kind,
+    origin,
+    ...status === void 0 ? {} : { status }
+  };
+}
+function boundText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+// src/receipt.ts
+var tileflowCaptureReceiptSchemaVersion = 4;
+var tileflowCaptureReceiptLimits = Object.freeze({ maximumBytes: 64 * 1024 });
+var maximumReceiptBindingEntries = 128;
+function createTileflowCaptureReceipt(input) {
+  return validateTileflowCaptureReceipt({
+    schemaVersion: tileflowCaptureReceiptSchemaVersion,
+    scene: {
+      name: input.scene,
+      map: input.map,
+      theme: input.theme,
+      target: input.target,
+      sha256: input.sceneSha256
+    },
+    style: { sha256: input.styleSha256 },
+    image: {
+      sha256: input.pngSha256,
+      cssWidth: input.width,
+      cssHeight: input.height,
+      physicalWidth: input.width * input.dpr,
+      physicalHeight: input.height * input.dpr,
+      dpr: input.dpr
+    },
+    renderer: input.renderer,
+    platform: { os: process.platform, architecture: process.arch },
+    data: normalizeCaptureDataInput(input.data),
+    verification: verificationForTarget(input.target),
+    networkDependent: input.networkDependent
+  });
+}
+function serializeTileflowCaptureReceipt(receipt) {
+  const serialized = `${serializeCanonicalJson(validateTileflowCaptureReceipt(receipt))}
+`;
+  if (new TextEncoder().encode(serialized).byteLength > tileflowCaptureReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The capture receipt exceeds the supported byte limit.");
+  }
+  return serialized;
+}
+function parseTileflowCaptureReceipt(source) {
+  const byteLength = typeof source === "string" ? new TextEncoder().encode(source).byteLength : source.byteLength;
+  if (byteLength > tileflowCaptureReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The baseline 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 baseline receipt is not valid UTF-8 JSON.", error);
+  }
+  const receipt = validateTileflowCaptureReceipt(value);
+  if (text.trim() !== serializeCanonicalJson(value)) {
+    throw invalidReceipt("The baseline receipt is not canonical JSON.");
+  }
+  return receipt;
+}
+function validateTileflowCaptureReceipt(value) {
+  assertPlainReceiptData(value);
+  const receipt = requireRecord(value, "receipt");
+  const schemaVersion = receipt.schemaVersion;
+  if (schemaVersion !== 2 && schemaVersion !== 3 && schemaVersion !== tileflowCaptureReceiptSchemaVersion) {
+    throw invalidReceipt("The baseline receipt schema version is unsupported.");
+  }
+  const commonKeys = [
+    "schemaVersion",
+    "scene",
+    "style",
+    "image",
+    "renderer",
+    "platform",
+    "data",
+    ...schemaVersion === 2 && receipt.verification === void 0 ? [] : ["verification"],
+    "networkDependent"
+  ];
+  requireExactKeys(receipt, commonKeys);
+  const scene = requireRecord(receipt.scene, "scene");
+  requireExactKeys(
+    scene,
+    schemaVersion === tileflowCaptureReceiptSchemaVersion ? ["name", "map", "theme", "target", "sha256"] : ["name", "map", "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;
+  if (scene.target !== "map" && scene.target !== "application") {
+    throw invalidReceipt("The baseline receipt has an invalid scene target.");
+  }
+  const verification = validateVerification(receipt.verification, scene.target);
+  const style = requireRecord(receipt.style, "style");
+  requireExactKeys(style, ["sha256"]);
+  const image = requireRecord(receipt.image, "image");
+  requireExactKeys(image, [
+    "sha256",
+    "cssWidth",
+    "cssHeight",
+    "physicalWidth",
+    "physicalHeight",
+    "dpr"
+  ]);
+  const cssWidth = requirePositiveFinite(image.cssWidth, "image.cssWidth");
+  const cssHeight = requirePositiveFinite(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 baseline receipt has an invalid image DPR.");
+  }
+  if (cssWidth * image.dpr !== physicalWidth || cssHeight * image.dpr !== physicalHeight) {
+    throw invalidReceipt("The baseline receipt image dimensions are inconsistent.");
+  }
+  if (physicalWidth > tileflowCaptureSceneLimits.viewport.maximum * 2 || physicalHeight > tileflowCaptureSceneLimits.viewport.maximum * 2 || physicalWidth * physicalHeight > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+    throw invalidReceipt("The baseline receipt image exceeds the supported pixel limit.");
+  }
+  const renderer = requireRecord(receipt.renderer, "renderer");
+  requireExactKeys(renderer, [
+    "tileflow",
+    "maplibre",
+    "playwright",
+    "chromiumRevision",
+    "chromiumVersion"
+  ]);
+  const platform = requireRecord(receipt.platform, "platform");
+  requireExactKeys(platform, ["os", "architecture"]);
+  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 normalized = {
+    schemaVersion,
+    scene: {
+      name,
+      map,
+      ...theme === void 0 ? {} : { theme },
+      target: scene.target,
+      sha256: requireHash(scene.sha256, "scene.sha256")
+    },
+    style: { sha256: requireHash(style.sha256, "style.sha256") },
+    image: {
+      sha256: requireHash(image.sha256, "image.sha256"),
+      cssWidth,
+      cssHeight,
+      physicalWidth,
+      physicalHeight,
+      dpr: image.dpr
+    },
+    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,
+    verification,
+    networkDependent: receipt.networkDependent
+  };
+  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."
+    );
+  }
+  requireExactKeys(data, [
+    ...data.bindings === void 0 ? [] : ["bindings"],
+    ...data.capabilities === void 0 ? [] : ["capabilities"],
+    "kind",
+    ...data.generation === void 0 ? [] : ["generation"],
+    ...data.revision === void 0 ? [] : ["revision"],
+    "schema",
+    "schemaVersion",
+    ...data.semantics === void 0 ? [] : ["semantics"],
+    "sourceId",
+    ...data.source === void 0 ? [] : ["source"],
+    ...data.url === void 0 ? [] : ["url"]
+  ]);
+  if (data.kind !== "tileflow-world" && data.kind !== "vector-tiles") {
+    throw invalidReceipt("The baseline receipt has an invalid data.kind.");
+  }
+  if (data.schema !== "openmaptiles" || data.sourceId !== "tileflow") {
+    throw invalidReceipt("The baseline receipt has an unsupported data contract.");
+  }
+  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."
+      );
+    }
+  } else if (data.generation !== void 0) {
+    throw invalidReceipt("The baseline receipt has an invalid data.generation.");
+  }
+  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 } : {}
+  };
+}
+function validateDataIdentityV3(value) {
+  const data = requireRecord(value, "data");
+  if (data.kind === "tileflow-world") {
+    requireExactKeys(data, [
+      "archiveSha256",
+      "contractSha256",
+      "dataContractSha256",
+      "descriptorSha256",
+      "kind",
+      "product",
+      "releaseId",
+      "schema",
+      "schemaVersion",
+      ...data.semantics === void 0 ? [] : ["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"),
+      dataContractSha256: requireHash(data.dataContractSha256, "data.dataContractSha256"),
+      descriptorSha256: requireHash(data.descriptorSha256, "data.descriptorSha256"),
+      kind: "tileflow-world",
+      product: "world-v1",
+      releaseId: requireWorldReleaseId(data.releaseId),
+      schema: "openmaptiles",
+      schemaVersion: requirePositiveInteger(data.schemaVersion, "data.schemaVersion"),
+      ...semantics2 ? { semantics: semantics2 } : {},
+      sourceId: "tileflow"
+    };
+  }
+  if (data.kind !== "vector-tiles") {
+    throw invalidReceipt("The baseline receipt has an invalid data.kind.");
+  }
+  requireExactKeys(data, [
+    ...data.bindings === void 0 ? [] : ["bindings"],
+    ...data.capabilities === void 0 ? [] : ["capabilities"],
+    "kind",
+    ...data.revision === void 0 ? [] : ["revision"],
+    "schema",
+    "schemaVersion",
+    ...data.semantics === void 0 ? [] : ["semantics"],
+    "sourceId",
+    ...data.source === void 0 ? [] : ["source"]
+  ]);
+  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 } : {},
+    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") }
+  };
+}
+function normalizeCaptureDataInput(input) {
+  if (input.kind === "tileflow-world") return input;
+  const { url, ...identity } = input;
+  return {
+    ...identity,
+    ...url === void 0 ? {} : { source: fingerprintLegacyDataUrl(url) }
+  };
+}
+function validateDataSemantics(value, field) {
+  const semantics = requireRecord(value, field);
+  requireExactKeys(semantics, ["parkLayer"]);
+  if (semantics.parkLayer !== "mixed" && semantics.parkLayer !== "protected-only") {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.parkLayer.`);
+  }
+  return { parkLayer: semantics.parkLayer };
+}
+function validateDataBindings(value, field) {
+  const bindings = requireRecord(value, field);
+  requireExactKeys(bindings, ["fields", "layers"]);
+  return {
+    fields: validateStringBindings(bindings.fields, `${field}.fields`),
+    layers: validateStringBindings(bindings.layers, `${field}.layers`)
+  };
+}
+function validateStringBindings(value, field) {
+  const bindings = requireRecord(value, field);
+  const entries = Object.entries(bindings);
+  if (entries.length === 0 || entries.length > maximumReceiptBindingEntries) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field} object.`);
+  }
+  return Object.fromEntries(
+    entries.map(([name, binding]) => [
+      requireBindingKey(name, `${field} key`),
+      requireBindingValue(binding, `${field}.${name}`)
+    ]).sort(([left], [right]) => compareCodeUnits(left, right))
+  );
+}
+function requireBindingKey(value, field) {
+  if (!/^[A-Za-z][A-Za-z0-9]{0,63}$/.test(value)) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function requireBindingValue(value, field) {
+  if (typeof value !== "string" || value.length > 256 || value.trim().length === 0) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function validateDataCapabilities(value, field) {
+  const capabilities = requireRecord(value, field);
+  requireExactKeys(capabilities, [
+    "businessCorridor",
+    ...capabilities.bathymetry === void 0 ? [] : ["bathymetry"],
+    "globalLandcover",
+    "tree"
+  ]);
+  if (typeof capabilities.businessCorridor !== "boolean" || capabilities.bathymetry !== void 0 && typeof capabilities.bathymetry !== "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 },
+    globalLandcover: capabilities.globalLandcover,
+    tree: capabilities.tree
+  };
+}
+function validateDataSource(value, field) {
+  const source = requireRecord(value, field);
+  requireExactKeys(source, ["kind", "sha256"]);
+  if (source.kind !== "loopback" && source.kind !== "opaque" && source.kind !== "remote" && source.kind !== "root-relative") {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.kind.`);
+  }
+  return { kind: source.kind, sha256: requireHash(source.sha256, `${field}.sha256`) };
+}
+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) {
+    throw invalidReceipt(
+      `The baseline receipt verification does not match its ${target} capture target.`
+    );
+  }
+  return expected;
+}
+function verificationForTarget(target) {
+  const state = target === "map" ? "rendered" : "expected-unverified";
+  return { data: state, style: state };
+}
+function assertCanonicalReceiptByteLimit(receipt) {
+  const serialized = `${serializeCanonicalJson(receipt)}
+`;
+  if (new TextEncoder().encode(serialized).byteLength > tileflowCaptureReceiptLimits.maximumBytes) {
+    throw invalidReceipt("The capture receipt exceeds the supported byte limit.");
+  }
+}
+function assertPlainReceiptData(value, path = "receipt", state = {
+  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)) {
+    throw invalidReceipt(`The baseline receipt has an executable or non-plain ${path} value.`);
+  }
+  if (nodeUtilTypes.isProxy(value)) {
+    throw invalidReceipt(`The baseline receipt has an executable proxy at ${path}.`);
+  }
+  if (depth > 32 || ++state.nodes > 4096) {
+    throw invalidReceipt("The baseline receipt exceeds the supported structural limit.");
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw invalidReceipt(`The baseline receipt has a non-plain ${path} object.`);
+  }
+  if (state.ancestors.has(value)) {
+    throw invalidReceipt("The baseline receipt must not contain cyclic data.");
+  }
+  state.ancestors.add(value);
+  try {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const keys = Reflect.ownKeys(descriptors);
+    state.nodes += keys.length;
+    if (state.nodes > 4096) {
+      throw invalidReceipt("The baseline receipt exceeds the supported structural limit.");
+    }
+    for (const key of keys) {
+      if (typeof key !== "string") {
+        throw invalidReceipt("The baseline receipt contains an unsupported symbol field.");
+      }
+      const descriptor = descriptors[key];
+      if (!("value" in descriptor) || !descriptor.enumerable) {
+        throw invalidReceipt("The baseline receipt contains an accessor or non-enumerable field.");
+      }
+      assertPlainReceiptData(descriptor.value, `${path}.${key}`, 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.`);
+  }
+  return value;
+}
+function requireExactKeys(value, expected) {
+  const actual = Object.keys(value).sort();
+  const wanted = [...expected].sort();
+  if (actual.length !== wanted.length || actual.some((key, index) => key !== wanted[index])) {
+    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}.`);
+  return result.data;
+}
+function requireConcreteTheme(value) {
+  const result = tileflowThemeNameSchema.safeParse(value);
+  if (!result.success) throw invalidReceipt("The baseline receipt has an invalid scene.theme.");
+  return result.data;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function requireSceneName(value) {
+  const result = tileflowCaptureSceneNameSchema.safeParse(value);
+  if (!result.success) throw invalidReceipt("The baseline receipt has an invalid scene.name.");
+  return result.data;
+}
+function requireHash(value, field) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function requirePositiveFinite(value, field) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function requirePositiveInteger(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function requireBoundedString(value, field) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 64 || !isSafeRuntimeIdentity(value)) {
+    throw invalidReceipt(`The baseline receipt has an invalid ${field}.`);
+  }
+  return value;
+}
+function requireSourceRevision(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)) {
+    throw invalidReceipt("The baseline receipt has an invalid data.revision.");
+  }
+  return value;
+}
+function fingerprintLegacyDataUrl(value) {
+  if (typeof value !== "string" || value.length < 1 || value.length > 2048) {
+    throw invalidReceipt("The baseline receipt has an invalid data.url.");
+  }
+  if (value.startsWith("/") && !value.startsWith("//")) {
+    const url = new URL(value, "https://tileflow.invalid");
+    return fingerprintDataSource("root-relative", `root-relative:${url.pathname}`);
+  }
+  try {
+    const url = new URL(value);
+    if (!url.username && !url.password && url.protocol !== "file:") {
+      if (isLoopbackHostname(url.hostname)) {
+        return fingerprintDataSource("loopback", `loopback:${url.pathname}`);
+      }
+      const kind = url.protocol === "http:" || url.protocol === "https:" ? "remote" : "opaque";
+      return fingerprintDataSource(kind, `${kind}:${url.protocol}//${url.host}${url.pathname}`);
+    }
+  } catch {
+  }
+  throw invalidReceipt("The baseline receipt has an invalid data.url.");
+}
+function fingerprintDataSource(kind, identity) {
+  return { kind, sha256: createHash("sha256").update(identity).digest("hex") };
+}
+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.");
+  }
+  return value;
+}
+function isSafeRuntimeIdentity(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._:+-]*$/.test(value);
+}
+function invalidReceipt(message, cause) {
+  return new TileflowCaptureError("BASELINE_INVALID", message, { cause });
+}
+
+export {
+  TileflowCaptureError,
+  captureErrorMessage,
+  tileflowCaptureReceiptSchemaVersion,
+  tileflowCaptureReceiptLimits,
+  createTileflowCaptureReceipt,
+  serializeTileflowCaptureReceipt,
+  parseTileflowCaptureReceipt,
+  validateTileflowCaptureReceipt
+};