tileflow 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/chunk-5U4J6E6Y.js

@@ -0,0 +1,4911 @@
+import {
+  layerNamePattern,
+  maximumZoom,
+  parseSourceCrsOption,
+  recipeFromSettings,
+  recipeHash,
+  resolveCrs,
+  statementFromGeojsonCrs,
+  statementFromGeopackageSrs,
+  wgs84Statement
+} from "./chunk-JVTGXPGV.js";
+import {
+  SampleComplete,
+  TilesetBuildError,
+  featureTooLarge,
+  featureTooManyBytes,
+  listChoices,
+  maximumFeatureBytes,
+  maximumFeaturePositions,
+  yieldToEventLoop
+} from "./chunk-43VQMAQO.js";
+import {
+  getCliVersion
+} from "./chunk-GPPOECR5.js";
+
+// src/tileset-build/build.ts
+import { existsSync as existsSync2, mkdtempSync, readdirSync as readdirSync2, rmSync, statfsSync, statSync as statSync2 } from "fs";
+import { rename } from "fs/promises";
+import { basename as basename3, dirname as dirname2, extname as extname3, join as join4, resolve } from "path";
+import { serializeCanonicalJson } from "@tileflow/core";
+import { inspectTileflowPmtiles } from "@tileflow/dev/tilesets";
+
+// src/tileset-build/ingest.ts
+import { createHash } from "crypto";
+
+// src/tileset-build/spool.ts
+import { closeSync, openSync, readSync, unlinkSync, writeSync } from "fs";
+import { join } from "path";
+var field = {
+  words: 0,
+  type: 1,
+  minX: 2,
+  minY: 3,
+  maxX: 4,
+  maxY: 5,
+  parts: 6,
+  points: 7,
+  propertyBytes: 8,
+  idLow: 9,
+  idHigh: 10,
+  /** 1 when the parent tile drew this feature, so that this tile must too. */
+  kept: 11
+};
+var headerWords = 12;
+var worldSize = 2 ** 31;
+var geometryType = { line: 2, point: 1, polygon: 3 };
+var memoryLimitWords = 4 * 1024 * 1024 / 4;
+var fileBufferWords = 1024 * 1024 / 4;
+var readChunkWords = 16 * 1024 * 1024 / 4;
+var SpoolDirectory = class {
+  constructor(path) {
+    this.path = path;
+  }
+  path;
+  #next = 0;
+  nextFile() {
+    return join(this.path, `spool-${this.#next += 1}`);
+  }
+};
+var FeatureSpool = class _FeatureSpool {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  directory;
+  words = new Int32Array(1024);
+  length = 0;
+  count = 0;
+  #descriptor = null;
+  #path = null;
+  /** Return the offset of `size` writable words in `this.words`. */
+  reserve(size) {
+    if (this.length + size > this.words.length) this.#makeRoom(size);
+    const offset = this.length;
+    this.length += size;
+    this.count += 1;
+    return offset;
+  }
+  append(source, offset, size) {
+    const target = this.reserve(size);
+    this.words.set(source.subarray(offset, offset + size), target);
+  }
+  /** Visit each record; `words` is only valid during the callback. */
+  forEach(visit) {
+    if (this.#path === null) {
+      visitRecords(this.words, this.length, visit);
+      return;
+    }
+    this.#flush();
+    if (this.#descriptor !== null) {
+      closeSync(this.#descriptor);
+      this.#descriptor = null;
+    }
+    const descriptor = openSync(this.#path, "r");
+    try {
+      let chunk = new Int32Array(readChunkWords);
+      let carried = 0;
+      for (; ; ) {
+        const bytes = readSync(
+          descriptor,
+          new Uint8Array(chunk.buffer),
+          carried * 4,
+          (chunk.length - carried) * 4,
+          null
+        );
+        const available = carried + bytes / 4;
+        const consumed = visitRecords(chunk, available, visit);
+        carried = available - consumed;
+        if (bytes === 0) break;
+        chunk.copyWithin(0, consumed, available);
+        if (carried > 0 && chunk[field.words] > chunk.length) {
+          const larger = new Int32Array(chunk[field.words] * 2);
+          larger.set(chunk.subarray(0, carried));
+          chunk = larger;
+        }
+      }
+    } finally {
+      closeSync(descriptor);
+    }
+  }
+  /**
+   * Rewrite the records from the highest key to the lowest, keeping input order between equals, and
+   * dispose of this spool. Holds about 24 bytes per record in memory; the records stay on disk.
+   */
+  reordered(keys) {
+    const sizes = new Uint32Array(this.count);
+    let visited = 0;
+    this.forEach((words, offset) => {
+      sizes[visited] = words[offset + field.words];
+      visited += 1;
+    });
+    const order = new Uint32Array(this.count);
+    for (let index = 0; index < order.length; index += 1) order[index] = index;
+    order.sort((left, right) => keys[right] - keys[left] || 0 || left - right);
+    const positions = new Float64Array(this.count);
+    let position = 0;
+    for (const index of order) {
+      positions[index] = position;
+      position += sizes[index];
+    }
+    const target = new _FeatureSpool(this.directory);
+    target.count = this.count;
+    if (this.#path === null) {
+      target.words = new Int32Array(position);
+      target.length = position;
+      visited = 0;
+      this.forEach((words, offset) => {
+        target.words.set(words.subarray(offset, offset + sizes[visited]), positions[visited]);
+        visited += 1;
+      });
+      this.dispose();
+      return target;
+    }
+    target.#path = this.directory.nextFile();
+    const descriptor = openSync(target.#path, "w");
+    try {
+      visited = 0;
+      this.forEach((words, offset) => {
+        const bytes = new Uint8Array(
+          words.buffer,
+          words.byteOffset + offset * 4,
+          sizes[visited] * 4
+        );
+        let written = 0;
+        while (written < bytes.length) {
+          written += writeSync(
+            descriptor,
+            bytes,
+            written,
+            bytes.length - written,
+            positions[visited] * 4 + written
+          );
+        }
+        visited += 1;
+      });
+    } finally {
+      closeSync(descriptor);
+    }
+    this.dispose();
+    return target;
+  }
+  dispose() {
+    if (this.#descriptor !== null) closeSync(this.#descriptor);
+    if (this.#path !== null) unlinkSync(this.#path);
+    this.#descriptor = null;
+    this.#path = null;
+    this.words = new Int32Array(0);
+    this.length = 0;
+  }
+  #makeRoom(size) {
+    if (this.#path === null && this.length + size > memoryLimitWords) {
+      this.#path = this.directory.nextFile();
+      this.#descriptor = openSync(this.#path, "w");
+    }
+    if (this.#path !== null) {
+      this.#flush();
+      if (size <= fileBufferWords && this.words.length >= fileBufferWords) return;
+    }
+    const needed = this.length + size;
+    const capacity = Math.max(needed, Math.min(this.words.length * 2, memoryLimitWords));
+    const grown = new Int32Array(this.#path === null ? capacity : Math.max(size, fileBufferWords));
+    grown.set(this.words.subarray(0, this.length));
+    this.words = grown;
+  }
+  #flush() {
+    if (this.length === 0 || this.#descriptor === null) return;
+    const bytes = new Uint8Array(this.words.buffer, 0, this.length * 4);
+    let written = 0;
+    while (written < bytes.length) {
+      written += writeSync(this.#descriptor, bytes, written, bytes.length - written);
+    }
+    this.length = 0;
+  }
+};
+function visitRecords(words, available, visit) {
+  let offset = 0;
+  while (offset < available) {
+    const size = words[offset + field.words];
+    if (offset + size > available) break;
+    visit(words, offset);
+    offset += size;
+  }
+  return offset;
+}
+
+// src/tileset-build/ingest.ts
+var fieldNamePattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$/u;
+var maximumFields = 512;
+var maximumMercatorLatitude = 85.0511287798066;
+var coordinateToleranceDegrees = 1e-3;
+var sampleCapacity = 1 << 18;
+var unranked = -Infinity;
+var typeBits = { boolean: 1, number: 2, string: 4 };
+var maximumFieldValues = 64;
+var maximumFieldValueCharacters = 64;
+var largestHashedId = BigInt(Number.MAX_SAFE_INTEGER);
+var FeatureIngest = class {
+  constructor(spool, selection, transform, rank = null, featureId = null) {
+    this.spool = spool;
+    this.selection = selection;
+    this.rank = rank;
+    this.featureId = featureId;
+    this.#transform = transform;
+    if (rank) this.#rankKeys = new Float64Array(1024);
+  }
+  spool;
+  selection;
+  rank;
+  featureId;
+  #keys = /* @__PURE__ */ new Map();
+  #keyTypes = [];
+  #statistics = [];
+  #transform;
+  #properties = new Uint8Array(4096);
+  #propertiesView = new DataView(this.#properties.buffer);
+  #propertyLength = 0;
+  #points = [];
+  #parts = [];
+  #warnings = /* @__PURE__ */ new Set();
+  #features = 0;
+  #emptyGeometry = 0;
+  #outsideMercator = 0;
+  #clampedLatitude = 0;
+  #wideSegments = 0;
+  #nonNumericIds = 0;
+  #usableIds = 0;
+  #degenerateParts = 0;
+  #nudgedCoordinates = 0;
+  #minLon = Infinity;
+  #minLat = Infinity;
+  #maxLon = -Infinity;
+  #maxLat = -Infinity;
+  #types = /* @__PURE__ */ new Set();
+  #sampleStride = 1;
+  #sampleSeen = 0;
+  #rankKeys = new Float64Array(0);
+  #currentRank = unranked;
+  #ranked = 0;
+  #unrankedFeatures = 0;
+  /** Bounded, evenly thinned vertex sample used to choose a maximum zoom. */
+  sample = new Int32Array(sampleCapacity * 2);
+  sampleCount = 0;
+  /** Set by readers so that errors name the offending feature. */
+  location = "input";
+  /** When set, the read ends with `SampleComplete` after this many features. */
+  stopAfter;
+  get featureCount() {
+    return this.#features;
+  }
+  get sampleStride() {
+    return this.#sampleStride;
+  }
+  warn(message) {
+    this.#warnings.add(message);
+  }
+  add(geometry, properties, id) {
+    if (geometry === null || geometry === void 0) {
+      this.#emptyGeometry += 1;
+      return;
+    }
+    if (this.#features === this.stopAfter) throw new SampleComplete();
+    this.#encodeProperties(properties);
+    if (this.rank) this.#readRank(properties[this.rank.field]);
+    const numericId = this.#numericId(this.featureId ? this.#selectedId(properties) : id);
+    this.#addGeometry(geometry, numericId);
+  }
+  skipEmpty() {
+    this.#emptyGeometry += 1;
+  }
+  /** The features in descending priority, or the input order when no rank was requested. */
+  rankedSpool(spool) {
+    if (!this.rank) return spool;
+    return spool.reordered(this.#rankKeys.subarray(0, spool.count));
+  }
+  #readRank(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      this.#currentRank = this.rank?.ascending ? -value : value;
+      this.#ranked += 1;
+    } else {
+      this.#currentRank = unranked;
+      this.#unrankedFeatures += 1;
+    }
+  }
+  /** Summarize the pass and finalize names that downstream tile consumers accept. */
+  finish() {
+    if (this.#keys.size > maximumFields) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_TOO_MANY_FIELDS",
+        "input.fields",
+        `The input has ${this.#keys.size} attribute fields; the limit is ${maximumFields}. Pick what maps need with --include.`
+      );
+    }
+    if (this.rank && this.#features > 0 && this.#ranked === 0) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_RANK_INVALID",
+        "rankBy",
+        `No feature has a numeric value in "${this.rank.field}". --rank-by needs a numeric attribute.`
+      );
+    }
+    if (this.#unrankedFeatures > 0) {
+      this.#warnings.add(
+        `${this.#unrankedFeatures} features have no numeric "${this.rank?.field}" and are the first to be thinned.`
+      );
+    }
+    if (this.featureId && this.#features > 0 && this.#usableIds === 0) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_FEATURE_ID_INVALID",
+        "featureId",
+        `No feature has a non-negative integer in "${this.featureId.field}". Hash text values with --hash-feature-id.`
+      );
+    }
+    if (this.#features === 0) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_EMPTY",
+        "input",
+        `The input has no usable features (${this.#emptyGeometry} without geometry, ${this.#outsideMercator} outside the Web Mercator range).`
+      );
+    }
+    const taken = /* @__PURE__ */ new Set();
+    const fields = [...this.#keys].map(([sourceName, key]) => {
+      const name = safeFieldName(sourceName, key);
+      if (taken.has(name)) {
+        throw new TilesetBuildError(
+          "TF_TILESET_BUILD_FIELD_CONFLICT",
+          "input.fields",
+          `Field "${sourceName}" becomes "${name}", which another field already uses. Remove one with --exclude.`
+        );
+      }
+      taken.add(name);
+      if (name !== sourceName) {
+        this.#warnings.add(`Field "${sourceName}" was renamed to "${name}".`);
+      }
+      return { name, sourceName, type: fieldType(this.#keyTypes[key]), ...this.#fieldSummary(key) };
+    });
+    if (this.#clampedLatitude > 0) {
+      this.#warnings.add(
+        `${this.#clampedLatitude} features extend past latitude \xB185.05 and were cut at the Web Mercator limit.`
+      );
+    }
+    if (this.#outsideMercator > 0) {
+      this.#warnings.add(
+        `${this.#outsideMercator} points past latitude \xB185.05 were skipped; Web Mercator tiles cannot hold them.`
+      );
+    }
+    if (this.#nudgedCoordinates > 0) {
+      this.#warnings.add(
+        `${this.#nudgedCoordinates} coordinates up to ${coordinateToleranceDegrees}\xB0 past longitude \xB1180 or latitude \xB190 were moved to that limit.`
+      );
+    }
+    if (this.#wideSegments > 0) {
+      this.#warnings.add(
+        `${this.#wideSegments} features have segments spanning more than 180\xB0 of longitude and will draw across the map. Split them at the antimeridian first.`
+      );
+    }
+    if (this.#nonNumericIds > 0) {
+      this.#warnings.add(
+        `${this.#nonNumericIds} feature ids are not non-negative integers and were dropped; vector tiles only store integer ids.`
+      );
+    }
+    if (this.#degenerateParts > 0) {
+      this.#warnings.add(
+        `${this.#degenerateParts} rings or lines with too few positions were skipped.`
+      );
+    }
+    if (this.#emptyGeometry > 0) {
+      this.#warnings.add(`${this.#emptyGeometry} features without geometry were skipped.`);
+    }
+    return {
+      bounds: [this.#minLon, this.#minLat, this.#maxLon, this.#maxLat],
+      features: this.#features,
+      fields,
+      geometryTypes: [...this.#types].sort(),
+      skipped: { emptyGeometry: this.#emptyGeometry, outsideMercator: this.#outsideMercator },
+      warnings: [...this.#warnings]
+    };
+  }
+  #fieldSummary(key) {
+    const { complete, count, max, min, values } = this.#statistics[key];
+    return {
+      count,
+      ...Number.isFinite(max) ? { max, min } : {},
+      values: [...values].sort(compareFieldValues),
+      valuesComplete: complete
+    };
+  }
+  #recordValue(key, value) {
+    const statistics = this.#statistics[key];
+    statistics.count += 1;
+    if (typeof value === "number") {
+      if (value < statistics.min) statistics.min = value;
+      if (value > statistics.max) statistics.max = value;
+    }
+    if (typeof value === "string" && value.length > maximumFieldValueCharacters || typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+      statistics.complete = false;
+    } else if (statistics.values.size < maximumFieldValues) {
+      statistics.values.add(value);
+    } else if (statistics.complete && !statistics.values.has(value)) {
+      statistics.complete = false;
+    }
+  }
+  keyNames(summary) {
+    return summary.fields.map((item) => item.name);
+  }
+  #selectedId(properties) {
+    const value = properties[this.featureId.field];
+    if (!this.featureId?.hash || value === void 0 || value === null) return value;
+    const digest = createHash("sha256").update(String(value)).digest();
+    return Number((digest.readBigUInt64BE(0) >> 11n) % largestHashedId);
+  }
+  #numericId(id) {
+    if (id === void 0 || id === null) return 0;
+    if (typeof id === "number" && Number.isSafeInteger(id) && id >= 0 && id < 2 ** 53 - 1) {
+      this.#usableIds += 1;
+      return id + 1;
+    }
+    this.#nonNumericIds += 1;
+    return 0;
+  }
+  #addGeometry(geometry, id) {
+    const { coordinates, type } = geometry;
+    switch (type) {
+      case "Point":
+        this.#resetGeometry();
+        if (isEmptyList(coordinates)) return this.skipEmpty();
+        this.#pushPosition(coordinates, true);
+        if (this.#points.length === 0) return;
+        this.#parts.push(1);
+        return this.#commit(geometryType.point, "Point", id);
+      case "MultiPoint": {
+        this.#resetGeometry();
+        const positions = this.#list(coordinates);
+        if (positions.length === 0) return this.skipEmpty();
+        for (const position of positions) this.#pushPosition(position, true);
+        if (this.#points.length === 0) return;
+        this.#parts.push(this.#points.length / 2);
+        return this.#commit(geometryType.point, "Point", id);
+      }
+      case "LineString":
+      case "MultiLineString": {
+        this.#resetGeometry();
+        const lines = type === "LineString" ? [coordinates] : this.#list(coordinates);
+        for (const line of lines) this.#pushLine(line);
+        if (this.#parts.length === 0) return this.skipEmpty();
+        return this.#commit(geometryType.line, "LineString", id);
+      }
+      case "Polygon":
+      case "MultiPolygon": {
+        this.#resetGeometry();
+        const polygons = type === "Polygon" ? [coordinates] : this.#list(coordinates);
+        for (const polygon of polygons) {
+          const rings = this.#list(polygon);
+          for (let index = 0; index < rings.length; index += 1) {
+            this.#pushRing(rings[index], index === 0);
+          }
+        }
+        if (this.#parts.length === 0) return this.skipEmpty();
+        return this.#commit(geometryType.polygon, "Polygon", id);
+      }
+      case "GeometryCollection": {
+        const geometries = this.#list(geometry.geometries);
+        if (geometries.length === 0) return this.skipEmpty();
+        for (const child of geometries) this.#addGeometry(child, id);
+        return;
+      }
+      default:
+        throw this.#invalid(`unsupported geometry type ${JSON.stringify(type)}`);
+    }
+  }
+  #resetGeometry() {
+    this.#points.length = 0;
+    this.#parts.length = 0;
+    this.#clampedThisFeature = false;
+  }
+  #list(value) {
+    if (!Array.isArray(value)) throw this.#invalid("coordinates are not an array");
+    return value;
+  }
+  #pushLine(line) {
+    const positions = this.#list(line);
+    if (positions.length === 0) return;
+    if (positions.length < 2) {
+      this.#degenerateParts += 1;
+      return;
+    }
+    const start = this.#points.length;
+    for (const position of positions) this.#pushPosition(position);
+    this.#checkWideSegments(start);
+    this.#parts.push(positions.length);
+  }
+  #pushRing(ring, exterior) {
+    const positions = this.#list(ring);
+    if (positions.length === 0) return;
+    const start = this.#points.length;
+    const clampedBefore = this.#clampedThisFeature;
+    for (const position of positions) this.#pushPosition(position);
+    this.#checkWideSegments(start);
+    const points = this.#points;
+    let count = (points.length - start) / 2;
+    if (points[start] === points.at(-2) && points[start + 1] === points.at(-1)) {
+      count -= 1;
+      points.length -= 2;
+    }
+    if (count < 3) {
+      points.length = start;
+      this.#clampedThisFeature = clampedBefore;
+      this.#degenerateParts += 1;
+      return;
+    }
+    orientRing(points, start, count, exterior);
+    this.#parts.push(count);
+  }
+  #checkWideSegments(start) {
+    const points = this.#points;
+    for (let index = start + 2; index < points.length; index += 2) {
+      if (Math.abs(points[index] - points[index - 2]) > worldSize / 2) {
+        this.#wideSegments += 1;
+        return;
+      }
+    }
+  }
+  #pushPosition(position, dropPastMercator = false) {
+    if (!Array.isArray(position) || position.length < 2) {
+      throw this.#invalid("a position must be [longitude, latitude]");
+    }
+    this.#pushXY(position[0], position[1], dropPastMercator);
+  }
+  #pushXY(sourceX, sourceY, dropPastMercator) {
+    if (this.#points.length >= maximumFeaturePositions * 2) throw featureTooLarge(this.location);
+    if (typeof sourceX !== "number" || typeof sourceY !== "number" || !Number.isFinite(sourceX) || !Number.isFinite(sourceY)) {
+      throw this.#invalid(`coordinate [${String(sourceX)}, ${String(sourceY)}] is not numeric`);
+    }
+    let longitude = sourceX;
+    let latitude = sourceY;
+    if (this.#transform) [longitude, latitude] = this.#transform(sourceX, sourceY);
+    if (!Number.isFinite(longitude) || !Number.isFinite(latitude) || Math.abs(longitude) > 180 + coordinateToleranceDegrees || Math.abs(latitude) > 90 + coordinateToleranceDegrees) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_COORDINATES_OUT_OF_RANGE",
+        "input",
+        this.#transform ? `${this.location}: [${sourceX}, ${sourceY}] did not convert to a valid longitude and latitude. The stated CRS probably does not match the data.` : `${this.location}: [${sourceX}, ${sourceY}] is outside WGS84 longitude and latitude. The data looks projected or has swapped axes. State its CRS with --source-crs <crs> --reproject; the build will not guess.`
+      );
+    }
+    if (Math.abs(longitude) > 180 || Math.abs(latitude) > 90) {
+      longitude = Math.max(-180, Math.min(180, longitude));
+      latitude = Math.max(-90, Math.min(90, latitude));
+      this.#nudgedCoordinates += 1;
+    }
+    if (dropPastMercator && Math.abs(latitude) > maximumMercatorLatitude) {
+      this.#outsideMercator += 1;
+      return;
+    }
+    if (longitude < this.#minLon) this.#minLon = longitude;
+    if (longitude > this.#maxLon) this.#maxLon = longitude;
+    const clampedLatitude = Math.max(
+      -maximumMercatorLatitude,
+      Math.min(maximumMercatorLatitude, latitude)
+    );
+    if (clampedLatitude !== latitude) this.#markClamped();
+    if (clampedLatitude < this.#minLat) this.#minLat = clampedLatitude;
+    if (clampedLatitude > this.#maxLat) this.#maxLat = clampedLatitude;
+    const sine = Math.sin(clampedLatitude * Math.PI / 180);
+    const worldX = (longitude + 180) / 360 * worldSize;
+    const worldY = (0.5 - Math.log((1 + sine) / (1 - sine)) / (4 * Math.PI)) * worldSize;
+    this.#points.push(
+      Math.min(worldSize - 1, Math.max(0, Math.round(worldX))),
+      Math.min(worldSize - 1, Math.max(0, Math.round(worldY)))
+    );
+  }
+  #clampedThisFeature = false;
+  #markClamped() {
+    this.#clampedThisFeature = true;
+  }
+  #commit(type, typeName, id) {
+    if (this.#clampedThisFeature) this.#clampedLatitude += 1;
+    this.#clampedThisFeature = false;
+    if (this.rank) {
+      if (this.#features === this.#rankKeys.length) {
+        const grown = new Float64Array(this.#rankKeys.length * 2);
+        grown.set(this.#rankKeys);
+        this.#rankKeys = grown;
+      }
+      this.#rankKeys[this.#features] = this.#currentRank;
+    }
+    const points = this.#points;
+    const partCount = this.#parts.length;
+    const pointCount = points.length / 2;
+    const propertyWords = Math.ceil(this.#propertyLength / 4);
+    const size = headerWords + partCount + points.length + propertyWords;
+    const offset = this.spool.reserve(size);
+    const words = this.spool.words;
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let target = offset + headerWords + partCount;
+    for (let index = 0; index < points.length; index += 2) {
+      const x = points[index];
+      const y = points[index + 1];
+      if (x < minX) minX = x;
+      if (x > maxX) maxX = x;
+      if (y < minY) minY = y;
+      if (y > maxY) maxY = y;
+      words[target] = x;
+      words[target + 1] = y;
+      target += 2;
+      this.#sampleVertex(x, y);
+    }
+    words[offset + field.words] = size;
+    words[offset + field.type] = type;
+    words[offset + field.minX] = minX;
+    words[offset + field.minY] = minY;
+    words[offset + field.maxX] = maxX;
+    words[offset + field.maxY] = maxY;
+    words[offset + field.parts] = partCount;
+    words[offset + field.points] = pointCount;
+    words[offset + field.propertyBytes] = this.#propertyLength;
+    words[offset + field.idLow] = id % 2 ** 32;
+    words[offset + field.idHigh] = Math.floor(id / 2 ** 32);
+    words[offset + field.kept] = 0;
+    for (let index = 0; index < partCount; index += 1) {
+      words[offset + headerWords + index] = this.#parts[index];
+    }
+    if (propertyWords > 0) {
+      words[offset + size - 1] = 0;
+      new Uint8Array(words.buffer, words.byteOffset + target * 4, this.#propertyLength).set(
+        this.#properties.subarray(0, this.#propertyLength)
+      );
+    }
+    this.#features += 1;
+    this.#types.add(typeName);
+  }
+  #sampleVertex(x, y) {
+    this.#sampleSeen += 1;
+    if (this.#sampleSeen % this.#sampleStride !== 0) return;
+    if (this.sampleCount === sampleCapacity) {
+      for (let index = 0; index < sampleCapacity / 2; index += 1) {
+        this.sample[index * 2] = this.sample[index * 4];
+        this.sample[index * 2 + 1] = this.sample[index * 4 + 1];
+      }
+      this.sampleCount = sampleCapacity / 2;
+      this.#sampleStride *= 2;
+      if (this.#sampleSeen % this.#sampleStride !== 0) return;
+    }
+    this.sample[this.sampleCount * 2] = x;
+    this.sample[this.sampleCount * 2 + 1] = y;
+    this.sampleCount += 1;
+  }
+  #encodeProperties(properties) {
+    this.#propertyLength = 0;
+    const { exclude, include } = this.selection;
+    for (const name in properties) {
+      if (!Object.hasOwn(properties, name)) continue;
+      const value = properties[name];
+      if (value === null || value === void 0) continue;
+      if (include ? !include.has(name) : exclude?.has(name)) continue;
+      this.#encodeProperty(name, value);
+    }
+  }
+  #encodeProperty(name, value) {
+    let key = this.#keys.get(name);
+    if (key === void 0) {
+      key = this.#keys.size;
+      if (key >= 65535) {
+        throw new TilesetBuildError(
+          "TF_TILESET_BUILD_TOO_MANY_FIELDS",
+          "input.fields",
+          `The input has more than ${key} attribute fields. Pick what maps need with --include.`
+        );
+      }
+      this.#keys.set(name, key);
+      this.#keyTypes.push(0);
+      this.#statistics.push({
+        complete: true,
+        count: 0,
+        max: -Infinity,
+        min: Infinity,
+        values: /* @__PURE__ */ new Set()
+      });
+    }
+    this.#recordValue(key, value);
+    const start = this.#propertyLength + 6;
+    let end;
+    if (typeof value === "number" && Number.isFinite(value)) {
+      this.#keyTypes[key] |= typeBits.number;
+      end = this.#encodeNumber(start, value);
+    } else if (typeof value === "boolean") {
+      this.#keyTypes[key] |= typeBits.boolean;
+      this.#ensureProperties(start + 2);
+      this.#properties[start] = 56;
+      this.#properties[start + 1] = value ? 1 : 0;
+      end = start + 2;
+    } else {
+      this.#keyTypes[key] |= typeBits.string;
+      end = this.#encodeString(start, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    this.#propertiesView.setUint16(this.#propertyLength, key, true);
+    this.#propertiesView.setUint32(this.#propertyLength + 2, end - start, true);
+    this.#propertyLength = end;
+  }
+  #encodeNumber(start, value) {
+    this.#ensureProperties(start + 12);
+    if (Number.isSafeInteger(value)) {
+      let remaining = value >= 0 ? value * 2 : -value * 2 - 1;
+      let cursor = start;
+      this.#properties[cursor] = 48;
+      cursor += 1;
+      while (remaining >= 128) {
+        this.#properties[cursor] = remaining % 128 | 128;
+        cursor += 1;
+        remaining = Math.floor(remaining / 128);
+      }
+      this.#properties[cursor] = remaining;
+      return cursor + 1;
+    }
+    this.#properties[start] = 25;
+    this.#propertiesView.setFloat64(start + 1, value, true);
+    return start + 9;
+  }
+  #encodeString(start, value) {
+    const byteLength = Buffer.byteLength(value);
+    this.#ensureProperties(start + 6 + byteLength);
+    let cursor = start;
+    this.#properties[cursor] = 10;
+    cursor += 1;
+    let remaining = byteLength;
+    while (remaining >= 128) {
+      this.#properties[cursor] = remaining & 127 | 128;
+      cursor += 1;
+      remaining >>>= 7;
+    }
+    this.#properties[cursor] = remaining;
+    cursor += 1;
+    Buffer.from(this.#properties.buffer).write(value, cursor, "utf8");
+    return cursor + byteLength;
+  }
+  #ensureProperties(size) {
+    if (size <= this.#properties.length) return;
+    const grown = new Uint8Array(Math.max(size, this.#properties.length * 2));
+    grown.set(this.#properties);
+    this.#properties = grown;
+    this.#propertiesView = new DataView(grown.buffer);
+  }
+  #invalid(reason) {
+    return new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `${this.location}: ${reason}.`
+    );
+  }
+};
+function isEmptyList(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+function orientRing(points, start, count, exterior) {
+  let area = 0;
+  let previousX = points[start + (count - 1) * 2];
+  let previousY = points[start + (count - 1) * 2 + 1];
+  for (let index = 0; index < count; index += 1) {
+    const x = points[start + index * 2];
+    const y = points[start + index * 2 + 1];
+    area += previousX * y - x * previousY;
+    previousX = x;
+    previousY = y;
+  }
+  if (area === 0 || area > 0 === exterior) return;
+  for (let low = 0, high = count - 1; low < high; low += 1, high -= 1) {
+    const x = points[start + low * 2];
+    const y = points[start + low * 2 + 1];
+    points[start + low * 2] = points[start + high * 2];
+    points[start + low * 2 + 1] = points[start + high * 2 + 1];
+    points[start + high * 2] = x;
+    points[start + high * 2 + 1] = y;
+  }
+}
+function safeFieldName(name, key) {
+  if (fieldNamePattern.test(name)) return name;
+  const cleaned = name.normalize("NFKD").replace(/\p{M}/gu, "").replace(/[^A-Za-z0-9._:-]+/gu, "_").replace(/^[^A-Za-z0-9]+/u, "").slice(0, 192);
+  return cleaned || `field_${key + 1}`;
+}
+function fieldType(bits) {
+  if (bits === typeBits.boolean) return "Boolean";
+  if (bits === typeBits.number) return "Number";
+  if (bits === typeBits.string) return "String";
+  return "Mixed";
+}
+function compareFieldValues(left, right) {
+  if (typeof left === "number" && typeof right === "number") return left - right;
+  const [a, b] = [String(left), String(right)];
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+// src/tileset-build/pmtiles-writer.ts
+import { createHash as createHash2 } from "crypto";
+import { closeSync as closeSync2, openSync as openSync2, readSync as readSync2, writeSync as writeSync2 } from "fs";
+import { zxyToTileId } from "pmtiles";
+
+// src/tileset-build/gzip.ts
+import { deflateSync } from "fflate";
+import { gzip as gzipCallback, gzipSync } from "zlib";
+var operatingSystemByte = 9;
+var unknownOperatingSystem = 255;
+function withStableHeader(compressed) {
+  compressed[operatingSystemByte] = unknownOperatingSystem;
+  return compressed;
+}
+function stableGzipSync(bytes) {
+  return withStableHeader(gzipSync(bytes));
+}
+function stableGzip(bytes) {
+  return new Promise((resolve2, reject) => {
+    gzipCallback(bytes, (error, result) => {
+      if (error) reject(error);
+      else resolve2(withStableHeader(result));
+    });
+  });
+}
+function compressedSizeForBudget(bytes) {
+  return deflateSync(bytes, { level: 6 }).length;
+}
+
+// src/tileset-build/pmtiles-writer.ts
+var headerBytes = 127;
+var rootLimitBytes = 16384 - headerBytes;
+var maximumEntries = 16e6;
+var maximumClusteredContents = 2e5;
+var deduplicatedTileBytes = 4096;
+var maximumKnownContents = 2e6;
+var concurrentCompression = 8;
+var TileArchiveWriter = class {
+  constructor(dataPath) {
+    this.dataPath = dataPath;
+    this.#descriptor = openSync2(dataPath, "w");
+  }
+  dataPath;
+  #descriptor;
+  #dataOffset = 0;
+  #contentOffsets = [];
+  #contentLengths = [];
+  #tileIds = new Float64Array(1024);
+  #runLengths = new Float64Array(1024);
+  #contents = new Int32Array(1024);
+  #entryCount = 0;
+  #addressed = 0;
+  #known = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Set();
+  #failure = null;
+  get tileCount() {
+    return this.#entryCount;
+  }
+  /** Register tile bytes and return a content reference other tiles may share. */
+  async addTile(z, x, y, tile) {
+    let content = -1;
+    let identity = null;
+    if (tile.length <= deduplicatedTileBytes) {
+      identity = createHash2("sha1").update(tile).digest("base64");
+      content = this.#known.get(identity) ?? -1;
+    }
+    if (content < 0) {
+      content = this.#contentOffsets.length;
+      this.#contentOffsets.push(-1);
+      this.#contentLengths.push(0);
+      if (identity !== null && this.#known.size < maximumKnownContents) {
+        this.#known.set(identity, content);
+      }
+      await this.#compress(content, tile);
+    }
+    this.#addEntry(zxyToTileId(z, x, y), 1, content);
+    return content;
+  }
+  /** Point a whole z/x/y subtree level at one content; Hilbert ordering keeps it contiguous. */
+  addSubtreeLevel(z, x, y, depth, content) {
+    const levelStart = (4 ** (z + depth) - 1) / 3;
+    const span = 4 ** depth;
+    const sample = zxyToTileId(z + depth, x * 2 ** depth, y * 2 ** depth) - levelStart;
+    this.#addEntry(levelStart + Math.floor(sample / span) * span, span, content);
+  }
+  /** Wait for compression, then write the finished archive. Tile contents are copied in order. */
+  async finish(archivePath, fields, metadata) {
+    await Promise.all(this.#pending);
+    if (this.#failure) throw this.#failure;
+    this.close();
+    const entries = this.#sortedEntries();
+    const input = openSync2(this.dataPath, "r");
+    const output = openSync2(archivePath, "w");
+    try {
+      return this.#layOut(entries, input, output, fields, metadata);
+    } finally {
+      closeSync2(input);
+      closeSync2(output);
+    }
+  }
+  close() {
+    if (this.#descriptor !== null) closeSync2(this.#descriptor);
+    this.#descriptor = null;
+  }
+  #addEntry(tileId, runLength, content) {
+    if (this.#entryCount === maximumEntries) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_TOO_MANY_TILES",
+        "zoom",
+        `The archive would exceed ${maximumEntries} tile entries. Lower --maxzoom.`
+      );
+    }
+    if (this.#entryCount === this.#tileIds.length) {
+      const size = this.#entryCount * 2;
+      const tileIds = new Float64Array(size);
+      const runLengths = new Float64Array(size);
+      const contents = new Int32Array(size);
+      tileIds.set(this.#tileIds);
+      runLengths.set(this.#runLengths);
+      contents.set(this.#contents);
+      this.#tileIds = tileIds;
+      this.#runLengths = runLengths;
+      this.#contents = contents;
+    }
+    this.#tileIds[this.#entryCount] = tileId;
+    this.#runLengths[this.#entryCount] = runLength;
+    this.#contents[this.#entryCount] = content;
+    this.#entryCount += 1;
+    this.#addressed += runLength;
+  }
+  /** Tile compression runs on the thread pool; results land in completion order, which is fine. */
+  async #compress(content, tile) {
+    while (this.#pending.size >= concurrentCompression) await Promise.race(this.#pending);
+    if (this.#failure) throw this.#failure;
+    const task = stableGzip(tile).then((compressed) => {
+      if (this.#descriptor === null) return;
+      let written = 0;
+      while (written < compressed.length) {
+        written += writeSync2(this.#descriptor, compressed, written);
+      }
+      this.#contentOffsets[content] = this.#dataOffset;
+      this.#contentLengths[content] = compressed.length;
+      this.#dataOffset += compressed.length;
+    }).catch((error) => {
+      this.#failure = error;
+    }).finally(() => {
+      this.#pending.delete(task);
+    });
+    this.#pending.add(task);
+  }
+  #sortedEntries() {
+    const order = new Uint32Array(this.#entryCount);
+    for (let index = 0; index < order.length; index += 1) order[index] = index;
+    const tileIds = this.#tileIds;
+    return order.sort((left, right) => tileIds[left] - tileIds[right]);
+  }
+  #layOut(order, input, output, fields, metadata) {
+    const finalOffsets = new Float64Array(this.#contentOffsets.length).fill(-1);
+    const contentOrder = [];
+    let tileDataLength = 0;
+    const entries = [];
+    for (const index of order) {
+      const content = this.#contents[index];
+      const tileId = this.#tileIds[index];
+      const runLength = this.#runLengths[index];
+      const previous = entries.at(-1);
+      if (previous && previous.content === content && previous.tileId + previous.runLength === tileId) {
+        previous.runLength += runLength;
+        continue;
+      }
+      if (finalOffsets[content] < 0) {
+        finalOffsets[content] = tileDataLength;
+        contentOrder.push(content);
+        tileDataLength += this.#contentLengths[content];
+      }
+      entries.push({
+        content,
+        length: this.#contentLengths[content],
+        offset: finalOffsets[content],
+        runLength,
+        tileId
+      });
+    }
+    const { leaves, root } = buildDirectories(entries);
+    const metadataBytes = stableGzipSync(Buffer.from(metadata, "utf8"));
+    const rootOffset = headerBytes;
+    const metadataOffset = rootOffset + root.length;
+    const leafOffset = metadataOffset + metadataBytes.length;
+    const dataOffset = leafOffset + leaves.length;
+    const clustered = contentOrder.length <= maximumClusteredContents;
+    const header = Buffer.alloc(headerBytes);
+    header.write("PMTiles", 0, "latin1");
+    header[7] = 3;
+    const writeOffsets = [
+      [8, rootOffset],
+      [16, root.length],
+      [24, metadataOffset],
+      [32, metadataBytes.length],
+      [40, leafOffset],
+      [48, leaves.length],
+      [56, dataOffset],
+      [64, tileDataLength],
+      [72, this.#addressed],
+      [80, entries.length],
+      [88, contentOrder.length]
+    ];
+    for (const [position, value] of writeOffsets) header.writeBigUInt64LE(BigInt(value), position);
+    header[96] = clustered ? 1 : 0;
+    header[97] = 2;
+    header[98] = 2;
+    header[99] = 1;
+    header[100] = fields.minzoom;
+    header[101] = fields.maxzoom;
+    header.writeInt32LE(Math.round(fields.bounds[0] * 1e7), 102);
+    header.writeInt32LE(Math.round(fields.bounds[1] * 1e7), 106);
+    header.writeInt32LE(Math.round(fields.bounds[2] * 1e7), 110);
+    header.writeInt32LE(Math.round(fields.bounds[3] * 1e7), 114);
+    header[118] = fields.center[2];
+    header.writeInt32LE(Math.round(fields.center[0] * 1e7), 119);
+    header.writeInt32LE(Math.round(fields.center[1] * 1e7), 123);
+    for (const section of [header, root, metadataBytes, leaves]) writeAll(output, section);
+    let buffer = Buffer.allocUnsafe(1024 * 1024);
+    for (const content of contentOrder) {
+      const length = this.#contentLengths[content];
+      if (length > buffer.length) buffer = Buffer.allocUnsafe(length);
+      readSync2(input, buffer, 0, length, this.#contentOffsets[content]);
+      writeAll(output, buffer.subarray(0, length));
+    }
+    return {
+      addressedTiles: this.#addressed,
+      byteCount: dataOffset + tileDataLength,
+      tileContents: contentOrder.length,
+      tileEntries: entries.length
+    };
+  }
+};
+function writeAll(descriptor, bytes) {
+  let written = 0;
+  while (written < bytes.length) {
+    written += writeSync2(descriptor, bytes, written, bytes.length - written);
+  }
+}
+function buildDirectories(entries) {
+  const root = serializeDirectory(entries);
+  if (root.length <= rootLimitBytes) return { leaves: Buffer.alloc(0), root };
+  for (let leafSize = 4096; ; leafSize = Math.ceil(leafSize * 1.2)) {
+    const rootEntries = [];
+    const leaves = [];
+    let offset = 0;
+    for (let start = 0; start < entries.length; start += leafSize) {
+      const leaf = serializeDirectory(entries.slice(start, start + leafSize));
+      rootEntries.push({
+        content: -1,
+        length: leaf.length,
+        offset,
+        runLength: 0,
+        tileId: entries[start].tileId
+      });
+      leaves.push(leaf);
+      offset += leaf.length;
+    }
+    const serialized = serializeDirectory(rootEntries);
+    if (serialized.length <= rootLimitBytes) {
+      return { leaves: Buffer.concat(leaves), root: serialized };
+    }
+  }
+}
+function serializeDirectory(entries) {
+  const bytes = Buffer.allocUnsafe(10 + entries.length * 40);
+  let cursor = 0;
+  const varint = (value) => {
+    while (value >= 128) {
+      bytes[cursor] = value % 128 | 128;
+      cursor += 1;
+      value = Math.floor(value / 128);
+    }
+    bytes[cursor] = value;
+    cursor += 1;
+  };
+  varint(entries.length);
+  let lastId = 0;
+  for (const entry of entries) {
+    varint(entry.tileId - lastId);
+    lastId = entry.tileId;
+  }
+  for (const entry of entries) varint(entry.runLength);
+  for (const entry of entries) varint(entry.length);
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    const previous = entries[index - 1];
+    const contiguous = previous && entry.offset === previous.offset + previous.length;
+    varint(contiguous ? 0 : entry.offset + 1);
+  }
+  return stableGzipSync(bytes.subarray(0, cursor));
+}
+
+// src/tileset-build/read-csv.ts
+import { closeSync as closeSync3, openSync as openSync3, readSync as readSync3 } from "fs";
+var chunkBytes = 4 * 1024 * 1024;
+var numberPattern = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+var longitudeNames = /* @__PURE__ */ new Set(["lon", "lng", "long", "longitude", "x_lon", "lon_x"]);
+var latitudeNames = /* @__PURE__ */ new Set(["lat", "latitude", "y_lat", "lat_y"]);
+async function readCsv(path, ingest, options) {
+  const delimiter = detectDelimiter(path);
+  let header = null;
+  let types = [];
+  await forEachRow(path, delimiter, (row, line) => {
+    if (!header) {
+      header = row;
+      types = row.map(() => null);
+      return;
+    }
+    if (row.length === 1 && row[0] === "") return;
+    if (row.length !== header.length) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_INVALID",
+        "input",
+        `row ${line}: expected ${header.length} columns but found ${row.length}. Check quoting and the delimiter.`
+      );
+    }
+    for (let index = 0; index < row.length; index += 1) {
+      types[index] = mergeType(types[index], row[index]);
+    }
+  });
+  if (!header) {
+    throw new TilesetBuildError("TF_TILESET_BUILD_EMPTY", "input", "The CSV file is empty.");
+  }
+  const columns = header;
+  const longitude = coordinateColumn(columns, options.lonColumn, longitudeNames, "longitude");
+  const latitude = coordinateColumn(columns, options.latColumn, latitudeNames, "latitude");
+  let isHeader = true;
+  await forEachRow(path, delimiter, (row, line) => {
+    if (isHeader) {
+      isHeader = false;
+      return;
+    }
+    if (row.length === 1 && row[0] === "") return;
+    ingest.location = `row ${line}`;
+    const rawX = row[longitude].trim();
+    const rawY = row[latitude].trim();
+    if (rawX === "" && rawY === "") {
+      ingest.skipEmpty();
+      return;
+    }
+    const x = Number(rawX);
+    const y = Number(rawY);
+    if (rawX === "" || rawY === "" || !Number.isFinite(x) || !Number.isFinite(y)) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_INVALID",
+        "input",
+        `row ${line}: coordinates "${rawX}", "${rawY}" are not numbers. Decimal commas are not supported.`
+      );
+    }
+    const properties = {};
+    for (let index = 0; index < row.length; index += 1) {
+      if (index === longitude || index === latitude) continue;
+      const value = typedValue(row[index], types[index]);
+      if (value !== null) properties[columns[index]] = value;
+    }
+    ingest.add({ coordinates: [x, y], type: "Point" }, properties);
+  });
+}
+async function csvColumnsNameCoordinates(path, options) {
+  if (options.lonColumn || options.latColumn) return true;
+  let names = [];
+  await forEachRow(path, detectDelimiter(path), (row) => {
+    names = row;
+    return "stop";
+  });
+  const normalized = names.map(normalizeName);
+  return normalized.some((name) => longitudeNames.has(name)) && normalized.some((name) => latitudeNames.has(name));
+}
+async function csvColumnNames(path) {
+  let names = [];
+  await forEachRow(path, detectDelimiter(path), (row) => {
+    names = row;
+    return "stop";
+  });
+  return names;
+}
+function normalizeName(name) {
+  return name.trim().toLowerCase();
+}
+function coordinateColumn(header, requested, names, label) {
+  if (requested !== void 0) {
+    const index = header.indexOf(requested);
+    if (index < 0) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_CSV_COLUMNS",
+        "input.columns",
+        `Column "${requested}" does not exist. Available columns: ${header.join(", ")}.`
+      );
+    }
+    return index;
+  }
+  const matches2 = header.flatMap((name, index) => names.has(normalizeName(name)) ? [index] : []);
+  if (matches2.length === 1) return matches2[0];
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_CSV_COLUMNS",
+    "input.columns",
+    matches2.length > 1 ? `Several columns could hold the ${label}: ${matches2.map((index) => header[index]).join(", ")}. Pick one with --${label === "longitude" ? "lon" : "lat"}-column.` : `No ${label} column found among: ${header.join(", ")}. Name it with --${label === "longitude" ? "lon" : "lat"}-column. Columns such as x and y are never assumed to be WGS84.`
+  );
+}
+function mergeType(current2, value) {
+  if (value === "") return current2;
+  const type = valueType(value);
+  if (current2 === null || current2 === type) return type;
+  return "string";
+}
+function valueType(value) {
+  if (value === "true" || value === "false") return "boolean";
+  if (numberPattern.test(value) && Number.isFinite(Number(value))) {
+    return value.includes(".") || value.includes("e") || value.includes("E") || Number.isSafeInteger(Number(value)) ? "number" : "string";
+  }
+  return "string";
+}
+function typedValue(value, type) {
+  if (value === "") return null;
+  if (type === "number") return Number(value);
+  if (type === "boolean") return value === "true";
+  return value;
+}
+function detectDelimiter(path) {
+  const descriptor = openSync3(path, "r");
+  const buffer = Buffer.allocUnsafe(65536);
+  const bytes = readSync3(descriptor, buffer, 0, buffer.length, 0);
+  closeSync3(descriptor);
+  const firstLine = buffer.subarray(0, bytes).toString("utf8").split(/\r?\n/u, 1)[0] ?? "";
+  let best = ",";
+  let bestCount = 0;
+  for (const candidate of [",", ";", "	", "|"]) {
+    const count = firstLine.split(candidate).length - 1;
+    if (count > bestCount) {
+      best = candidate;
+      bestCount = count;
+    }
+  }
+  return best;
+}
+async function forEachRow(path, delimiter, visit) {
+  const descriptor = openSync3(path, "r");
+  const buffer = Buffer.allocUnsafe(chunkBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let row = [];
+  let cell = "";
+  let quoted = false;
+  let quotePending = false;
+  let line = 1;
+  let rowLine = 1;
+  let first = true;
+  const endCell = () => {
+    row.push(cell);
+    cell = "";
+  };
+  let stopped = false;
+  const endRow = () => {
+    endCell();
+    if (visit(row, rowLine) === "stop") stopped = true;
+    row = [];
+  };
+  const decode = (bytes) => {
+    try {
+      return bytes ? decoder.decode(bytes, { stream: true }) : decoder.decode();
+    } catch {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_INVALID",
+        "input",
+        `Near row ${line}: the CSV file is not valid UTF-8. Re-encode it as UTF-8 first.`
+      );
+    }
+  };
+  const consume = (text) => {
+    let start = 0;
+    let index = 0;
+    const length = text.length;
+    while (index < length && !stopped) {
+      const character = text[index];
+      if (quoted) {
+        if (character === '"') {
+          cell += text.slice(start, index);
+          quoted = false;
+          quotePending = true;
+          start = index + 1;
+        } else if (character === "\n") {
+          line += 1;
+        }
+        index += 1;
+        continue;
+      }
+      if (quotePending) {
+        quotePending = false;
+        if (character === '"') {
+          cell += '"';
+          quoted = true;
+          start = index + 1;
+          index += 1;
+          continue;
+        }
+      }
+      if (character === '"' && start === index && cell === "") {
+        quoted = true;
+        start = index + 1;
+      } else if (character === delimiter) {
+        cell += text.slice(start, index);
+        endCell();
+        start = index + 1;
+      } else if (character === "\n") {
+        cell += text.slice(start, index);
+        if (cell.endsWith("\r")) cell = cell.slice(0, -1);
+        endRow();
+        line += 1;
+        rowLine = line;
+        start = index + 1;
+      }
+      index += 1;
+    }
+    cell += text.slice(start, length);
+  };
+  try {
+    for (; ; ) {
+      const bytes = readSync3(descriptor, buffer, 0, chunkBytes, null);
+      if (bytes === 0) break;
+      let text = decode(buffer.subarray(0, bytes));
+      if (first) {
+        first = false;
+        if (text.charCodeAt(0) === 65279) text = text.slice(1);
+      }
+      consume(text);
+      if (stopped) return;
+      await yieldToEventLoop();
+    }
+    consume(decode());
+    if (quoted) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_INVALID",
+        "input",
+        `row ${rowLine}: a quoted value never closes.`
+      );
+    }
+    if (cell !== "" || row.length > 0) {
+      if (cell.endsWith("\r")) cell = cell.slice(0, -1);
+      endRow();
+    }
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+
+// src/tileset-build/read-geojson.ts
+import { closeSync as closeSync4, fstatSync, openSync as openSync4, readFileSync, readSync as readSync4 } from "fs";
+var chunkBytes2 = 4 * 1024 * 1024;
+var maximumWholeDocumentBytes = 512 * 1024 * 1024;
+var quote = 34;
+var backslash = 92;
+var openBrace = 123;
+var closeBrace = 125;
+var openBracket = 91;
+var closeBracket = 93;
+var comma = 44;
+var colon = 58;
+async function readGeojson(path, ingest, onCrs) {
+  let index = 0;
+  const scanner = new TopLevelScanner((bytes) => {
+    index += 1;
+    ingest.location = `feature ${index}`;
+    addFeature(parseJson(bytes, ingest.location), ingest);
+  }, onCrs);
+  await forEachChunk(path, (chunk) => scanner.write(chunk));
+  scanner.end();
+  if (!scanner.sawFeatures) readSingleObject(path, ingest, onCrs);
+}
+async function readGeojsonSequence(path, ingest) {
+  let line = 0;
+  let carried = [];
+  let carriedBytes = 0;
+  const emit = (bytes) => {
+    line += 1;
+    let start = 0;
+    let end = bytes.length;
+    while (start < end && isSpaceOrSeparator(bytes[start])) start += 1;
+    while (end > start && isSpaceOrSeparator(bytes[end - 1])) end -= 1;
+    if (start === end) return;
+    ingest.location = `line ${line}`;
+    addFeature(parseJson(bytes.subarray(start, end), ingest.location), ingest);
+  };
+  await forEachChunk(path, (chunk) => {
+    let start = 0;
+    for (; ; ) {
+      const newline = chunk.indexOf(10, start);
+      if (newline < 0) break;
+      const piece = chunk.subarray(start, newline);
+      if (carried.length > 0) {
+        emit(Buffer.concat([...carried, piece]));
+        carried = [];
+        carriedBytes = 0;
+      } else {
+        emit(piece);
+      }
+      start = newline + 1;
+    }
+    if (start < chunk.length) {
+      carried.push(Buffer.from(chunk.subarray(start)));
+      carriedBytes += chunk.length - start;
+      if (carriedBytes > maximumFeatureBytes) throw featureTooManyBytes(`line ${line + 1}`);
+    }
+  });
+  if (carried.length > 0) emit(Buffer.concat(carried));
+}
+function readSingleObject(path, ingest, onCrs) {
+  const descriptor = openSync4(path, "r");
+  const size = fstatSync(descriptor).size;
+  closeSync4(descriptor);
+  if (size > maximumWholeDocumentBytes) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      "Single-object GeoJSON documents are limited to 512 MiB. Use a FeatureCollection or newline-delimited features."
+    );
+  }
+  ingest.location = "document";
+  const document = parseJson(readFileSync(path), ingest.location);
+  if (document.type === "FeatureCollection") return;
+  const crs = document.crs;
+  if (crs !== void 0) onCrs(crs);
+  addFeature(document, ingest);
+}
+function addFeature(value, ingest) {
+  if (value === null || typeof value !== "object") {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `${ingest.location}: expected a GeoJSON object.`
+    );
+  }
+  if (value.type === "Feature") {
+    ingest.add(value.geometry, value.properties ?? {}, value.id);
+  } else {
+    ingest.add(value, {});
+  }
+}
+function parseJson(bytes, location) {
+  try {
+    return JSON.parse(bytes.toString("utf8"));
+  } catch (error) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `${location}: invalid JSON (${error instanceof Error ? error.message : "parse failure"}). A file with one feature per line needs --format geojsonseq.`
+    );
+  }
+}
+async function forEachChunk(path, visit) {
+  const descriptor = openSync4(path, "r");
+  const buffer = Buffer.allocUnsafe(chunkBytes2);
+  try {
+    for (; ; ) {
+      const bytes = readSync4(descriptor, buffer, 0, chunkBytes2, null);
+      if (bytes === 0) return;
+      visit(buffer.subarray(0, bytes));
+      await yieldToEventLoop();
+    }
+  } finally {
+    closeSync4(descriptor);
+  }
+}
+function isSpaceOrSeparator(byte) {
+  return byte === 32 || byte === 9 || byte === 13 || byte === 10 || byte === 30;
+}
+var TopLevelScanner = class {
+  constructor(onFeature, onCrs) {
+    this.onFeature = onFeature;
+    this.onCrs = onCrs;
+  }
+  onFeature;
+  onCrs;
+  sawFeatures = false;
+  #depth = 0;
+  #inString = false;
+  #escaped = false;
+  #inFeatures = false;
+  #capture = [];
+  #capturedBytes = 0;
+  #featuresEmitted = 0;
+  #captureStart = -1;
+  #key = [];
+  #keyStart = -1;
+  #afterColon = false;
+  #currentKey = "";
+  #crsStart = false;
+  write(chunk) {
+    let index = 0;
+    const length = chunk.length;
+    while (index < length) {
+      const byte = chunk[index];
+      if (this.#inString) {
+        if (this.#escaped) {
+          this.#escaped = false;
+          index += 1;
+          continue;
+        }
+        if (byte === backslash) {
+          this.#escaped = true;
+          index += 1;
+          continue;
+        }
+        if (byte === quote) {
+          this.#inString = false;
+          if (this.#keyStart >= 0) {
+            this.#key.push(Buffer.from(chunk.subarray(this.#keyStart, index)));
+            this.#keyStart = -1;
+          }
+        }
+        index += 1;
+        continue;
+      }
+      switch (byte) {
+        case quote:
+          this.#inString = true;
+          if (this.#depth === 1 && !this.#afterColon) {
+            this.#key = [];
+            this.#keyStart = index + 1;
+          }
+          break;
+        case openBrace:
+        case openBracket:
+          if (this.#depth === 1 && this.#afterColon) {
+            if (this.#currentKey === "features" && byte === openBracket) {
+              this.#inFeatures = true;
+              this.sawFeatures = true;
+              this.#afterColon = false;
+              this.#depth += 1;
+              break;
+            }
+            if (this.#currentKey === "crs" && this.#captureStart < 0) {
+              this.#crsStart = true;
+              this.#captureStart = index;
+            }
+          } else if (this.#inFeatures && this.#depth === 2 && this.#captureStart < 0) {
+            this.#captureStart = index;
+          }
+          this.#depth += 1;
+          break;
+        case closeBrace:
+        case closeBracket:
+          this.#depth -= 1;
+          if (this.#inFeatures) {
+            if (this.#depth === 1) {
+              this.#inFeatures = false;
+            } else if (this.#depth === 2) {
+              this.#emitFeature(chunk, index + 1);
+            }
+          } else if (this.#crsStart && this.#depth === 1) {
+            this.#emitCrs(chunk, index + 1);
+          }
+          break;
+        case comma:
+          if (this.#depth === 1) this.#afterColon = false;
+          break;
+        case colon:
+          if (this.#depth === 1 && !this.#afterColon) {
+            this.#afterColon = true;
+            this.#currentKey = Buffer.concat(this.#key).toString("utf8");
+          }
+          break;
+        default:
+          break;
+      }
+      index += 1;
+    }
+    if (this.#keyStart >= 0) {
+      this.#key.push(Buffer.from(chunk.subarray(this.#keyStart)));
+      this.#keyStart = 0;
+    }
+    if (this.#captureStart >= 0) {
+      this.#capture.push(Buffer.from(chunk.subarray(this.#captureStart)));
+      this.#capturedBytes += chunk.length - this.#captureStart;
+      this.#captureStart = 0;
+      if (this.#capturedBytes > maximumFeatureBytes) {
+        throw featureTooManyBytes(`feature ${this.#featuresEmitted + 1}`);
+      }
+    }
+  }
+  end() {
+    if (this.#depth !== 0 || this.#inString) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_INVALID",
+        "input",
+        "The GeoJSON document ends before its top-level object closes; the file may be truncated."
+      );
+    }
+  }
+  #take(chunk, end) {
+    const tail = chunk.subarray(this.#captureStart, end);
+    const bytes = this.#capture.length > 0 ? Buffer.concat([...this.#capture, tail]) : tail;
+    this.#capture = [];
+    this.#capturedBytes = 0;
+    this.#captureStart = -1;
+    return bytes;
+  }
+  #emitFeature(chunk, end) {
+    this.#featuresEmitted += 1;
+    this.onFeature(this.#take(chunk, end));
+  }
+  #emitCrs(chunk, end) {
+    this.#crsStart = false;
+    this.onCrs(parseJson(this.#take(chunk, end), "crs member"));
+  }
+};
+
+// src/tileset-build/read-geopackage.ts
+import { statSync } from "fs";
+import { pathToFileURL } from "url";
+var requiredTables = ["gpkg_contents", "gpkg_geometry_columns", "gpkg_spatial_ref_sys"];
+var maximumLayers = 65536;
+var maximumGeometryDepth = 16;
+var yieldEveryRows = 8192;
+var yieldEveryBytes = 64 * 1024 * 1024;
+var GeoPackageLayer = class _GeoPackageLayer {
+  constructor(database, layer, crsStatement) {
+    this.database = database;
+    this.layer = layer;
+    this.crsStatement = crsStatement;
+  }
+  database;
+  layer;
+  crsStatement;
+  static open(path, requested) {
+    const database = openDatabase(loadSqlite(), path);
+    try {
+      return guarded(() => {
+        database.exec("PRAGMA trusted_schema=OFF; PRAGMA query_only=ON;");
+        const tables = plainTables(database);
+        requireGeoPackage(tables);
+        const layer = chooseLayer(listLayers(database, tables), requested);
+        return new _GeoPackageLayer(
+          database,
+          layer,
+          statementFromGeopackageSrs(layer.name, readSrs(database, layer.srsId))
+        );
+      });
+    } catch (error) {
+      database.close();
+      throw error;
+    }
+  }
+  close() {
+    this.database.close();
+  }
+  /** `trustRowSrs` is false when --source-crs overrides what the rows say about themselves. */
+  async read(ingest, trustRowSrs) {
+    const { database, layer } = this;
+    await guardedAsync(async () => {
+      const columns = database.prepare("SELECT name, type, pk, hidden FROM pragma_table_xinfo(?)").all(layer.name);
+      const stored = columns.filter((column) => column.hidden === 0);
+      if (!stored.some((column) => column.name === layer.geometryColumn)) {
+        throw invalid(`layer "${layer.name}" has no column "${layer.geometryColumn}".`);
+      }
+      if (stored.length !== columns.length) {
+        ingest.warn("Generated columns in the GeoPackage were ignored.");
+      }
+      const primary = stored.filter((column) => column.pk > 0);
+      const idColumn = primary.length === 1 ? primary[0].name : null;
+      const attributes = [];
+      for (const column of stored) {
+        if (column.name === layer.geometryColumn || column.name === idColumn) continue;
+        if (/^blob/iu.test(column.type)) {
+          ingest.warn(blobWarning);
+          continue;
+        }
+        attributes.push({ boolean: /^bool/iu.test(column.type), name: column.name });
+      }
+      const selected = [
+        layer.geometryColumn,
+        ...idColumn === null ? [] : [idColumn],
+        ...attributes.map((column) => column.name)
+      ];
+      const statement = database.prepare(
+        `SELECT ${selected.map(quoteIdentifier).join(", ")} FROM ${quoteIdentifier(layer.name)} NOT INDEXED`
+      );
+      statement.setReadBigInts(true);
+      await readRows(statement, {
+        attributes,
+        expectedSrs: trustRowSrs ? layer.srsId : null,
+        geometryColumn: layer.geometryColumn,
+        idColumn,
+        ingest,
+        layerName: layer.name
+      });
+    });
+  }
+};
+var blobWarning = "Binary (BLOB) attributes in the GeoPackage have no vector tile equivalent and were skipped.";
+async function readRows(statement, plan) {
+  const { attributes, expectedSrs, geometryColumn, idColumn, ingest } = plan;
+  let index = 0;
+  let pendingBytes = 0;
+  for (const row of statement.iterate()) {
+    index += 1;
+    ingest.location = `row ${index}`;
+    const value = row[geometryColumn];
+    if (value !== null && !(value instanceof Uint8Array)) {
+      throw invalid(`${ingest.location}: the geometry is not a GeoPackage binary value.`);
+    }
+    const blob = value;
+    pendingBytes += blob?.length ?? 0;
+    if (index % yieldEveryRows === 0 || pendingBytes >= yieldEveryBytes) {
+      pendingBytes = 0;
+      await yieldToEventLoop();
+    }
+    const decoded = blob === null ? null : decodeGeometry(blob, ingest.location);
+    if (decoded?.geometry && expectedSrs !== null && decoded.srsId !== expectedSrs) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_CRS_MIXED",
+        "crs",
+        `${ingest.location}: the geometry uses srs_id ${decoded.srsId}, but layer "${plan.layerName}" declares ${expectedSrs}. Pass --source-crs if every row really shares one CRS.`
+      );
+    }
+    if (decoded?.extraDimensions) ingest.warn("Z and M values in the GeoPackage were ignored.");
+    const properties = /* @__PURE__ */ Object.create(null);
+    for (const column of attributes) {
+      const value2 = row[column.name];
+      if (value2 instanceof Uint8Array) {
+        ingest.warn(blobWarning);
+        continue;
+      }
+      properties[column.name] = attributeValue(value2, column.boolean);
+    }
+    ingest.add(
+      decoded?.geometry ?? null,
+      properties,
+      idColumn === null ? void 0 : idValue(row[idColumn])
+    );
+  }
+}
+function attributeValue(value, boolean) {
+  if (typeof value === "bigint") {
+    const number = Number(value);
+    if (!Number.isSafeInteger(number)) return value.toString();
+    return boolean && (number === 0 || number === 1) ? number === 1 : number;
+  }
+  return typeof value === "number" && !Number.isFinite(value) ? null : value;
+}
+function idValue(value) {
+  if (typeof value !== "bigint") return value;
+  const number = Number(value);
+  return Number.isSafeInteger(number) ? number : value.toString();
+}
+function loadSqlite() {
+  const emitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    if (String(warning).includes("SQLite is an experimental feature")) return;
+    emitWarning.call(process, warning, ...rest);
+  });
+  try {
+    const sqlite = process.getBuiltinModule?.("node:sqlite");
+    if (typeof sqlite?.StatementSync?.prototype?.iterate === "function") return sqlite;
+  } finally {
+    process.emitWarning = emitWarning;
+  }
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_RUNTIME_UNSUPPORTED",
+    "input",
+    `Reading a GeoPackage needs Node.js 22.13 or later; this is ${process.version}. Upgrade Node.js, or convert the data to GeoJSON first.`
+  );
+}
+function openDatabase(sqlite, path) {
+  const unfinished = (suffix) => (statSync(`${path}${suffix}`, { throwIfNoEntry: false })?.size ?? 0) > 0;
+  if (!unfinished("-wal") && !unfinished("-journal")) {
+    try {
+      return new sqlite.DatabaseSync(`${pathToFileURL(path).href}?immutable=1`, { readOnly: true });
+    } catch {
+    }
+  }
+  return guarded(() => new sqlite.DatabaseSync(path, { readOnly: true }));
+}
+function plainTables(database) {
+  const rows = database.prepare("SELECT name FROM pragma_table_list WHERE schema = 'main' AND type = 'table'").all();
+  return new Set(rows.map((row) => row.name.toLowerCase()));
+}
+function requireGeoPackage(tables) {
+  const missing = requiredTables.filter((name) => !tables.has(name));
+  if (missing.length > 0) {
+    throw invalid(`the file is not a GeoPackage: it has no ${missing.join(", ")} table.`);
+  }
+}
+function listLayers(database, tables) {
+  const read = (query) => {
+    const rows = database.prepare(`${query} LIMIT ${maximumLayers + 1}`).all();
+    if (rows.length > maximumLayers) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_LIMIT",
+        "input",
+        `The GeoPackage lists more than ${maximumLayers} tables.`
+      );
+    }
+    return rows;
+  };
+  const columns = new Map(
+    read(
+      "SELECT table_name AS name, column_name AS geometryColumn, srs_id AS srsId FROM gpkg_geometry_columns"
+    ).map((row) => [row.name.toLowerCase(), row])
+  );
+  const layers = [];
+  for (const { name } of read(
+    "SELECT table_name AS name FROM gpkg_contents WHERE data_type = 'features'"
+  )) {
+    const key = name.toLowerCase();
+    const column = columns.get(key);
+    if (column && tables.has(key)) layers.push({ ...column, name });
+  }
+  return layers.sort((left, right) => left.name < right.name ? -1 : 1);
+}
+function chooseLayer(layers, requested) {
+  const names = layers.map((layer) => layer.name);
+  if (layers.length === 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_LAYER_INVALID",
+      "inputLayer",
+      "The GeoPackage has no feature tables. Tile matrices, attribute tables and SQL views are not read."
+    );
+  }
+  if (requested !== void 0) {
+    const match = layers.find((layer) => layer.name === requested);
+    if (match) return match;
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_LAYER_INVALID",
+      "inputLayer",
+      `The GeoPackage has no feature table named "${requested}". It has: ${listChoices(names)}.`
+    );
+  }
+  if (layers.length > 1) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_LAYER_INVALID",
+      "inputLayer",
+      `The GeoPackage has ${names.length} feature tables. Choose one with --input-layer: ${listChoices(names)}.`,
+      names
+    );
+  }
+  return layers[0];
+}
+function readSrs(database, srsId) {
+  const hasWkt2 = database.prepare(
+    "SELECT 1 FROM pragma_table_xinfo('gpkg_spatial_ref_sys') WHERE name = 'definition_12_063'"
+  ).get();
+  const row = database.prepare(
+    `SELECT srs_id AS srsId, organization, organization_coordsys_id AS organizationCode,
+              definition${hasWkt2 ? ", definition_12_063 AS definition12063" : ""}
+       FROM gpkg_spatial_ref_sys WHERE srs_id = ?`
+  ).get(srsId);
+  return row ? { ...row, definition12063: row.definition12063 ?? null } : void 0;
+}
+function quoteIdentifier(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function invalid(detail) {
+  return new TilesetBuildError(
+    "TF_TILESET_BUILD_INPUT_INVALID",
+    "input",
+    `The GeoPackage could not be read: ${detail}`
+  );
+}
+function unreadable(error) {
+  if (error instanceof TilesetBuildError) return error;
+  return invalid(`${error instanceof Error ? error.message : "unknown error"}.`);
+}
+function guarded(run) {
+  try {
+    return run();
+  } catch (error) {
+    throw unreadable(error);
+  }
+}
+async function guardedAsync(run) {
+  try {
+    await run();
+  } catch (error) {
+    throw unreadable(error);
+  }
+}
+function decodeGeometry(blob, location) {
+  const bytes = Buffer.from(blob.buffer, blob.byteOffset, blob.byteLength);
+  if (bytes.length < 8 || bytes[0] !== 71 || bytes[1] !== 80) {
+    throw invalid(`${location}: the geometry has no GeoPackage binary header.`);
+  }
+  const flags = bytes[3];
+  if ((flags & 32) !== 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+      "input",
+      `${location}: the geometry uses the extended GeoPackage binary encoding, which is not supported.`
+    );
+  }
+  const envelopeKind = flags >> 1 & 7;
+  if (envelopeKind > 4) throw invalid(`${location}: the geometry header is malformed.`);
+  const envelopeBytes = [0, 32, 48, 48, 64][envelopeKind];
+  const srsId = (flags & 1) === 1 ? bytes.readInt32LE(4) : bytes.readInt32BE(4);
+  if ((flags & 16) !== 0) return { extraDimensions: false, geometry: null, srsId };
+  const reader = new WkbReader(bytes, 8 + envelopeBytes, location);
+  const geometry = reader.geometry(0);
+  return { extraDimensions: reader.extraDimensions, geometry, srsId };
+}
+var WkbReader = class {
+  constructor(bytes, offset, location) {
+    this.bytes = bytes;
+    this.offset = offset;
+    this.location = location;
+  }
+  bytes;
+  offset;
+  location;
+  extraDimensions = false;
+  #positions = 0;
+  geometry(depth, expected) {
+    if (depth > maximumGeometryDepth) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_LIMIT",
+        "input",
+        `${this.location}: geometries nest more than ${maximumGeometryDepth} levels deep.`
+      );
+    }
+    this.#need(5);
+    const littleEndian = this.bytes[this.offset] === 1;
+    const code = littleEndian ? this.bytes.readUInt32LE(this.offset + 1) : this.bytes.readUInt32BE(this.offset + 1);
+    this.offset += 5;
+    const base = code % 1e3;
+    const dimensionCode = Math.floor(code / 1e3);
+    if (dimensionCode > 3) throw this.#malformed(`unknown geometry code ${code}`);
+    if (expected !== void 0 && base !== expected) {
+      throw this.#malformed(`a multi-geometry holds geometry code ${code}`);
+    }
+    const size = dimensionCode === 0 ? 2 : dimensionCode === 3 ? 4 : 3;
+    if (size > 2) this.extraDimensions = true;
+    const read = { littleEndian, size };
+    switch (base) {
+      case 1: {
+        const position = this.#position(read);
+        return Number.isNaN(position[0]) ? null : { coordinates: position, type: "Point" };
+      }
+      case 2:
+        return { coordinates: this.#line(read), type: "LineString" };
+      case 3:
+        return { coordinates: this.#rings(read), type: "Polygon" };
+      case 4:
+        return {
+          coordinates: this.#children(read, depth, 1).map((child) => child.coordinates),
+          type: "MultiPoint"
+        };
+      case 5:
+        return {
+          coordinates: this.#children(read, depth, 2).map((child) => child.coordinates),
+          type: "MultiLineString"
+        };
+      case 6:
+        return {
+          coordinates: this.#children(read, depth, 3).map((child) => child.coordinates),
+          type: "MultiPolygon"
+        };
+      case 7:
+        return { geometries: this.#children(read, depth), type: "GeometryCollection" };
+      case 8:
+      case 9:
+      case 10:
+      case 11:
+      case 12:
+      case 13:
+      case 14:
+      case 15:
+      case 16:
+      case 17:
+        throw new TilesetBuildError(
+          "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+          "input",
+          `${this.location}: curved and surface geometries are not supported. Convert them to lines and polygons first.`
+        );
+      default:
+        throw this.#malformed(`unknown geometry code ${code}`);
+    }
+  }
+  #children(read, depth, expected) {
+    const count = this.#count(read, 5);
+    const children = [];
+    for (let index = 0; index < count; index += 1) {
+      this.#spendPosition();
+      const child = this.geometry(depth + 1, expected);
+      if (child) children.push(child);
+    }
+    return children;
+  }
+  #rings(read) {
+    const count = this.#count(read, 4);
+    const rings = [];
+    for (let index = 0; index < count; index += 1) {
+      this.#spendPosition();
+      rings.push(this.#line(read));
+    }
+    return rings;
+  }
+  #line(read) {
+    const count = this.#count(read, read.size * 8);
+    const positions = [];
+    for (let index = 0; index < count; index += 1) positions.push(this.#position(read));
+    return positions;
+  }
+  #position(read) {
+    this.#spendPosition();
+    this.#need(read.size * 8);
+    const { bytes, offset } = this;
+    this.offset += read.size * 8;
+    return read.littleEndian ? [bytes.readDoubleLE(offset), bytes.readDoubleLE(offset + 8)] : [bytes.readDoubleBE(offset), bytes.readDoubleBE(offset + 8)];
+  }
+  /** Positions and parts count alike: an empty part costs memory too. */
+  #spendPosition() {
+    this.#positions += 1;
+    if (this.#positions > maximumFeaturePositions) throw featureTooLarge(this.location);
+  }
+  #count(read, itemBytes) {
+    this.#need(4);
+    const count = read.littleEndian ? this.bytes.readUInt32LE(this.offset) : this.bytes.readUInt32BE(this.offset);
+    this.offset += 4;
+    this.#need(count * itemBytes);
+    return count;
+  }
+  #need(size) {
+    if (this.offset + size > this.bytes.length) throw this.#malformed("the geometry ends early");
+  }
+  #malformed(reason) {
+    return invalid(`${this.location}: ${reason}.`);
+  }
+};
+
+// src/tileset-build/read-xml.ts
+import { createReadStream } from "fs";
+var chunkBytes3 = 4 * 1024 * 1024;
+var maximumDepth = 128;
+var maximumAttributes = 256;
+var maximumMarkupCharacters = 1024 * 1024;
+var longestReference = 64;
+function fileChunks(path) {
+  return createReadStream(path, { highWaterMark: chunkBytes3 });
+}
+async function readXml(source, handler) {
+  let decoder = null;
+  const scanner = new XmlScanner(handler);
+  try {
+    for await (const chunk of source) {
+      decoder ??= decoderFor(chunk);
+      scanner.write(decoder.decode(chunk, { stream: true }));
+      await yieldToEventLoop();
+    }
+    if (decoder) scanner.write(decoder.decode());
+  } catch (error) {
+    if (error.code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
+      throw invalid2("the file's bytes do not match its declared text encoding.");
+    }
+    throw error;
+  }
+  scanner.end();
+}
+function documentVocabulary(root, label, extensions = /* @__PURE__ */ new Map()) {
+  let prefix = null;
+  const bound = new Map([...extensions.values()].map((value) => [value, value]));
+  return (name, attributes) => {
+    const colon2 = name.indexOf(":");
+    const namePrefix = colon2 < 0 ? "" : name.slice(0, colon2);
+    const local = name.slice(colon2 + 1);
+    if (prefix === null) {
+      if (local !== root) throw invalid2(`the file is not ${label}: its root is <${name}>.`);
+      prefix = namePrefix;
+      for (const [attribute, value] of attributes) {
+        const canonical2 = extensions.get(value);
+        if (canonical2 && attribute.startsWith("xmlns:")) bound.set(attribute.slice(6), canonical2);
+      }
+    }
+    if (namePrefix === prefix) return local;
+    const canonical = bound.get(namePrefix);
+    return canonical ? `${canonical}:${local}` : "";
+  };
+}
+var TextCapture = class {
+  constructor(limit2, location) {
+    this.limit = limit2;
+    this.location = location;
+  }
+  limit;
+  location;
+  #parts = [];
+  #size = 0;
+  write(fragment) {
+    this.#size += fragment.length;
+    if (this.#size > this.limit) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_LIMIT",
+        "input",
+        `${this.location()}: a text value is longer than ${this.limit} characters.`
+      );
+    }
+    this.#parts.push(fragment);
+  }
+  value() {
+    return this.#parts.join("").trim();
+  }
+};
+function invalid2(detail) {
+  return new TilesetBuildError(
+    "TF_TILESET_BUILD_INPUT_INVALID",
+    "input",
+    `The XML could not be read: ${detail}`
+  );
+}
+function decoderFor(first) {
+  const label = bomEncoding(first) ?? declaredEncoding(first) ?? "utf-8";
+  try {
+    return new TextDecoder(label, { fatal: true });
+  } catch {
+    throw invalid2(`it declares an unknown text encoding, "${label}".`);
+  }
+}
+function bomEncoding(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 254) return "utf-16le";
+  if (bytes[0] === 254 && bytes[1] === 255) return "utf-16be";
+  return null;
+}
+function declaredEncoding(bytes) {
+  const prolog = bytes.subarray(0, 256).toString("latin1");
+  return /^\s*<\?xml[^>]*?encoding\s*=\s*["']([A-Za-z0-9._-]+)["']/u.exec(prolog)?.[1] ?? null;
+}
+function isSpace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13;
+}
+function decodeReferences(value) {
+  if (!value.includes("&")) return value;
+  return value.replace(
+    /&(#x[0-9a-fA-F]{1,60}|#[0-9]{1,60}|[A-Za-z][A-Za-z0-9]{0,59});|&/gu,
+    (match, reference) => {
+      switch (reference) {
+        case void 0:
+          throw invalid2('a bare "&" must be written as "&amp;".');
+        case "amp":
+          return "&";
+        case "lt":
+          return "<";
+        case "gt":
+          return ">";
+        case "quot":
+          return '"';
+        case "apos":
+          return "'";
+        default:
+          break;
+      }
+      if (!reference.startsWith("#")) {
+        throw invalid2(`the entity ${match} is not defined; only the five XML entities are read.`);
+      }
+      const hex = reference.startsWith("#x");
+      const code = Number.parseInt(reference.slice(hex ? 2 : 1), hex ? 16 : 10);
+      if (code === 0 || code > 1114111 || code >= 55296 && code <= 57343) {
+        throw invalid2(`${match} is not a valid character.`);
+      }
+      return String.fromCodePoint(code);
+    }
+  );
+}
+var XmlScanner = class {
+  constructor(handler) {
+    this.handler = handler;
+  }
+  handler;
+  #buffer = "";
+  #position = 0;
+  #consumed = 0;
+  #mode = "content";
+  #stack = [];
+  #sawRoot = false;
+  write(text) {
+    this.#consumed += this.#position;
+    this.#buffer = this.#buffer.slice(this.#position) + text;
+    this.#position = 0;
+    this.#scan();
+  }
+  end() {
+    if (this.#mode !== "content" || this.#position < this.#buffer.length) {
+      throw this.#malformed("the document ends inside a tag, comment or CDATA section");
+    }
+    if (!this.#sawRoot) throw invalid2("the file has no XML elements.");
+    if (this.#stack.length > 0) {
+      throw this.#malformed(`<${this.#stack.at(-1)}> is never closed; the file may be truncated`);
+    }
+  }
+  #scan() {
+    for (; ; ) {
+      if (this.#mode === "comment") {
+        const end = this.#buffer.indexOf("-->", this.#position);
+        if (end < 0) {
+          this.#position = Math.max(this.#position, this.#buffer.length - 2);
+          return;
+        }
+        this.#position = end + 3;
+        this.#mode = "content";
+      } else if (this.#mode === "cdata") {
+        const end = this.#buffer.indexOf("]]>", this.#position);
+        if (end < 0) {
+          const safe = Math.max(this.#position, this.#buffer.length - 2);
+          this.#emitRaw(safe);
+          return;
+        }
+        this.#emitRaw(end);
+        this.#position = end + 3;
+        this.#mode = "content";
+      } else {
+        const open = this.#buffer.indexOf("<", this.#position);
+        if (open < 0) {
+          this.#emitText(this.#safeTextEnd());
+          return;
+        }
+        this.#emitText(open);
+        if (!this.#markup()) return;
+      }
+    }
+  }
+  #emitRaw(end) {
+    if (end > this.#position) this.handler.text(this.#buffer.slice(this.#position, end));
+    this.#position = end;
+  }
+  #emitText(end) {
+    if (end <= this.#position) return;
+    const text = this.#buffer.slice(this.#position, end);
+    this.#position = end;
+    if (this.#stack.length > 0) {
+      this.handler.text(decodeReferences(text));
+    } else if (text.trim() !== "") {
+      throw this.#malformed("text appears outside the root element");
+    }
+  }
+  /** Holds back a trailing `&...` so that a reference split across chunks stays whole. */
+  #safeTextEnd() {
+    const length = this.#buffer.length;
+    const ampersand = this.#buffer.lastIndexOf("&");
+    if (ampersand < Math.max(this.#position, length - longestReference)) return length;
+    return this.#buffer.includes(";", ampersand) ? length : ampersand;
+  }
+  /** Consumes one markup token at `#position`, or returns false if it needs more input. */
+  #markup() {
+    const buffer = this.#buffer;
+    const start = this.#position;
+    const next2 = buffer[start + 1];
+    if (next2 === void 0) return false;
+    if (next2 === "?") {
+      const end = buffer.indexOf("?>", start + 2);
+      if (end < 0) return this.#wait();
+      this.#checkTagLength(end - start);
+      this.#position = end + 2;
+      return true;
+    }
+    if (next2 === "!") return this.#declaration();
+    if (next2 === "/") {
+      const end = buffer.indexOf(">", start + 2);
+      if (end < 0) return this.#wait();
+      this.#checkTagLength(end - start);
+      const name = buffer.slice(start + 2, end).trimEnd();
+      const expected = this.#stack.pop();
+      if (name !== expected) {
+        throw this.#malformed(`</${name}> does not close <${expected ?? "anything"}>`);
+      }
+      this.#position = end + 1;
+      this.handler.close(name);
+      return true;
+    }
+    return this.#startTag();
+  }
+  #declaration() {
+    const buffer = this.#buffer;
+    const start = this.#position;
+    if (buffer.startsWith("<!--", start)) {
+      this.#mode = "comment";
+      this.#position = start + 4;
+      return true;
+    }
+    if (buffer.startsWith("<![CDATA[", start)) {
+      if (this.#stack.length === 0) throw this.#malformed("CDATA appears outside the root element");
+      this.#mode = "cdata";
+      this.#position = start + 9;
+      return true;
+    }
+    const head = buffer.slice(start, start + 9);
+    if ("<!--".startsWith(head) || "<![CDATA[".startsWith(head)) return false;
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_UNSAFE",
+      "input",
+      "The XML has a DOCTYPE or entity declaration. KML and GPX never need one, and it is how entity-expansion attacks work, so the file is refused."
+    );
+  }
+  #startTag() {
+    const buffer = this.#buffer;
+    const length = buffer.length;
+    const start = this.#position;
+    let index = start + 1;
+    while (index < length && !this.#endsName(buffer.charCodeAt(index))) index += 1;
+    if (index >= length) return this.#wait();
+    const name = buffer.slice(start + 1, index);
+    if (name === "") throw this.#malformed('a "<" does not start a tag');
+    const attributes = /* @__PURE__ */ new Map();
+    let selfClosing = false;
+    for (; ; ) {
+      while (index < length && isSpace(buffer.charCodeAt(index))) index += 1;
+      if (index >= length) return this.#wait();
+      const character = buffer[index];
+      if (character === ">") {
+        index += 1;
+        break;
+      }
+      if (character === "/") {
+        if (index + 1 >= length) return this.#wait();
+        if (buffer[index + 1] !== ">") throw this.#malformed(`<${name}> has a stray "/"`);
+        selfClosing = true;
+        index += 2;
+        break;
+      }
+      const nameStart = index;
+      while (index < length && buffer[index] !== "=" && !this.#endsName(buffer.charCodeAt(index))) {
+        index += 1;
+      }
+      if (index >= length) return this.#wait();
+      const attribute = buffer.slice(nameStart, index);
+      while (index < length && isSpace(buffer.charCodeAt(index))) index += 1;
+      if (index >= length) return this.#wait();
+      if (buffer[index] !== "=" || attribute === "") {
+        throw this.#malformed(`<${name}> has a malformed attribute`);
+      }
+      index += 1;
+      while (index < length && isSpace(buffer.charCodeAt(index))) index += 1;
+      if (index >= length) return this.#wait();
+      const quote2 = buffer[index];
+      if (quote2 !== '"' && quote2 !== "'") {
+        throw this.#malformed(`attribute "${attribute}" of <${name}> is not quoted`);
+      }
+      const valueEnd = buffer.indexOf(quote2, index + 1);
+      if (valueEnd < 0) return this.#wait();
+      const raw = buffer.slice(index + 1, valueEnd);
+      if (raw.includes("<")) throw this.#malformed(`attribute "${attribute}" contains "<"`);
+      attributes.set(attribute, decodeReferences(raw));
+      if (attributes.size > maximumAttributes) {
+        throw limit(`<${name}> has more than ${maximumAttributes} attributes.`);
+      }
+      index = valueEnd + 1;
+    }
+    this.#checkTagLength(index - start);
+    if (this.#stack.length === 0 && this.#sawRoot) {
+      throw this.#malformed("the document has more than one root element");
+    }
+    if (this.#stack.length >= maximumDepth) {
+      throw limit(`elements nest more than ${maximumDepth} levels deep.`);
+    }
+    this.#sawRoot = true;
+    this.#position = index;
+    this.handler.open(name, attributes);
+    if (selfClosing) this.handler.close(name);
+    else this.#stack.push(name);
+    return true;
+  }
+  #endsName(code) {
+    return isSpace(code) || code === 47 || code === 62;
+  }
+  /** An incomplete token waits for the next chunk, unless it has already grown past reason. */
+  #wait() {
+    this.#checkTagLength(this.#buffer.length - this.#position);
+    return false;
+  }
+  /** Checked on complete tags too, so that the answer does not depend on where chunks fall. */
+  #checkTagLength(length) {
+    if (length > maximumMarkupCharacters) {
+      throw limit(`one tag is longer than ${maximumMarkupCharacters} characters.`);
+    }
+  }
+  #malformed(reason) {
+    return invalid2(`near character ${this.#consumed + this.#position}: ${reason}.`);
+  }
+};
+function limit(detail) {
+  return new TilesetBuildError(
+    "TF_TILESET_BUILD_INPUT_LIMIT",
+    "input",
+    `The XML exceeds a safety limit: ${detail}`
+  );
+}
+
+// src/tileset-build/read-gpx.ts
+var maximumFieldCharacters = 1024 * 1024;
+var textFields = /* @__PURE__ */ new Set(["cmt", "desc", "name", "sym", "src", "time", "type"]);
+var numericFields = /* @__PURE__ */ new Set(["ele", "number"]);
+var locations = { rte: "route", trk: "track", wpt: "waypoint" };
+async function readGpx(source, ingest) {
+  const reader = new GpxReader(ingest);
+  await readXml(source, reader);
+  reader.finish();
+}
+var GpxReader = class {
+  constructor(ingest) {
+    this.ingest = ingest;
+  }
+  ingest;
+  #resolve = documentVocabulary("gpx", "a GPX document");
+  #path = [];
+  #counts = { rte: 0, trk: 0, wpt: 0 };
+  #feature = null;
+  #capture = null;
+  #pointDetailIgnored = false;
+  open = (raw, attributes) => {
+    const name = this.#resolve(raw, attributes);
+    const parent = this.#path.at(-1) ?? "";
+    this.#path.push(name);
+    if (this.#capture) return;
+    if (parent === "gpx" && (name === "wpt" || name === "rte" || name === "trk")) {
+      this.#begin(name, attributes);
+      return;
+    }
+    const feature = this.#feature;
+    if (!feature) return;
+    if (parent === feature.kind && (textFields.has(name) || numericFields.has(name))) {
+      this.#capture = {
+        depth: this.#path.length - 1,
+        field: name,
+        text: new TextCapture(maximumFieldCharacters, () => this.ingest.location)
+      };
+    } else if (name === "rtept" && parent === "rte") {
+      if (feature.lines.length === 0) feature.lines.push([]);
+      this.#addPoint(feature, feature.lines[0], attributes);
+    } else if (name === "trkseg" && parent === "trk") {
+      this.#spendPosition(feature);
+      feature.lines.push([]);
+    } else if (name === "trkpt" && parent === "trkseg") {
+      this.#addPoint(feature, feature.lines[feature.lines.length - 1], attributes);
+    } else if ((name === "ele" || name === "time") && (parent === "rtept" || parent === "trkpt")) {
+      this.#pointDetailIgnored = true;
+    }
+  };
+  close = () => {
+    const name = this.#path.pop() ?? "";
+    const capture = this.#capture;
+    if (capture && this.#path.length === capture.depth) {
+      this.#capture = null;
+      this.#store(capture.field, capture.text.value());
+      return;
+    }
+    if (capture) return;
+    const feature = this.#feature;
+    if (feature && this.#path.length === 1 && name === feature.kind) this.#finishFeature(feature);
+  };
+  text = (fragment) => {
+    this.#capture?.text.write(fragment);
+  };
+  finish() {
+    if (this.#pointDetailIgnored) {
+      this.ingest.warn("Elevation and time on GPX route and track points were ignored.");
+    }
+  }
+  #begin(kind, attributes) {
+    this.#counts[kind] += 1;
+    this.ingest.location = `${locations[kind]} ${this.#counts[kind]}`;
+    this.#feature = {
+      kind,
+      lines: [],
+      point: kind === "wpt" ? this.#position(attributes) : null,
+      positions: 0,
+      properties: /* @__PURE__ */ Object.create(null)
+    };
+  }
+  #store(field2, value) {
+    if (value === "" || !this.#feature) return;
+    if (numericFields.has(field2)) {
+      const number = Number(value);
+      if (Number.isFinite(number)) this.#feature.properties[field2] = number;
+      return;
+    }
+    this.#feature.properties[field2] = value;
+  }
+  #addPoint(feature, line, attributes) {
+    if (!line) throw this.#invalid("a track point sits outside a track segment");
+    this.#spendPosition(feature);
+    line.push(this.#position(attributes));
+  }
+  /** Positions and segments count alike: an empty segment costs memory too. */
+  #spendPosition(feature) {
+    feature.positions += 1;
+    if (feature.positions > maximumFeaturePositions) throw featureTooLarge(this.ingest.location);
+  }
+  #position(attributes) {
+    const lon = attributes.get("lon")?.trim();
+    const lat = attributes.get("lat")?.trim();
+    if (!lon || !lat) throw this.#invalid("a point needs both lat and lon attributes");
+    return [Number(lon), Number(lat)];
+  }
+  #finishFeature(feature) {
+    this.#feature = null;
+    if (feature.kind === "wpt") {
+      this.ingest.add({ coordinates: feature.point, type: "Point" }, feature.properties);
+    } else if (feature.kind === "rte") {
+      this.ingest.add(
+        { coordinates: feature.lines[0] ?? [], type: "LineString" },
+        feature.properties
+      );
+    } else {
+      this.ingest.add({ coordinates: feature.lines, type: "MultiLineString" }, feature.properties);
+    }
+  }
+  #invalid(reason) {
+    return new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `${this.ingest.location}: ${reason}.`
+    );
+  }
+};
+
+// src/tileset-build/read-kml.ts
+var maximumFieldCharacters2 = 8 * 1024 * 1024;
+var maximumFeatureTextCharacters = 64 * 1024 * 1024;
+var maximumFolderNameCharacters = 1024 * 1024;
+var maximumTupleCharacters = 256;
+var maximumSchemaFields = 65536;
+var maximumSchemaCharacters = 16 * 1024 * 1024;
+var coordinateParents = /* @__PURE__ */ new Set(["LinearRing", "LineString", "Point"]);
+var placemarkFields = /* @__PURE__ */ new Set(["address", "description", "name", "phoneNumber"]);
+var builtInFields = /* @__PURE__ */ new Set([...placemarkFields, "begin", "end", "folder", "timestamp"]);
+var ignoredFeatures = /* @__PURE__ */ new Set(["GroundOverlay", "NetworkLink", "PhotoOverlay", "ScreenOverlay"]);
+var trackElements = /* @__PURE__ */ new Set(["Track", "gx:Track"]);
+var coordElements = /* @__PURE__ */ new Set(["coord", "gx:coord"]);
+var numericSchemaTypes = /* @__PURE__ */ new Set(["double", "float", "int", "short", "uint", "ushort"]);
+async function readKml(source, ingest) {
+  const reader = new KmlReader(ingest);
+  await readXml(source, reader);
+  reader.finish();
+}
+var KmlReader = class {
+  constructor(ingest) {
+    this.ingest = ingest;
+  }
+  ingest;
+  #resolve = documentVocabulary(
+    "kml",
+    "a KML document",
+    /* @__PURE__ */ new Map([["http://www.google.com/kml/ext/2.2", "gx"]])
+  );
+  #path = [];
+  #folders = [];
+  #schemaFields = /* @__PURE__ */ new Map();
+  #schemaId = "";
+  #schemaUrl = "";
+  #schemaCharacters = 0;
+  #dataName = null;
+  #placemark = null;
+  #placemarks = 0;
+  #capture = null;
+  #tuple = null;
+  #positions = [];
+  #altitudeIgnored = false;
+  #ignoredFeatures = 0;
+  open = (raw, attributes) => {
+    const name = this.#resolve(raw, attributes);
+    const parent = this.#path.at(-1) ?? "";
+    this.#path.push(name);
+    if (this.#capture) return;
+    if (this.#placemark) {
+      this.#openInPlacemark(name, parent, attributes);
+      return;
+    }
+    if (name === "Folder") {
+      this.#folders.push(null);
+    } else if (name === "name" && parent === "Folder") {
+      this.#captureText((value) => {
+        this.#folders[this.#folders.length - 1] = value;
+      }, maximumFolderNameCharacters);
+    } else if (name === "Placemark") {
+      this.#placemarks += 1;
+      this.ingest.location = `Placemark ${this.#placemarks}`;
+      const properties = /* @__PURE__ */ Object.create(null);
+      const folder = this.#folders.at(-1);
+      if (folder) properties.folder = folder;
+      this.#placemark = {
+        geometries: [],
+        polygon: null,
+        positions: 0,
+        properties,
+        textCharacters: 0,
+        track: null
+      };
+    } else if (name === "Schema") {
+      this.#schemaId = attributes.get("id") ?? "";
+    } else if (name === "SimpleField" && parent === "Schema") {
+      this.#addSchemaField(attributes);
+    } else if (ignoredFeatures.has(name)) {
+      this.#ignoredFeatures += 1;
+    }
+  };
+  close = () => {
+    const name = this.#path.pop() ?? "";
+    const parent = this.#path.at(-1) ?? "";
+    const capture = this.#capture;
+    if (capture && this.#path.length === capture.depth) {
+      this.#capture = null;
+      capture.finish(capture.text.value());
+      return;
+    }
+    if (capture) return;
+    if (name === "Folder" && !this.#placemark) {
+      this.#folders.pop();
+    } else if (this.#placemark) {
+      this.#closeInPlacemark(name, parent);
+    }
+  };
+  text = (fragment) => {
+    if (this.#tuple !== null) this.#writeCoordinates(fragment);
+    else this.#capture?.text.write(fragment);
+  };
+  finish() {
+    if (this.#altitudeIgnored) this.ingest.warn("Altitude values in the KML were ignored.");
+    if (this.#ignoredFeatures > 0) {
+      this.ingest.warn(
+        `${this.#ignoredFeatures} overlays and network links in the KML were ignored; only Placemarks are read, and remote content is never fetched.`
+      );
+    }
+  }
+  #openInPlacemark(name, parent, attributes) {
+    const placemark = this.#placemark;
+    if (parent === "Placemark" && placemarkFields.has(name)) {
+      this.#captureField(name);
+    } else if (name === "when" && parent === "TimeStamp" || parent === "TimeSpan") {
+      if (name === "when") this.#captureField("timestamp");
+      else if (name === "begin" || name === "end") this.#captureField(name);
+    } else if (name === "Data" && parent === "ExtendedData") {
+      this.#dataName = attributes.get("name") ?? null;
+    } else if (name === "value" && parent === "Data" && this.#dataName) {
+      this.#captureField(this.#dataName);
+    } else if (name === "SchemaData") {
+      this.#schemaUrl = (attributes.get("schemaUrl") ?? "").replace(/^.*#/u, "");
+    } else if (name === "SimpleData" && parent === "SchemaData") {
+      const field2 = attributes.get("name");
+      if (field2) this.#captureField(field2, this.#schemaFields.get(this.#schemaKey(field2)));
+    } else if (name === "coordinates" && coordinateParents.has(parent)) {
+      this.#positions = [];
+      this.#tuple = "";
+    } else if (name === "Polygon") {
+      placemark.polygon = { inner: [], outer: null };
+    } else if (trackElements.has(name)) {
+      placemark.track = [];
+    } else if (coordElements.has(name) && trackElements.has(parent)) {
+      this.#captureText((value) => {
+        this.#addPosition(value.split(/\s+/u));
+      }, maximumTupleCharacters);
+    }
+  }
+  #closeInPlacemark(name, parent) {
+    const placemark = this.#placemark;
+    switch (name) {
+      case "coordinates":
+        if (this.#tuple) this.#addPosition(this.#tuple.split(","));
+        this.#tuple = null;
+        break;
+      case "Point":
+        if (this.#positions.length > 0) {
+          this.#addGeometry({ coordinates: this.#positions[0], type: "Point" });
+        }
+        this.#positions = [];
+        break;
+      case "LineString":
+        this.#addGeometry({ coordinates: this.#takePositions(), type: "LineString" });
+        break;
+      case "LinearRing": {
+        const ring = this.#takePositions();
+        if (parent === "outerBoundaryIs" && placemark.polygon) placemark.polygon.outer = ring;
+        else if (parent === "innerBoundaryIs" && placemark.polygon) {
+          this.#spendPosition();
+          placemark.polygon.inner.push(ring);
+        } else this.#addGeometry({ coordinates: ring, type: "LineString" });
+        break;
+      }
+      case "Polygon":
+        if (placemark.polygon?.outer) {
+          this.#addGeometry({
+            coordinates: [placemark.polygon.outer, ...placemark.polygon.inner],
+            type: "Polygon"
+          });
+        }
+        placemark.polygon = null;
+        break;
+      case "Track":
+      case "gx:Track":
+        if (placemark.track) this.#addGeometry({ coordinates: placemark.track, type: "LineString" });
+        placemark.track = null;
+        break;
+      case "Placemark":
+        this.ingest.add(combine(placemark.geometries), placemark.properties);
+        this.#placemark = null;
+        break;
+      default:
+        break;
+    }
+  }
+  #addGeometry(geometry) {
+    this.#spendPosition();
+    this.#placemark.geometries.push(geometry);
+  }
+  #spendPosition() {
+    const placemark = this.#placemark;
+    placemark.positions += 1;
+    if (placemark.positions > maximumFeaturePositions) throw featureTooLarge(this.ingest.location);
+  }
+  #takePositions() {
+    const positions = this.#positions;
+    this.#positions = [];
+    return positions;
+  }
+  #captureField(field2, schemaType) {
+    this.#captureText((value) => {
+      if (value === "") return;
+      const placemark = this.#placemark;
+      placemark.textCharacters += field2.length + value.length;
+      if (placemark.textCharacters > maximumFeatureTextCharacters) {
+        throw new TilesetBuildError(
+          "TF_TILESET_BUILD_INPUT_LIMIT",
+          "input",
+          `${this.ingest.location}: the attributes hold more than ${maximumFeatureTextCharacters} characters.`
+        );
+      }
+      if (builtInFields.has(field2) && field2 in placemark.properties) {
+        this.ingest.warn(
+          `A Placemark gives more than one value for "${field2}", counting ExtendedData; the last one was kept.`
+        );
+      }
+      placemark.properties[field2] = typed(value, schemaType);
+    });
+  }
+  #captureText(finish, limit2 = maximumFieldCharacters2) {
+    this.#capture = {
+      depth: this.#path.length - 1,
+      finish,
+      text: new TextCapture(limit2, () => this.ingest.location)
+    };
+  }
+  #addSchemaField(attributes) {
+    const field2 = attributes.get("name");
+    const type = attributes.get("type");
+    if (!field2 || !type) return;
+    this.#schemaCharacters += this.#schemaId.length + field2.length + type.length;
+    if (this.#schemaFields.size >= maximumSchemaFields || this.#schemaCharacters > maximumSchemaCharacters) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_INPUT_LIMIT",
+        "input",
+        `The KML schemas are too large: the limits are ${maximumSchemaFields} fields and ${maximumSchemaCharacters} characters.`
+      );
+    }
+    this.#schemaFields.set(`${this.#schemaId}\0${field2}`, type);
+  }
+  #schemaKey(field2) {
+    return `${this.#schemaUrl}\0${field2}`;
+  }
+  /** Tuples are separated by whitespace; a space after a comma is tolerated, as most tools do. */
+  #writeCoordinates(fragment) {
+    let tuple = this.#tuple ?? "";
+    let start = 0;
+    for (let index = 0; index < fragment.length; index += 1) {
+      const code = fragment.charCodeAt(index);
+      if (code !== 32 && code !== 10 && code !== 9 && code !== 13) continue;
+      tuple += fragment.slice(start, index);
+      start = index + 1;
+      this.#checkTuple(tuple);
+      if (tuple !== "" && !tuple.endsWith(",")) {
+        this.#addPosition(tuple.split(","));
+        tuple = "";
+      }
+    }
+    tuple += fragment.slice(start);
+    this.#checkTuple(tuple);
+    this.#tuple = tuple;
+  }
+  #checkTuple(tuple) {
+    if (tuple.length > maximumTupleCharacters) {
+      throw this.#invalid("coordinates are not longitude,latitude tuples");
+    }
+  }
+  #addPosition(parts) {
+    const placemark = this.#placemark;
+    if (parts.length < 2 || parts.length > 3 || parts[0] === "" || parts[1] === "") {
+      throw this.#invalid("a position must be longitude,latitude[,altitude]");
+    }
+    this.#spendPosition();
+    if (parts.length === 3 && Number(parts[2]) !== 0) this.#altitudeIgnored = true;
+    const position = [Number(parts[0]), Number(parts[1])];
+    if (placemark.track) placemark.track.push(position);
+    else this.#positions.push(position);
+  }
+  #invalid(reason) {
+    return new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `${this.ingest.location}: ${reason}.`
+    );
+  }
+};
+function typed(value, schemaType) {
+  if (schemaType && numericSchemaTypes.has(schemaType)) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : value;
+  }
+  if (schemaType === "bool") {
+    if (value === "true" || value === "1") return true;
+    if (value === "false" || value === "0") return false;
+  }
+  return value;
+}
+function combine(geometries) {
+  if (geometries.length === 0) return null;
+  if (geometries.length === 1) return geometries[0];
+  const [{ type }] = geometries;
+  if (!geometries.every((geometry) => geometry.type === type)) {
+    return { geometries: [...geometries], type: "GeometryCollection" };
+  }
+  return {
+    coordinates: geometries.map((geometry) => geometry.coordinates),
+    type: `Multi${String(type)}`
+  };
+}
+
+// src/tileset-build/read-shapefile.ts
+import { closeSync as closeSync5, existsSync, openSync as openSync5, readdirSync, readFileSync as readFileSync2, readSync as readSync5 } from "fs";
+import { basename, dirname, extname, join as join2 } from "path";
+var shapeHeaderBytes = 100;
+var dbfFieldBytes = 32;
+function shapefileSidecar(path, extension) {
+  const stem = basename(path, extname(path));
+  const directory = dirname(path);
+  for (const candidate of [extension, extension.toUpperCase()]) {
+    const direct = join2(directory, `${stem}${candidate}`);
+    if (existsSync(direct)) return direct;
+  }
+  const lower = `${stem}${extension}`.toLowerCase();
+  const match = readdirSync(directory).find((entry) => entry.toLowerCase() === lower);
+  return match ? join2(directory, match) : null;
+}
+function shapefileCrsStatement(path) {
+  const prj = shapefileSidecar(path, ".prj");
+  const label = `${basename(path)}${prj ? " (.prj)" : " (no .prj file)"}`;
+  return {
+    authority: "declared",
+    definition: prj ? readFileSync2(prj, "utf8").trim() || null : null,
+    label
+  };
+}
+async function readShapefile(path, ingest) {
+  const shp = openSync5(path, "r");
+  let table = null;
+  try {
+    const dbfPath = shapefileSidecar(path, ".dbf");
+    if (dbfPath) table = openDbf(dbfPath, shapefileSidecar(path, ".cpg"));
+    else ingest.warn("No .dbf file was found, so features have no attributes.");
+    const header = Buffer.allocUnsafe(shapeHeaderBytes);
+    if (readSync5(shp, header, 0, shapeHeaderBytes, 0) !== shapeHeaderBytes || header.readInt32BE(0) !== 9994) {
+      throw invalid3("file is not a Shapefile (.shp header is wrong).");
+    }
+    const fileBytes = header.readInt32BE(24) * 2;
+    const shapeType = header.readInt32LE(32);
+    if (![0, 1, 3, 5, 8, 11, 13, 15, 18, 21, 23, 25, 28].includes(shapeType)) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+        "input",
+        `Shapefile geometry type ${shapeType} is not supported; MultiPatch has no vector tile equivalent.`
+      );
+    }
+    if (shapeType >= 11) ingest.warn("Z and M values in the Shapefile were ignored.");
+    const stream = new SequentialReader(shp, shapeHeaderBytes);
+    let index = 0;
+    while (stream.position < fileBytes) {
+      index += 1;
+      if (index % 8192 === 0) await yieldToEventLoop();
+      ingest.location = `record ${index}`;
+      const recordHeader = stream.read(8);
+      if (!recordHeader) throw invalid3(`record ${index}: the .shp file ends early.`);
+      const bytes = recordHeader.readInt32BE(4) * 2;
+      if (bytes > maximumFeatureBytes) throw featureTooManyBytes(ingest.location);
+      const content = stream.read(bytes);
+      if (!content) throw invalid3(`record ${index}: the .shp file ends early.`);
+      const row = table?.next();
+      if (row === null) continue;
+      ingest.add(decodeShape(content, index), row ?? {});
+    }
+    if (table && table.remainingRows > 0) {
+      ingest.warn(
+        `The .dbf has ${table.remainingRows} extra attribute ${table.remainingRows === 1 ? "row" : "rows"} after the last Shapefile record.`
+      );
+    }
+  } finally {
+    closeSync5(shp);
+    table?.close();
+  }
+}
+function invalid3(message) {
+  return new TilesetBuildError("TF_TILESET_BUILD_INPUT_INVALID", "input", message);
+}
+function decodeShape(content, index) {
+  const type = content.readInt32LE(0);
+  switch (type) {
+    case 0:
+      return null;
+    case 1:
+    case 11:
+    case 21:
+      return {
+        coordinates: [content.readDoubleLE(4), content.readDoubleLE(12)],
+        type: "Point"
+      };
+    case 8:
+    case 18:
+    case 28: {
+      const count = content.readInt32LE(36);
+      if (count > maximumFeaturePositions) throw featureTooLarge(`record ${index}`);
+      return { coordinates: readPoints(content, 40, count), type: "MultiPoint" };
+    }
+    case 3:
+    case 13:
+    case 23:
+      return { coordinates: readParts(content, index), type: "MultiLineString" };
+    case 5:
+    case 15:
+    case 25:
+      return { coordinates: assemblePolygons(readParts(content, index)), type: "MultiPolygon" };
+    default:
+      throw invalid3(`record ${index}: unsupported shape type ${type}.`);
+  }
+}
+function readPoints(content, offset, count) {
+  const points = new Array(count);
+  for (let index = 0; index < count; index += 1) {
+    points[index] = [
+      content.readDoubleLE(offset + index * 16),
+      content.readDoubleLE(offset + index * 16 + 8)
+    ];
+  }
+  return points;
+}
+function readParts(content, index) {
+  const partCount = content.readInt32LE(36);
+  const pointCount = content.readInt32LE(40);
+  if (partCount > maximumFeaturePositions || pointCount > maximumFeaturePositions) {
+    throw featureTooLarge(`record ${index}`);
+  }
+  const pointsOffset = 44 + partCount * 4;
+  const parts = [];
+  for (let part = 0; part < partCount; part += 1) {
+    const start = content.readInt32LE(44 + part * 4);
+    const end = part + 1 < partCount ? content.readInt32LE(44 + (part + 1) * 4) : pointCount;
+    if (start < 0 || end < start || end > pointCount) {
+      throw invalid3(`record ${index}: the part offsets are out of order.`);
+    }
+    parts.push(readPoints(content, pointsOffset + start * 16, end - start));
+  }
+  return parts;
+}
+function assemblePolygons(rings) {
+  const exteriors = [];
+  const holes = [];
+  for (const points of rings) {
+    if (points.length === 0) continue;
+    const ring = describeRing(points);
+    (ring.area <= 0 ? exteriors : holes).push(ring);
+  }
+  if (exteriors.length === 1 && holes.length === 0) return [[exteriors[0].points]];
+  const polygons = exteriors.map((ring) => ({ ring, rings: [ring.points] }));
+  for (const hole of holes) {
+    let owner = null;
+    for (const polygon of polygons) {
+      if (!boundsContain(polygon.ring.bounds, hole.bounds)) continue;
+      if (!pointInRing(hole.points[0], polygon.ring.points)) continue;
+      if (!owner || Math.abs(polygon.ring.area) < Math.abs(owner.ring.area)) owner = polygon;
+    }
+    if (owner) owner.rings.push(hole.points);
+    else polygons.push({ ring: hole, rings: [hole.points] });
+  }
+  return polygons.map((polygon) => polygon.rings);
+}
+function describeRing(points) {
+  let area = 0;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let previous = points[points.length - 1];
+  for (const point of points) {
+    area += previous[0] * point[1] - point[0] * previous[1];
+    previous = point;
+    if (point[0] < minX) minX = point[0];
+    if (point[0] > maxX) maxX = point[0];
+    if (point[1] < minY) minY = point[1];
+    if (point[1] > maxY) maxY = point[1];
+  }
+  return { area, bounds: [minX, minY, maxX, maxY], points };
+}
+function boundsContain(outer, inner) {
+  return outer[0] <= inner[0] && outer[1] <= inner[1] && outer[2] >= inner[2] && outer[3] >= inner[3];
+}
+function pointInRing(point, ring) {
+  const [x, y] = point;
+  let inside = false;
+  for (let index = 0, previous = ring.length - 1; index < ring.length; previous = index++) {
+    const [ax, ay] = ring[index];
+    const [bx, by] = ring[previous];
+    if (ay > y !== by > y && x < (bx - ax) * (y - ay) / (by - ay) + ax) inside = !inside;
+  }
+  return inside;
+}
+var SequentialReader = class {
+  constructor(descriptor, position) {
+    this.descriptor = descriptor;
+    this.position = position;
+  }
+  descriptor;
+  #buffer = Buffer.allocUnsafe(4 * 1024 * 1024);
+  #start = 0;
+  #end = 0;
+  position;
+  read(size) {
+    if (this.#end - this.#start < size) {
+      const available = this.#end - this.#start;
+      const target = size > this.#buffer.length ? Buffer.allocUnsafe(size * 2) : this.#buffer;
+      this.#buffer.copy(target, 0, this.#start, this.#end);
+      this.#buffer = target;
+      this.#start = 0;
+      this.#end = available;
+      const bytes = readSync5(
+        this.descriptor,
+        this.#buffer,
+        this.#end,
+        this.#buffer.length - this.#end,
+        this.position + available
+      );
+      this.#end += bytes;
+      if (this.#end < size) return null;
+    }
+    const view = this.#buffer.subarray(this.#start, this.#start + size);
+    this.#start += size;
+    this.position += size;
+    return view;
+  }
+};
+function openDbf(path, cpgPath) {
+  const descriptor = openSync5(path, "r");
+  try {
+    return readDbfTable(descriptor, cpgPath);
+  } catch (error) {
+    closeSync5(descriptor);
+    throw error;
+  }
+}
+function readDbfTable(descriptor, cpgPath) {
+  const header = Buffer.alloc(32);
+  if (readSync5(descriptor, header, 0, header.length, 0) !== header.length) {
+    throw invalid3("record 1: the .dbf header is incomplete.");
+  }
+  const records = header.readUInt32LE(4);
+  const headerBytes2 = header.readUInt16LE(8);
+  const recordBytes = header.readUInt16LE(10);
+  if (headerBytes2 < 33 || recordBytes < 1)
+    throw invalid3("record 1: the .dbf row layout is invalid.");
+  const descriptors = Buffer.allocUnsafe(headerBytes2 - 32);
+  if (readSync5(descriptor, descriptors, 0, descriptors.length, 32) !== descriptors.length) {
+    throw invalid3("record 1: the .dbf field descriptors are incomplete.");
+  }
+  const encoding = cpgPath ? readFileSync2(cpgPath, "utf8").trim() : "utf-8";
+  const decoder = createDecoder(encoding);
+  const fields = [];
+  let offset = 1;
+  for (let cursor = 0; cursor + dbfFieldBytes <= descriptors.length; cursor += dbfFieldBytes) {
+    if (descriptors[cursor] === 13) break;
+    const raw = descriptors.subarray(cursor, cursor + 11);
+    const end = raw.indexOf(0);
+    const length = descriptors[cursor + 16];
+    fields.push({
+      length,
+      name: decoder.decode(raw.subarray(0, end < 0 ? 11 : end)),
+      offset,
+      type: String.fromCharCode(descriptors[cursor + 11])
+    });
+    offset += length;
+  }
+  const stream = new SequentialReader(descriptor, headerBytes2);
+  let index = 0;
+  return {
+    close: () => closeSync5(descriptor),
+    get remainingRows() {
+      return records - index;
+    },
+    /** One row of attributes, `null` for a deleted row. */
+    next() {
+      if (index >= records) throw invalid3(`record ${index + 1}: the .dbf has no matching row.`);
+      index += 1;
+      const row = stream.read(recordBytes);
+      if (!row || row[0] === 26) throw invalid3(`record ${index}: the .dbf row is incomplete.`);
+      if (row[0] === 42) return null;
+      const properties = {};
+      for (const item of fields) {
+        const value = dbfValue(row, item, decoder);
+        if (value !== null) properties[item.name] = value;
+      }
+      return properties;
+    }
+  };
+}
+function createDecoder(encoding) {
+  try {
+    return new TextDecoder(/^\d+$/u.test(encoding) ? `windows-${encoding}` : encoding);
+  } catch {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `The .cpg file names an unknown text encoding: ${encoding}.`
+    );
+  }
+}
+function dbfValue(row, item, decoder) {
+  const bytes = row.subarray(item.offset, item.offset + item.length);
+  switch (item.type) {
+    case "N":
+    case "F": {
+      const text = bytes.toString("latin1").trim();
+      const value = Number(text);
+      return text === "" || !Number.isFinite(value) ? null : value;
+    }
+    case "L": {
+      const flag = String.fromCharCode(bytes[0]).toUpperCase();
+      if ("YT".includes(flag)) return true;
+      if ("NF".includes(flag)) return false;
+      return null;
+    }
+    case "D": {
+      const text = bytes.toString("latin1").trim();
+      return text.length === 8 ? `${text.slice(0, 4)}-${text.slice(4, 6)}-${text.slice(6)}` : null;
+    }
+    case "C": {
+      const text = decoder.decode(bytes).trim();
+      return text === "" ? null : text;
+    }
+    default:
+      return null;
+  }
+}
+
+// src/tileset-build/read-zip.ts
+import { createWriteStream } from "fs";
+import { basename as basename2, extname as extname2, join as join3, posix } from "path";
+import { pipeline } from "stream/promises";
+import yauzl from "yauzl";
+var projectionExtension = ".prj";
+var dataExtensions = [".shp", ".dbf", ".cpg"];
+var maximumEntries2 = 65536;
+var maximumKmlBytes = 4 * 1024 ** 3;
+var ZippedShapefile = class _ZippedShapefile {
+  constructor(zip, members, stem, uncompressedBytes) {
+    this.zip = zip;
+    this.members = members;
+    this.stem = stem;
+    this.uncompressedBytes = uncompressedBytes;
+  }
+  zip;
+  members;
+  stem;
+  uncompressedBytes;
+  static async open(path, requested) {
+    const zip = await openZip(path);
+    try {
+      const entries = await listEntries(zip);
+      const shapefiles = entries.filter(isShapefile);
+      const chosen = chooseShapefile(shapefiles, requested);
+      const stem = withoutExtension(chosen.fileName).toLowerCase();
+      const members = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        if (withoutExtension(entry.fileName).toLowerCase() !== stem) continue;
+        const extension = extname2(entry.fileName).toLowerCase();
+        if (extension === projectionExtension || dataExtensions.includes(extension)) {
+          members.set(extension, entry);
+        }
+      }
+      const uncompressedBytes = [...members.values()].reduce(
+        (total, entry) => total + entry.uncompressedSize,
+        0
+      );
+      return new _ZippedShapefile(
+        zip,
+        members,
+        basename2(withoutExtension(chosen.fileName)),
+        uncompressedBytes
+      );
+    } catch (error) {
+      zip.close();
+      throw error;
+    }
+  }
+  /** The `.prj` comes first, so that a refused CRS does not pay for extracting the data. */
+  async extractProjection(directory) {
+    await this.#extract(directory, [projectionExtension]);
+    return this.#shapefilePath(directory);
+  }
+  async extractData(directory) {
+    await this.#extract(directory, dataExtensions);
+    return this.#shapefilePath(directory);
+  }
+  close() {
+    this.zip.close();
+  }
+  #shapefilePath(directory) {
+    return join3(directory, `${this.stem}.shp`);
+  }
+  async #extract(directory, extensions) {
+    for (const extension of extensions) {
+      const entry = this.members.get(extension);
+      if (!entry) continue;
+      try {
+        const stream = await openEntry(this.zip, entry);
+        await pipeline(stream, createWriteStream(join3(directory, `${this.stem}${extension}`)));
+      } catch (error) {
+        if (error.code === "ENOSPC") throw error;
+        throw unreadable2(error);
+      }
+    }
+  }
+};
+var ZippedKml = class _ZippedKml {
+  constructor(zip, entry) {
+    this.zip = zip;
+    this.entry = entry;
+  }
+  zip;
+  entry;
+  static async open(path, requested) {
+    const zip = await openZip(path);
+    try {
+      const entry = chooseKml((await listEntries(zip)).filter(isKml), requested);
+      if (entry.uncompressedSize > maximumKmlBytes) {
+        throw new TilesetBuildError(
+          "TF_TILESET_BUILD_INPUT_LIMIT",
+          "input",
+          `${entry.fileName} expands to more than ${maximumKmlBytes / 1024 ** 3} GiB. Convert it to a format that can be streamed from disk first.`
+        );
+      }
+      return new _ZippedKml(zip, entry);
+    } catch (error) {
+      zip.close();
+      throw error;
+    }
+  }
+  get uncompressedBytes() {
+    return this.entry.uncompressedSize;
+  }
+  async *chunks() {
+    try {
+      for await (const chunk of await openEntry(this.zip, this.entry)) yield chunk;
+    } catch (error) {
+      throw unreadable2(error);
+    }
+  }
+  close() {
+    this.zip.close();
+  }
+};
+function isDataEntry(entry, extension) {
+  const name = entry.fileName;
+  return !name.endsWith("/") && extname2(name).toLowerCase() === extension && !basename2(name).startsWith(".") && !name.split("/").includes("__MACOSX");
+}
+function isShapefile(entry) {
+  return isDataEntry(entry, ".shp");
+}
+function isKml(entry) {
+  return isDataEntry(entry, ".kml");
+}
+function chooseKml(documents, requested) {
+  const names = documents.map((entry) => entry.fileName).sort();
+  if (names.length === 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "input",
+      "The KMZ has no .kml file."
+    );
+  }
+  if (requested !== void 0) {
+    const match = documents.find((entry) => entry.fileName === requested);
+    if (match) return match;
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "zipEntry",
+      `The KMZ has no KML document named "${requested}". It has: ${listChoices(names)}.`
+    );
+  }
+  const main = documents.find((entry) => entry.fileName.toLowerCase() === "doc.kml");
+  if (main) return main;
+  if (documents.length > 1) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "zipEntry",
+      `The KMZ has ${names.length} KML documents and no doc.kml. Choose one with --zip-entry: ${listChoices(names)}.`,
+      names
+    );
+  }
+  return documents[0];
+}
+function chooseShapefile(shapefiles, requested) {
+  const names = shapefiles.map((entry) => entry.fileName).sort();
+  if (names.length === 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "input",
+      "The zip has no .shp file. Only Shapefiles can be read from a zip; extract other formats first."
+    );
+  }
+  const listed = listChoices(names);
+  if (requested !== void 0) {
+    const match = shapefiles.find((entry) => entry.fileName === requested);
+    if (match) return match;
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "zipEntry",
+      `The zip has no Shapefile named "${requested}". It has: ${listed}.`
+    );
+  }
+  if (shapefiles.length > 1) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "zipEntry",
+      `The zip has ${names.length} Shapefiles. Choose one with --zip-entry: ${listed}.`,
+      names
+    );
+  }
+  return shapefiles[0];
+}
+function withoutExtension(name) {
+  return name.slice(0, name.length - posix.extname(name).length);
+}
+function openZip(path) {
+  return new Promise((resolve2, reject) => {
+    yauzl.open(path, { autoClose: false, lazyEntries: true }, (error, zip) => {
+      if (error) reject(unreadable2(error));
+      else resolve2(zip);
+    });
+  });
+}
+function listEntries(zip) {
+  return new Promise((resolve2, reject) => {
+    const entries = [];
+    zip.on("entry", (entry) => {
+      entries.push(entry);
+      if (entries.length > maximumEntries2) {
+        reject(
+          new TilesetBuildError(
+            "TF_TILESET_BUILD_INPUT_LIMIT",
+            "input",
+            `The archive has more than ${maximumEntries2} entries.`
+          )
+        );
+        return;
+      }
+      zip.readEntry();
+    });
+    zip.once("end", () => resolve2(entries));
+    zip.once("error", (error) => reject(unreadable2(error)));
+    zip.readEntry();
+  });
+}
+function openEntry(zip, entry) {
+  return new Promise((resolve2, reject) => {
+    zip.openReadStream(entry, (error, stream) => {
+      if (error) reject(error);
+      else resolve2(stream);
+    });
+  });
+}
+function unreadable2(error) {
+  if (error instanceof TilesetBuildError) return error;
+  const detail = error instanceof Error ? error.message : "unknown error";
+  return new TilesetBuildError(
+    "TF_TILESET_BUILD_INPUT_INVALID",
+    "input",
+    `The zip could not be read: ${detail}.`
+  );
+}
+
+// src/tileset-build/signature.ts
+import { closeSync as closeSync6, openSync as openSync6, readSync as readSync6 } from "fs";
+var probeBytes = 64 * 1024;
+var sqliteHeader = Buffer.from("SQLite format 3\0", "latin1");
+var shapefileFileCode = 9994;
+var utf8Bom = [239, 187, 191];
+var recordSeparator = 30;
+var formatNames = {
+  csv: "CSV",
+  geojson: "GeoJSON",
+  geojsonseq: "newline-delimited GeoJSON",
+  geopackage: "GeoPackage",
+  gpx: "GPX",
+  kml: "KML",
+  shapefile: "a Shapefile"
+};
+function firstCharacter(bytes) {
+  let index = utf8Bom.every((byte, position) => bytes[position] === byte) ? 3 : 0;
+  while (index < bytes.length && isWhitespace(bytes[index])) index += 1;
+  return bytes[index];
+}
+function isWhitespace(byte) {
+  return byte === 32 || byte === 9 || byte === 10 || byte === 13 || byte === recordSeparator;
+}
+function matches(bytes, format) {
+  switch (format) {
+    case "csv":
+      return !bytes.includes(0);
+    case "geojson":
+    case "geojsonseq":
+      return firstCharacter(bytes) === 123;
+    case "geopackage":
+      return bytes.subarray(0, sqliteHeader.length).equals(sqliteHeader);
+    case "gpx":
+    case "kml":
+      return firstCharacter(bytes) === 60 || hasUtf16Bom(bytes);
+    case "shapefile":
+      return bytes.length >= 4 && bytes.readInt32BE(0) === shapefileFileCode;
+  }
+}
+function hasUtf16Bom(bytes) {
+  return bytes[0] === 255 && bytes[1] === 254 || bytes[0] === 254 && bytes[1] === 255;
+}
+function isZipHeader(bytes) {
+  return bytes[0] === 80 && bytes[1] === 75 && [3, 5].includes(bytes[2]);
+}
+function checkInputSignature(path, format, container) {
+  const descriptor = openSync6(path, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(probeBytes);
+    const bytes = buffer.subarray(0, readSync6(descriptor, buffer, 0, probeBytes, 0));
+    if (bytes.length === 0) return;
+    if (container ? isZipHeader(bytes) : matches(bytes, format)) return;
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_INVALID",
+      "input",
+      `The file does not look like ${container ? `a ${container.toUpperCase()} archive` : formatNames[format]}. Check the file, or pass --format if its extension is misleading.`
+    );
+  } finally {
+    closeSync6(descriptor);
+  }
+}
+
+// src/tileset-build/source-hash.ts
+import { createHash as createHash3 } from "crypto";
+import { createReadStream as createReadStream2 } from "fs";
+async function hashSource(input, format, zipped) {
+  const hash = createHash3("sha256");
+  const sidecars = format === "shapefile" && !zipped ? [".dbf", ".prj", ".cpg"].flatMap((extension) => shapefileSidecar(input, extension) ?? []) : [];
+  for (const path of [input, ...sidecars]) {
+    for await (const chunk of createReadStream2(path)) hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+
+// src/tileset-build/clip.ts
+var Geometry = class {
+  coordinates = new Int32Array(4096);
+  parts = new Int32Array(64);
+  partCount = 0;
+  pointCount = 0;
+  reset() {
+    this.partCount = 0;
+    this.pointCount = 0;
+  }
+  push(x, y) {
+    if ((this.pointCount + 1) * 2 > this.coordinates.length) {
+      const grown = new Int32Array(this.coordinates.length * 2);
+      grown.set(this.coordinates);
+      this.coordinates = grown;
+    }
+    this.coordinates[this.pointCount * 2] = x;
+    this.coordinates[this.pointCount * 2 + 1] = y;
+    this.pointCount += 1;
+  }
+  endPart(start, minimumPoints) {
+    const size = this.pointCount - start;
+    if (size < minimumPoints) {
+      this.pointCount = start;
+      return;
+    }
+    if (this.partCount === this.parts.length) {
+      const grown = new Int32Array(this.parts.length * 2);
+      grown.set(this.parts);
+      this.parts = grown;
+    }
+    this.parts[this.partCount] = size;
+    this.partCount += 1;
+  }
+};
+var current = new Geometry();
+var next = new Geometry();
+function clipRecordInto(words, offset, box, target) {
+  if (words[offset + field.maxX] < box.minX || words[offset + field.minX] > box.maxX || words[offset + field.maxY] < box.minY || words[offset + field.minY] > box.maxY) {
+    return;
+  }
+  if (words[offset + field.minX] >= box.minX && words[offset + field.maxX] <= box.maxX && words[offset + field.minY] >= box.minY && words[offset + field.maxY] <= box.maxY) {
+    target.append(words, offset, words[offset + field.words]);
+    return;
+  }
+  const type = words[offset + field.type];
+  const partCount = words[offset + field.parts];
+  const pointCount = words[offset + field.points];
+  const partsStart = offset + headerWords;
+  const coordinatesStart = partsStart + partCount;
+  current.reset();
+  let cursor = coordinatesStart;
+  for (let part = 0; part < partCount; part += 1) {
+    const size2 = words[partsStart + part];
+    const start2 = current.pointCount;
+    for (let point = 0; point < size2; point += 1) {
+      current.push(words[cursor], words[cursor + 1]);
+      cursor += 2;
+    }
+    current.endPart(start2, 1);
+  }
+  clipAxis(type, 0, box.minX, 1);
+  clipAxis(type, 0, box.maxX, -1);
+  clipAxis(type, 1, box.minY, 1);
+  clipAxis(type, 1, box.maxY, -1);
+  if (current.partCount === 0) return;
+  const propertyBytes = words[offset + field.propertyBytes];
+  const propertyWords = Math.ceil(propertyBytes / 4);
+  const size = headerWords + current.partCount + current.pointCount * 2 + propertyWords;
+  const start = target.reserve(size);
+  const output = target.words;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let index = 0; index < current.pointCount; index += 1) {
+    const x = current.coordinates[index * 2];
+    const y = current.coordinates[index * 2 + 1];
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  output[start + field.words] = size;
+  output[start + field.type] = type;
+  output[start + field.minX] = minX;
+  output[start + field.minY] = minY;
+  output[start + field.maxX] = maxX;
+  output[start + field.maxY] = maxY;
+  output[start + field.parts] = current.partCount;
+  output[start + field.points] = current.pointCount;
+  output[start + field.propertyBytes] = propertyBytes;
+  output[start + field.idLow] = words[offset + field.idLow];
+  output[start + field.idHigh] = words[offset + field.idHigh];
+  output[start + field.kept] = words[offset + field.kept];
+  output.set(current.parts.subarray(0, current.partCount), start + headerWords);
+  output.set(
+    current.coordinates.subarray(0, current.pointCount * 2),
+    start + headerWords + current.partCount
+  );
+  output.set(
+    words.subarray(
+      coordinatesStart + pointCount * 2,
+      coordinatesStart + pointCount * 2 + propertyWords
+    ),
+    start + headerWords + current.partCount + current.pointCount * 2
+  );
+}
+function clipAxis(type, axis, bound, sign) {
+  if (type === geometryType.point) clipPoints(axis, bound, sign);
+  else if (type === geometryType.line) clipLines(axis, bound, sign);
+  else clipRings(axis, bound, sign);
+  const swap = current;
+  current = next;
+  next = swap;
+}
+function clipPoints(axis, bound, sign) {
+  next.reset();
+  const start = 0;
+  for (let index = 0; index < current.pointCount; index += 1) {
+    const x = current.coordinates[index * 2];
+    const y = current.coordinates[index * 2 + 1];
+    if (sign * ((axis === 0 ? x : y) - bound) >= 0) next.push(x, y);
+  }
+  next.endPart(start, 1);
+}
+function clipLines(axis, bound, sign) {
+  next.reset();
+  let cursor = 0;
+  for (let part = 0; part < current.partCount; part += 1) {
+    const size = current.parts[part];
+    let start = next.pointCount;
+    let previousX = 0;
+    let previousY = 0;
+    let previousInside = false;
+    for (let index = 0; index < size; index += 1) {
+      const x = current.coordinates[cursor * 2];
+      const y = current.coordinates[cursor * 2 + 1];
+      cursor += 1;
+      const inside = sign * ((axis === 0 ? x : y) - bound) >= 0;
+      if (index > 0 && inside !== previousInside) {
+        pushCrossing(axis, bound, previousX, previousY, x, y);
+        if (!inside) {
+          next.endPart(start, 2);
+          start = next.pointCount;
+        }
+      }
+      if (inside) next.push(x, y);
+      previousX = x;
+      previousY = y;
+      previousInside = inside;
+    }
+    next.endPart(start, 2);
+  }
+}
+function clipRings(axis, bound, sign) {
+  next.reset();
+  let cursor = 0;
+  for (let part = 0; part < current.partCount; part += 1) {
+    const size = current.parts[part];
+    const start = next.pointCount;
+    let previousX = current.coordinates[(cursor + size - 1) * 2];
+    let previousY = current.coordinates[(cursor + size - 1) * 2 + 1];
+    let previousInside = sign * ((axis === 0 ? previousX : previousY) - bound) >= 0;
+    for (let index = 0; index < size; index += 1) {
+      const x = current.coordinates[cursor * 2];
+      const y = current.coordinates[cursor * 2 + 1];
+      cursor += 1;
+      const inside = sign * ((axis === 0 ? x : y) - bound) >= 0;
+      if (inside !== previousInside) pushCrossing(axis, bound, previousX, previousY, x, y);
+      if (inside) next.push(x, y);
+      previousX = x;
+      previousY = y;
+      previousInside = inside;
+    }
+    next.endPart(start, 3);
+  }
+}
+function pushCrossing(axis, bound, fromX, fromY, toX, toY) {
+  if (axis === 0) {
+    next.push(bound, Math.round(fromY + (bound - fromX) * (toY - fromY) / (toX - fromX)));
+  } else {
+    next.push(Math.round(fromX + (bound - fromY) * (toX - fromX) / (toY - fromY)), bound);
+  }
+}
+
+// src/tileset-build/mvt.ts
+var tileExtent = 4096;
+var tileBufferUnits = 64;
+var extentBits = 12;
+var markSize = 2;
+var ByteWriter = class {
+  bytes = new Uint8Array(4096);
+  length = 0;
+  #ensure(size) {
+    if (this.length + size <= this.bytes.length) return;
+    const grown = new Uint8Array(Math.max(this.bytes.length * 2, this.length + size));
+    grown.set(this.bytes.subarray(0, this.length));
+    this.bytes = grown;
+  }
+  byte(value) {
+    this.#ensure(1);
+    this.bytes[this.length] = value;
+    this.length += 1;
+  }
+  varint(value) {
+    this.#ensure(10);
+    while (value >= 128) {
+      this.bytes[this.length] = value % 128 | 128;
+      this.length += 1;
+      value = Math.floor(value / 128);
+    }
+    this.bytes[this.length] = value;
+    this.length += 1;
+  }
+  raw(source, start, end) {
+    this.#ensure(end - start);
+    this.bytes.set(source.subarray(start, end), this.length);
+    this.length += end - start;
+  }
+  string(value) {
+    const encoded = Buffer.from(value, "utf8");
+    this.varint(encoded.length);
+    this.raw(encoded, 0, encoded.length);
+  }
+  reset() {
+    this.length = 0;
+  }
+};
+function varintLength(value) {
+  let length = 1;
+  while (value >= 128) {
+    length += 1;
+    value = Math.floor(value / 128);
+  }
+  return length;
+}
+var TileEncoder = class {
+  constructor(layer, keys) {
+    this.layer = layer;
+    this.keys = keys;
+    this.#keyIndex = new Int32Array(keys.length).fill(-1);
+  }
+  layer;
+  keys;
+  #features = new ByteWriter();
+  #tags = new ByteWriter();
+  #geometry = new ByteWriter();
+  #values = new ByteWriter();
+  #output = new ByteWriter();
+  #keyIndex;
+  /** Open-addressing table of value indexes, so interning allocates nothing per feature. */
+  #valueSlots = new Int32Array(1 << 12).fill(-1);
+  #valueStarts = [];
+  #valueLengths = [];
+  #usedKeys = [];
+  #shift = 0;
+  #originX = 0;
+  #originY = 0;
+  #tolerance = 0;
+  #minimumArea = 0;
+  #keepCollapsedLines = false;
+  #scratch = new Int32Array(8192);
+  #keep = new Uint8Array(4096);
+  #stack = [];
+  featureCount = 0;
+  /** The number of bytes `finish` would need, ignoring the small key and header overhead. */
+  get approximateBytes() {
+    return this.#features.length + this.#values.length;
+  }
+  begin(z, x, y, options) {
+    this.#features.reset();
+    this.#values.reset();
+    if (this.#valueStarts.length > 0) this.#valueSlots.fill(-1);
+    this.#valueStarts.length = 0;
+    this.#valueLengths.length = 0;
+    for (const key of this.#usedKeys) this.#keyIndex[key] = -1;
+    this.#usedKeys = [];
+    this.featureCount = 0;
+    this.#shift = 31 - z - extentBits;
+    this.#originX = x * 2 ** (31 - z);
+    this.#originY = y * 2 ** (31 - z);
+    this.#tolerance = options.tolerance;
+    this.#minimumArea = options.minimumArea;
+    this.#keepCollapsedLines = options.keepCollapsedLines;
+  }
+  /** Add one record. Returns false when its geometry collapses at this zoom and has no mark. */
+  add(words, offset) {
+    this.#geometry.reset();
+    const type = words[offset + field.type];
+    const partCount = words[offset + field.parts];
+    const pointCount = words[offset + field.points];
+    const partsStart = offset + headerWords;
+    const coordinatesStart = partsStart + partCount;
+    const encoded = type === geometryType.point ? this.#encodePoints(words, coordinatesStart, pointCount) : this.#encodeParts(type, words, partsStart, partCount, coordinatesStart);
+    if (!encoded) return false;
+    this.#tags.reset();
+    this.#encodeTags(words, coordinatesStart + pointCount * 2, words[offset + field.propertyBytes]);
+    const id = idOf(words, offset);
+    const body = (id > 0 ? 1 + varintLength(id - 1) : 0) + (this.#tags.length > 0 ? 1 + varintLength(this.#tags.length) + this.#tags.length : 0) + 2 + 1 + varintLength(this.#geometry.length) + this.#geometry.length;
+    const features = this.#features;
+    features.byte(18);
+    features.varint(body);
+    if (id > 0) {
+      features.byte(8);
+      features.varint(id - 1);
+    }
+    if (this.#tags.length > 0) {
+      features.byte(18);
+      features.varint(this.#tags.length);
+      features.raw(this.#tags.bytes, 0, this.#tags.length);
+    }
+    features.byte(24);
+    features.byte(type);
+    features.byte(34);
+    features.varint(this.#geometry.length);
+    features.raw(this.#geometry.bytes, 0, this.#geometry.length);
+    this.featureCount += 1;
+    return true;
+  }
+  finish() {
+    const output = this.#output;
+    output.reset();
+    const keySection = new ByteWriter();
+    for (const key of this.#usedKeys) {
+      keySection.byte(26);
+      keySection.string(this.keys[key]);
+    }
+    const name = Buffer.from(this.layer, "utf8");
+    const layerLength = 2 + 1 + varintLength(name.length) + name.length + this.#features.length + keySection.length + this.#values.length + 3;
+    output.byte(26);
+    output.varint(layerLength);
+    output.byte(120);
+    output.byte(2);
+    output.byte(10);
+    output.varint(name.length);
+    output.raw(name, 0, name.length);
+    output.raw(this.#features.bytes, 0, this.#features.length);
+    output.raw(keySection.bytes, 0, keySection.length);
+    output.raw(this.#values.bytes, 0, this.#values.length);
+    output.byte(40);
+    output.varint(tileExtent);
+    return output.bytes.slice(0, output.length);
+  }
+  #encodeTags(words, start, byteLength) {
+    if (byteLength === 0) return;
+    const bytes = new Uint8Array(words.buffer, words.byteOffset + start * 4, byteLength);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, byteLength);
+    let cursor = 0;
+    while (cursor < byteLength) {
+      const key = view.getUint16(cursor, true);
+      const length = view.getUint32(cursor + 2, true);
+      cursor += 6;
+      let keyIndex = this.#keyIndex[key];
+      if (keyIndex < 0) {
+        keyIndex = this.#usedKeys.length;
+        this.#keyIndex[key] = keyIndex;
+        this.#usedKeys.push(key);
+      }
+      const valueIndex = this.#internValue(bytes, cursor, length);
+      this.#tags.varint(keyIndex);
+      this.#tags.varint(valueIndex);
+      cursor += length;
+    }
+  }
+  /** Attribute values are spooled as encoded Value messages, so interning needs no decoding. */
+  #internValue(bytes, start, length) {
+    let hash = 2166136261;
+    for (let index2 = start; index2 < start + length; index2 += 1) {
+      hash = Math.imul(hash ^ bytes[index2], 16777619);
+    }
+    const mask = this.#valueSlots.length - 1;
+    let slot = hash & mask;
+    for (; ; ) {
+      const candidate = this.#valueSlots[slot];
+      if (candidate < 0) break;
+      if (this.#sameValue(candidate, bytes, start, length)) return candidate;
+      slot = slot + 1 & mask;
+    }
+    const index = this.#valueStarts.length;
+    this.#valueSlots[slot] = index;
+    this.#values.byte(34);
+    this.#values.varint(length);
+    this.#valueStarts.push(this.#values.length);
+    this.#valueLengths.push(length);
+    this.#values.raw(bytes, start, start + length);
+    if ((index + 1) * 2 > this.#valueSlots.length) this.#growValueSlots();
+    return index;
+  }
+  #sameValue(index, bytes, start, length) {
+    if (this.#valueLengths[index] !== length) return false;
+    const stored = this.#values.bytes;
+    const offset = this.#valueStarts[index];
+    for (let cursor = 0; cursor < length; cursor += 1) {
+      if (stored[offset + cursor] !== bytes[start + cursor]) return false;
+    }
+    return true;
+  }
+  #growValueSlots() {
+    const slots = new Int32Array(this.#valueSlots.length * 2).fill(-1);
+    const mask = slots.length - 1;
+    const stored = this.#values.bytes;
+    for (let index = 0; index < this.#valueStarts.length; index += 1) {
+      const start = this.#valueStarts[index];
+      let hash = 2166136261;
+      for (let cursor = start; cursor < start + this.#valueLengths[index]; cursor += 1) {
+        hash = Math.imul(hash ^ stored[cursor], 16777619);
+      }
+      let slot = hash & mask;
+      while (slots[slot] >= 0) slot = slot + 1 & mask;
+      slots[slot] = index;
+    }
+    this.#valueSlots = slots;
+  }
+  #encodePoints(words, start, count) {
+    const geometry = this.#geometry;
+    geometry.varint((count << 3 | 1) >>> 0);
+    let lastX = 0;
+    let lastY = 0;
+    for (let index = 0; index < count; index += 1) {
+      const x = this.#tileX(words[start + index * 2]);
+      const y = this.#tileY(words[start + index * 2 + 1]);
+      geometry.varint(zigzag(x - lastX));
+      geometry.varint(zigzag(y - lastY));
+      lastX = x;
+      lastY = y;
+    }
+    return true;
+  }
+  #encodeParts(type, words, partsStart, partCount, coordinatesStart) {
+    const polygon = type === geometryType.polygon;
+    const minimumPoints = polygon ? 3 : 2;
+    const geometry = this.#geometry;
+    let cursor = coordinatesStart;
+    let lastX = 0;
+    let lastY = 0;
+    let exteriorKept = false;
+    for (let part = 0; part < partCount; part += 1) {
+      const size = words[partsStart + part];
+      const count = this.#projectPart(words, cursor, size, polygon);
+      cursor += size * 2;
+      if (polygon) {
+        const area = count < 3 ? 0 : doubledArea(this.#scratch, count);
+        const exterior = area > 0;
+        if (area === 0 || !exterior && !exteriorKept) continue;
+        if (Math.abs(area) < this.#minimumArea) {
+          if (exterior) exteriorKept = false;
+          continue;
+        }
+        if (exterior) exteriorKept = true;
+      } else if (count < minimumPoints) {
+        continue;
+      }
+      const scratch = this.#scratch;
+      geometry.varint(9);
+      geometry.varint(zigzag(scratch[0] - lastX));
+      geometry.varint(zigzag(scratch[1] - lastY));
+      lastX = scratch[0];
+      lastY = scratch[1];
+      geometry.varint((count - 1 << 3 | 2) >>> 0);
+      for (let index = 1; index < count; index += 1) {
+        const x = scratch[index * 2];
+        const y = scratch[index * 2 + 1];
+        geometry.varint(zigzag(x - lastX));
+        geometry.varint(zigzag(y - lastY));
+        lastX = x;
+        lastY = y;
+      }
+      if (polygon) geometry.varint(15);
+    }
+    if (geometry.length > 0) return true;
+    if (!polygon && !this.#keepCollapsedLines) return false;
+    this.#encodeMark(
+      polygon,
+      this.#tileX(words[coordinatesStart]),
+      this.#tileY(words[coordinatesStart + 1])
+    );
+    return true;
+  }
+  /** The smallest visible shape, so that a feature too small for this zoom does not disappear. */
+  #encodeMark(polygon, x, y) {
+    const geometry = this.#geometry;
+    geometry.varint(9);
+    geometry.varint(zigzag(x));
+    geometry.varint(zigzag(y));
+    if (polygon) {
+      geometry.varint((3 << 3 | 2) >>> 0);
+      for (const [dx, dy] of [
+        [markSize, 0],
+        [0, markSize],
+        [-markSize, 0]
+      ]) {
+        geometry.varint(zigzag(dx));
+        geometry.varint(zigzag(dy));
+      }
+      geometry.varint(15);
+    } else {
+      geometry.varint(10);
+      geometry.varint(zigzag(markSize));
+      geometry.varint(zigzag(0));
+    }
+  }
+  /** Project one part to tile units, drop repeats and simplify. Returns the kept point count. */
+  #projectPart(words, start, size, ring) {
+    if (size * 2 > this.#scratch.length) {
+      this.#scratch = new Int32Array(size * 4);
+      this.#keep = new Uint8Array(size * 2);
+    }
+    const scratch = this.#scratch;
+    let count = 0;
+    for (let index = 0; index < size; index += 1) {
+      const x = this.#tileX(words[start + index * 2]);
+      const y = this.#tileY(words[start + index * 2 + 1]);
+      if (count > 0 && scratch[count * 2 - 2] === x && scratch[count * 2 - 1] === y) continue;
+      scratch[count * 2] = x;
+      scratch[count * 2 + 1] = y;
+      count += 1;
+    }
+    if (ring) {
+      while (count > 1 && scratch[0] === scratch[count * 2 - 2] && scratch[1] === scratch[count * 2 - 1]) {
+        count -= 1;
+      }
+    }
+    if (this.#tolerance === 0 || count < 3) return count;
+    return this.#simplify(count, ring);
+  }
+  /** Douglas-Peucker. Rings keep their first point and the point farthest from it. */
+  #simplify(count, ring) {
+    const scratch = this.#scratch;
+    const keep = this.#keep;
+    keep.fill(0, 0, count + 1);
+    const tolerance = this.#tolerance * this.#tolerance;
+    const stack = this.#stack;
+    let last = count - 1;
+    keep[0] = 1;
+    keep[last] = 1;
+    if (ring) {
+      let farthest = 1;
+      let distance = -1;
+      for (let index = 1; index < count; index += 1) {
+        const dx = scratch[index * 2] - scratch[0];
+        const dy = scratch[index * 2 + 1] - scratch[1];
+        if (dx * dx + dy * dy > distance) {
+          distance = dx * dx + dy * dy;
+          farthest = index;
+        }
+      }
+      keep[last] = 0;
+      keep[farthest] = 1;
+      stack.push(farthest, last + 1);
+      last = farthest;
+    }
+    stack.push(0, last);
+    while (stack.length > 0) {
+      const end = stack.pop();
+      const start = stack.pop();
+      if (end - start < 2) continue;
+      const ax = scratch[start * 2];
+      const ay = scratch[start * 2 + 1];
+      const closing = end === count;
+      const bx = scratch[(closing ? 0 : end) * 2];
+      const by = scratch[(closing ? 0 : end) * 2 + 1];
+      let farthest = -1;
+      let distance = tolerance;
+      for (let index = start + 1; index < end; index += 1) {
+        const value = segmentDistanceSquared(
+          scratch[index * 2],
+          scratch[index * 2 + 1],
+          ax,
+          ay,
+          bx,
+          by
+        );
+        if (value > distance) {
+          distance = value;
+          farthest = index;
+        }
+      }
+      if (farthest >= 0) {
+        keep[farthest] = 1;
+        stack.push(start, farthest, farthest, end);
+      }
+    }
+    let kept = 0;
+    for (let index = 0; index < count; index += 1) {
+      if (keep[index] === 0) continue;
+      scratch[kept * 2] = scratch[index * 2];
+      scratch[kept * 2 + 1] = scratch[index * 2 + 1];
+      kept += 1;
+    }
+    return kept;
+  }
+  #tileX(value) {
+    return roundShift(value - this.#originX, this.#shift);
+  }
+  #tileY(value) {
+    return roundShift(value - this.#originY, this.#shift);
+  }
+};
+function idOf(words, offset) {
+  return (words[offset + field.idHigh] >>> 0) * 2 ** 32 + (words[offset + field.idLow] >>> 0);
+}
+function roundShift(value, shift) {
+  return Math.round(value / 2 ** shift);
+}
+function zigzag(value) {
+  return value >= 0 ? value * 2 : -value * 2 - 1;
+}
+function doubledArea(points, count) {
+  let area = 0;
+  let previousX = points[(count - 1) * 2];
+  let previousY = points[(count - 1) * 2 + 1];
+  for (let index = 0; index < count; index += 1) {
+    const x = points[index * 2];
+    const y = points[index * 2 + 1];
+    area += previousX * y - x * previousY;
+    previousX = x;
+    previousY = y;
+  }
+  return area;
+}
+function segmentDistanceSquared(x, y, ax, ay, bx, by) {
+  let dx = bx - ax;
+  let dy = by - ay;
+  if (dx !== 0 || dy !== 0) {
+    const t = ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy);
+    if (t > 1) {
+      ax = bx;
+      ay = by;
+    } else if (t > 0) {
+      ax += dx * t;
+      ay += dy * t;
+    }
+  }
+  dx = x - ax;
+  dy = y - ay;
+  return dx * dx + dy * dy;
+}
+
+// src/tileset-build/tiler.ts
+var maximumTileBytes = 6e6;
+var targetCompressedBytes = 500 * 1024;
+var maximumBufferedBytes = 64 * 1024 * 1024;
+var maximumAttempts = 7;
+var tileCellsPerAxis = 512;
+var bufferCells = tileBufferUnits * tileCellsPerAxis / 4096;
+var selectionCellsPerAxis = tileCellsPerAxis + bufferCells * 2;
+var pointsPerCell = 1;
+var minimumFeaturesToThinPoints = 2048;
+var simplifyTolerance = 4;
+var lastZoomTolerance = 1;
+var dotSpan = 8;
+var minimumExteriorArea = 8;
+var yieldEveryTiles = 256;
+async function buildPyramid(root, options) {
+  const statistics = [];
+  for (let zoom = 0; zoom <= options.maxzoom; zoom += 1) {
+    statistics.push({ features: 0, largestTileBytes: 0, thinnedFeatures: 0, tiles: 0, zoom });
+  }
+  const pyramid = new Pyramid(options, statistics);
+  await pyramid.visit(0, 0, 0, root);
+  return statistics;
+}
+var Pyramid = class {
+  constructor(options, statistics) {
+    this.options = options;
+    this.statistics = statistics;
+    this.#encoder = new TileEncoder(options.layer, options.keys);
+  }
+  options;
+  statistics;
+  #encoder;
+  #cellCounts = new Uint32Array(selectionCellsPerAxis ** 2);
+  #cellSeen = new Uint32Array(selectionCellsPerAxis ** 2);
+  /** Which records of the tile just encoded were drawn; read while clipping its children. */
+  #drawn = new Uint8Array(0);
+  #visited = 0;
+  async visit(z, x, y, spool) {
+    const { archive, maxzoom, minzoom } = this.options;
+    let content = -1;
+    if (z >= minzoom) {
+      const tile = this.#encodeTile(z, x, y, spool);
+      if (tile !== null) content = await archive.addTile(z, x, y, tile);
+    }
+    this.#visited += 1;
+    if (this.#visited % yieldEveryTiles === 0) {
+      this.options.onTile?.(archive.tileCount);
+      await new Promise((resolve2) => setImmediate(resolve2));
+    }
+    if (z === maxzoom) {
+      spool.dispose();
+      return;
+    }
+    if (content >= 0 && isSolidTile(spool, tileBox(z, x, y))) {
+      for (let depth = 1; depth <= maxzoom - z; depth += 1) {
+        archive.addSubtreeLevel(z, x, y, depth, content);
+      }
+      spool.dispose();
+      return;
+    }
+    const children = [];
+    const boxes = [];
+    for (let index = 0; index < 4; index += 1) {
+      children.push(new FeatureSpool(this.options.directory));
+      boxes.push(tileBox(z + 1, x * 2 + (index & 1), y * 2 + (index >> 1)));
+    }
+    const encoded = z >= minzoom;
+    let record = 0;
+    spool.forEach((words, offset) => {
+      words[offset + field.kept] = encoded ? this.#drawn[record] : 0;
+      record += 1;
+      for (let index = 0; index < 4; index += 1) {
+        clipRecordInto(words, offset, boxes[index], children[index]);
+      }
+    });
+    spool.dispose();
+    for (let index = 0; index < 4; index += 1) {
+      const child = children[index];
+      if (child.count > 0) {
+        await this.visit(z + 1, x * 2 + (index & 1), y * 2 + (index >> 1), child);
+      } else {
+        child.dispose();
+      }
+    }
+  }
+  #encodeTile(z, x, y, spool) {
+    const { maxzoom } = this.options;
+    const encoder = this.#encoder;
+    const lastZoom = z === maxzoom;
+    const stats = this.statistics[z];
+    const encodeOptions = lastZoom ? { keepCollapsedLines: true, minimumArea: 0, tolerance: lastZoomTolerance } : {
+      keepCollapsedLines: false,
+      minimumArea: minimumExteriorArea,
+      tolerance: simplifyTolerance
+    };
+    const pointCap = !lastZoom && spool.count > minimumFeaturesToThinPoints ? pointsPerCell : Infinity;
+    const unit = 2 ** (31 - z) / tileCellsPerAxis;
+    const originX = x * 2 ** (31 - z) - bufferCells * unit;
+    const originY = y * 2 ** (31 - z) - bufferCells * unit;
+    const dotWorldSpan = dotSpan * 2 ** (19 - z);
+    let featureLimit = Infinity;
+    let honorParent = true;
+    if (this.#drawn.length < spool.count) this.#drawn = new Uint8Array(spool.count * 2);
+    const drawn = this.#drawn;
+    for (let attempt = 0; ; attempt += 1) {
+      drawn.fill(0, 0, spool.count);
+      const quota = featureLimit === Infinity ? Infinity : this.#quotaFor(featureLimit);
+      const cellShare = quota === Infinity ? 1 : this.#cellShareFor(quota, featureLimit);
+      const trackCells = quota !== Infinity || pointCap !== Infinity;
+      if (trackCells) this.#cellSeen.fill(0);
+      encoder.begin(z, x, y, encodeOptions);
+      let thinned = 0;
+      let abandoned = false;
+      let record = -1;
+      let optional = 0;
+      spool.forEach((words, offset) => {
+        record += 1;
+        if (abandoned) return;
+        const required = honorParent && words[offset + field.kept] === 1;
+        if (trackCells) {
+          const cell = selectionCell(words, offset, originX, originY, unit);
+          const cap = isDot(words, offset, dotWorldSpan) ? Math.min(pointCap, quota) : quota;
+          if (!required && (this.#cellSeen[cell] >= cap || cellRank(cell) >= cellShare)) {
+            thinned += 1;
+            return;
+          }
+          this.#cellSeen[cell] += 1;
+        }
+        if (encoder.add(words, offset)) {
+          drawn[record] = 1;
+          if (!required) optional += 1;
+          if (encoder.approximateBytes <= maximumBufferedBytes) {
+            if (!lastZoom || encoder.approximateBytes <= maximumTileBytes) return;
+          }
+          if (lastZoom) throw tooLarge(z, x, y);
+          abandoned = true;
+        } else {
+          thinned += 1;
+        }
+      });
+      if (encoder.featureCount === 0) return null;
+      const tile = encoder.finish();
+      const size = lastZoom ? tile.length : measuredSize(tile);
+      const decodable = !abandoned && tile.length <= maximumTileBytes;
+      const settled = optional === 0 || attempt === maximumAttempts;
+      if (lastZoom || decodable && (size <= targetCompressedBytes || settled)) {
+        stats.tiles += 1;
+        stats.features += encoder.featureCount;
+        stats.thinnedFeatures += thinned;
+        if (tile.length > stats.largestTileBytes) stats.largestTileBytes = tile.length;
+        return tile;
+      }
+      if (attempt === maximumAttempts) throw tooLarge(z, x, y);
+      if (optional === 0) honorParent = false;
+      if (featureLimit === Infinity) {
+        this.#countCells(spool, originX, originY, unit, pointCap, dotWorldSpan);
+      }
+      const ratio = Math.min(targetCompressedBytes / size, maximumTileBytes / tile.length);
+      featureLimit = Math.max(1, Math.floor(encoder.featureCount * ratio * 0.9));
+    }
+  }
+  #countCells(spool, originX, originY, unit, pointCap, dotWorldSpan) {
+    this.#cellCounts.fill(0);
+    spool.forEach((words, offset) => {
+      const cell = selectionCell(words, offset, originX, originY, unit);
+      if (!isDot(words, offset, dotWorldSpan) || this.#cellCounts[cell] < pointCap) {
+        this.#cellCounts[cell] += 1;
+      }
+    });
+  }
+  /** When one feature per cell is still too many, the share of cells that may keep theirs. */
+  #cellShareFor(quota, limit2) {
+    if (quota > 1) return 1;
+    let occupied = 0;
+    for (const count of this.#cellCounts) if (count > 0) occupied += 1;
+    return Math.min(1, limit2 / occupied);
+  }
+  /** The largest per-cell allowance that fits the limit, which thins dense areas first. */
+  #quotaFor(limit2) {
+    let low = 1;
+    let high = 1;
+    for (const count of this.#cellCounts) if (count > high) high = count;
+    while (low < high) {
+      const candidate = Math.ceil((low + high) / 2);
+      let total = 0;
+      for (const count of this.#cellCounts) total += Math.min(count, candidate);
+      if (total <= limit2) low = candidate;
+      else high = candidate - 1;
+    }
+    return low;
+  }
+};
+function tileBox(z, x, y) {
+  const size = 2 ** (31 - z);
+  const buffer = tileBufferUnits * 2 ** (19 - z);
+  return {
+    maxX: (x + 1) * size + buffer,
+    maxY: (y + 1) * size + buffer,
+    minX: x * size - buffer,
+    minY: y * size - buffer
+  };
+}
+function selectionCell(words, offset, originX, originY, unit) {
+  const centerX = (words[offset + field.minX] + words[offset + field.maxX]) / 2;
+  const centerY = (words[offset + field.minY] + words[offset + field.maxY]) / 2;
+  const limit2 = selectionCellsPerAxis - 1;
+  const cellX = Math.max(0, Math.min(limit2, Math.floor((centerX - originX) / unit)));
+  const cellY = Math.max(0, Math.min(limit2, Math.floor((centerY - originY) / unit)));
+  return cellY * selectionCellsPerAxis + cellX;
+}
+function isDot(words, offset, span) {
+  const type = words[offset + field.type];
+  if (type === geometryType.point) return true;
+  return type === geometryType.polygon && words[offset + field.maxX] - words[offset + field.minX] < span && words[offset + field.maxY] - words[offset + field.minY] < span;
+}
+function cellRank(cell) {
+  return (Math.imul(cell + 1, 2654435761) >>> 0) / 2 ** 32;
+}
+function isSolidTile(spool, box) {
+  if (spool.count !== 1) return false;
+  let solid = false;
+  spool.forEach((words, offset) => {
+    if (words[offset + field.type] !== geometryType.polygon || words[offset + field.parts] !== 1 || words[offset + field.minX] !== box.minX || words[offset + field.minY] !== box.minY || words[offset + field.maxX] !== box.maxX || words[offset + field.maxY] !== box.maxY) {
+      return;
+    }
+    const start = offset + headerWords + 1;
+    const end = start + words[offset + field.points] * 2;
+    let previousX = words[end - 2];
+    let previousY = words[end - 1];
+    let leftEdgeTravel = 0;
+    for (let cursor = start; cursor < end; cursor += 2) {
+      const x = words[cursor];
+      const y = words[cursor + 1];
+      if (previousX === x && (x === box.minX || x === box.maxX)) {
+        if (x === box.minX) leftEdgeTravel += y - previousY;
+      } else if (previousY !== y || y !== box.minY && y !== box.maxY) {
+        return;
+      }
+      previousX = x;
+      previousY = y;
+    }
+    solid = Math.abs(leftEdgeTravel) === box.maxY - box.minY;
+  });
+  return solid;
+}
+function measuredSize(tile) {
+  return tile.length <= targetCompressedBytes ? tile.length : compressedSizeForBudget(tile);
+}
+function tooLarge(z, x, y) {
+  return new TilesetBuildError(
+    "TF_TILESET_BUILD_TILE_TOO_LARGE",
+    "zoom",
+    `Tile ${z}/${x}/${y} cannot fit in ${maximumTileBytes} bytes without losing features. Raise --maxzoom, or remove attributes with --include or --exclude.`
+  );
+}
+
+// src/tileset-build/zoom.ts
+var maximumAutoZoom = 14;
+var pointMinimumZoom = 10;
+var shapeMinimumZoom = 4;
+var detailBits = 12;
+var retainedFraction = 0.9;
+var maximumVerticesPerTile = 5e4;
+function chooseMaxzoom(ingest, summary) {
+  const count = ingest.sampleCount;
+  const sample = ingest.sample;
+  const floor = summary.geometryTypes.every((type) => type === "Point") ? pointMinimumZoom : shapeMinimumZoom;
+  const fullResolution = distinctCells(sample, count, maximumAutoZoom + detailBits);
+  let resolved = maximumAutoZoom;
+  for (let zoom = 0; zoom < maximumAutoZoom; zoom += 1) {
+    if (distinctCells(sample, count, zoom + detailBits) >= fullResolution * retainedFraction) {
+      resolved = zoom;
+      break;
+    }
+  }
+  let density = maximumAutoZoom;
+  for (let zoom = 0; zoom <= maximumAutoZoom; zoom += 1) {
+    if (densestCell(sample, count, zoom) * ingest.sampleStride <= maximumVerticesPerTile) {
+      density = zoom;
+      break;
+    }
+  }
+  return Math.max(floor, resolved, density);
+}
+function cellKeys(sample, count, level) {
+  const shift = 2 ** (31 - level);
+  const keys = new Float64Array(count);
+  for (let index = 0; index < count; index += 1) {
+    const x = Math.floor(sample[index * 2] / shift);
+    const y = Math.floor(sample[index * 2 + 1] / shift);
+    keys[index] = x * 2 ** level + y;
+  }
+  return keys.sort();
+}
+function distinctCells(sample, count, level) {
+  const keys = cellKeys(sample, count, Math.min(level, 26));
+  let distinct = 0;
+  for (let index = 0; index < count; index += 1) {
+    if (index === 0 || keys[index] !== keys[index - 1]) distinct += 1;
+  }
+  return distinct;
+}
+function densestCell(sample, count, level) {
+  const keys = cellKeys(sample, count, level);
+  let densest = 0;
+  let run = 0;
+  for (let index = 0; index < count; index += 1) {
+    run = index > 0 && keys[index] === keys[index - 1] ? run + 1 : 1;
+    if (run > densest) densest = run;
+  }
+  return densest;
+}
+
+// src/tileset-build/build.ts
+var minimumFreeBytes = 64 * 1024 * 1024;
+var readingProgressMilliseconds = 5e3;
+var extractedExtensions = /* @__PURE__ */ new Set([".cpg", ".dbf", ".prj", ".shp"]);
+var maximumTileStatisticsCharacters = 128 * 1024;
+var maximumArchiveBytes = 8e9;
+var nullIslandDegrees = 1;
+async function buildTileset(options) {
+  const input = resolve(options.input);
+  const format = options.format ?? detectFormat(input);
+  const inputStat = statSync2(input, { throwIfNoEntry: false });
+  if (!inputStat?.isFile()) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_MISSING",
+      "input",
+      `Input file not found: ${options.input}.`
+    );
+  }
+  const zipped = isZip(input);
+  const kmz = isKmz(input);
+  checkContainerFormat(format, zipped, kmz);
+  if (!zipped && !kmz && options.zipEntry !== void 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZIP_ENTRY_INVALID",
+      "zipEntry",
+      "--zip-entry only applies to a .zip or .kmz input."
+    );
+  }
+  if (format !== "geopackage" && options.inputLayer !== void 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_INPUT_LAYER_INVALID",
+      "inputLayer",
+      "--input-layer only applies to a GeoPackage input."
+    );
+  }
+  if (options.rankAscending && options.rankBy === void 0) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_RANK_INVALID",
+      "rankBy",
+      "--rank-ascending needs --rank-by."
+    );
+  }
+  const outputOption = options.output ?? join4(dirname2(options.input), `${inputStem(input)}.pmtiles`);
+  const output = resolve(outputOption);
+  if (output === input) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_OUTPUT_INVALID",
+      "output",
+      "The output path must differ from the input."
+    );
+  }
+  if (existsSync2(output) && !options.force) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_OUTPUT_EXISTS",
+      "output",
+      `${outputOption} already exists. Pass --force to replace it.`
+    );
+  }
+  const layer = chooseLayer2(options.layer, options.inputLayer, input);
+  const zoomRange = checkZooms(options);
+  const outputDirectory = dirname2(output);
+  checkFreeSpace(outputDirectory, zipped ? 0 : inputStat.size);
+  checkInputSignature(input, format, zipped ? "zip" : kmz ? "kmz" : null);
+  const zip = zipped ? await ZippedShapefile.open(input, options.zipEntry) : null;
+  const zippedKml = kmz ? await ZippedKml.open(input, options.zipEntry) : null;
+  checkExtractedSize(zip?.uncompressedBytes ?? zippedKml?.uncompressedBytes, options);
+  const geopackage = format === "geopackage" ? GeoPackageLayer.open(input, options.inputLayer) : null;
+  const temporary = mkdtempSync(join4(outputDirectory, ".tileflow-tileset-build-"));
+  const removeTemporary = () => rmSync(temporary, { force: true, recursive: true });
+  const interrupt = () => {
+    removeTemporary();
+    process.exit(130);
+  };
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", interrupt);
+  let archive = null;
+  try {
+    if (zip) checkFreeSpace(outputDirectory, zip.uncompressedBytes, zip.uncompressedBytes);
+    if (zippedKml) checkFreeSpace(outputDirectory, zippedKml.uncompressedBytes);
+    const shapefile = zip ? await zip.extractProjection(temporary) : input;
+    const statement = await chooseCrsStatement(format, shapefile, options, geopackage);
+    const crs = resolveCrs(statement, options.reproject === true);
+    if (zip) await zip.extractData(temporary);
+    const directory = new SpoolDirectory(temporary);
+    const spool = new FeatureSpool(directory);
+    const ingest = new FeatureIngest(
+      spool,
+      {
+        exclude: options.exclude ? new Set(options.exclude) : null,
+        include: options.include ? new Set(options.include) : null
+      },
+      crs.transform,
+      options.rankBy === void 0 ? null : { ascending: options.rankAscending === true, field: options.rankBy },
+      options.featureId ?? null
+    );
+    if (crs.warning) ingest.warn(crs.warning);
+    async function readFeatures() {
+      switch (format) {
+        case "csv":
+          await readCsv(input, ingest, options);
+          break;
+        case "geojson":
+          await readGeojson(input, ingest, (member) => checkDocumentCrs(member, options));
+          break;
+        case "geojsonseq":
+          await readGeojsonSequence(input, ingest);
+          break;
+        case "geopackage":
+          await geopackage.read(ingest, options.sourceCrs === void 0);
+          break;
+        case "gpx":
+          await readGpx(fileChunks(input), ingest);
+          break;
+        case "kml":
+          await readKml(zippedKml ? zippedKml.chunks() : fileChunks(input), ingest);
+          break;
+        case "shapefile":
+          await readShapefile(shapefile, ingest);
+          break;
+      }
+    }
+    const sourceSha256 = await hashSource(input, format, zipped);
+    options.onProgress?.({ message: "Reading features.", stage: "reading" });
+    const readingProgress = setInterval(() => {
+      const features = ingest.featureCount;
+      options.onProgress?.({ features, message: `Read ${features} features.`, stage: "reading" });
+    }, readingProgressMilliseconds);
+    try {
+      await readFeatures();
+    } finally {
+      clearInterval(readingProgress);
+    }
+    if (options.deleteInputAfterRead) {
+      rmSync(input, { force: true });
+      for (const name2 of zip ? readdirSync2(temporary) : []) {
+        if (extractedExtensions.has(extname3(name2).toLowerCase())) {
+          rmSync(join4(temporary, name2), { force: true });
+        }
+      }
+    }
+    const summary = ingest.finish();
+    const maxzoom = zoomRange.maxzoom ?? Math.max(chooseMaxzoom(ingest, summary), zoomRange.minzoom);
+    const fieldMetadata = Object.fromEntries(summary.fields.map((item) => [item.name, item.type]));
+    options.onProgress?.({
+      features: summary.features,
+      message: `Tiling ${summary.features} features through zoom ${maxzoom}.`,
+      stage: "tiling"
+    });
+    archive = new TileArchiveWriter(join4(temporary, "tiles.bin"));
+    const root = ingest.rankedSpool(spool);
+    const zooms = await buildPyramid(root, {
+      archive,
+      directory,
+      keys: ingest.keyNames(summary),
+      layer,
+      maxzoom,
+      minzoom: zoomRange.minzoom,
+      onTile: (count) => {
+        if (count % 65536 < 256) {
+          options.onProgress?.({ message: `Wrote ${count} tiles.`, stage: "tiling", tiles: count });
+        }
+      }
+    });
+    const pending = join4(temporary, "archive.pmtiles");
+    const bounds = summary.bounds;
+    const name = options.name ?? layer;
+    const recipe = recipeFromSettings({ ...options, maxzoom, minzoom: zoomRange.minzoom }, layer);
+    options.onProgress?.({ message: "Writing the archive.", stage: "archiving" });
+    const totals = await archive.finish(
+      pending,
+      {
+        bounds,
+        center: [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2, zoomRange.minzoom],
+        maxzoom,
+        minzoom: zoomRange.minzoom
+      },
+      serializeCanonicalJson({
+        ...options.attribution ? { attribution: options.attribution } : {},
+        ...options.description ? { description: options.description } : {},
+        format: "pbf",
+        generator: "tileflow tileset build",
+        generator_version: getCliVersion(),
+        name,
+        tileflow_recipe_hash: recipeHash(recipe),
+        tileflow_source_hash: `sha256:${sourceSha256}`,
+        tilestats: tileStatistics(layer, summary),
+        type: "overlay",
+        vector_layers: [{ fields: fieldMetadata, id: layer, maxzoom, minzoom: zoomRange.minzoom }],
+        version: "1"
+      })
+    );
+    if (totals.byteCount > maximumArchiveBytes) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_ARCHIVE_TOO_LARGE",
+        "output",
+        `The archive is ${formatBytes(totals.byteCount)}; publishable archives are limited to ${formatBytes(maximumArchiveBytes)}. Lower --maxzoom, or remove attributes with --include or --exclude.`
+      );
+    }
+    options.onProgress?.({ message: "Validating the archive.", stage: "validating" });
+    const inspection = await inspectTileflowPmtiles(pending, { sample: true });
+    await rename(pending, output);
+    return {
+      archive: {
+        addressedTiles: totals.addressedTiles,
+        bounds,
+        byteCount: totals.byteCount,
+        maxzoom,
+        maxzoomSource: zoomRange.maxzoom === void 0 ? "auto" : "option",
+        minzoom: zoomRange.minzoom,
+        path: outputOption,
+        tileContents: totals.tileContents
+      },
+      command: "tileset build",
+      crs: { authority: crs.authority, label: crs.label, reprojected: crs.reprojected },
+      input: {
+        features: summary.features,
+        format,
+        geometryTypes: summary.geometryTypes,
+        skipped: summary.skipped
+      },
+      layer: { fields: summary.fields, id: layer },
+      recipe,
+      schemaVersion: 1,
+      source: { sha256: sourceSha256 },
+      warnings: [
+        ...summary.warnings,
+        ...placementWarnings(bounds, crs.label, options.sourceCrs !== void 0 || crs.reprojected),
+        ...inspection.warnings.map((warning) => warning.message)
+      ],
+      zooms: zooms.filter((item) => item.zoom >= zoomRange.minzoom)
+    };
+  } catch (error) {
+    if (isNoSpace(error)) {
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_DISK_FULL",
+        "output",
+        "The disk ran out of space during the build. Free space beside the output, or write the output to another disk."
+      );
+    }
+    throw error;
+  } finally {
+    archive?.close();
+    zip?.close();
+    zippedKml?.close();
+    geopackage?.close();
+    process.removeListener("SIGINT", interrupt);
+    process.removeListener("SIGTERM", interrupt);
+    removeTemporary();
+  }
+}
+function tileStatistics(layer, summary) {
+  let budget = maximumTileStatisticsCharacters;
+  const attributes = summary.fields.map((field2) => {
+    const size = field2.values.reduce((total, value) => total + String(value).length, 0);
+    const values = size <= budget ? field2.values : [];
+    budget -= size <= budget ? size : 0;
+    return {
+      attribute: field2.name,
+      count: values.length,
+      ...field2.max === void 0 ? {} : { max: field2.max, min: field2.min },
+      type: field2.type.toLowerCase(),
+      values
+    };
+  });
+  const geometries = summary.geometryTypes;
+  return {
+    layerCount: 1,
+    layers: [
+      {
+        attributeCount: attributes.length,
+        attributes,
+        count: summary.features,
+        geometry: geometries.length === 1 ? geometries[0] : "Unknown",
+        layer
+      }
+    ]
+  };
+}
+function checkContainerFormat(format, zipped, kmz) {
+  if (zipped && format !== "shapefile") {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+      "format",
+      "Only Shapefiles can be read from a zip; extract other formats first."
+    );
+  }
+  if (kmz && format !== "kml") {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+      "format",
+      "A .kmz file can only be read as KML."
+    );
+  }
+}
+function detectFormat(path) {
+  const extension = extname3(path).toLowerCase();
+  switch (extension) {
+    case ".geojson":
+    case ".json":
+      return "geojson";
+    case ".ndjson":
+    case ".geojsonl":
+    case ".geojsons":
+    case ".geojsonseq":
+    case ".jsonl":
+      return "geojsonseq";
+    case ".csv":
+    case ".tsv":
+      return "csv";
+    case ".shp":
+    case ".zip":
+      return "shapefile";
+    case ".gpkg":
+      return "geopackage";
+    case ".kml":
+    case ".kmz":
+      return "kml";
+    case ".gpx":
+      return "gpx";
+    default:
+      throw new TilesetBuildError(
+        "TF_TILESET_BUILD_FORMAT_UNSUPPORTED",
+        "input",
+        `Unsupported input extension "${extension}". Supported: .geojson, .json, .ndjson, .geojsonl, .csv, .tsv, .shp, a .zip holding a Shapefile, .gpkg, .kml, .kmz and .gpx. Use --format if the extension is misleading.`
+      );
+  }
+}
+async function chooseCrsStatement(format, input, options, geopackage) {
+  if (options.sourceCrs !== void 0) return parseSourceCrsOption(options.sourceCrs);
+  switch (format) {
+    case "shapefile":
+      return shapefileCrsStatement(input);
+    case "geopackage":
+      return geopackage.crsStatement;
+    case "gpx":
+      return wgs84Statement("format", "GPX (WGS84 by definition)");
+    case "kml":
+      return wgs84Statement("format", "KML (WGS84 by definition)");
+    case "geojson":
+    case "geojsonseq":
+      return wgs84Statement("format", "GeoJSON (WGS84 by RFC 7946)");
+    case "csv":
+      return await csvColumnsNameCoordinates(input, options) ? wgs84Statement("format", "CSV longitude and latitude columns") : { authority: "format", definition: null, label: "This CSV" };
+  }
+}
+function checkDocumentCrs(member, options) {
+  if (options.sourceCrs !== void 0 || member === null) return;
+  const resolved = resolveCrs(statementFromGeojsonCrs(member), true);
+  if (resolved.transform === null) return;
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_CRS_NOT_WGS84",
+    "crs",
+    `${resolved.label} is not WGS84. Pass --source-crs with the same CRS plus --reproject.`
+  );
+}
+function isZip(path) {
+  return extname3(path).toLowerCase() === ".zip";
+}
+function isKmz(path) {
+  return extname3(path).toLowerCase() === ".kmz";
+}
+function inputStem(path) {
+  const stem = basename3(path, extname3(path));
+  return isZip(path) ? stem.replace(/\.shp$/iu, "") : stem;
+}
+function placementWarnings(bounds, label, stated) {
+  const warnings = [];
+  const [west, south, east, north] = bounds.map((value) => value.toFixed(4));
+  if (stated) {
+    warnings.push(
+      `With ${label}, the features cover longitude ${west} to ${east} and latitude ${south} to ${north}. If that is not where the data belongs, the stated CRS is wrong.`
+    );
+  }
+  if (bounds.every((value) => Math.abs(value) <= nullIslandDegrees)) {
+    warnings.push(
+      `Every feature is within ${nullIslandDegrees}\xB0 of longitude 0, latitude 0, in the Gulf of Guinea. Check for a wrong CRS or placeholder zero coordinates.`
+    );
+  }
+  return warnings;
+}
+function chooseLayer2(requested, inputLayer, input) {
+  const candidate = requested ?? (inputLayer ?? inputStem(input)).replace(/[^A-Za-z0-9._:-]+/gu, "_").replace(/^[^A-Za-z0-9]+/u, "");
+  if (!layerNamePattern.test(candidate)) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_LAYER_INVALID",
+      "layer",
+      `Layer name "${candidate}" is invalid. Use letters, digits, dots, underscores, colons and hyphens, starting with a letter or digit.`
+    );
+  }
+  return candidate;
+}
+function checkZooms(options) {
+  const minzoom = options.minzoom ?? 0;
+  const { maxzoom } = options;
+  if (!Number.isInteger(minzoom) || minzoom < 0 || minzoom > maximumZoom || maxzoom !== void 0 && (!Number.isInteger(maxzoom) || maxzoom > maximumZoom || maxzoom < minzoom)) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_ZOOM_INVALID",
+      "zoom",
+      `Zooms must be integers with 0 <= --minzoom <= --maxzoom <= ${maximumZoom}.`
+    );
+  }
+  return { ...maxzoom === void 0 ? {} : { maxzoom }, minzoom };
+}
+function checkExtractedSize(uncompressedBytes, options) {
+  const limit2 = options.maximumExtractedBytes;
+  if (uncompressedBytes === void 0 || limit2 === void 0 || uncompressedBytes <= limit2) return;
+  throw new TilesetBuildError(
+    "TF_TILESET_BUILD_INPUT_LIMIT",
+    "input",
+    `The archive expands to ${formatBytes(uncompressedBytes)}; the limit here is ${formatBytes(limit2)}.`
+  );
+}
+function checkFreeSpace(directory, inputBytes, extractedBytes = 0) {
+  if (!existsSync2(directory)) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_OUTPUT_INVALID",
+      "output",
+      "The output directory does not exist."
+    );
+  }
+  const volume = statfsSync(directory);
+  const required = Math.max(minimumFreeBytes, inputBytes * 2) + extractedBytes;
+  const available = Number(volume.bavail) * Number(volume.bsize);
+  if (available < required) {
+    throw new TilesetBuildError(
+      "TF_TILESET_BUILD_DISK_FULL",
+      "output",
+      `The build needs about ${formatBytes(required)} of free space beside the output for temporary files; ${formatBytes(available)} is available.`
+    );
+  }
+}
+function formatBytes(bytes) {
+  return `${(bytes / 1024 ** 3).toFixed(2)} GiB`;
+}
+function isNoSpace(error) {
+  return error?.code === "ENOSPC";
+}
+
+export {
+  SpoolDirectory,
+  FeatureSpool,
+  FeatureIngest,
+  readCsv,
+  csvColumnsNameCoordinates,
+  csvColumnNames,
+  readGeojson,
+  readGeojsonSequence,
+  GeoPackageLayer,
+  fileChunks,
+  readGpx,
+  readKml,
+  readShapefile,
+  ZippedShapefile,
+  ZippedKml,
+  checkInputSignature,
+  buildTileset,
+  checkContainerFormat,
+  detectFormat,
+  chooseCrsStatement,
+  isZip,
+  isKmz,
+  chooseLayer2 as chooseLayer
+};