@tileflow/capture 0.0.0-bootstrap.0

package/dist/index.js

@@ -0,0 +1,2084 @@
+// src/browser.ts
+import { spawn } from "child_process";
+import { chromium } from "playwright";
+
+// 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/metadata.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+var require2 = createRequire(import.meta.url);
+var capturePackage = readJson(new URL("../package.json", import.meta.url));
+var playwrightPackagePath = require2.resolve("playwright/package.json");
+var playwrightPackage = readJson(playwrightPackagePath);
+var requireFromPlaywright = createRequire(playwrightPackagePath);
+var playwrightCorePackagePath = requireFromPlaywright.resolve("playwright-core/package.json");
+var browsers = readJson(
+  join(dirname(playwrightCorePackagePath), "browsers.json")
+);
+var maplibrePackage = readJson(require2.resolve("maplibre-gl/package.json"));
+var chromiumHeadlessShell = browsers.browsers.find(
+  (browser) => browser.name === "chromium-headless-shell"
+);
+if (!chromiumHeadlessShell) {
+  throw new Error("The installed Playwright package does not declare a Chromium headless shell.");
+}
+var tileflowCaptureRuntime = Object.freeze({
+  tileflow: capturePackage.version,
+  maplibre: maplibrePackage.version,
+  playwright: playwrightPackage.version,
+  chromiumRevision: chromiumHeadlessShell.revision,
+  chromiumVersion: chromiumHeadlessShell.browserVersion ?? "unknown"
+});
+function createTileflowCaptureRendererIdentity(browser) {
+  return {
+    ...tileflowCaptureRuntime,
+    chromiumVersion: browser?.version() ?? tileflowCaptureRuntime.chromiumVersion
+  };
+}
+function getPlaywrightCliPath() {
+  return join(dirname(playwrightPackagePath), "cli.js");
+}
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+// src/browser.ts
+var chromiumEnvironmentAllowlist = [
+  "APPDATA",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "LOCALAPPDATA",
+  "PATH",
+  "SystemRoot",
+  "TEMP",
+  "TMP",
+  "TMPDIR",
+  "TZ",
+  "USERPROFILE",
+  "WINDIR",
+  "XDG_CACHE_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_RUNTIME_DIR"
+];
+var installerEnvironmentAllowlist = [
+  ...chromiumEnvironmentAllowlist,
+  "ALL_PROXY",
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "all_proxy",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "PLAYWRIGHT_BROWSERS_PATH",
+  "PLAYWRIGHT_CHROMIUM_DOWNLOAD_HOST",
+  "PLAYWRIGHT_DOWNLOAD_CONNECTION_TIMEOUT",
+  "PLAYWRIGHT_DOWNLOAD_HOST"
+];
+function createTileflowCaptureBrowserEnvironment(source = process.env) {
+  const environment = {
+    HOME: source.HOME || source.USERPROFILE || source.TMPDIR || source.TEMP || source.TMP || "/tmp",
+    LANG: source.LANG || "C.UTF-8"
+  };
+  for (const key of chromiumEnvironmentAllowlist) {
+    const value = source[key];
+    if (value) {
+      environment[key] = value;
+    }
+  }
+  return environment;
+}
+async function launchTileflowCaptureBrowser(options = {}) {
+  return launchTileflowCaptureBrowserWithDependencies(options, {
+    install: installPinnedBrowser,
+    launch: launchPinnedBrowser
+  });
+}
+async function launchTileflowCaptureBrowserWithDependencies(options, dependencies) {
+  throwIfAborted(options.signal);
+  try {
+    return await dependencies.launch();
+  } catch (error) {
+    if (!isMissingBrowserError(error)) {
+      throw new TileflowCaptureError(
+        "BROWSER_START_FAILED",
+        "Pinned Chromium could not start for Tileflow capture.",
+        { cause: error }
+      );
+    }
+    if (options.allowInstall === false) {
+      throw new TileflowCaptureError(
+        "BROWSER_MISSING",
+        "Pinned Chromium is not installed. Run `tileflow setup capture` or allow browser installation.",
+        { cause: error }
+      );
+    }
+    options.onInstallProgress?.("installing");
+    await dependencies.install(options.signal);
+    throwIfAborted(options.signal);
+    options.onInstallProgress?.("installed");
+    try {
+      return await dependencies.launch();
+    } catch (retryError) {
+      throw new TileflowCaptureError(
+        "BROWSER_START_FAILED",
+        "Pinned Chromium was installed but could not start for Tileflow capture.",
+        { cause: retryError }
+      );
+    }
+  }
+}
+async function setupTileflowCaptureBrowser(options = {}) {
+  const browser = await launchTileflowCaptureBrowser(options);
+  try {
+    return createTileflowCaptureRendererIdentity(browser);
+  } finally {
+    await browser.close();
+  }
+}
+var TileflowCaptureBrowserManager = class {
+  #dependencies;
+  #options;
+  #browserPromise;
+  #closed = false;
+  constructor(options = {}, dependencies = {
+    install: installPinnedBrowser,
+    launch: launchPinnedBrowser
+  }) {
+    this.#options = options;
+    this.#dependencies = dependencies;
+  }
+  getBrowser(signal = this.#options.signal) {
+    if (this.#closed) {
+      return Promise.reject(
+        new TileflowCaptureError("BROWSER_START_FAILED", "Tileflow capture session is closed.")
+      );
+    }
+    try {
+      throwIfAborted(signal);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    this.#browserPromise ??= launchTileflowCaptureBrowserWithDependencies(
+      { ...this.#options, signal },
+      this.#dependencies
+    ).catch((error) => {
+      this.#browserPromise = void 0;
+      throw error;
+    });
+    return this.#browserPromise;
+  }
+  async close() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    const browserPromise = this.#browserPromise;
+    this.#browserPromise = void 0;
+    if (!browserPromise) {
+      return;
+    }
+    try {
+      const browser = await browserPromise;
+      await browser.close();
+    } catch {
+    }
+  }
+};
+function launchPinnedBrowser() {
+  return chromium.launch({
+    args: ["--disable-dev-shm-usage"],
+    chromiumSandbox: true,
+    env: createTileflowCaptureBrowserEnvironment(),
+    handleSIGHUP: false,
+    handleSIGINT: false,
+    handleSIGTERM: false,
+    headless: true
+  });
+}
+async function installPinnedBrowser(signal) {
+  throwIfAborted(signal);
+  const invocation = getPlaywrightInstallerInvocation();
+  await new Promise((resolve2, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+      env: createTileflowCaptureBrowserInstallerEnvironment(),
+      shell: false,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    let settled = false;
+    const finish = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      callback();
+    };
+    const onAbort = () => {
+      child.kill("SIGTERM");
+      finish(() => reject(new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.")));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.once("error", (error) => {
+      finish(
+        () => reject(
+          new TileflowCaptureError(
+            "BROWSER_INSTALL_FAILED",
+            "Pinned Chromium installation could not start.",
+            { cause: error }
+          )
+        )
+      );
+    });
+    child.once("exit", (code, exitSignal) => {
+      finish(() => {
+        if (code === 0) {
+          resolve2();
+          return;
+        }
+        reject(
+          new TileflowCaptureError(
+            "BROWSER_INSTALL_FAILED",
+            `Pinned Chromium installation failed${exitSignal ? ` after ${exitSignal}` : ""}.`
+          )
+        );
+      });
+    });
+  });
+}
+function createTileflowCaptureBrowserInstallerEnvironment(source = process.env) {
+  return pickEnvironment(installerEnvironmentAllowlist, source);
+}
+function getPlaywrightInstallerInvocation() {
+  return {
+    command: process.execPath,
+    args: [getPlaywrightCliPath(), "install", "--only-shell", "chromium"]
+  };
+}
+function pickEnvironment(keys, source = process.env) {
+  const environment = {};
+  for (const key of keys) {
+    const value = source[key];
+    if (value) {
+      environment[key] = value;
+    }
+  }
+  environment.HOME ||= environment.USERPROFILE || environment.TMPDIR || environment.TEMP || environment.TMP || "/tmp";
+  environment.LANG ||= "C.UTF-8";
+  return environment;
+}
+function isMissingBrowserError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Executable doesn't exist") || message.includes("Executable does not exist");
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+  }
+}
+
+// src/capture.ts
+import { resolve } from "path";
+import {
+  compareCodeUnits as compareCodeUnits3,
+  normalizeTileflowCaptureScene,
+  serializeCanonicalJson as serializeCanonicalJson2,
+  sha256Hex,
+  tileflowCaptureSceneNameSchema as tileflowCaptureSceneNameSchema2
+} from "@tileflow/core";
+import {
+  assertValidTileflowStyle as assertValidTileflowStyle2,
+  createTileflowBuildArtifacts,
+  defaultTileflowConfigPath,
+  TileflowStyleValidationError as TileflowStyleValidationError2
+} from "@tileflow/dev";
+
+// src/application.ts
+import { tileflowCaptureSceneLimits } from "@tileflow/core";
+
+// src/standalone.ts
+import { createRequire as createRequire2 } from "module";
+import {
+  assertValidTileflowStyle,
+  TileflowStyleValidationError
+} from "@tileflow/dev";
+var tileflowSyntheticAssetOrigin = "https://tileflow.local.invalid";
+var require3 = createRequire2(import.meta.url);
+var maplibreJsPath = require3.resolve("maplibre-gl/dist/maplibre-gl.js");
+var maplibreCssPath = require3.resolve("maplibre-gl/dist/maplibre-gl.css");
+async function captureStandaloneTileflowScene(input) {
+  if (input.scene.target.kind !== "map") {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_REQUIRED",
+      "Application scenes require an explicit loopback application origin."
+    );
+  }
+  try {
+    assertValidTileflowStyle(input.style, input.scene.map);
+  } catch (error) {
+    if (error instanceof TileflowStyleValidationError) {
+      throw new TileflowCaptureError("STYLE_INVALID", error.message, {
+        cause: error,
+        details: {
+          diagnostics: error.issues,
+          phase: "style-validation"
+        }
+      });
+    }
+    throw error;
+  }
+  const timeoutMs = input.timeoutMs ?? 3e4;
+  let termination;
+  let context;
+  let phase = "browser-start";
+  let timeout;
+  const onAbort = () => {
+    termination = "aborted";
+    void context?.close().catch(() => void 0);
+  };
+  if (input.signal?.aborted) {
+    throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+  }
+  try {
+    context = await input.browser.newContext({
+      acceptDownloads: false,
+      colorScheme: "light",
+      deviceScaleFactor: input.scene.viewport.dpr,
+      ignoreHTTPSErrors: false,
+      javaScriptEnabled: true,
+      locale: "en-US",
+      reducedMotion: "reduce",
+      serviceWorkers: "block",
+      timezoneId: "UTC",
+      viewport: {
+        height: input.scene.viewport.height,
+        width: input.scene.viewport.width
+      }
+    });
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    if (input.signal?.aborted) {
+      onAbort();
+      throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+    }
+    timeout = setTimeout(() => {
+      termination = "timeout";
+      void context?.close().catch(() => void 0);
+    }, timeoutMs);
+    timeout.unref?.();
+    const assets = new Map(input.assets.map((asset) => [asset.fileName, asset]));
+    const remoteOrigins = /* @__PURE__ */ new Set();
+    let syntheticAssetFailure;
+    const resourceFailures = [];
+    let pageFailed = false;
+    const recordResourceFailure = (url, status) => {
+      const diagnostic = classifyResource(url, status);
+      if (!diagnostic || resourceFailures.length >= 16) return;
+      const key = JSON.stringify(diagnostic);
+      if (!resourceFailures.some((item) => JSON.stringify(item) === key)) {
+        resourceFailures.push(diagnostic);
+      }
+    };
+    await context.route("**/*", async (route) => {
+      const url = new URL(route.request().url());
+      if (url.origin === tileflowSyntheticAssetOrigin) {
+        const fileName = decodeURIComponent(url.pathname.slice(1));
+        const asset = url.search === "" ? assets.get(fileName) : void 0;
+        if (!asset) {
+          syntheticAssetFailure = fileName || "unknown";
+          await route.abort("blockedbyclient");
+          return;
+        }
+        await route.fulfill({
+          body: typeof asset.source === "string" ? asset.source : Buffer.from(asset.source),
+          contentType: asset.contentType,
+          status: 200
+        });
+        return;
+      }
+      if (url.protocol === "http:" || url.protocol === "https:") {
+        if (!isLoopbackUrl(url)) remoteOrigins.add(url.origin);
+        await route.continue();
+        return;
+      }
+      pageFailed = true;
+      await route.abort("blockedbyclient");
+    });
+    await context.routeWebSocket(/.*/, async (socket) => {
+      pageFailed = true;
+      await socket.close({ code: 1008, reason: "WebSockets are disabled during capture" });
+    });
+    const page = await context.newPage();
+    page.on("dialog", (dialog) => void dialog.dismiss());
+    page.on("popup", (popup) => void popup.close());
+    page.on("pageerror", () => {
+      pageFailed = true;
+    });
+    page.on("response", (response) => {
+      if (response.status() >= 400) {
+        recordResourceFailure(response.url(), response.status());
+      }
+    });
+    page.on("requestfailed", (request) => recordResourceFailure(request.url()));
+    page.setDefaultTimeout(timeoutMs);
+    await page.setContent(renderHtml(input.scene.viewport), { waitUntil: "domcontentloaded" });
+    await page.addStyleTag({ path: maplibreCssPath });
+    await page.addScriptTag({ path: maplibreJsPath });
+    await page.addScriptTag({ content: renderMapInPageScript });
+    phase = "map-load";
+    const loadResult = await page.evaluate(
+      (renderInput) => {
+        const renderWindow = window;
+        return renderWindow.__tileflowCaptureLoad(renderInput);
+      },
+      {
+        mapEventTimeoutMs: Math.max(1, timeoutMs - 1e3),
+        style: input.style
+      }
+    );
+    assertPhaseSucceeded(loadResult, phase, syntheticAssetFailure, resourceFailures, pageFailed);
+    phase = "map-idle";
+    const idleResult = await page.evaluate(
+      (renderInput) => {
+        const renderWindow = window;
+        return renderWindow.__tileflowCaptureIdle(renderInput);
+      },
+      {
+        camera: input.scene.camera,
+        mapEventTimeoutMs: Math.max(1, timeoutMs - 1e3)
+      }
+    );
+    assertPhaseSucceeded(idleResult, phase, syntheticAssetFailure, resourceFailures, pageFailed);
+    phase = "screenshot";
+    let png;
+    try {
+      png = new Uint8Array(
+        await page.locator("#map").screenshot({ animations: "disabled", type: "png" })
+      );
+    } catch (error) {
+      throw new TileflowCaptureError(
+        "SCREENSHOT_FAILED",
+        "Tileflow could not produce the map PNG.",
+        {
+          cause: error,
+          details: { phase }
+        }
+      );
+    }
+    assertPostScreenshotSucceeded(syntheticAssetFailure, resourceFailures, pageFailed);
+    assertPngDimensions(
+      png,
+      input.scene.viewport.width * input.scene.viewport.dpr,
+      input.scene.viewport.height * input.scene.viewport.dpr
+    );
+    const warnings = [...remoteOrigins].sort(compareCodeUnits).map((origin) => `Capture requested remote resources from ${origin}.`);
+    return {
+      height: input.scene.viewport.height,
+      networkDependent: remoteOrigins.size > 0,
+      png,
+      warnings,
+      width: input.scene.viewport.width
+    };
+  } catch (error) {
+    if (termination === "aborted") {
+      throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.", { cause: error });
+    }
+    if (termination === "timeout") {
+      throw new TileflowCaptureError("CAPTURE_TIMEOUT", timeoutMessage(phase), {
+        cause: error,
+        details: { phase }
+      });
+    }
+    if (error instanceof TileflowCaptureError) {
+      throw error;
+    }
+    if (phase === "browser-start") {
+      throw new TileflowCaptureError(
+        "BROWSER_START_FAILED",
+        "Tileflow could not create an isolated capture page.",
+        { cause: error, details: { phase } }
+      );
+    }
+    if (phase === "screenshot") {
+      throw new TileflowCaptureError(
+        "SCREENSHOT_FAILED",
+        "Tileflow could not produce the map PNG.",
+        {
+          cause: error,
+          details: { phase }
+        }
+      );
+    }
+    throw new TileflowCaptureError("MAP_LOAD_FAILED", mapFailureMessage(phase), {
+      cause: error,
+      details: { phase }
+    });
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    input.signal?.removeEventListener("abort", onAbort);
+    await context?.close().catch(() => void 0);
+  }
+}
+function assertPhaseSucceeded(result, phase, syntheticAssetFailure, resourceFailures, pageFailed) {
+  if (syntheticAssetFailure) {
+    throw new TileflowCaptureError(
+      "SYNTHETIC_ASSET_NOT_FOUND",
+      `Compiled capture asset is unavailable: ${safeAssetName(syntheticAssetFailure)}`,
+      { details: { phase: "resource-load" } }
+    );
+  }
+  if (resourceFailures.length > 0) throwResourceFailure(resourceFailures);
+  if (result.status === "failed" && result.reason === "timeout") {
+    throw new TileflowCaptureError("CAPTURE_TIMEOUT", timeoutMessage(phase), {
+      details: { phase }
+    });
+  }
+  if (result.status === "failed" || pageFailed) {
+    throw new TileflowCaptureError("MAP_LOAD_FAILED", mapFailureMessage(phase), {
+      details: { phase }
+    });
+  }
+}
+function assertPostScreenshotSucceeded(syntheticAssetFailure, resourceFailures, pageFailed) {
+  if (syntheticAssetFailure) {
+    throw new TileflowCaptureError(
+      "SYNTHETIC_ASSET_NOT_FOUND",
+      `Compiled capture asset is unavailable: ${safeAssetName(syntheticAssetFailure)}`,
+      { details: { phase: "resource-load" } }
+    );
+  }
+  if (resourceFailures.length > 0) throwResourceFailure(resourceFailures);
+  if (pageFailed) {
+    throw new TileflowCaptureError(
+      "SCREENSHOT_FAILED",
+      "The capture page failed while producing the map PNG.",
+      { details: { phase: "screenshot" } }
+    );
+  }
+}
+function throwResourceFailure(resources) {
+  const first = [...resources].sort(compareResources)[0];
+  const label = resourceLabel(first.kind);
+  const status = first.status === void 0 ? "failed" : `returned HTTP ${first.status}`;
+  throw new TileflowCaptureError(
+    "RESOURCE_FAILED",
+    `${label} resource ${status} from ${first.origin}.`,
+    {
+      details: {
+        phase: "resource-load",
+        resources
+      }
+    }
+  );
+}
+function classifyResource(value, status) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return void 0;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+  const path = url.pathname.toLowerCase();
+  let kind = "other-http";
+  let context;
+  if (/(?:^|\/)(?:fonts?|glyphs?)(?:\/|$)/.test(path)) {
+    kind = "glyph";
+    context = fontStackContext(url.pathname);
+  } else if (/sprite(?:@2x)?\.json$/.test(path)) {
+    kind = "sprite-json";
+  } else if (/sprite(?:@2x)?\.(?:png|webp)$/.test(path)) {
+    kind = "sprite-image";
+  } else if (/(?:tiles|tilejson)\.json$/.test(path) || path.includes("/tilejson/")) {
+    kind = "tilejson";
+  } else if (/\.pbf$/.test(path) || /\/tiles?\/\d+\/\d+\/\d+/.test(path)) {
+    kind = "vector-tile";
+  }
+  return {
+    ...context ? { context } : {},
+    kind,
+    origin: url.origin,
+    ...status === void 0 ? {} : { status }
+  };
+}
+function fontStackContext(path) {
+  const segments = path.split("/").filter(Boolean);
+  const index = segments.findIndex((segment) => /^(?:fonts?|glyphs?)$/i.test(segment));
+  if (index < 0 || !segments[index + 1]) return void 0;
+  try {
+    const stack = decodeURIComponent(segments[index + 1]).replace(/[^A-Za-z0-9 _.,:@+-]/g, "").trim().slice(0, 96);
+    return stack ? `fontStack: ${stack}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function compareResources(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 compareCodeUnits(leftKey, rightKey);
+}
+function resourceLabel(kind) {
+  return {
+    glyph: "Glyph",
+    "other-http": "HTTP",
+    "sprite-image": "Sprite image",
+    "sprite-json": "Sprite JSON",
+    tilejson: "TileJSON",
+    "vector-tile": "Vector tile"
+  }[kind];
+}
+function timeoutMessage(phase) {
+  if (phase === "map-load") return "MapLibre did not finish loading before the capture timeout.";
+  if (phase === "map-idle") return "MapLibre did not become idle before the capture timeout.";
+  if (phase === "screenshot") return "PNG production exceeded the capture timeout.";
+  return "Tileflow capture exceeded its timeout while creating the browser page.";
+}
+function mapFailureMessage(phase) {
+  return phase === "map-load" ? "MapLibre failed while loading the compiled style." : "MapLibre failed while waiting for the committed camera to become idle.";
+}
+function safeAssetName(value) {
+  return value.replace(/[^A-Za-z0-9._/-]/g, "").slice(0, 200) || "unknown";
+}
+function isLoopbackUrl(url) {
+  const hostname = url.hostname.toLowerCase();
+  return hostname === "localhost" || hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(hostname);
+}
+function readPngDimensions(png) {
+  if (png.byteLength < 24 || png[0] !== 137 || png[1] !== 80 || png[2] !== 78 || png[3] !== 71 || png[4] !== 13 || png[5] !== 10 || png[6] !== 26 || png[7] !== 10) {
+    throw new TileflowCaptureError("INVALID_PNG", "Capture output is not a valid PNG image.");
+  }
+  const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function assertPngDimensions(png, width, height) {
+  let actual;
+  try {
+    actual = readPngDimensions(png);
+  } catch (error) {
+    throw new TileflowCaptureError("INVALID_PNG", "Capture output is not a valid PNG image.", {
+      cause: error,
+      details: { phase: "screenshot" }
+    });
+  }
+  if (actual.width !== width || actual.height !== height) {
+    throw new TileflowCaptureError(
+      "INVALID_PNG",
+      `Capture PNG dimensions are ${actual.width}x${actual.height}; expected ${width}x${height}.`,
+      { details: { phase: "screenshot" } }
+    );
+  }
+}
+function renderHtml(viewport) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+      html, body, #map {
+        width: ${viewport.width}px;
+        height: ${viewport.height}px;
+        margin: 0;
+        overflow: hidden;
+      }
+      body { background: transparent; }
+    </style>
+  </head>
+  <body><div id="map"></div></body>
+</html>`;
+}
+var renderMapInPageScript = String.raw`
+window.__tileflowCaptureLoad = async function(input) {
+  try {
+    const map = new window.maplibregl.Map({
+      attributionControl: false,
+      container: "map",
+      fadeDuration: 0,
+      interactive: false,
+      style: input.style
+    });
+    window.__tileflowMap = map;
+    return await waitForMapEvent(map, "load", input.mapEventTimeoutMs);
+  } catch {
+    return {status: "failed", reason: "error"};
+  }
+};
+
+window.__tileflowCaptureIdle = async function(input) {
+  const map = window.__tileflowMap;
+  if (!map) return {status: "failed", reason: "error"};
+
+  try {
+    applyCamera(map, input.camera);
+    const result = await waitForMapEvent(map, "idle", input.mapEventTimeoutMs);
+    if (result.status === "failed") return result;
+    await nextFrame();
+    await nextFrame();
+    return {status: "ok"};
+  } catch {
+    return {status: "failed", reason: "error"};
+  }
+};
+
+function applyCamera(mapInstance, camera) {
+  if (camera.type === "bounds") {
+    mapInstance.fitBounds(
+      [
+        [camera.bounds[0], camera.bounds[1]],
+        [camera.bounds[2], camera.bounds[3]]
+      ],
+      {
+        bearing: camera.bearing,
+        duration: 0,
+        padding: camera.padding,
+        pitch: camera.pitch
+      }
+    );
+    return;
+  }
+
+  mapInstance.jumpTo({
+    bearing: camera.bearing,
+    center: camera.center,
+    pitch: camera.pitch,
+    zoom: camera.zoom
+  });
+}
+
+function waitForMapEvent(mapInstance, event, timeoutMs) {
+  return new Promise((resolve) => {
+    const timeout = window.setTimeout(() => {
+      cleanup();
+      resolve({status: "failed", reason: "timeout"});
+    }, timeoutMs);
+    const onSuccess = () => {
+      cleanup();
+      resolve({status: "ok"});
+    };
+    const onError = () => {
+      cleanup();
+      resolve({status: "failed", reason: "error"});
+    };
+    const cleanup = () => {
+      window.clearTimeout(timeout);
+      mapInstance.off(event, onSuccess);
+      mapInstance.off("error", onError);
+    };
+
+    mapInstance.once(event, onSuccess);
+    mapInstance.once("error", onError);
+  });
+}
+
+function nextFrame() {
+  return new Promise((resolve) => window.requestAnimationFrame(() => resolve()));
+}
+`;
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/application.ts
+var maximumApplicationUrlLength = tileflowCaptureSceneLimits.applicationPathLength + 512;
+function resolveTileflowApplicationUrl(input) {
+  if (input.appOrigin && input.appUrl) {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_INVALID",
+      "Use either an application origin or a full application URL, not both."
+    );
+  }
+  if (input.appUrl) {
+    const url2 = parseLoopbackHttpUrl(input.appUrl, false);
+    return { origin: url2.origin, url: url2.toString() };
+  }
+  if (!input.appOrigin) {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_REQUIRED",
+      "Application capture requires --app-origin, --url, TILEFLOW_APP_ORIGIN, or a programmatic equivalent."
+    );
+  }
+  const origin = parseLoopbackHttpUrl(input.appOrigin, true);
+  const url = parseLoopbackHttpUrl(new URL(input.path, `${origin.origin}/`).toString(), false);
+  return { origin: origin.origin, url: url.toString() };
+}
+async function captureApplicationTileflowScene(input) {
+  const application = resolveTileflowApplicationUrl({
+    appOrigin: input.appOrigin,
+    appUrl: input.appUrl,
+    path: input.scene.target.path
+  });
+  const timeoutMs = input.timeoutMs ?? 3e4;
+  let context;
+  let termination;
+  let timeout;
+  const onAbort = () => {
+    termination = "aborted";
+    void context?.close().catch(() => void 0);
+  };
+  if (input.signal?.aborted) {
+    throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+  }
+  try {
+    context = await input.browser.newContext({
+      acceptDownloads: false,
+      colorScheme: "light",
+      deviceScaleFactor: input.scene.viewport.dpr,
+      ignoreHTTPSErrors: false,
+      javaScriptEnabled: true,
+      locale: "en-US",
+      reducedMotion: "reduce",
+      serviceWorkers: "block",
+      timezoneId: "UTC",
+      viewport: {
+        height: input.scene.viewport.height,
+        width: input.scene.viewport.width
+      }
+    });
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    if (input.signal?.aborted) {
+      onAbort();
+      throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+    }
+    timeout = setTimeout(() => {
+      termination = "timeout";
+      void context?.close().catch(() => void 0);
+    }, timeoutMs);
+    timeout.unref?.();
+    const page = await context.newPage();
+    const remoteOrigins = /* @__PURE__ */ new Set();
+    let applicationFailure = false;
+    let applicationOriginEscape = false;
+    page.setDefaultTimeout(timeoutMs);
+    await page.route("**/*", async (route) => {
+      const request = route.request();
+      try {
+        if (request.isNavigationRequest() && request.frame().parentFrame() === null && !isApprovedApplicationDocumentUrl(request.url(), application.origin)) {
+          applicationOriginEscape = true;
+          await route.abort("blockedbyclient");
+          return;
+        }
+      } catch {
+      }
+      await route.continue();
+    });
+    page.on("dialog", (dialog) => void dialog.dismiss());
+    page.on("popup", (popup) => void popup.close());
+    page.on("console", (message) => {
+      if (message.type() === "error") applicationFailure = true;
+    });
+    page.on("pageerror", () => {
+      applicationFailure = true;
+    });
+    page.on("websocket", (socket) => {
+      try {
+        const url = new URL(socket.url());
+        if ((url.protocol === "ws:" || url.protocol === "wss:") && webSocketHttpOrigin(url) !== application.origin) {
+          remoteOrigins.add(url.origin);
+        }
+      } catch {
+      }
+    });
+    page.on("request", (request) => {
+      try {
+        const url = new URL(request.url());
+        if ((url.protocol === "http:" || url.protocol === "https:") && url.origin !== application.origin) {
+          remoteOrigins.add(url.origin);
+        }
+      } catch {
+      }
+    });
+    page.on("response", (response) => {
+      if (response.status() >= 400 && new URL(response.url()).origin === application.origin) {
+        applicationFailure = true;
+      }
+    });
+    let navigationResponse;
+    try {
+      navigationResponse = await page.goto(application.url, { waitUntil: "domcontentloaded" });
+    } catch (error) {
+      throw new TileflowCaptureError(
+        "APPLICATION_NAVIGATION_FAILED",
+        "The loopback application page could not be loaded.",
+        { cause: error }
+      );
+    }
+    if (!navigationResponse || navigationResponse.status() >= 400 || !isApprovedApplicationDocumentUrl(navigationResponse.url(), application.origin) || !isApprovedApplicationDocumentUrl(page.url(), application.origin) || applicationOriginEscape) {
+      throw new TileflowCaptureError(
+        "APPLICATION_NAVIGATION_FAILED",
+        "The loopback application page did not return a successful document on the approved origin."
+      );
+    }
+    const locator = createTargetLocator(page, input.scene);
+    let targetCount;
+    try {
+      targetCount = await locator.count();
+    } catch (error) {
+      throw new TileflowCaptureError(
+        "APPLICATION_TARGET_NOT_FOUND",
+        "The application capture selector is invalid.",
+        { cause: error }
+      );
+    }
+    if (targetCount === 0) {
+      throw new TileflowCaptureError(
+        "APPLICATION_TARGET_NOT_FOUND",
+        "The application page did not contain the requested Tileflow capture target."
+      );
+    }
+    if (targetCount !== 1) {
+      throw new TileflowCaptureError(
+        "APPLICATION_TARGET_AMBIGUOUS",
+        `The application page contained ${targetCount} matching Tileflow capture targets; expected exactly one.`
+      );
+    }
+    await locator.waitFor({ state: "visible" });
+    await waitForApplicationTarget(
+      locator,
+      input.scene.target.selector !== void 0,
+      timeoutMs,
+      () => applicationFailure || applicationOriginEscape
+    );
+    if (applicationFailure || applicationOriginEscape) {
+      throw new TileflowCaptureError(
+        "APPLICATION_ERROR",
+        "The application reported an error before its capture target became ready."
+      );
+    }
+    if (!isApprovedApplicationDocumentUrl(page.url(), application.origin)) {
+      throw new TileflowCaptureError(
+        "APPLICATION_NAVIGATION_FAILED",
+        "The application page left the approved loopback origin before capture."
+      );
+    }
+    if (input.scene.target.frame === "map") {
+      await assertApplicationTargetPixelBounds(locator, input.scene.viewport.dpr);
+    }
+    const png = new Uint8Array(
+      input.scene.target.frame === "viewport" ? await page.screenshot({ animations: "disabled", type: "png" }) : await locator.screenshot({ animations: "disabled", type: "png" })
+    );
+    await assertApplicationTargetRemainsReady(locator, input.scene.target.selector !== void 0);
+    if (applicationFailure || applicationOriginEscape) {
+      throw new TileflowCaptureError(
+        "APPLICATION_ERROR",
+        "The application reported an error before capture completed."
+      );
+    }
+    if (!isApprovedApplicationDocumentUrl(page.url(), application.origin)) {
+      throw new TileflowCaptureError(
+        "APPLICATION_NAVIGATION_FAILED",
+        "The application page left the approved loopback origin during capture."
+      );
+    }
+    const physical = readPngDimensions(png);
+    if (physical.width > tileflowCaptureSceneLimits.viewport.maximum * 2 || physical.height > tileflowCaptureSceneLimits.viewport.maximum * 2 || physical.width * physical.height > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+      throw new TileflowCaptureError(
+        "RENDER_FAILED",
+        "The application capture target exceeded the bounded visual pixel limit."
+      );
+    }
+    const warnings = [...remoteOrigins].sort(compareCodeUnits2).map((origin) => `Application capture requested remote resources from ${origin}.`);
+    return {
+      height: physical.height / input.scene.viewport.dpr,
+      networkDependent: remoteOrigins.size > 0,
+      png,
+      warnings,
+      width: physical.width / input.scene.viewport.dpr
+    };
+  } catch (error) {
+    if (termination === "aborted") {
+      throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.", { cause: error });
+    }
+    if (termination === "timeout") {
+      throw new TileflowCaptureError(
+        "CAPTURE_TIMEOUT",
+        "Tileflow capture timed out before the application target became idle.",
+        { cause: error }
+      );
+    }
+    if (error instanceof TileflowCaptureError) throw error;
+    throw new TileflowCaptureError(
+      "APPLICATION_ERROR",
+      "The application target failed before capture completed.",
+      { cause: error }
+    );
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    input.signal?.removeEventListener("abort", onAbort);
+    await context?.close().catch(() => void 0);
+  }
+}
+async function assertApplicationTargetRemainsReady(locator, allowUnmarkedSelector) {
+  const state = await locator.getAttribute("data-tileflow-state");
+  if (state === "idle" || state === null && allowUnmarkedSelector) return;
+  throw new TileflowCaptureError(
+    "APPLICATION_ERROR",
+    "The application capture target stopped being ready while its screenshot was produced."
+  );
+}
+function webSocketHttpOrigin(url) {
+  const comparable = new URL(url);
+  comparable.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  return comparable.origin;
+}
+async function assertApplicationTargetPixelBounds(locator, dpr) {
+  const box = await locator.boundingBox();
+  if (!box || !Number.isFinite(box.width) || !Number.isFinite(box.height)) {
+    throw new TileflowCaptureError(
+      "RENDER_FAILED",
+      "The application capture target did not have stable bounded dimensions."
+    );
+  }
+  const physicalWidth = Math.ceil(box.width * dpr);
+  const physicalHeight = Math.ceil(box.height * dpr);
+  if (physicalWidth <= 0 || physicalHeight <= 0 || physicalWidth > tileflowCaptureSceneLimits.viewport.maximum * 2 || physicalHeight > tileflowCaptureSceneLimits.viewport.maximum * 2 || physicalWidth * physicalHeight > tileflowCaptureSceneLimits.maximumPhysicalPixels) {
+    throw new TileflowCaptureError(
+      "RENDER_FAILED",
+      "The application capture target exceeded the bounded visual pixel limit."
+    );
+  }
+}
+function createTargetLocator(page, scene) {
+  try {
+    if (scene.target.captureId) {
+      return page.locator(`[data-tileflow-capture-id="${scene.target.captureId}"]`);
+    }
+    if (scene.target.selector) return page.locator(scene.target.selector);
+    return page.locator(`[data-tileflow-map="${scene.map}"]`);
+  } catch (error) {
+    throw new TileflowCaptureError(
+      "APPLICATION_TARGET_NOT_FOUND",
+      "The application capture selector is invalid.",
+      { cause: error }
+    );
+  }
+}
+async function waitForApplicationTarget(locator, allowUnmarkedSelector, timeoutMs, hasApplicationFailure) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (hasApplicationFailure()) {
+      throw new TileflowCaptureError(
+        "APPLICATION_ERROR",
+        "The application reported an error before its capture target became ready."
+      );
+    }
+    const state = await locator.getAttribute("data-tileflow-state");
+    if (state === "error") {
+      throw new TileflowCaptureError(
+        "APPLICATION_ERROR",
+        "The application capture target entered the error state."
+      );
+    }
+    if (state === "idle" || state === null && allowUnmarkedSelector) {
+      await locator.evaluate(
+        () => new Promise(
+          (resolveReady) => requestAnimationFrame(() => requestAnimationFrame(() => resolveReady()))
+        )
+      );
+      return;
+    }
+    await new Promise((resolveWait) => setTimeout(resolveWait, 20));
+  }
+  throw new TileflowCaptureError(
+    "CAPTURE_TIMEOUT",
+    "The application capture target did not become idle."
+  );
+}
+function parseLoopbackHttpUrl(value, requireOriginOnly) {
+  if (value !== value.trim() || value.length > maximumApplicationUrlLength || hasControlCharacter(value)) {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_INVALID",
+      "Application capture requires a bounded loopback HTTP(S) URL without surrounding whitespace or control characters."
+    );
+  }
+  let url;
+  try {
+    url = new URL(value);
+  } catch (error) {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_INVALID",
+      "Application capture requires a valid loopback HTTP(S) URL.",
+      { cause: error }
+    );
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || !isLoopbackHostname(url.hostname) || url.username !== "" || url.password !== "" || url.hash !== "" || requireOriginOnly && (url.pathname !== "/" || url.search !== "")) {
+    throw new TileflowCaptureError(
+      "APPLICATION_ORIGIN_INVALID",
+      requireOriginOnly ? "Application origin must be an HTTP(S) loopback origin without credentials, path, query, or fragment." : "Application URL must use HTTP(S) loopback without credentials or a fragment."
+    );
+  }
+  return url;
+}
+function isApprovedApplicationDocumentUrl(value, origin) {
+  try {
+    return parseLoopbackHttpUrl(value, false).origin === origin;
+  } catch {
+    return false;
+  }
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+function isLoopbackHostname(hostname) {
+  const normalized = hostname.toLowerCase();
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "[::1]") {
+    return true;
+  }
+  const octets = normalized.split(".");
+  return octets.length === 4 && octets.every((part) => /^\d{1,3}$/.test(part) && Number(part) <= 255) && Number(octets[0]) === 127;
+}
+function compareCodeUnits2(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/receipt.ts
+import {
+  serializeCanonicalJson,
+  tileflowCaptureIdSchema,
+  tileflowCaptureSceneLimits as tileflowCaptureSceneLimits2,
+  tileflowCaptureSceneNameSchema
+} from "@tileflow/core";
+var tileflowCaptureReceiptSchemaVersion = 1;
+var tileflowCaptureReceiptLimits = Object.freeze({ maximumBytes: 64 * 1024 });
+function createTileflowCaptureReceipt(input) {
+  return validateTileflowCaptureReceipt({
+    schemaVersion: tileflowCaptureReceiptSchemaVersion,
+    scene: {
+      name: input.scene,
+      map: input.map,
+      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 },
+    source: { tilesetVersion: input.sourceVersion ?? null },
+    networkDependent: input.networkDependent
+  });
+}
+function serializeTileflowCaptureReceipt(receipt) {
+  return `${serializeCanonicalJson(validateTileflowCaptureReceipt(receipt))}
+`;
+}
+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(receipt)) {
+    throw invalidReceipt("The baseline receipt is not canonical JSON.");
+  }
+  return receipt;
+}
+function validateTileflowCaptureReceipt(value) {
+  const receipt = requireRecord(value, "receipt");
+  const commonKeys = [
+    "schemaVersion",
+    "scene",
+    "style",
+    "image",
+    "renderer",
+    "platform",
+    "source",
+    "networkDependent"
+  ];
+  if (receipt.schemaVersion !== tileflowCaptureReceiptSchemaVersion) {
+    throw invalidReceipt("The baseline receipt schema version is unsupported.");
+  }
+  requireExactKeys(receipt, commonKeys);
+  const scene = requireRecord(receipt.scene, "scene");
+  requireExactKeys(scene, ["name", "map", "target", "sha256"]);
+  const name = requireSceneName(scene.name);
+  const map = requireIdentifier(scene.map, "scene.map");
+  if (scene.target !== "map" && scene.target !== "application") {
+    throw invalidReceipt("The baseline receipt has an invalid 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 > tileflowCaptureSceneLimits2.viewport.maximum * 2 || physicalHeight > tileflowCaptureSceneLimits2.viewport.maximum * 2 || physicalWidth * physicalHeight > tileflowCaptureSceneLimits2.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 source = requireRecord(receipt.source, "source");
+  requireExactKeys(source, ["tilesetVersion"]);
+  return {
+    schemaVersion: tileflowCaptureReceiptSchemaVersion,
+    scene: {
+      name,
+      map,
+      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")
+    },
+    source: { tilesetVersion: requireNullableSourceVersion(source.tilesetVersion) },
+    networkDependent: receipt.networkDependent
+  };
+}
+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 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 requireNullableSourceVersion(value) {
+  if (value === null) return null;
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)) {
+    throw invalidReceipt("The baseline receipt has an invalid source.tilesetVersion.");
+  }
+  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 });
+}
+
+// src/capture.ts
+var tileflowCaptureResultSchemaVersion = 1;
+async function captureTileflowScenes(options) {
+  const session = createTileflowCaptureSession(options);
+  try {
+    return await session.capture(options.scenes, options.signal);
+  } finally {
+    await session.close();
+  }
+}
+function createTileflowCaptureSession(options = {}) {
+  return new TileflowCaptureSessionImpl(options);
+}
+var TileflowCaptureSessionImpl = class {
+  #options;
+  #browserManager;
+  #closed = false;
+  constructor(options = {}) {
+    this.#options = options;
+    this.#browserManager = new TileflowCaptureBrowserManager({
+      allowInstall: options.allowBrowserInstall,
+      onInstallProgress: options.onBrowserInstallProgress,
+      signal: options.signal
+    });
+  }
+  async capture(scenes, signal) {
+    this.#assertOpen();
+    const artifacts = await this.#createArtifacts();
+    return this.captureArtifacts(artifacts, scenes, signal ?? this.#options.signal);
+  }
+  async captureAll(signal) {
+    this.#assertOpen();
+    const artifacts = await this.#createArtifacts();
+    return this.captureArtifacts(
+      artifacts,
+      Object.keys(artifacts.project.scenes ?? {}),
+      signal ?? this.#options.signal
+    );
+  }
+  async captureDefinitions(scenes, signal) {
+    this.#assertOpen();
+    const artifacts = await this.#createArtifacts();
+    const withDefinitions = {
+      ...artifacts,
+      project: { ...artifacts.project, scenes }
+    };
+    return this.captureArtifacts(
+      withDefinitions,
+      Object.keys(scenes),
+      signal ?? this.#options.signal
+    );
+  }
+  async captureArtifacts(artifacts, requestedScenes, signal) {
+    this.#assertOpen();
+    const sceneNames = selectTileflowCaptureSceneNames(artifacts, requestedScenes);
+    const validatedMaps = /* @__PURE__ */ new Set();
+    for (const sceneName of sceneNames) {
+      const scene = this.#resolveScene(artifacts, sceneName);
+      if (scene.target.kind === "application" && !this.#options.appOrigin && !this.#options.appUrl) {
+        throw new TileflowCaptureError(
+          "APPLICATION_ORIGIN_REQUIRED",
+          `Scene "${sceneName}" requires --app-origin or TILEFLOW_APP_ORIGIN.`
+        );
+      }
+      const style = Object.hasOwn(artifacts.styles, scene.map) ? artifacts.styles[scene.map] : void 0;
+      if (!style) {
+        throw new TileflowCaptureError(
+          "SCENE_NOT_FOUND",
+          `Scene "${sceneName}" references unavailable map "${scene.map}".`
+        );
+      }
+      if (!validatedMaps.has(scene.map)) {
+        try {
+          assertValidTileflowStyle2(style, scene.map);
+        } catch (error) {
+          throwCaptureStyleValidationError(error);
+        }
+        validatedMaps.add(scene.map);
+      }
+    }
+    throwIfAborted2(signal);
+    const browser = await this.#browserManager.getBrowser(signal);
+    const renderer = createTileflowCaptureRendererIdentity(browser);
+    const captures = [];
+    for (const sceneName of sceneNames) {
+      throwIfAborted2(signal);
+      const scene = this.#resolveScene(artifacts, sceneName);
+      const style = Object.hasOwn(artifacts.styles, scene.map) ? artifacts.styles[scene.map] : void 0;
+      if (!style) {
+        throw new TileflowCaptureError(
+          "SCENE_NOT_FOUND",
+          `Scene "${sceneName}" references unavailable map "${scene.map}".`
+        );
+      }
+      const rendered = scene.target.kind === "application" ? await captureApplicationTileflowScene({
+        appOrigin: this.#options.appOrigin,
+        appUrl: this.#options.appUrl,
+        browser,
+        scene: { ...scene, target: scene.target },
+        signal,
+        timeoutMs: this.#options.timeoutMs
+      }) : await captureStandaloneTileflowScene({
+        assets: artifacts.assets,
+        browser,
+        scene,
+        signal,
+        style,
+        timeoutMs: this.#options.timeoutMs
+      });
+      const [sha256, sceneSha256, styleSha256] = await Promise.all([
+        sha256Hex(rendered.png),
+        sha256Hex(serializeCanonicalJson2(scene)),
+        sha256Hex(serializeCanonicalJson2(style))
+      ]);
+      const target = scene.target.kind;
+      const receipt = createTileflowCaptureReceipt({
+        dpr: scene.viewport.dpr,
+        height: rendered.height,
+        map: scene.map,
+        networkDependent: rendered.networkDependent,
+        pngSha256: sha256,
+        renderer,
+        scene: sceneName,
+        sceneSha256,
+        styleSha256,
+        ...typeof style.metadata?.["tileflow:tilesetVersion"] === "string" ? { sourceVersion: style.metadata["tileflow:tilesetVersion"] } : {},
+        target,
+        width: rendered.width
+      });
+      captures.push({
+        scene: sceneName,
+        map: scene.map,
+        target,
+        png: rendered.png,
+        sha256,
+        sceneSha256,
+        styleSha256,
+        width: rendered.width,
+        height: rendered.height,
+        dpr: scene.viewport.dpr,
+        networkDependent: rendered.networkDependent,
+        renderer,
+        receipt,
+        warnings: rendered.warnings.sort(compareCodeUnits3)
+      });
+    }
+    return { schemaVersion: tileflowCaptureResultSchemaVersion, captures };
+  }
+  async close() {
+    if (this.#closed) {
+      return;
+    }
+    this.#closed = true;
+    await this.#browserManager.close();
+  }
+  #createArtifacts() {
+    const cwd = resolve(this.#options.cwd ?? process.cwd());
+    return createTileflowBuildArtifacts({
+      assetBaseUrl: tileflowSyntheticAssetOrigin,
+      config: this.#options.config ?? defaultTileflowConfigPath,
+      cwd
+    }).catch((error) => throwCaptureStyleValidationError(error));
+  }
+  #assertOpen() {
+    if (this.#closed) {
+      throw new TileflowCaptureError("BROWSER_START_FAILED", "Tileflow capture session is closed.");
+    }
+  }
+  #resolveScene(artifacts, sceneName) {
+    const scene = normalizeScene(artifacts, sceneName);
+    const hasApplicationOverrides = this.#options.appUrl !== void 0 || this.#options.selector !== void 0 || this.#options.frame !== void 0;
+    if (!hasApplicationOverrides) return scene;
+    if (scene.target.kind !== "application" && !this.#options.appUrl) {
+      throw new TileflowCaptureError(
+        "APPLICATION_ORIGIN_REQUIRED",
+        "Application selector/frame overrides require an application scene or --url."
+      );
+    }
+    const existing = scene.target.kind === "application" ? scene.target : void 0;
+    let path = existing?.path ?? "/";
+    if (this.#options.appUrl) {
+      const resolved = resolveTileflowApplicationUrl({ appUrl: this.#options.appUrl, path });
+      const url = new URL(resolved.url);
+      path = `${url.pathname}${url.search}`;
+    }
+    const selector = this.#options.selector ?? existing?.selector;
+    const captureId = this.#options.selector ? void 0 : existing?.captureId;
+    return {
+      ...scene,
+      target: {
+        kind: "application",
+        path,
+        ...captureId ? { captureId } : {},
+        ...selector ? { selector } : {},
+        frame: this.#options.frame ?? existing?.frame ?? "map"
+      }
+    };
+  }
+};
+function selectTileflowCaptureSceneNames(artifacts, requestedScenes) {
+  const availableScenes = Object.keys(artifacts.project.scenes ?? {}).filter((sceneName) => tileflowCaptureSceneNameSchema2.safeParse(sceneName).success).sort(compareCodeUnits3);
+  const sceneNames = [...new Set(requestedScenes)].sort(compareCodeUnits3);
+  if (sceneNames.length === 0) {
+    throw new TileflowCaptureError(
+      "SCENE_NOT_FOUND",
+      "Select at least one capture scene or request every configured scene explicitly."
+    );
+  }
+  for (const sceneName of sceneNames) {
+    if (!tileflowCaptureSceneNameSchema2.safeParse(sceneName).success) {
+      throw new TileflowCaptureError(
+        "SCENE_NOT_FOUND",
+        "Expected a portable Tileflow capture scene name."
+      );
+    }
+    if (!Object.hasOwn(artifacts.project.scenes ?? {}, sceneName)) {
+      const suffix = availableScenes.length > 0 ? ` Available scenes: ${availableScenes.join(", ")}.` : " The config defines no capture scenes.";
+      throw new TileflowCaptureError(
+        "SCENE_NOT_FOUND",
+        `Unknown Tileflow capture scene "${sceneName}".${suffix}`
+      );
+    }
+  }
+  return sceneNames;
+}
+function normalizeScene(artifacts, sceneName) {
+  const scene = Object.hasOwn(artifacts.project.scenes ?? {}, sceneName) ? artifacts.project.scenes?.[sceneName] : void 0;
+  if (!scene) {
+    throw new TileflowCaptureError("SCENE_NOT_FOUND", `Unknown Tileflow scene "${sceneName}".`);
+  }
+  return normalizeTileflowCaptureScene(scene);
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    throw new TileflowCaptureError("ABORTED", "Tileflow capture was aborted.");
+  }
+}
+function throwCaptureStyleValidationError(error) {
+  if (error instanceof TileflowStyleValidationError2) {
+    throw new TileflowCaptureError("STYLE_INVALID", error.message, {
+      cause: error,
+      details: {
+        diagnostics: error.issues,
+        phase: "style-validation"
+      }
+    });
+  }
+  throw error;
+}
+
+// src/visual.ts
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+import {
+  compareCodeUnits as compareCodeUnits4,
+  serializeCanonicalJson as serializeCanonicalJson3,
+  sha256Hex as sha256Hex2,
+  tileflowCaptureSceneLimits as tileflowCaptureSceneLimits3
+} from "@tileflow/core";
+var tileflowVisualComparisonSchemaVersion = 1;
+var tileflowVisualAnalysisSchemaVersion = 1;
+var tileflowVisualPerceptualThreshold = 0.1;
+var tileflowVisualArtifactLimits = Object.freeze({
+  maximumPngBytes: 256 * 1024 * 1024,
+  maximumPaletteColors: 16
+});
+function validateTileflowVisualReferencePng(png) {
+  const image = decodePng(png, "reference");
+  return { width: image.width, height: image.height };
+}
+async function analyzeTileflowCaptureReference(actualCapture, referencePng) {
+  const receipt = validateTileflowCaptureReceipt(actualCapture.receipt);
+  const actualImage = await validatePngAgainstReceipt(actualCapture.png, receipt, "actual");
+  const referenceImage = decodePng(referencePng, "reference");
+  const dimensionsMatch = referenceImage.width === actualImage.width && referenceImage.height === actualImage.height;
+  const common = {
+    schemaVersion: tileflowVisualAnalysisSchemaVersion,
+    scene: receipt.scene.name,
+    map: receipt.scene.map,
+    target: receipt.scene.target,
+    dimensionsMatch,
+    reference: {
+      sha256: await sha256Hex2(referencePng),
+      physicalWidth: referenceImage.width,
+      physicalHeight: referenceImage.height,
+      palette: createQuantizedPalette(referenceImage.data)
+    },
+    actual: {
+      sha256: receipt.image.sha256,
+      physicalWidth: actualImage.width,
+      physicalHeight: actualImage.height,
+      palette: createQuantizedPalette(actualImage.data)
+    }
+  };
+  if (!dimensionsMatch) {
+    return {
+      ...common,
+      exact: null,
+      perceptual: null,
+      meanAbsoluteChannelDifference: null,
+      warnings: [
+        "The reference and actual PNG dimensions differ; pixel metrics and diff were not computed.",
+        ...networkWarnings(void 0, receipt)
+      ].sort(compareCodeUnits4)
+    };
+  }
+  const totalPixels = actualImage.width * actualImage.height;
+  const exactChangedPixels = countExactChangedPixels(referenceImage.data, actualImage.data);
+  const diffData = new Uint8Array(totalPixels * 4);
+  const perceptualChangedPixels = pixelmatch(
+    referenceImage.data,
+    actualImage.data,
+    diffData,
+    actualImage.width,
+    actualImage.height,
+    {
+      checkerboard: true,
+      diffColor: [255, 0, 255],
+      diffColorAlt: [0, 255, 255],
+      diffMask: true,
+      includeAA: true,
+      threshold: tileflowVisualPerceptualThreshold
+    }
+  );
+  return {
+    ...common,
+    exact: pixelMetric(exactChangedPixels, totalPixels),
+    perceptual: {
+      threshold: tileflowVisualPerceptualThreshold,
+      ...pixelMetric(perceptualChangedPixels, totalPixels)
+    },
+    meanAbsoluteChannelDifference: meanAbsoluteChannelDifference(
+      referenceImage.data,
+      actualImage.data
+    ),
+    diffPng: encodeDiffPng(diffData, actualImage.width, actualImage.height),
+    warnings: networkWarnings(void 0, receipt)
+  };
+}
+function createTileflowVisualReferenceAnalysisDocument(analysis) {
+  const { diffPng: _diffPng, ...document } = analysis;
+  return document;
+}
+async function compareTileflowCaptureToBaseline(actualCapture, baseline) {
+  const actualReceipt = validateTileflowCaptureReceipt(actualCapture.receipt);
+  const actual = imageIdentity(actualReceipt);
+  const common = {
+    schemaVersion: tileflowVisualComparisonSchemaVersion,
+    scene: actualReceipt.scene.name,
+    map: actualReceipt.scene.map,
+    target: actualReceipt.scene.target,
+    actual,
+    actualScene: actualReceipt.scene,
+    actualRuntime: runtimeIdentity(actualReceipt)
+  };
+  const actualImage = await validatePngAgainstReceipt(actualCapture.png, actualReceipt, "actual");
+  if (!baseline) {
+    return {
+      ...common,
+      status: "missing-baseline",
+      changeKind: null,
+      baselineScene: null,
+      baselineRuntime: null,
+      baseline: null,
+      dimensionsMatch: null,
+      exact: null,
+      perceptual: null,
+      rendererMatch: null,
+      sceneMatch: null,
+      warnings: networkWarnings(void 0, actualReceipt)
+    };
+  }
+  const baselineReceipt = typeof baseline.receipt === "string" || baseline.receipt instanceof Uint8Array ? parseTileflowCaptureReceipt(baseline.receipt) : validateTileflowCaptureReceipt(baseline.receipt);
+  const baselineImage = await validatePngAgainstReceipt(baseline.png, baselineReceipt, "baseline");
+  const baselineIdentity = imageIdentity(baselineReceipt);
+  const baselineScene = baselineReceipt.scene;
+  const baselineRuntime = runtimeIdentity(baselineReceipt);
+  const warnings = networkWarnings(baselineReceipt, actualReceipt);
+  const sceneMatch = sameSceneIdentity(baselineReceipt, actualReceipt);
+  if (!sceneMatch) {
+    return {
+      ...common,
+      status: "scene-mismatch",
+      changeKind: null,
+      baselineScene,
+      baselineRuntime,
+      baseline: baselineIdentity,
+      dimensionsMatch: null,
+      exact: null,
+      perceptual: null,
+      rendererMatch: null,
+      sceneMatch: false,
+      warnings
+    };
+  }
+  const rendererMatch = sameRuntimeIdentity(baselineReceipt, actualReceipt);
+  if (!rendererMatch) {
+    return {
+      ...common,
+      status: "runtime-mismatch",
+      changeKind: null,
+      baselineScene,
+      baselineRuntime,
+      baseline: baselineIdentity,
+      dimensionsMatch: null,
+      exact: null,
+      perceptual: null,
+      rendererMatch: false,
+      sceneMatch: true,
+      warnings
+    };
+  }
+  const dimensionsMatch = baselineReceipt.image.physicalWidth === actualReceipt.image.physicalWidth && baselineReceipt.image.physicalHeight === actualReceipt.image.physicalHeight;
+  if (!dimensionsMatch) {
+    const diffWidth = Math.max(
+      baselineReceipt.image.physicalWidth,
+      actualReceipt.image.physicalWidth
+    );
+    const diffHeight = Math.max(
+      baselineReceipt.image.physicalHeight,
+      actualReceipt.image.physicalHeight
+    );
+    const boundedWidth = diffWidth * diffHeight <= tileflowCaptureSceneLimits3.maximumPhysicalPixels ? diffWidth : actualReceipt.image.physicalWidth;
+    const boundedHeight = diffWidth * diffHeight <= tileflowCaptureSceneLimits3.maximumPhysicalPixels ? diffHeight : actualReceipt.image.physicalHeight;
+    return {
+      ...common,
+      status: "changed",
+      changeKind: "dimensions",
+      baselineScene,
+      baselineRuntime,
+      baseline: baselineIdentity,
+      dimensionsMatch: false,
+      exact: null,
+      perceptual: null,
+      rendererMatch: true,
+      sceneMatch: true,
+      diffPng: encodeSolidDiffPng(boundedWidth, boundedHeight),
+      warnings: [
+        ...warnings,
+        "The PNG dimensions differ; exact and perceptual pixel metrics were not computed."
+      ].sort(compareCodeUnits4)
+    };
+  }
+  const width = actualImage.width;
+  const height = actualImage.height;
+  const totalPixels = width * height;
+  const exactChangedPixels = countExactChangedPixels(baselineImage.data, actualImage.data);
+  const diffData = new Uint8Array(totalPixels * 4);
+  const perceptualChangedPixels = pixelmatch(
+    baselineImage.data,
+    actualImage.data,
+    diffData,
+    width,
+    height,
+    {
+      checkerboard: true,
+      diffColor: [255, 0, 255],
+      diffColorAlt: [0, 255, 255],
+      diffMask: true,
+      includeAA: true,
+      threshold: tileflowVisualPerceptualThreshold
+    }
+  );
+  const status = exactChangedPixels === 0 ? "unchanged" : "changed";
+  return {
+    ...common,
+    status,
+    changeKind: status === "changed" ? "pixels" : null,
+    baselineScene,
+    baselineRuntime,
+    baseline: baselineIdentity,
+    dimensionsMatch: true,
+    exact: pixelMetric(exactChangedPixels, totalPixels),
+    perceptual: {
+      threshold: tileflowVisualPerceptualThreshold,
+      ...pixelMetric(perceptualChangedPixels, totalPixels)
+    },
+    rendererMatch: true,
+    sceneMatch: true,
+    diffPng: encodeDiffPng(diffData, width, height),
+    warnings
+  };
+}
+function createTileflowVisualComparisonDocument(comparison) {
+  const { diffPng: _diffPng, ...document } = comparison;
+  return document;
+}
+function serializeTileflowVisualComparison(comparison) {
+  return `${serializeCanonicalJson3(createTileflowVisualComparisonDocument(comparison))}
+`;
+}
+function imageIdentity(receipt) {
+  return {
+    sha256: receipt.image.sha256,
+    cssWidth: receipt.image.cssWidth,
+    cssHeight: receipt.image.cssHeight,
+    physicalWidth: receipt.image.physicalWidth,
+    physicalHeight: receipt.image.physicalHeight,
+    dpr: receipt.image.dpr,
+    networkDependent: receipt.networkDependent
+  };
+}
+function runtimeIdentity(receipt) {
+  return { renderer: receipt.renderer, platform: receipt.platform };
+}
+async function validatePngAgainstReceipt(png, receipt, role) {
+  const image = decodePng(png, role);
+  if (image.width !== receipt.image.physicalWidth || image.height !== receipt.image.physicalHeight) {
+    throw invalidBaseline(`The ${role} PNG dimensions do not match its receipt.`);
+  }
+  if (await sha256Hex2(png) !== receipt.image.sha256) {
+    throw invalidBaseline(`The ${role} PNG hash does not match its receipt.`);
+  }
+  return image;
+}
+function preflightPng(png, role) {
+  if (png.byteLength > tileflowVisualArtifactLimits.maximumPngBytes) {
+    throw invalidBaseline(`The ${role} PNG exceeds the visual artifact byte limit.`);
+  }
+  let dimensions;
+  try {
+    dimensions = readPngDimensions(png);
+  } catch (error) {
+    throw invalidBaseline(`The ${role} image is not a valid PNG.`, error);
+  }
+  const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+  if (png.byteLength < 29 || view.getUint32(8) !== 13 || png[12] !== 73 || png[13] !== 72 || png[14] !== 68 || png[15] !== 82) {
+    throw invalidBaseline(`The ${role} image does not begin with a canonical PNG header.`);
+  }
+  if (png[28] !== 0) {
+    throw invalidBaseline(
+      `The ${role} PNG is interlaced and cannot be decoded within fixed bounds.`
+    );
+  }
+  if (dimensions.width > tileflowCaptureSceneLimits3.viewport.maximum * 2 || dimensions.height > tileflowCaptureSceneLimits3.viewport.maximum * 2 || dimensions.width * dimensions.height > tileflowCaptureSceneLimits3.maximumPhysicalPixels) {
+    throw invalidBaseline(`The ${role} PNG exceeds the visual pixel limit.`);
+  }
+  return dimensions;
+}
+function decodePng(png, role) {
+  preflightPng(png, role);
+  try {
+    const decoded = PNG.sync.read(Buffer.from(png), { checkCRC: true, skipRescale: false });
+    if (decoded.data.byteLength !== decoded.width * decoded.height * 4) {
+      throw new Error("Decoded PNG did not produce bounded RGBA pixels.");
+    }
+    return decoded;
+  } catch (error) {
+    throw invalidBaseline(`The ${role} PNG could not be decoded safely.`, error);
+  }
+}
+function encodeDiffPng(data, width, height) {
+  const image = new PNG({ height, width });
+  image.data = Buffer.from(data);
+  return new Uint8Array(
+    PNG.sync.write(image, {
+      bitDepth: 8,
+      colorType: 6,
+      deflateLevel: 9,
+      deflateStrategy: 3,
+      filterType: 4,
+      inputColorType: 6,
+      inputHasAlpha: true
+    })
+  );
+}
+function encodeSolidDiffPng(width, height) {
+  const data = new Uint8Array(width * height * 4);
+  for (let offset = 0; offset < data.byteLength; offset += 4) {
+    data.set([255, 0, 255, 255], offset);
+  }
+  return encodeDiffPng(data, width, height);
+}
+function countExactChangedPixels(left, right) {
+  if (left.byteLength !== right.byteLength || left.byteLength % 4 !== 0) {
+    throw invalidBaseline("Comparable PNGs did not decode to equal RGBA dimensions.");
+  }
+  let changed = 0;
+  for (let index = 0; index < left.byteLength; index += 4) {
+    if (left[index] !== right[index] || left[index + 1] !== right[index + 1] || left[index + 2] !== right[index + 2] || left[index + 3] !== right[index + 3]) {
+      changed += 1;
+    }
+  }
+  return changed;
+}
+function createQuantizedPalette(data) {
+  if (data.byteLength === 0 || data.byteLength % 4 !== 0) {
+    throw invalidBaseline("The decoded PNG did not contain bounded RGBA pixels.");
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < data.byteLength; offset += 4) {
+    const alpha = data[offset + 3];
+    const red = compositeOnWhite(data[offset], alpha);
+    const green = compositeOnWhite(data[offset + 1], alpha);
+    const blue = compositeOnWhite(data[offset + 2], alpha);
+    const color = `#${quantizeChannel(red)}${quantizeChannel(green)}${quantizeChannel(blue)}`;
+    counts.set(color, (counts.get(color) ?? 0) + 1);
+  }
+  const totalPixels = data.byteLength / 4;
+  return [...counts].sort((left, right) => right[1] - left[1] || compareCodeUnits4(left[0], right[0])).slice(0, tileflowVisualArtifactLimits.maximumPaletteColors).map(([color, count]) => ({ color, count, ratio: count / totalPixels }));
+}
+function compositeOnWhite(channel, alpha) {
+  return Math.round((channel * alpha + 255 * (255 - alpha)) / 255);
+}
+function quantizeChannel(channel) {
+  return (Math.round(channel / 17) * 17).toString(16).padStart(2, "0");
+}
+function meanAbsoluteChannelDifference(left, right) {
+  if (left.byteLength !== right.byteLength || left.byteLength === 0) {
+    throw invalidBaseline("Comparable PNGs did not decode to equal RGBA dimensions.");
+  }
+  let sum = 0;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    sum += Math.abs(left[index] - right[index]);
+  }
+  return Math.round(sum / left.byteLength * 1e6) / 1e6;
+}
+function pixelMetric(changedPixels, totalPixels) {
+  return { changedPixels, totalPixels, ratio: changedPixels / totalPixels };
+}
+function sameSceneIdentity(baseline, actual) {
+  return baseline.scene.name === actual.scene.name && baseline.scene.map === actual.scene.map && baseline.scene.target === actual.scene.target && baseline.scene.sha256 === actual.scene.sha256 && baseline.source.tilesetVersion === actual.source.tilesetVersion;
+}
+function sameRuntimeIdentity(baseline, actual) {
+  return baseline.renderer.tileflow === actual.renderer.tileflow && baseline.renderer.maplibre === actual.renderer.maplibre && baseline.renderer.playwright === actual.renderer.playwright && baseline.renderer.chromiumRevision === actual.renderer.chromiumRevision && baseline.renderer.chromiumVersion === actual.renderer.chromiumVersion && baseline.platform.os === actual.platform.os && baseline.platform.architecture === actual.platform.architecture;
+}
+function networkWarnings(baseline, actual) {
+  const warnings = [];
+  if (baseline?.networkDependent) {
+    warnings.push("The baseline used remote resources and may not be globally byte-stable.");
+  }
+  if (actual.networkDependent) {
+    warnings.push("The actual capture used remote resources and may not be globally byte-stable.");
+  }
+  return warnings.sort(compareCodeUnits4);
+}
+function invalidBaseline(message, cause) {
+  return new TileflowCaptureError("BASELINE_INVALID", message, { cause });
+}
+export {
+  TileflowCaptureBrowserManager,
+  TileflowCaptureError,
+  analyzeTileflowCaptureReference,
+  captureErrorMessage,
+  captureTileflowScenes,
+  compareTileflowCaptureToBaseline,
+  createTileflowCaptureBrowserEnvironment,
+  createTileflowCaptureReceipt,
+  createTileflowCaptureRendererIdentity,
+  createTileflowCaptureSession,
+  createTileflowVisualComparisonDocument,
+  createTileflowVisualReferenceAnalysisDocument,
+  launchTileflowCaptureBrowser,
+  parseTileflowCaptureReceipt,
+  resolveTileflowApplicationUrl,
+  serializeTileflowCaptureReceipt,
+  serializeTileflowVisualComparison,
+  setupTileflowCaptureBrowser,
+  tileflowCaptureReceiptLimits,
+  tileflowCaptureReceiptSchemaVersion,
+  tileflowCaptureResultSchemaVersion,
+  tileflowCaptureRuntime,
+  tileflowSyntheticAssetOrigin,
+  tileflowVisualArtifactLimits,
+  tileflowVisualComparisonSchemaVersion,
+  tileflowVisualPerceptualThreshold,
+  validateTileflowCaptureReceipt,
+  validateTileflowVisualReferencePng
+};