@tileflow/dev 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/inspect.js

@@ -0,0 +1,805 @@
+import {
+  createTileflowCommandSummary
+} from "./chunk-XHJBCVBB.js";
+import {
+  assertValidTileflowStyle,
+  sanitizeDiagnosticSecrets
+} from "./chunk-KDFTE4Q5.js";
+import {
+  defaultTileflowConfigPath,
+  loadValidTileflowConfigWithInputs
+} from "./chunk-AQUGMUZW.js";
+import "./chunk-D4OE4ITL.js";
+
+// src/inspect.ts
+import { isAbsolute, relative, resolve, win32 } from "path";
+import {
+  auditTileflowMapThemeValues,
+  compareCodeUnits as compareCodeUnits2,
+  parseTileflowMap,
+  resolveTileflowTheme
+} from "@tileflow/core";
+
+// src/feature-inspection.ts
+import { VectorTile } from "@mapbox/vector-tile";
+import { PbfReader } from "pbf";
+import { compareCodeUnits } from "@tileflow/core";
+import {
+  createStyleFromCatalog
+} from "@tileflow/core/build";
+var mercatorLatitudeLimit = 85.0511287798066;
+var maxTileJsonBytes = 1024 * 1024;
+var maxTileBytes = 6 * 1024 * 1024;
+var maxTotalTileBytes = 24 * 1024 * 1024;
+var maxTiles = 32;
+var maxScannedFeatures = 2e4;
+var maxStringLength = 256;
+async function inspectTileflowFeatures(project, mapName, input) {
+  const options = validateInspectionOptions(input);
+  if (!Object.hasOwn(project.maps, mapName)) {
+    const available = Object.keys(project.maps).sort(compareCodeUnits);
+    throw new Error(
+      `Unknown map "${mapName}". Available maps: ${available.join(", ") || "(none)"}`
+    );
+  }
+  const style = createStyleFromCatalog(project, mapName, {
+    apiBaseUrl: options.apiBaseUrl,
+    preparedAssets: options.preparedAssets
+  });
+  assertValidTileflowStyle(style, mapName);
+  const source = resolveVectorSource(style, options.sourceLayers);
+  const fetchImplementation = options.fetch ?? globalThis.fetch;
+  const remoteOrigins = /* @__PURE__ */ new Set();
+  const tileSource = await resolveTileSource(
+    source.definition,
+    fetchImplementation,
+    options,
+    remoteOrigins
+  );
+  const bounds = viewportBounds(options.center, options.zoom, options.width, options.height);
+  const tileZoom = resolveTileZoom(options.zoom, tileSource.minzoom, tileSource.maxzoom);
+  const tileCoordinates = tileCover(bounds, tileZoom);
+  if (tileCoordinates.length > maxTiles) {
+    throw new Error(
+      `Feature inspection would read ${tileCoordinates.length} tiles; narrow the viewport or increase zoom (maximum ${maxTiles}).`
+    );
+  }
+  const features = [];
+  let scannedFeatures = 0;
+  let totalTileBytes = 0;
+  let scanTruncated = false;
+  for (const coordinate of tileCoordinates) {
+    const tileUrl = resolveTileUrl(tileSource.template, coordinate, tileSource.scheme);
+    const bytes = await fetchBytes(tileUrl, {
+      fetchImplementation,
+      label: "vector tile",
+      limit: maxTileBytes,
+      signal: options.signal,
+      timeoutMs: options.timeoutMs
+    });
+    remoteOrigins.add(safeOrigin(bytes.finalUrl));
+    totalTileBytes += bytes.body.byteLength;
+    if (totalTileBytes > maxTotalTileBytes) {
+      throw new Error(
+        `Feature inspection exceeded the ${maxTotalTileBytes}-byte total vector-tile limit.`
+      );
+    }
+    const reader = new PbfReader(bytes.body);
+    const tile = new VectorTile(reader);
+    for (const sourceLayer of options.sourceLayers) {
+      const layer = tile.layers[sourceLayer];
+      if (!layer) continue;
+      for (let index = 0; index < layer.length; index += 1) {
+        scannedFeatures += 1;
+        if (scannedFeatures > maxScannedFeatures) {
+          scanTruncated = true;
+          break;
+        }
+        const vectorFeature = layer.feature(index);
+        const geoJsonFeature = vectorFeature.toGeoJSON(coordinate.x, coordinate.y, coordinate.z);
+        const geometry = summarizeGeometry(geoJsonFeature.geometry);
+        if (!geometry || !boundsIntersect(bounds, geometry.bounds)) continue;
+        features.push({
+          sourceLayer,
+          id: typeof vectorFeature.id === "number" && Number.isSafeInteger(vectorFeature.id) ? vectorFeature.id : null,
+          geometry,
+          properties: projectProperties(vectorFeature.properties, options.properties)
+        });
+      }
+      if (scanTruncated) break;
+    }
+    if (scanTruncated) break;
+  }
+  const uniqueFeatures = deduplicateFeatures(features).sort(compareInspectedFeatures);
+  const limitedFeatures = uniqueFeatures.slice(0, options.limit);
+  const dataIdentity = style.metadata?.["tileflow:data"];
+  const metadataVersion = dataIdentity && typeof dataIdentity === "object" && "revision" in dataIdentity ? dataIdentity.revision : void 0;
+  return {
+    schemaVersion: 1,
+    map: mapName,
+    camera: {
+      center: [...options.center],
+      zoom: options.zoom,
+      viewport: { width: options.width, height: options.height }
+    },
+    source: {
+      id: source.id,
+      origin: tileSource.origin,
+      tileJsonPath: tileSource.tileJsonPath,
+      tileOrigins: [...remoteOrigins].sort(compareCodeUnits),
+      version: typeof metadataVersion === "string" ? metadataVersion : null
+    },
+    sourceLayers: options.sourceLayers,
+    properties: options.properties,
+    tileZoom,
+    tilesRead: tileCoordinates.length,
+    scannedFeatures: Math.min(scannedFeatures, maxScannedFeatures),
+    truncated: scanTruncated || uniqueFeatures.length > options.limit,
+    features: limitedFeatures
+  };
+}
+function validateInspectionOptions(input) {
+  const center = input.center;
+  if (!Array.isArray(center) || center.length !== 2 || !Number.isFinite(center[0]) || !Number.isFinite(center[1]) || center[0] < -180 || center[0] > 180 || center[1] < -mercatorLatitudeLimit || center[1] > mercatorLatitudeLimit) {
+    throw new Error(
+      `Feature inspection center must be [longitude, latitude] inside Web Mercator bounds.`
+    );
+  }
+  if (!Number.isFinite(input.zoom) || input.zoom < 0 || input.zoom > 24) {
+    throw new Error("Feature inspection zoom must be between 0 and 24.");
+  }
+  const width = boundedInteger(input.width ?? 512, 64, 2048, "width");
+  const height = boundedInteger(input.height ?? 512, 64, 2048, "height");
+  const limit = boundedInteger(input.limit ?? 200, 1, 500, "limit");
+  const timeoutMs = boundedInteger(input.timeoutMs ?? 1e4, 100, 6e4, "timeout");
+  const sourceLayers = normalizeNames(input.sourceLayers, 1, 12, "source layer");
+  const properties = normalizeNames(input.properties ?? [], 0, 16, "property");
+  return {
+    ...input,
+    center: [center[0], center[1]],
+    height,
+    limit,
+    properties,
+    sourceLayers,
+    timeoutMs,
+    width
+  };
+}
+function boundedInteger(value, minimum, maximum, label) {
+  if (!Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new Error(
+      `Feature inspection ${label} must be an integer from ${minimum} to ${maximum}.`
+    );
+  }
+  return value;
+}
+function normalizeNames(values, minimum, maximum, label) {
+  if (!Array.isArray(values) || values.length < minimum || values.length > maximum) {
+    throw new Error(
+      `Feature inspection requires ${minimum}-${maximum} ${label}${maximum === 1 ? "" : "s"}.`
+    );
+  }
+  const normalized = [...new Set(values)].sort(compareCodeUnits);
+  for (const value of normalized) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/.test(value)) {
+      throw new Error(`Invalid feature inspection ${label} "${value}".`);
+    }
+  }
+  return normalized;
+}
+function resolveVectorSource(style, sourceLayers) {
+  const requested = new Set(sourceLayers);
+  const referencedSourceIds = new Set(
+    style.layers.filter((layer) => requested.has(String(layer["source-layer"] ?? ""))).map((layer) => layer.source).filter((sourceId) => typeof sourceId === "string")
+  );
+  const vectorSources = Object.entries(style.sources).filter(
+    ([, definition2]) => definition2.type === "vector"
+  );
+  const candidates = referencedSourceIds.size > 0 ? vectorSources.filter(([sourceId]) => referencedSourceIds.has(sourceId)) : vectorSources;
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Feature inspection requires exactly one vector source for the selected layers; found ${candidates.length}.`
+    );
+  }
+  const [id, definition] = candidates[0];
+  return { id, definition };
+}
+async function resolveTileSource(definition, fetchImplementation, options, origins) {
+  if (Array.isArray(definition.tiles) && typeof definition.tiles[0] === "string") {
+    const template2 = safeHttpUrl(definition.tiles[0], "vector tile template");
+    origins.add(template2.origin);
+    return {
+      maxzoom: finiteZoom(definition.maxzoom, 22),
+      minzoom: finiteZoom(definition.minzoom, 0),
+      origin: template2.origin,
+      scheme: definition.scheme === "tms" ? "tms" : "xyz",
+      template: template2,
+      tileJsonPath: null
+    };
+  }
+  if (typeof definition.url !== "string") {
+    throw new Error("Feature inspection vector source must define an HTTP(S) TileJSON URL.");
+  }
+  const tileJsonUrl = safeHttpUrl(definition.url, "TileJSON URL");
+  const response = await fetchBytes(tileJsonUrl, {
+    fetchImplementation,
+    label: "TileJSON",
+    limit: maxTileJsonBytes,
+    signal: options.signal,
+    timeoutMs: options.timeoutMs
+  });
+  const finalTileJsonUrl = safeHttpUrl(response.finalUrl, "TileJSON response URL");
+  origins.add(finalTileJsonUrl.origin);
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(response.body));
+  } catch {
+    throw new Error("Feature inspection received invalid TileJSON JSON.");
+  }
+  const tileJson = parseTileJson(parsed);
+  const template = safeHttpUrl(
+    new URL(tileJson.tiles[0], finalTileJsonUrl).toString(),
+    "vector tile template"
+  );
+  origins.add(template.origin);
+  return {
+    maxzoom: finiteZoom(tileJson.maxzoom, 22),
+    minzoom: finiteZoom(tileJson.minzoom, 0),
+    origin: finalTileJsonUrl.origin,
+    scheme: tileJson.scheme === "tms" ? "tms" : "xyz",
+    template,
+    tileJsonPath: finalTileJsonUrl.pathname
+  };
+}
+function parseTileJson(value) {
+  if (!isRecord(value) || !Array.isArray(value.tiles) || value.tiles.length === 0) {
+    throw new Error("Feature inspection TileJSON must contain a non-empty tiles array.");
+  }
+  const tiles = value.tiles.filter((entry) => typeof entry === "string");
+  if (tiles.length !== value.tiles.length || tiles.length > 8) {
+    throw new Error("Feature inspection TileJSON tiles must contain 1-8 URL templates.");
+  }
+  return {
+    tiles,
+    ...typeof value.maxzoom === "number" ? { maxzoom: value.maxzoom } : {},
+    ...typeof value.minzoom === "number" ? { minzoom: value.minzoom } : {},
+    ...typeof value.scheme === "string" ? { scheme: value.scheme } : {}
+  };
+}
+function finiteZoom(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 24 ? value : fallback;
+}
+function resolveTileZoom(zoom, minzoom, maxzoom) {
+  if (minzoom > maxzoom) throw new Error("Feature inspection source minzoom exceeds maxzoom.");
+  return Math.max(minzoom, Math.min(maxzoom, Math.floor(zoom)));
+}
+function viewportBounds(center, zoom, width, height) {
+  const centerX = longitudeToWorldX(center[0]);
+  const centerY = latitudeToWorldY(center[1]);
+  const scale = 512 * 2 ** zoom;
+  const westX = centerX - width / 2 / scale;
+  const eastX = centerX + width / 2 / scale;
+  if (westX < 0 || eastX > 1) {
+    throw new Error("Feature inspection viewports that cross the antimeridian are not supported.");
+  }
+  const northY = Math.max(0, centerY - height / 2 / scale);
+  const southY = Math.min(1, centerY + height / 2 / scale);
+  return [
+    worldXToLongitude(westX),
+    worldYToLatitude(southY),
+    worldXToLongitude(eastX),
+    worldYToLatitude(northY)
+  ];
+}
+function tileCover(bounds, zoom) {
+  const count = 2 ** zoom;
+  const minimumX = clampTile(Math.floor(longitudeToWorldX(bounds[0]) * count), count);
+  const maximumX = clampTile(Math.floor(longitudeToWorldX(bounds[2]) * count), count);
+  const minimumY = clampTile(Math.floor(latitudeToWorldY(bounds[3]) * count), count);
+  const maximumY = clampTile(Math.floor(latitudeToWorldY(bounds[1]) * count), count);
+  const coordinates = [];
+  for (let y = minimumY; y <= maximumY; y += 1) {
+    for (let x = minimumX; x <= maximumX; x += 1) coordinates.push({ x, y, z: zoom });
+  }
+  return coordinates;
+}
+function clampTile(value, count) {
+  return Math.max(0, Math.min(count - 1, value));
+}
+function resolveTileUrl(template, coordinate, scheme) {
+  const y = scheme === "tms" ? 2 ** coordinate.z - 1 - coordinate.y : coordinate.y;
+  const replacements = {
+    z: coordinate.z,
+    x: coordinate.x,
+    y,
+    "-y": 2 ** coordinate.z - 1 - coordinate.y
+  };
+  let value = template.toString();
+  for (const [token, replacement] of Object.entries(replacements)) {
+    value = value.replace(
+      new RegExp(`(?:\\{${token}\\}|%7B${token}%7D)`, "giu"),
+      String(replacement)
+    );
+  }
+  if (/(?:\{(?:z|x|-?y)\}|%7B(?:z|x|-?y)%7D)/iu.test(value)) {
+    throw new Error("Feature inspection tile template contains unresolved coordinates.");
+  }
+  return new URL(value);
+}
+async function fetchBytes(url, options) {
+  const timeout = AbortSignal.timeout(options.timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+  const response = await options.fetchImplementation(url, { signal });
+  if (!response.ok) {
+    throw new Error(`${options.label} request failed with HTTP ${response.status}.`);
+  }
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > options.limit) {
+    throw new Error(`${options.label} exceeds the ${options.limit}-byte limit.`);
+  }
+  if (!response.body) throw new Error(`${options.label} response had no body.`);
+  const chunks = [];
+  let length = 0;
+  const reader = response.body.getReader();
+  while (true) {
+    const result = await reader.read();
+    if (result.done) break;
+    length += result.value.byteLength;
+    if (length > options.limit) {
+      await reader.cancel();
+      throw new Error(`${options.label} exceeds the ${options.limit}-byte limit.`);
+    }
+    chunks.push(result.value);
+  }
+  const body = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { body, finalUrl: response.url || url.toString() };
+}
+function summarizeGeometry(value) {
+  if (!isRecord(value) || typeof value.type !== "string" || !("coordinates" in value)) return;
+  const points = [];
+  collectCoordinates(value.coordinates, points);
+  if (points.length === 0) return;
+  let west = Infinity;
+  let south = Infinity;
+  let east = -Infinity;
+  let north = -Infinity;
+  for (const [longitude, latitude] of points) {
+    west = Math.min(west, longitude);
+    south = Math.min(south, latitude);
+    east = Math.max(east, longitude);
+    north = Math.max(north, latitude);
+  }
+  return {
+    type: value.type,
+    center: [roundCoordinate((west + east) / 2), roundCoordinate((south + north) / 2)],
+    bounds: [
+      roundCoordinate(west),
+      roundCoordinate(south),
+      roundCoordinate(east),
+      roundCoordinate(north)
+    ]
+  };
+}
+function collectCoordinates(value, points) {
+  if (!Array.isArray(value)) return;
+  if (value.length >= 2 && typeof value[0] === "number" && Number.isFinite(value[0]) && typeof value[1] === "number" && Number.isFinite(value[1])) {
+    points.push([value[0], value[1]]);
+    return;
+  }
+  for (const child of value) collectCoordinates(child, points);
+}
+function boundsIntersect(left, right) {
+  return left[0] <= right[2] && left[2] >= right[0] && left[1] <= right[3] && left[3] >= right[1];
+}
+function projectProperties(source, properties) {
+  const projected = {};
+  for (const property of properties) {
+    const value = source[property];
+    if (typeof value === "string") projected[property] = value.slice(0, maxStringLength);
+    else if (typeof value === "boolean") projected[property] = value;
+    else if (typeof value === "number" && Number.isFinite(value)) projected[property] = value;
+  }
+  return projected;
+}
+function deduplicateFeatures(features) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const feature of features) {
+    const key = feature.id === null ? `${feature.sourceLayer}|${JSON.stringify(feature.geometry)}|${JSON.stringify(feature.properties)}` : `${feature.sourceLayer}|id:${feature.id}`;
+    if (!unique.has(key)) unique.set(key, feature);
+  }
+  return [...unique.values()];
+}
+function compareInspectedFeatures(left, right) {
+  const leftName = typeof left.properties.name === "string" ? left.properties.name : "";
+  const rightName = typeof right.properties.name === "string" ? right.properties.name : "";
+  return compareCodeUnits(left.sourceLayer, right.sourceLayer) || Number(rightName.length > 0) - Number(leftName.length > 0) || compareCodeUnits(leftName, rightName) || (left.id ?? Number.MAX_SAFE_INTEGER) - (right.id ?? Number.MAX_SAFE_INTEGER) || compareCodeUnits(JSON.stringify(left), JSON.stringify(right));
+}
+function safeHttpUrl(value, label) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error(`Feature inspection ${label} is not a valid URL.`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`Feature inspection ${label} must use HTTP or HTTPS.`);
+  }
+  return parsed;
+}
+function safeOrigin(value) {
+  return safeHttpUrl(value, "response URL").origin;
+}
+function longitudeToWorldX(longitude) {
+  return (longitude + 180) / 360;
+}
+function worldXToLongitude(x) {
+  return x * 360 - 180;
+}
+function latitudeToWorldY(latitude) {
+  const radians = latitude * Math.PI / 180;
+  return (1 - Math.log(Math.tan(radians) + 1 / Math.cos(radians)) / Math.PI) / 2;
+}
+function worldYToLatitude(y) {
+  return Math.atan(Math.sinh(Math.PI * (1 - 2 * y))) * 180 / Math.PI;
+}
+function roundCoordinate(value) {
+  return Math.round(value * 1e7) / 1e7;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+// src/inspect.ts
+async function inspectTileflowConfig(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const loaded = await loadValidTileflowConfigWithInputs(
+    options.config ?? defaultTileflowConfigPath,
+    options
+  );
+  return inspectLoadedTileflowConfig(loaded, { cwd, map: options.map });
+}
+function inspectLoadedTileflowConfig(loaded, options) {
+  const mapIds = Object.keys(loaded.project.maps).sort(compareCodeUnits2);
+  if (options.map && !Object.hasOwn(loaded.project.maps, options.map)) {
+    throw new TileflowConfigInspectionError(
+      "INSPECT_MAP_NOT_FOUND",
+      `Unknown Tileflow map "${options.map}". Available maps: ${mapIds.join(", ") || "(none)"}.`,
+      "map"
+    );
+  }
+  const selectedMapIds = options.map ? [options.map] : mapIds;
+  const maps = selectedMapIds.map(
+    (mapId) => inspectResolvedMap(loaded, mapId, resolve(options.cwd))
+  );
+  const summary = createTileflowCommandSummary({
+    code: "INSPECTION_READY",
+    command: "inspect",
+    message: `Resolved Tileflow config inspection is ready (${maps.length} ${maps.length === 1 ? "map" : "maps"}).`,
+    ok: true,
+    path: "",
+    phase: "config-inspection",
+    severity: "info",
+    suggestion: "Use lineage and provenance paths to make the smallest authoring change."
+  });
+  return { ...summary, command: "inspect", ok: true, maps, diagnostics: [] };
+}
+var TileflowConfigInspectionError = class extends Error {
+  constructor(code, message, path) {
+    super(message);
+    this.code = code;
+    this.name = "TileflowConfigInspectionError";
+    this.issues = [{ code, message, path, phase: this.phase }];
+  }
+  code;
+  phase = "config-inspection";
+  issues;
+};
+function inspectResolvedMap(loaded, mapId, cwd) {
+  const sourceMap = loaded.authoringMaps[mapId];
+  const resolvedMap = loaded.project.maps[mapId];
+  if (!sourceMap || !resolvedMap) {
+    throw new TileflowConfigInspectionError(
+      "INSPECT_MAP_SOURCE_MISSING",
+      `Unable to inspect Tileflow map "${mapId}".`,
+      `maps.${mapId}`
+    );
+  }
+  const sourceLineage = collectAuthoringLineage(sourceMap).reverse();
+  const snapshots = sourceLineage.map((map) => parseTileflowMap(map));
+  const resolved = sanitizeInspectValue(resolvedMap, cwd);
+  if (!isRecord2(resolved)) {
+    throw new TileflowConfigInspectionError(
+      "INSPECT_RESOLVED_MAP_INVALID",
+      `Resolved Tileflow map "${mapId}" is not an object.`,
+      `maps.${mapId}`
+    );
+  }
+  return {
+    id: sanitizeDiagnosticSecrets(mapId),
+    lineage: sourceLineage.map((map, depth) => ({
+      depth,
+      declaredPaths: collectLeafEntries(map, { cwd, excludeExtends: true }).map(
+        (entry) => entry.path
+      ),
+      id: sanitizeDiagnosticSecrets(map.id),
+      version: map.version
+    })),
+    provenance: createMergeProvenance(
+      resolvedMap,
+      sourceLineage,
+      snapshots,
+      cwd
+    ),
+    resolved,
+    themeContract: inspectThemeContract(resolvedMap, cwd)
+  };
+}
+function inspectThemeContract(map, cwd) {
+  const names = Object.keys(map.themes).sort(compareCodeUnits2);
+  const defaultResolved = resolveTileflowTheme(map.themes[map.defaultTheme]);
+  const comparableDefault = {
+    colorScheme: defaultResolved.colorScheme,
+    lighting: defaultResolved.lighting,
+    tokens: defaultResolved.tokens,
+    typography: defaultResolved.typography
+  };
+  const themes = Object.fromEntries(
+    names.map((name) => {
+      const resolved = resolveTileflowTheme(map.themes[name]);
+      const comparable = {
+        colorScheme: resolved.colorScheme,
+        lighting: resolved.lighting,
+        tokens: resolved.tokens,
+        typography: resolved.typography
+      };
+      return [
+        name,
+        {
+          colorScheme: resolved.colorScheme,
+          differencesFromDefault: name === map.defaultTheme ? [] : compareThemeValues(comparableDefault, comparable, cwd),
+          id: sanitizeDiagnosticSecrets(resolved.id),
+          isDefault: name === map.defaultTheme,
+          lighting: sanitizeInspectableRecord(resolved.lighting, cwd),
+          name,
+          systemFor: ["dark", "light"].filter(
+            (scheme) => map.systemThemes?.[scheme] === name
+          ),
+          tokens: sanitizeInspectValue(resolved.tokens, cwd),
+          typography: sanitizeInspectableRecord(resolved.typography, cwd),
+          version: resolved.version
+        }
+      ];
+    })
+  );
+  const tokenSchema = {
+    color: Object.keys(defaultResolved.tokens.color).sort(compareCodeUnits2),
+    font: Object.keys(defaultResolved.tokens.font).sort(compareCodeUnits2),
+    image: Object.keys(defaultResolved.tokens.image).sort(compareCodeUnits2),
+    number: Object.keys(defaultResolved.tokens.number).sort(compareCodeUnits2)
+  };
+  const audit = auditTileflowMapThemeValues(map).map((diagnostic) => {
+    const value = sanitizeInspectValue(diagnostic.value, cwd);
+    return {
+      ...diagnostic,
+      message: sanitizeDiagnosticSecrets(diagnostic.message),
+      ...diagnostic.owner === void 0 ? {} : { owner: sanitizeDiagnosticSecrets(diagnostic.owner) },
+      path: sanitizeDiagnosticSecrets(diagnostic.path),
+      suggestion: sanitizeDiagnosticSecrets(diagnostic.suggestion),
+      ...diagnostic.target === void 0 ? {} : { target: sanitizeDiagnosticSecrets(diagnostic.target) },
+      value: typeof value === "number" ? value : String(value)
+    };
+  });
+  return {
+    audit,
+    defaultTheme: map.defaultTheme,
+    ...map.systemThemes ? { systemThemes: map.systemThemes } : {},
+    themes,
+    tokenSchema
+  };
+}
+function compareThemeValues(from, to, cwd) {
+  const differences = [];
+  const visit = (left, right, segments) => {
+    if (isRecord2(left) || isRecord2(right)) {
+      const keys = /* @__PURE__ */ new Set([
+        ...Object.keys(isRecord2(left) ? left : {}),
+        ...Object.keys(isRecord2(right) ? right : {})
+      ]);
+      for (const key of [...keys].sort(compareCodeUnits2)) {
+        visit(isRecord2(left) ? left[key] : void 0, isRecord2(right) ? right[key] : void 0, [
+          ...segments,
+          key
+        ]);
+      }
+      return;
+    }
+    if (equalInspectableValues(left, right)) return;
+    differences.push({
+      from: sanitizeInspectValue(left, cwd),
+      path: formatConfigPath(segments, cwd),
+      to: sanitizeInspectValue(right, cwd)
+    });
+  };
+  visit(from, to, []);
+  return differences.sort((left, right) => compareCodeUnits2(left.path, right.path));
+}
+function sanitizeInspectableRecord(value, cwd) {
+  const sanitized = sanitizeInspectValue(value, cwd);
+  return isRecord2(sanitized) ? sanitized : {};
+}
+function collectAuthoringLineage(map) {
+  const lineage = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = map;
+  while (current && !seen.has(current) && lineage.length < 64) {
+    seen.add(current);
+    lineage.push(current);
+    current = current.extends;
+  }
+  return lineage;
+}
+function createMergeProvenance(resolved, lineage, snapshots, cwd) {
+  return collectLeafEntries(resolved, { cwd }).map(({ path, segments }) => {
+    let sourceIndex = 0;
+    let declared = hasPath(lineage[0], segments);
+    for (let index = 1; index < snapshots.length; index += 1) {
+      const explicitlyDeclared = hasPath(lineage[index], segments);
+      if (explicitlyDeclared || !equalInspectableValues(
+        getPath(snapshots[index - 1], segments),
+        getPath(snapshots[index], segments)
+      )) {
+        sourceIndex = index;
+        declared = explicitlyDeclared;
+      }
+    }
+    return {
+      declared,
+      inherited: sourceIndex < lineage.length - 1,
+      operation: sourceIndex === 0 || !hasPath(snapshots[sourceIndex - 1], segments) ? "defined" : "overridden",
+      path,
+      sourceDepth: sourceIndex,
+      sourceMap: sanitizeDiagnosticSecrets(lineage[sourceIndex].id)
+    };
+  });
+}
+function collectLeafEntries(value, options) {
+  const entries = [];
+  const visit = (candidate, segments) => {
+    if (isRecord2(candidate) && Object.keys(candidate).length > 0) {
+      for (const key of Object.keys(candidate).sort(compareCodeUnits2)) {
+        if (options.excludeExtends && segments.length === 0 && key === "extends") continue;
+        visit(candidate[key], [...segments, key]);
+      }
+      return;
+    }
+    entries.push({ path: formatConfigPath(segments, options.cwd), segments });
+  };
+  visit(value, []);
+  return entries.sort((left, right) => compareCodeUnits2(left.path, right.path));
+}
+function formatConfigPath(segments, cwd) {
+  return segments.map((segment, index) => {
+    const safeSegment = sanitizeInspectKey(segment, cwd);
+    return /^[A-Za-z_][A-Za-z0-9_-]*$/u.test(safeSegment) ? `${index === 0 ? "" : "."}${safeSegment}` : `[${JSON.stringify(safeSegment).slice(0, 132)}]`;
+  }).join("");
+}
+function getPath(value, segments) {
+  let current = value;
+  for (const segment of segments) {
+    if (!isRecord2(current) || !Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function hasPath(value, segments) {
+  let current = value;
+  for (const segment of segments) {
+    if (!isRecord2(current) || !Object.hasOwn(current, segment)) return false;
+    current = current[segment];
+  }
+  return true;
+}
+function equalInspectableValues(left, right) {
+  return JSON.stringify(sortInspectableValue(left)) === JSON.stringify(sortInspectableValue(right));
+}
+function sortInspectableValue(value) {
+  if (Array.isArray(value)) return value.map(sortInspectableValue);
+  if (!isRecord2(value)) return value;
+  return Object.fromEntries(
+    Object.keys(value).sort(compareCodeUnits2).map((key) => [key, sortInspectableValue(value[key])])
+  );
+}
+function sanitizeTileflowInspectableValue(value, cwd) {
+  return sanitizeInspectValue(value, cwd);
+}
+function sanitizeInspectValue(value, cwd, seen = /* @__PURE__ */ new WeakSet(), path = []) {
+  if (typeof value === "string") return sanitizeInspectString(value, cwd, path);
+  if (value === null || typeof value === "boolean" || typeof value === "number") return value;
+  if (Array.isArray(value)) return value.map((item) => sanitizeInspectValue(item, cwd, seen, path));
+  if (!isRecord2(value)) return null;
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  const result = {};
+  for (const key of Object.keys(value).sort(compareCodeUnits2)) {
+    if (value[key] === void 0) continue;
+    const safeKey = uniqueInspectKey(result, sanitizeInspectKey(key, cwd));
+    result[safeKey] = sanitizeInspectValue(value[key], cwd, seen, [...path, key]);
+  }
+  seen.delete(value);
+  return result;
+}
+function sanitizeInspectKey(value, cwd) {
+  return boundInspectString(sanitizeInspectString(value, cwd, [])) || "(empty)";
+}
+function uniqueInspectKey(target, key) {
+  if (!Object.hasOwn(target, key)) return key;
+  let suffix = 2;
+  while (Object.hasOwn(target, `${key}#${suffix}`)) suffix += 1;
+  return `${key}#${suffix}`;
+}
+function sanitizeInspectString(value, cwd, path) {
+  const normalizedCwd = resolve(cwd);
+  if (value === normalizedCwd || value.startsWith(`${normalizedCwd}/`)) {
+    const local = relative(normalizedCwd, value).replaceAll("\\", "/");
+    return sanitizeDiagnosticSecrets(local ? `./${local}` : ".");
+  }
+  if (value.startsWith("data:")) return "data:[redacted]";
+  if (/^https?:\/\//iu.test(value)) {
+    try {
+      const url = new URL(value);
+      const suffix = `${url.search ? "?[redacted]" : ""}${url.hash ? "#[redacted]" : ""}`;
+      return boundInspectString(
+        sanitizeDiagnosticSecrets(`${url.protocol}//${url.host}${sanitizeUrlPath(url)}${suffix}`)
+      );
+    } catch {
+      return "(resource URL)";
+    }
+  }
+  if (win32.isAbsolute(value) || value.startsWith("file:")) {
+    return "(external path)";
+  }
+  if (path.at(-1) === "url") return sanitizeRelativeResourceUrl(value);
+  if (isAbsolute(value)) {
+    return "(external path)";
+  }
+  const sanitized = sanitizeDiagnosticSecrets(value.replace(/[\r\n]+/gu, " ").trim());
+  return boundInspectString(sanitized);
+}
+function sanitizeUrlPath(url) {
+  try {
+    const decoded = decodeURIComponent(url.pathname);
+    if (sanitizeDiagnosticSecrets(decoded) !== decoded) return "/[redacted]";
+  } catch {
+    return "/[redacted]";
+  }
+  return sanitizeDiagnosticSecrets(url.pathname);
+}
+function sanitizeRelativeResourceUrl(value) {
+  const queryIndex = value.indexOf("?");
+  const hashIndex = value.indexOf("#");
+  const cutoffs = [queryIndex, hashIndex].filter((index) => index >= 0);
+  const cutoff = cutoffs.length ? Math.min(...cutoffs) : value.length;
+  const path = sanitizeDiagnosticSecrets(value.slice(0, cutoff));
+  const hasQuery = queryIndex >= 0 && (hashIndex < 0 || queryIndex < hashIndex);
+  return boundInspectString(
+    `${path}${hasQuery ? "?[redacted]" : ""}${hashIndex >= 0 ? "#[redacted]" : ""}`
+  );
+}
+function boundInspectString(value) {
+  return value.length <= 2048 ? value : `${value.slice(0, 2047)}\u2026`;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+export {
+  TileflowConfigInspectionError,
+  inspectLoadedTileflowConfig,
+  inspectTileflowConfig,
+  inspectTileflowFeatures,
+  sanitizeTileflowInspectableValue
+};