map-zero 0.1.0 → 0.2.1

package/src/export-pmtiles.js

@@ -746,10 +746,11 @@ function createExportRecommendation(options) {
  */
 function tileRangeForBbox(bbox, z) {
   const [minLon, minLat, maxLon, maxLat] = bbox;
-  const minX = lonToTileX(minLon, z);
-  const maxX = lonToTileX(maxLon, z);
-  const minY = latToTileY(maxLat, z);
-  const maxY = latToTileY(minLat, z);
+  const maxTile = 2 ** z - 1;
+  const minX = clamp(lonToTileX(minLon, z) - 1, 0, maxTile);
+  const maxX = clamp(lonToTileX(maxLon, z) + 1, 0, maxTile);
+  const minY = clamp(latToTileY(maxLat, z) - 1, 0, maxTile);
+  const maxY = clamp(latToTileY(minLat, z) + 1, 0, maxTile);
   return {
     minX,
     maxX,
@@ -807,7 +808,7 @@ function formatInteger(value) {
  * @returns {string[]}
  */
 function activeLayerIdsForZoom(manifest, style, zoom) {
-  const layers = /** @type {Array<Record<string, unknown>>} */ (manifest.layers ?? []);
+  const layers = /** @type {string[]} */ (manifest.layers ?? []);
   const visualLayers = layers
     .filter((layer) => {
       const rule = layerStyleRule(style, layer);
@@ -825,19 +826,19 @@ function activeLayerIdsForZoom(manifest, style, zoom) {
 
       return true;
     })
-    .map((layer) => String(layer.id));
+    .map((layer) => String(layer));
 
   return visualLayers;
 }
 
 /**
  * @param {Record<string, unknown> | null} style
- * @param {Record<string, unknown>} layer
+ * @param {string} layerId
  * @returns {Record<string, unknown>}
  */
-function layerStyleRule(style, layer) {
+function layerStyleRule(style, layerId) {
   const styleLayers = /** @type {Record<string, unknown> | undefined} */ (style?.layers);
-  const rule = /** @type {Record<string, unknown>} */ (styleLayers?.[String(layer.style ?? layer.id)] ?? {});
+  const rule = /** @type {Record<string, unknown>} */ (styleLayers?.[layerId] ?? {});
   const visibility = rule.visibility && typeof rule.visibility === 'object'
     ? /** @type {Record<string, unknown>} */ (rule.visibility)
     : null;
@@ -902,7 +903,7 @@ function closeWriteStream(stream) {
  * @returns {Record<string, unknown>}
  */
 function createPmtilesMetadata(manifest, style, minZoom, maxZoom, bbox) {
-  const layers = /** @type {Array<Record<string, unknown>>} */ (manifest.layers ?? []);
+  const layers = /** @type {string[]} */ (manifest.layers ?? []);
   return {
     tilejson: '3.0.0',
     name: manifest.name ?? 'map-zero',
@@ -914,25 +915,25 @@ function createPmtilesMetadata(manifest, style, minZoom, maxZoom, bbox) {
     center: [(bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2, Math.min(Math.max(12, minZoom), maxZoom)],
     minzoom: minZoom,
     maxzoom: maxZoom,
-    vector_layers: layers.map((layer) => ({
-      id: String(layer.id),
-      fields: fieldsForLayer(style, layer)
+    vector_layers: layers.map((layerId) => ({
+      id: layerId,
+      fields: fieldsForLayer(style, layerId)
     }))
   };
 }
 
 /**
  * @param {Record<string, unknown> | null} style
- * @param {Record<string, unknown>} layer
+ * @param {string} layerId
  * @returns {Record<string, string>}
  */
-function fieldsForLayer(style, layer) {
+function fieldsForLayer(style, layerId) {
   const fields = {
     id: 'String',
     name: 'String',
     layer: 'String'
   };
-  const byProperty = /** @type {Record<string, unknown> | undefined} */ (layerStyleRule(style, layer).byProperty);
+  const byProperty = /** @type {Record<string, unknown> | undefined} */ (layerStyleRule(style, layerId).byProperty);
   if (byProperty) {
     for (const key of Object.keys(byProperty)) {
       fields[key] = 'String';

package/src/from-bbox.js

@@ -0,0 +1,335 @@
+import { createWriteStream, promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { once } from 'node:events';
+
+import { buildPackage } from './build.js';
+import { export3dTiles } from './3dtiles/export.js';
+import { exportPmtiles } from './export-pmtiles.js';
+import { packageMapZero } from './package.js';
+
+const GEOFABRIK_INDEX_URL = 'https://download.geofabrik.de/index-v1.json';
+
+/**
+ * Download the smallest matching OSM extract and build a complete map-zero
+ * package for the requested bbox.
+ *
+ * @param {{
+ *   bbox: [number, number, number, number],
+ *   out: string,
+ *   layers: string[],
+ *   minZoom?: number,
+ *   maxZoom?: number,
+ *   workers?: number,
+ *   forcePmtiles?: boolean,
+ *   pmtiles?: boolean,
+ *   tiles3d?: boolean,
+ *   zip?: boolean,
+ *   includeGpkg?: boolean,
+ *   batchSize?: number,
+ *   keepTemp?: boolean,
+ *   debugBuild?: boolean,
+ *   cacheDir?: string,
+ *   providerIndexUrl?: string,
+ *   forceDownload?: boolean,
+ *   onStage?: (message: string) => void,
+ *   onBuildProgress?: Parameters<typeof buildPackage>[0]['onProgress'],
+ *   onPmtilesProgress?: Parameters<typeof exportPmtiles>[0]['onProgress'],
+ *   on3dTilesProgress?: Parameters<typeof export3dTiles>[0]['onProgress']
+ * }} options
+ * @returns {Promise<{
+ *   outDir: string,
+ *   source: { name: string, id: string, url: string, path: string },
+ *   counts: Record<string, number>,
+ *   pmtiles?: Awaited<ReturnType<typeof exportPmtiles>>,
+ *   tiles3d?: Awaited<ReturnType<typeof export3dTiles>>,
+ *   zip?: Awaited<ReturnType<typeof packageMapZero>>
+ * }>}
+ */
+export async function createPackageFromBbox(options) {
+  const bbox = options.bbox;
+  const outDir = resolve(options.out);
+  const cacheDir = resolve(options.cacheDir ?? join(homedir(), '.cache', 'map-zero', 'osm'));
+  const provider = await findGeofabrikExtract(bbox, {
+    cacheDir,
+    indexUrl: options.providerIndexUrl
+  });
+
+  options.onStage?.(`Using OSM extract: ${provider.name} (${provider.id})`);
+  const sourcePath = await downloadExtract(provider, {
+    cacheDir,
+    forceDownload: Boolean(options.forceDownload),
+    onStage: options.onStage
+  });
+
+  options.onStage?.('Building map-zero package');
+  const build = await buildPackage({
+    source: sourcePath,
+    bbox,
+    layers: options.layers,
+    out: outDir,
+    keepTemp: options.keepTemp,
+    batchSize: options.batchSize,
+    debugBuild: options.debugBuild,
+    onProgress: options.onBuildProgress
+  });
+
+  /** @type {Awaited<ReturnType<typeof exportPmtiles>> | undefined} */
+  let pmtiles;
+  if (options.pmtiles !== false) {
+    options.onStage?.('Exporting PMTiles');
+    pmtiles = await exportPmtiles({
+      packageDir: outDir,
+      minZoom: options.minZoom ?? 8,
+      maxZoom: options.maxZoom ?? 16,
+      workers: options.workers ?? 1,
+      force: Boolean(options.forcePmtiles),
+      onProgress: options.onPmtilesProgress
+    });
+  }
+
+  /** @type {Awaited<ReturnType<typeof export3dTiles>> | undefined} */
+  let tiles3d;
+  if (options.tiles3d !== false) {
+    options.onStage?.('Exporting 3D Tiles');
+    tiles3d = await export3dTiles({
+      packageDir: outDir,
+      onProgress: options.on3dTilesProgress
+    });
+  }
+
+  /** @type {Awaited<ReturnType<typeof packageMapZero>> | undefined} */
+  let zip;
+  if (options.zip !== false) {
+    options.onStage?.('Creating portable zip');
+    zip = await packageMapZero({
+      packageDir: outDir,
+      includeGpkg: Boolean(options.includeGpkg)
+    });
+  }
+
+  return {
+    outDir,
+    source: {
+      name: provider.name,
+      id: provider.id,
+      url: provider.url,
+      path: sourcePath
+    },
+    counts: build.counts,
+    pmtiles,
+    tiles3d,
+    zip
+  };
+}
+
+/**
+ * @param {[number, number, number, number]} bbox
+ * @param {{ cacheDir: string, indexUrl?: string }} options
+ */
+async function findGeofabrikExtract(bbox, options) {
+  const index = await loadGeofabrikIndex(options.cacheDir, options.indexUrl ?? GEOFABRIK_INDEX_URL);
+  const features = Array.isArray(index.features) ? index.features : [];
+  const candidates = features
+    .map(normalizeGeofabrikFeature)
+    .filter(Boolean)
+    .filter((feature) => bboxInsideFeature(bbox, feature))
+    .sort((a, b) => featureArea(a) - featureArea(b));
+
+  const selected = candidates[0];
+  if (!selected) {
+    throw new Error(`no Geofabrik extract fully contains bbox ${formatBbox(bbox)}`);
+  }
+  return selected;
+}
+
+async function loadGeofabrikIndex(cacheDir, indexUrl) {
+  await fs.mkdir(cacheDir, { recursive: true });
+  const indexPath = join(cacheDir, 'geofabrik-index-v1.json');
+  const cached = await fs.readFile(indexPath, 'utf8').catch(() => null);
+  if (cached) {
+    return JSON.parse(cached);
+  }
+
+  const response = await fetch(indexUrl);
+  if (!response.ok) {
+    throw new Error(`failed to download Geofabrik index: HTTP ${response.status}`);
+  }
+  const text = await response.text();
+  await fs.writeFile(indexPath, text);
+  return JSON.parse(text);
+}
+
+function normalizeGeofabrikFeature(feature) {
+  const properties = feature?.properties && typeof feature.properties === 'object' ? feature.properties : {};
+  const urls = properties.urls && typeof properties.urls === 'object' ? properties.urls : {};
+  const url = typeof urls.pbf === 'string' ? urls.pbf : null;
+  const id = typeof properties.id === 'string' ? properties.id : null;
+  const name = typeof properties.name === 'string' ? properties.name : id;
+  if (!url || !id || !name || !feature?.geometry) {
+    return null;
+  }
+  return {
+    id,
+    name,
+    url,
+    geometry: feature.geometry,
+    bbox: geometryBbox(feature.geometry)
+  };
+}
+
+async function downloadExtract(provider, options) {
+  await fs.mkdir(options.cacheDir, { recursive: true });
+  const fileName = safeFileName(basename(new URL(provider.url).pathname) || `${provider.id}.osm.pbf`);
+  const filePath = join(options.cacheDir, fileName);
+  const stat = await fs.stat(filePath).catch(() => null);
+  if (stat?.isFile() && stat.size > 0 && !options.forceDownload) {
+    options.onStage?.(`Using cached extract: ${filePath}`);
+    return filePath;
+  }
+
+  options.onStage?.(`Downloading ${provider.url}`);
+  const response = await fetch(provider.url);
+  if (!response.ok || !response.body) {
+    throw new Error(`failed to download OSM extract: HTTP ${response.status}`);
+  }
+
+  const tempPath = `${filePath}.part`;
+  const stream = createWriteStream(tempPath);
+  for await (const chunk of response.body) {
+    if (!stream.write(Buffer.from(chunk))) {
+      await once(stream, 'drain');
+    }
+  }
+  stream.end();
+  await once(stream, 'finish');
+  await fs.rename(tempPath, filePath);
+  return filePath;
+}
+
+function bboxInsideFeature(bbox, feature) {
+  if (feature.bbox && !bboxInsideBbox(bbox, feature.bbox)) {
+    return false;
+  }
+  return bboxCorners(bbox).every((point) => pointInGeometry(point, feature.geometry));
+}
+
+function bboxInsideBbox(inner, outer) {
+  return inner[0] >= outer[0] &&
+    inner[1] >= outer[1] &&
+    inner[2] <= outer[2] &&
+    inner[3] <= outer[3];
+}
+
+function bboxCorners(bbox) {
+  return [
+    [bbox[0], bbox[1]],
+    [bbox[0], bbox[3]],
+    [bbox[2], bbox[1]],
+    [bbox[2], bbox[3]]
+  ];
+}
+
+function pointInGeometry(point, geometry) {
+  if (geometry?.type === 'Polygon') {
+    return pointInPolygon(point, geometry.coordinates);
+  }
+  if (geometry?.type === 'MultiPolygon') {
+    return geometry.coordinates.some((polygon) => pointInPolygon(point, polygon));
+  }
+  return false;
+}
+
+function pointInPolygon(point, rings) {
+  if (!Array.isArray(rings) || rings.length === 0) {
+    return false;
+  }
+  if (!pointInRing(point, rings[0])) {
+    return false;
+  }
+  return rings.slice(1).every((hole) => !pointInRing(point, hole));
+}
+
+function pointInRing(point, ring) {
+  let inside = false;
+  const x = point[0];
+  const y = point[1];
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i, i += 1) {
+    const xi = Number(ring[i]?.[0]);
+    const yi = Number(ring[i]?.[1]);
+    const xj = Number(ring[j]?.[0]);
+    const yj = Number(ring[j]?.[1]);
+    if (pointOnSegment(x, y, xi, yi, xj, yj)) {
+      return true;
+    }
+    const intersects = ((yi > y) !== (yj > y)) &&
+      x < ((xj - xi) * (y - yi)) / (yj - yi) + xi;
+    if (intersects) inside = !inside;
+  }
+  return inside;
+}
+
+function pointOnSegment(x, y, x1, y1, x2, y2) {
+  const cross = (x - x1) * (y2 - y1) - (y - y1) * (x2 - x1);
+  if (Math.abs(cross) > 1e-10) return false;
+  const dot = (x - x1) * (x2 - x1) + (y - y1) * (y2 - y1);
+  if (dot < 0) return false;
+  const lengthSquared = (x2 - x1) ** 2 + (y2 - y1) ** 2;
+  return dot <= lengthSquared;
+}
+
+function geometryBbox(geometry) {
+  const points = [];
+  collectGeometryPoints(geometry, points);
+  if (points.length === 0) return null;
+  let minLon = Infinity;
+  let minLat = Infinity;
+  let maxLon = -Infinity;
+  let maxLat = -Infinity;
+  for (const point of points) {
+    minLon = Math.min(minLon, point[0]);
+    minLat = Math.min(minLat, point[1]);
+    maxLon = Math.max(maxLon, point[0]);
+    maxLat = Math.max(maxLat, point[1]);
+  }
+  return [minLon, minLat, maxLon, maxLat];
+}
+
+function collectGeometryPoints(geometry, points) {
+  if (geometry?.type === 'Polygon') {
+    for (const ring of geometry.coordinates ?? []) {
+      collectRingPoints(ring, points);
+    }
+  }
+  if (geometry?.type === 'MultiPolygon') {
+    for (const polygon of geometry.coordinates ?? []) {
+      for (const ring of polygon) {
+        collectRingPoints(ring, points);
+      }
+    }
+  }
+}
+
+function collectRingPoints(ring, points) {
+  for (const point of ring ?? []) {
+    const lon = Number(point?.[0]);
+    const lat = Number(point?.[1]);
+    if (Number.isFinite(lon) && Number.isFinite(lat)) {
+      points.push([lon, lat]);
+    }
+  }
+}
+
+function featureArea(feature) {
+  const bbox = feature.bbox;
+  if (!bbox) return Infinity;
+  return Math.abs((bbox[2] - bbox[0]) * (bbox[3] - bbox[1]));
+}
+
+function safeFileName(value) {
+  return value.replace(/[^A-Za-z0-9._-]/g, '_');
+}
+
+function formatBbox(bbox) {
+  return bbox.map((value) => Number(value.toFixed(7))).join(',');
+}

package/src/gpkg-read.js

@@ -24,7 +24,7 @@ const LAYER_ALIASES = {
  *   bbox?: [number, number, number, number],
  *   data?: string,
  *   styles?: Record<string, string>,
- *   layers?: ManifestLayer[]
+ *   layers?: string[]
  * }} Manifest
  *
  * @typedef {Map<string, Map<string, Set<string>>>} HiddenFilters
@@ -64,7 +64,8 @@ export function openGeoPackageReader(options) {
   const statementCache = new Map();
 
   const layerById = new Map();
-  for (const layer of options.manifest.layers ?? []) {
+  for (const layerId of options.manifest.layers ?? []) {
+    const layer = manifestLayer(String(layerId));
     layerById.set(layer.id, layer);
     const alias = LAYER_ALIASES[layer.id];
     if (alias && !layerById.has(alias)) {
@@ -132,6 +133,18 @@ export function openGeoPackageReader(options) {
   };
 }
 
+/**
+ * @param {string} layerId
+ * @returns {ManifestLayer}
+ */
+function manifestLayer(layerId) {
+  return {
+    id: layerId,
+    table: layerId,
+    style: layerId
+  };
+}
+
 /**
  * @param {Database.Database} db
  */

package/src/html.js

@@ -138,8 +138,6 @@ export function createViewerHtml(options = {}) {
         titleEl.textContent = manifest.name || 'map-zero';
 
         const bbox = normalizeBbox(manifest.bbox);
-        const tiles3dBbox = normalizeBbox(manifest.tiles3d?.bbox);
-        const focusBbox = normalizeBbox(manifest.tiles3d?.focusBbox);
         const initialView = readInitialView(bbox);
         const map = new OLMap({
           target: 'map',
@@ -171,15 +169,15 @@ export function createViewerHtml(options = {}) {
 
         document.body.style.background = controller.style.background || '#000000';
 
-        for (const layer of controller.manifest.layers || []) {
-          addLayerToggle(layer, controller);
+        for (const layerId of controller.manifest.layers || []) {
+          addLayerToggle(String(layerId), controller);
         }
 
         updateStatus();
       }
 
-      function addLayerToggle(layer, controller) {
-        const rule = controller.style.layers?.[layer.style || layer.id] || {};
+      function addLayerToggle(layerId, controller) {
+        const rule = controller.style.layers?.[layerId] || {};
         const label = document.createElement('label');
         label.className = 'layer-row';
 
@@ -187,15 +185,15 @@ export function createViewerHtml(options = {}) {
         input.type = 'checkbox';
         input.checked = rule.visible !== false;
         input.addEventListener('change', () => {
-          controller.setVisible(layer.id, input.checked);
-          layerStatus.set(layer.id, input.checked ? 'visible' : 'hidden');
+          controller.setVisible(layerId, input.checked);
+          layerStatus.set(layerId, input.checked ? 'visible' : 'hidden');
           updateStatus();
         });
 
         const text = document.createElement('span');
-        text.textContent = layer.id;
+        text.textContent = layerId;
 
-        layerStatus.set(layer.id, input.checked ? 'visible' : 'hidden');
+        layerStatus.set(layerId, input.checked ? 'visible' : 'hidden');
         label.append(input, text);
         layersEl.append(label);
       }
@@ -291,6 +289,15 @@ export function createCesiumViewerHtml(options = {}) {
     <title>map-zero Cesium</title>
     <script src="https://cesium.com/downloads/cesiumjs/releases/1.141/Build/Cesium/Cesium.js"></script>
     <link rel="stylesheet" href="https://cesium.com/downloads/cesiumjs/releases/1.141/Build/Cesium/Widgets/widgets.css">
+    <script type="importmap">
+      {
+        "imports": {
+          "ol/": "https://esm.sh/ol@10.9.0/",
+          "pmtiles": "/vendor/pmtiles.js",
+          "fflate": "/vendor/fflate.js"
+        }
+      }
+    </script>
     <style>
       html,
       body {
@@ -413,6 +420,7 @@ export function createCesiumViewerHtml(options = {}) {
       const titleEl = document.getElementById('title');
       const layerControlsEl = document.getElementById('layerControls');
       const opacityEl = document.getElementById('layerOpacity');
+      const params = new URLSearchParams(globalThis.location.search);
 
       start().catch((error) => {
         statusEl.textContent = error.message;
@@ -426,17 +434,16 @@ export function createCesiumViewerHtml(options = {}) {
         statusEl.textContent = 'Loading manifest';
         const manifest = await loadMapZeroManifest('/manifest.json');
         titleEl.textContent = (manifest.name || 'map-zero') + ' 3D';
-        if (!manifest.tiles3d && !manifest.cesium?.tilesets) {
+        if (!manifest.tiles3d) {
           throw new Error('This package does not define manifest.tiles3d. Run: map-zero 3dtiles <package.mapzero>');
         }
-        const sourceLabel = manifest.tiles3d?.url || manifest.cesium?.tilesets?.buildings || '3dtiles';
+        const sourceLabel = manifest.tiles3d?.url || '3dtiles';
 
         statusEl.textContent = 'Creating Cesium viewer';
         const Cesium = globalThis.Cesium;
         Cesium.Ion.defaultAccessToken = '';
         const bbox = normalizeBbox(manifest.bbox);
-        const tiles3dBbox = normalizeBbox(manifest.tiles3d?.bbox || manifest.cesium?.bbox || manifest.bbox);
-        const focusBbox = normalizeBbox(manifest.tiles3d?.focusBbox || manifest.cesium?.focusBbox);
+        const tiles3dBbox = normalizeBbox(manifest.tiles3d?.bbox || manifest.bbox);
         const viewer = new Cesium.Viewer('cesiumContainer', {
           animation: false,
           baseLayer: false,
@@ -451,21 +458,25 @@ export function createCesiumViewerHtml(options = {}) {
           timeline: false,
           terrainProvider: new Cesium.EllipsoidTerrainProvider()
         });
+        globalThis.viewer = viewer;
         viewer.imageryLayers.removeAll();
 
         statusEl.textContent = 'Loading 3D Tileset';
         const controller = await addMapZeroToCesium(viewer, {
           manifestUrl: '/manifest.json',
-          style: 'cesium',
+          style: 'default',
           opacity: Number(opacityEl.value),
+          contextOverlay: params.get('overlay') !== '0',
+          contextOverzoomLevels: params.has('overzoom') ? Number(params.get('overzoom')) : undefined,
           zoomTo: false,
           applyDefaultSceneStyle: true
         });
+        globalThis.mapZeroController = controller;
 
         statusEl.textContent = 'Positioning camera';
         const firstTileset = Object.values(controller.tilesets)[0];
-        if (focusBbox || tiles3dBbox) {
-          const targetBbox = focusBbox || tiles3dBbox;
+        if (tiles3dBbox) {
+          const targetBbox = tiles3dBbox;
           const centerLon = (targetBbox[0] + targetBbox[2]) / 2;
           const centerLat = (targetBbox[1] + targetBbox[3]) / 2;
           const spanMeters = bboxDiagonalMeters(targetBbox);

package/src/manifest.js

@@ -1,4 +1,3 @@
-import { LAYER_DEFINITIONS } from './layers.js';
 import { packageNameFromPath } from './utils.js';
 
 /**
@@ -18,12 +17,6 @@ export function createManifest(options) {
       default: 'styles/neon-dark.json',
       'neon-dark': 'styles/neon-dark.json'
     },
-    layers: options.layers.map((layer) => ({
-      id: layer,
-      type: LAYER_DEFINITIONS[layer].type,
-      source: 'data.gpkg',
-      table: layer,
-      style: layer
-    }))
+    layers: options.layers
   };
 }

package/src/mvt.js

@@ -2,6 +2,7 @@ import geojsonvt from 'geojson-vt';
 import vtpbf from 'vt-pbf';
 
 const TILE_EXTENT = 4096;
+const TILE_QUERY_BUFFER_UNITS = 128;
 const MAX_ZOOM = 22;
 const DEFAULT_MAX_FEATURES = 12000;
 const TILE_DETAIL_LEVELS = new Set(['overview', 'normal', 'full']);
@@ -204,9 +205,10 @@ export function encodeMvtTile(reader, layerId, zValue, xValue, yValue, options =
 export function encodeMvtTileWithStats(reader, layerId, zValue, xValue, yValue, options = {}) {
   const { z, x, y } = parseTileParams(zValue, xValue, yValue);
   const bbox = tileToBbox(z, x, y);
+  const queryBbox = tileQueryBbox(z, x, y);
   const detail = normalizeDetail(options.detail, z);
   validateRequestedLayers(reader.getLayers(), new Set([layerId]));
-  const layerFeatures = readRequestedLayerFeatures(reader, layerId, bbox, z, options.style ?? null, Boolean(options.debugLabels));
+  const layerFeatures = readRequestedLayerFeatures(reader, layerId, queryBbox, z, options.style ?? null, Boolean(options.debugLabels));
   const limited = applyFeatureLimit([layerFeatures], maxFeaturesForZoom(z, options.maxFeatures), z);
   const layerTile = createLayerTile(limited.layers[0]?.features ?? [], bbox, z, x, y, layerId, detail);
   const tile = layerTile.tile;
@@ -267,6 +269,7 @@ export function encodeMvtTileSet(reader, zValue, xValue, yValue, layerIds, optio
 export function encodeMvtTileSetWithStats(reader, zValue, xValue, yValue, layerIds, options = {}) {
   const { z, x, y } = parseTileParams(zValue, xValue, yValue);
   const bbox = tileToBbox(z, x, y);
+  const queryBbox = tileQueryBbox(z, x, y);
   const detail = normalizeDetail(options.detail, z);
   /** @type {Record<string, { features: unknown[] }>} */
   const layers = {};
@@ -293,7 +296,7 @@ export function encodeMvtTileSetWithStats(reader, zValue, xValue, yValue, layerI
       }
     }
 
-    const layerFeatures = readRequestedLayerFeatures(reader, layerId, bbox, z, options.style ?? null, Boolean(options.debugLabels));
+    const layerFeatures = readRequestedLayerFeatures(reader, layerId, queryBbox, z, options.style ?? null, Boolean(options.debugLabels));
     originalFeatureCount += layerFeatures.originalFeatureCount;
     layerFeatureBatches.push(layerFeatures);
   }
@@ -2539,7 +2542,7 @@ function createTileIndex(features, z) {
       extent: TILE_EXTENT,
       maxZoom: z,
       indexMaxZoom: z,
-      buffer: 64,
+      buffer: TILE_QUERY_BUFFER_UNITS,
       // Geometries are already simplified in lon/lat before indexing.
       // Keep geojson-vt from applying a second aggressive simplification pass
       // that can erase small-but-valid low-zoom tile content.
@@ -2548,6 +2551,35 @@ function createTileIndex(features, z) {
   );
 }
 
+/**
+ * Return the feature-query bbox for a tile, expanded by the same edge buffer
+ * used during MVT clipping. Encoding still uses the exact tile bbox.
+ *
+ * @param {number} z
+ * @param {number} x
+ * @param {number} y
+ * @returns {[number, number, number, number]}
+ */
+function tileQueryBbox(z, x, y) {
+  return expandBboxByTileUnits(tileToBbox(z, x, y), TILE_QUERY_BUFFER_UNITS);
+}
+
+/**
+ * @param {[number, number, number, number]} bbox
+ * @param {number} units
+ * @returns {[number, number, number, number]}
+ */
+function expandBboxByTileUnits(bbox, units) {
+  const xMargin = ((bbox[2] - bbox[0]) * units) / TILE_EXTENT;
+  const yMargin = ((bbox[3] - bbox[1]) * units) / TILE_EXTENT;
+  return [
+    Math.max(-180, bbox[0] - xMargin),
+    Math.max(-85.05112878, bbox[1] - yMargin),
+    Math.min(180, bbox[2] + xMargin),
+    Math.min(85.05112878, bbox[3] + yMargin)
+  ];
+}
+
 /**
  * @param {string | undefined} detail
  * @param {number} z