@basemaps/cli-vector 8.2.0 → 8.4.0

package/dist/index.cjs

@@ -65691,14 +65691,14 @@ var require_polygon_clipping_cjs = __commonJS({
             if (windingsAfter[_i] === 0)
               continue;
             var _ring = ringsAfter[_i];
-            var poly = _ring.poly;
-            if (polysExclude.indexOf(poly) !== -1)
+            var poly2 = _ring.poly;
+            if (polysExclude.indexOf(poly2) !== -1)
               continue;
             if (_ring.isExterior)
-              polysAfter.push(poly);
+              polysAfter.push(poly2);
             else {
-              if (polysExclude.indexOf(poly) === -1)
-                polysExclude.push(poly);
+              if (polysExclude.indexOf(poly2) === -1)
+                polysExclude.push(poly2);
               var _index = polysAfter.indexOf(_ring.poly);
               if (_index !== -1)
                 polysAfter.splice(_index, 1);
@@ -65781,12 +65781,12 @@ var require_polygon_clipping_cjs = __commonJS({
       return Segment2;
     }();
     var RingIn = /* @__PURE__ */ function() {
-      function RingIn2(geomRing, poly, isExterior) {
+      function RingIn2(geomRing, poly2, isExterior) {
         _classCallCheck(this, RingIn2);
         if (!Array.isArray(geomRing) || geomRing.length === 0) {
           throw new Error("Input geometry is not a valid Polygon or MultiPolygon");
         }
-        this.poly = poly;
+        this.poly = poly2;
         this.isExterior = isExterior;
         this.segments = [];
         if (typeof geomRing[0][0] !== "number" || typeof geomRing[0][1] !== "number") {
@@ -65910,16 +65910,16 @@ var require_polygon_clipping_cjs = __commonJS({
           }
         };
         for (var i = 0, iMax = geom.length; i < iMax; i++) {
-          var poly = new PolyIn(geom[i], this);
-          if (poly.bbox.ll.x < this.bbox.ll.x)
-            this.bbox.ll.x = poly.bbox.ll.x;
-          if (poly.bbox.ll.y < this.bbox.ll.y)
-            this.bbox.ll.y = poly.bbox.ll.y;
-          if (poly.bbox.ur.x > this.bbox.ur.x)
-            this.bbox.ur.x = poly.bbox.ur.x;
-          if (poly.bbox.ur.y > this.bbox.ur.y)
-            this.bbox.ur.y = poly.bbox.ur.y;
-          this.polys.push(poly);
+          var poly2 = new PolyIn(geom[i], this);
+          if (poly2.bbox.ll.x < this.bbox.ll.x)
+            this.bbox.ll.x = poly2.bbox.ll.x;
+          if (poly2.bbox.ll.y < this.bbox.ll.y)
+            this.bbox.ll.y = poly2.bbox.ll.y;
+          if (poly2.bbox.ur.x > this.bbox.ur.x)
+            this.bbox.ur.x = poly2.bbox.ur.x;
+          if (poly2.bbox.ur.y > this.bbox.ur.y)
+            this.bbox.ur.y = poly2.bbox.ur.y;
+          this.polys.push(poly2);
         }
         this.isSubject = isSubject;
       }
@@ -70677,7 +70677,7 @@ var require_proj4_src = __commonJS({
         return p;
       }
       var names$19 = ["Polyconic", "poly"];
-      var poly = {
+      var poly2 = {
         init: init$18,
         forward: forward$17,
         inverse: inverse$17,
@@ -72157,7 +72157,7 @@ var require_proj4_src = __commonJS({
         proj4.Proj.projections.add(gnom);
         proj4.Proj.projections.add(cea);
         proj4.Proj.projections.add(eqc);
-        proj4.Proj.projections.add(poly);
+        proj4.Proj.projections.add(poly2);
         proj4.Proj.projections.add(nzmg);
         proj4.Proj.projections.add(mill);
         proj4.Proj.projections.add(sinu);
@@ -72643,6 +72643,225 @@ var require_src3 = __commonJS({
   }
 });
 
+// node_modules/tinyqueue/tinyqueue.js
+var require_tinyqueue = __commonJS({
+  "node_modules/tinyqueue/tinyqueue.js"(exports, module2) {
+    (function(global2, factory) {
+      typeof exports === "object" && typeof module2 !== "undefined" ? module2.exports = factory() : typeof define === "function" && define.amd ? define(factory) : (global2 = global2 || self, global2.TinyQueue = factory());
+    })(exports, function() {
+      "use strict";
+      var TinyQueue = function TinyQueue2(data, compare) {
+        if (data === void 0)
+          data = [];
+        if (compare === void 0)
+          compare = defaultCompare;
+        this.data = data;
+        this.length = this.data.length;
+        this.compare = compare;
+        if (this.length > 0) {
+          for (var i = (this.length >> 1) - 1; i >= 0; i--) {
+            this._down(i);
+          }
+        }
+      };
+      TinyQueue.prototype.push = function push2(item) {
+        this.data.push(item);
+        this.length++;
+        this._up(this.length - 1);
+      };
+      TinyQueue.prototype.pop = function pop() {
+        if (this.length === 0) {
+          return void 0;
+        }
+        var top = this.data[0];
+        var bottom = this.data.pop();
+        this.length--;
+        if (this.length > 0) {
+          this.data[0] = bottom;
+          this._down(0);
+        }
+        return top;
+      };
+      TinyQueue.prototype.peek = function peek() {
+        return this.data[0];
+      };
+      TinyQueue.prototype._up = function _up(pos) {
+        var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+        var item = data[pos];
+        while (pos > 0) {
+          var parent = pos - 1 >> 1;
+          var current = data[parent];
+          if (compare(item, current) >= 0) {
+            break;
+          }
+          data[pos] = current;
+          pos = parent;
+        }
+        data[pos] = item;
+      };
+      TinyQueue.prototype._down = function _down(pos) {
+        var ref = this;
+        var data = ref.data;
+        var compare = ref.compare;
+        var halfLength = this.length >> 1;
+        var item = data[pos];
+        while (pos < halfLength) {
+          var left = (pos << 1) + 1;
+          var best = data[left];
+          var right = left + 1;
+          if (right < this.length && compare(data[right], best) < 0) {
+            left = right;
+            best = data[right];
+          }
+          if (compare(best, item) >= 0) {
+            break;
+          }
+          data[pos] = best;
+          pos = left;
+        }
+        data[pos] = item;
+      };
+      function defaultCompare(a, b) {
+        return a < b ? -1 : a > b ? 1 : 0;
+      }
+      return TinyQueue;
+    });
+  }
+});
+
+// node_modules/polylabel/polylabel.js
+var require_polylabel = __commonJS({
+  "node_modules/polylabel/polylabel.js"(exports, module2) {
+    "use strict";
+    var Queue2 = require_tinyqueue();
+    if (Queue2.default)
+      Queue2 = Queue2.default;
+    module2.exports = polylabel2;
+    module2.exports.default = polylabel2;
+    function polylabel2(polygon, precision, debug) {
+      precision = precision || 1;
+      var minX, minY, maxX, maxY;
+      for (var i = 0; i < polygon[0].length; i++) {
+        var p = polygon[0][i];
+        if (!i || p[0] < minX)
+          minX = p[0];
+        if (!i || p[1] < minY)
+          minY = p[1];
+        if (!i || p[0] > maxX)
+          maxX = p[0];
+        if (!i || p[1] > maxY)
+          maxY = p[1];
+      }
+      var width = maxX - minX;
+      var height = maxY - minY;
+      var cellSize = Math.min(width, height);
+      var h = cellSize / 2;
+      if (cellSize === 0) {
+        var degeneratePoleOfInaccessibility = [minX, minY];
+        degeneratePoleOfInaccessibility.distance = 0;
+        return degeneratePoleOfInaccessibility;
+      }
+      var cellQueue = new Queue2(void 0, compareMax);
+      for (var x = minX; x < maxX; x += cellSize) {
+        for (var y = minY; y < maxY; y += cellSize) {
+          cellQueue.push(new Cell(x + h, y + h, h, polygon));
+        }
+      }
+      var bestCell = getCentroidCell(polygon);
+      var bboxCell = new Cell(minX + width / 2, minY + height / 2, 0, polygon);
+      if (bboxCell.d > bestCell.d)
+        bestCell = bboxCell;
+      var numProbes = cellQueue.length;
+      while (cellQueue.length) {
+        var cell = cellQueue.pop();
+        if (cell.d > bestCell.d) {
+          bestCell = cell;
+          if (debug)
+            console.log("found best %d after %d probes", Math.round(1e4 * cell.d) / 1e4, numProbes);
+        }
+        if (cell.max - bestCell.d <= precision)
+          continue;
+        h = cell.h / 2;
+        cellQueue.push(new Cell(cell.x - h, cell.y - h, h, polygon));
+        cellQueue.push(new Cell(cell.x + h, cell.y - h, h, polygon));
+        cellQueue.push(new Cell(cell.x - h, cell.y + h, h, polygon));
+        cellQueue.push(new Cell(cell.x + h, cell.y + h, h, polygon));
+        numProbes += 4;
+      }
+      if (debug) {
+        console.log("num probes: " + numProbes);
+        console.log("best distance: " + bestCell.d);
+      }
+      var poleOfInaccessibility = [bestCell.x, bestCell.y];
+      poleOfInaccessibility.distance = bestCell.d;
+      return poleOfInaccessibility;
+    }
+    function compareMax(a, b) {
+      return b.max - a.max;
+    }
+    function Cell(x, y, h, polygon) {
+      this.x = x;
+      this.y = y;
+      this.h = h;
+      this.d = pointToPolygonDist(x, y, polygon);
+      this.max = this.d + this.h * Math.SQRT2;
+    }
+    function pointToPolygonDist(x, y, polygon) {
+      var inside = false;
+      var minDistSq = Infinity;
+      for (var k = 0; k < polygon.length; k++) {
+        var ring = polygon[k];
+        for (var i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
+          var a = ring[i];
+          var b = ring[j];
+          if (a[1] > y !== b[1] > y && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0])
+            inside = !inside;
+          minDistSq = Math.min(minDistSq, getSegDistSq(x, y, a, b));
+        }
+      }
+      return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
+    }
+    function getCentroidCell(polygon) {
+      var area = 0;
+      var x = 0;
+      var y = 0;
+      var points = polygon[0];
+      for (var i = 0, len = points.length, j = len - 1; i < len; j = i++) {
+        var a = points[i];
+        var b = points[j];
+        var f = a[0] * b[1] - b[0] * a[1];
+        x += (a[0] + b[0]) * f;
+        y += (a[1] + b[1]) * f;
+        area += f * 3;
+      }
+      if (area === 0)
+        return new Cell(points[0][0], points[0][1], 0, polygon);
+      return new Cell(x / area, y / area, 0, polygon);
+    }
+    function getSegDistSq(px, py, a, b) {
+      var x = a[0];
+      var y = a[1];
+      var dx = b[0] - x;
+      var dy = b[1] - y;
+      if (dx !== 0 || dy !== 0) {
+        var t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+          x = b[0];
+          y = b[1];
+        } else if (t > 0) {
+          x += dx * t;
+          y += dy * t;
+        }
+      }
+      dx = px - x;
+      dy = py - y;
+      return dx * dx + dy * dy;
+    }
+  }
+});
+
 // ../../node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream2 = __commonJS({
   "../../node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
@@ -80329,9 +80548,9 @@ var ulid2 = __toESM(require_index_umd(), 1);
 var CliInfo = {
   // Detect unlinked packages looks for this string since its a package name, slightly work around it
   package: "@basemaps/cli",
-  version: "v8.2.0",
-  hash: "69195be692efa914369fa854d3bae16355dc0dc8",
-  buildId: "15601557572-1"
+  version: "v8.4.0",
+  hash: "f30c12a7491ec5556f62b3f35d985d2e89a15c39",
+  buildId: "15866391498-1"
 };
 var CliDate = (/* @__PURE__ */ new Date()).toISOString();
 var CliId = ulid2.ulid();
@@ -86582,8 +86801,8 @@ var Bounds = class _Bounds {
     let minY = multipoly[0][0][0][1];
     let maxX = minX;
     let maxY = minY;
-    for (const [poly] of multipoly) {
-      for (const [x, y] of poly) {
+    for (const [poly2] of multipoly) {
+      for (const [x, y] of poly2) {
         if (x < minX)
           minX = x;
         else if (x > maxX)
@@ -86795,57 +87014,6 @@ function toFeatureMultiPolygon(coordinates, properties = {}) {
   };
 }
 
-// ../linzjs-geojson/build/multipolygon/area.js
-var Area = {
-  /**
-   * Calculate the cartesian area of a ring using the shoelace formula.
-   * Assumes the ring is well-formed and simple (i.e. not self-intersecting).
-   * @param ring The ring to calculate the area of.
-   * @returns The area of the ring.
-   */
-  ring(ring) {
-    let total = 0;
-    for (let i = 0; i < ring.length - 1; i++)
-      total += ring[i][0] * ring[i + 1][1] - ring[i][1] * ring[i + 1][0];
-    return total / 2;
-  },
-  /**
-   * Calculate the cartesian area of a polygon using the shoelace formula.
-   * Assumes the polygon is well-formed and simple (i.e. not self-intersecting).
-   *
-   * [GeoJSON Polygons][1] are an array of rings, where the first ring is the
-   * exterior, and any subsequent rings are interior rings (holes).
-   * The coordinates of the exterior ring are ordered counterclockwise,
-   * while the coordinates of interior rings are ordered clockwise.
-   * Area.ring() gives a negative area value for these clockwise interior rings,
-   * hence adding the area of all rings together gives the valid area of the
-   * polygon, as adding the negative area of the interior rings subtracts it
-   * from the positive area of the exterior ring.
-   *
-   * [1]: https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6
-   * @param poly The polygon to calculate the area of.
-   * @returns The area of the polygon.
-   */
-  polygon(poly) {
-    let total = 0;
-    for (const ring of poly)
-      total += Area.ring(ring);
-    return total;
-  },
-  /**
-   * Calculate the cartesian area of a multipolygon using the shoelace formula.
-   * Assumes the multipolygon is well-formed and simple (i.e. not self-intersecting).
-   * @param multipoly The polygon to calculate the area of.
-   * @returns The area of the polygon.
-   */
-  multiPolygon(multipoly) {
-    let total = 0;
-    for (const poly of multipoly)
-      total += Area.polygon(poly);
-    return total;
-  }
-};
-
 // ../linzjs-geojson/build/multipolygon/clipped.js
 var import_lineclip = __toESM(require_lineclip(), 1);
 var import_polygon_clipping = __toESM(require_polygon_clipping_cjs(), 1);
@@ -86858,8 +87026,8 @@ function removeDegenerateEdges(polygons, bbox) {
 }
 function clipMultipolygon(polygons, bbox) {
   const result = [];
-  for (const poly of polygons) {
-    const clipped = import_lineclip.default.polygon(poly[0], bbox);
+  for (const poly2 of polygons) {
+    const clipped = import_lineclip.default.polygon(poly2[0], bbox);
     if (clipped.length !== 0) {
       if (!samePoint(clipped[0], clipped[clipped.length - 1]))
         clipped.push(clipped[0]);
@@ -87016,10 +87184,10 @@ var Wgs84 = {
        */
   multiPolygonToBbox(multipolygon) {
     let ans = null;
-    for (const poly of multipolygon) {
-      if (poly.length === 0)
+    for (const poly2 of multipolygon) {
+      if (poly2.length === 0)
         continue;
-      const ring = poly[0];
+      const ring = poly2[0];
       if (ring.length < 3)
         continue;
       const bbox = this.ringToBbox(ring);
@@ -87055,11 +87223,11 @@ function pointAtFrac(frac, a, b) {
 }
 function splitWgs84MultiPolygon(multipoly) {
   const result = [];
-  for (const poly of clipMultipolygon(multipoly, WorldBounds)) {
-    result.push(poly);
+  for (const poly2 of clipMultipolygon(multipoly, WorldBounds)) {
+    result.push(poly2);
   }
-  for (const poly of clipMultipolygon(multipoly, NextWorldBounds)) {
-    result.push(poly.map((ring) => ring.map((point) => [point[0] - 360, point[1]])));
+  for (const poly2 of clipMultipolygon(multipoly, NextWorldBounds)) {
+    result.push(poly2.map((ring) => ring.map((point) => [point[0] - 360, point[1]])));
   }
   return result;
 }
@@ -87250,7 +87418,7 @@ var Projection = class _Projection {
       return multipoly;
     const { toWgs84 } = this;
     const { fromWgs84 } = targetProjection;
-    return multipoly.map((poly) => poly.map((ring) => ring.map((p) => fromWgs84(toWgs84(p)))));
+    return multipoly.map((poly2) => poly2.map((ring) => ring.map((p) => fromWgs84(toWgs84(p)))));
   }
   /**
    * Convert source `[x, y]` coordinates to `[lon, lat]`
@@ -87399,48 +87567,6 @@ Object.defineProperty(Projection, "AllowedFloatingError", {
   value: 1e-8
 });
 
-// ../geo/build/proj/projection.loader.js
-var ProjectionLoader = class {
-  /**
-   * Ensure that a projection EPSG code is avialable for use in Proj4js
-   *
-   * If its not already loaded, lookup definition from spatialreference.org
-   * @param code
-   */
-  static async load(code) {
-    if (Projection.tryGet(code) != null)
-      return Epsg.get(code);
-    const url = `https://spatialreference.org/ref/epsg/${code}/ogcwkt/`;
-    const res = await this._fetch(url);
-    if (!res.ok)
-      throw new Error("Failed to load projection information for:" + code);
-    let epsg = Epsg.tryGet(code);
-    if (epsg == null)
-      epsg = new Epsg(code);
-    const text = await res.text();
-    Projection.define(epsg, text);
-    return epsg;
-  }
-};
-Object.defineProperty(ProjectionLoader, "_fetch", {
-  enumerable: true,
-  configurable: true,
-  writable: true,
-  value: fetch
-});
-
-// ../geo/build/proj/tile.set.name.js
-var TileSetName;
-(function(TileSetName2) {
-  TileSetName2["aerial"] = "aerial";
-})(TileSetName || (TileSetName = {}));
-
-// ../geo/build/quad.key.js
-var CHAR_0 = "0".charCodeAt(0);
-var CHAR_1 = "1".charCodeAt(0);
-var CHAR_2 = "2".charCodeAt(0);
-var CHAR_3 = "3".charCodeAt(0);
-
 // ../geo/build/xy.order.js
 function getXyOrder(epsg) {
   const code = typeof epsg === "number" ? epsg : epsg.code;
@@ -87726,25 +87852,25 @@ var TileMatrixSet = class {
   }
 };
 
-// ../geo/build/tms/citm2000.js
-var Citm2000Tmst = {
+// ../geo/build/tms/google.js
+var GoogleTmst = {
   type: "TileMatrixSetType",
-  title: "Debug tile matrix for EPSG:3793",
-  abstract: "",
-  identifier: "CITM2000Quad",
-  supportedCRS: "https://www.opengis.net/def/crs/EPSG/0/3793",
+  title: "Google Maps Compatible for the World",
+  identifier: "WebMercatorQuad",
   boundingBox: {
     type: "BoundingBoxType",
-    crs: "https://www.opengis.net/def/crs/EPSG/0/3793",
-    lowerCorner: [5051234111622438e-9, 3.4301543757978342e6],
-    upperCorner: [5207777145550478e-9, 3.5866974097258747e6]
+    crs: "http://www.opengis.net/def/crs/EPSG/0/3857",
+    lowerCorner: [-200375083427892e-7, -200375083427892e-7],
+    upperCorner: [200375083427892e-7, 200375083427892e-7]
   },
+  supportedCRS: "https://www.opengis.net/def/crs/EPSG/0/3857",
+  wellKnownScaleSet: "https://www.opengis.net/def/wkss/OGC/1.0/GoogleMapsCompatible",
   tileMatrix: [
     {
       type: "TileMatrixType",
       identifier: "0",
-      scaleDenominator: 218391509386217e-8,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 559082264028717e-6,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 1,
@@ -87753,8 +87879,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "1",
-      scaleDenominator: 109195754693108e-8,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 279541132014358e-6,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 2,
@@ -87763,8 +87889,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "2",
-      scaleDenominator: 545978.773465544,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 139770566007179e-6,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 4,
@@ -87773,8 +87899,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "3",
-      scaleDenominator: 272989.386732772,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 698852830035897e-7,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 8,
@@ -87783,8 +87909,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "4",
-      scaleDenominator: 136494.693366386,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 349426415017948e-7,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 16,
@@ -87793,8 +87919,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "5",
-      scaleDenominator: 68247.346683193,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 174713207508974e-7,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 32,
@@ -87803,8 +87929,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "6",
-      scaleDenominator: 34123.6733415964,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 873566037544871e-8,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 64,
@@ -87813,8 +87939,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "7",
-      scaleDenominator: 17061.8366707982,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 436783018772435e-8,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 128,
@@ -87823,8 +87949,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "8",
-      scaleDenominator: 8530.91833539913,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 218391509386217e-8,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 256,
@@ -87833,8 +87959,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "9",
-      scaleDenominator: 4265.45916769956,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 109195754693108e-8,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 512,
@@ -87843,8 +87969,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "10",
-      scaleDenominator: 2132.72958384978,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 545978.773465544,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 1024,
@@ -87853,8 +87979,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "11",
-      scaleDenominator: 1066.36479192489,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 272989.386732772,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 2048,
@@ -87863,8 +87989,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "12",
-      scaleDenominator: 533.182395962445,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 136494.693366386,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 4096,
@@ -87873,8 +87999,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "13",
-      scaleDenominator: 266.591197981222,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 68247.346683193,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 8192,
@@ -87883,8 +88009,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "14",
-      scaleDenominator: 133.295598990611,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 34123.6733415964,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 16384,
@@ -87893,8 +88019,8 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "15",
-      scaleDenominator: 66.6477994953056,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 17061.8366707982,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 32768,
@@ -87903,294 +88029,396 @@ var Citm2000Tmst = {
     {
       type: "TileMatrixType",
       identifier: "16",
-      scaleDenominator: 33.3238997476528,
-      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
+      scaleDenominator: 8530.91833539913,
+      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
       matrixWidth: 65536,
       matrixHeight: 65536
-    }
-  ],
-  $generated: {
-    package: "@basemaps/cli",
-    version: "v7.14.0-4-g2766010d",
-    hash: "2766010d8d2bb8b673f6bcbef2fe2636f2e0f4ea",
-    createdAt: "2025-02-10T20:34:46.643Z"
-  },
-  $options: {
-    sourceTileMatrix: "WebMercatorQuad",
-    zoomOffset: 8
-  }
-};
-var Citm2000Tms = new TileMatrixSet(Citm2000Tmst);
-
-// ../geo/build/tms/google.js
-var GoogleTmst = {
-  type: "TileMatrixSetType",
-  title: "Google Maps Compatible for the World",
-  identifier: "WebMercatorQuad",
-  boundingBox: {
-    type: "BoundingBoxType",
-    crs: "http://www.opengis.net/def/crs/EPSG/0/3857",
-    lowerCorner: [-200375083427892e-7, -200375083427892e-7],
-    upperCorner: [200375083427892e-7, 200375083427892e-7]
-  },
-  supportedCRS: "https://www.opengis.net/def/crs/EPSG/0/3857",
-  wellKnownScaleSet: "https://www.opengis.net/def/wkss/OGC/1.0/GoogleMapsCompatible",
-  tileMatrix: [
+    },
     {
       type: "TileMatrixType",
-      identifier: "0",
-      scaleDenominator: 559082264028717e-6,
+      identifier: "17",
+      scaleDenominator: 4265.45916769956,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 1,
-      matrixHeight: 1
+      matrixWidth: 131072,
+      matrixHeight: 131072
     },
     {
       type: "TileMatrixType",
-      identifier: "1",
-      scaleDenominator: 279541132014358e-6,
+      identifier: "18",
+      scaleDenominator: 2132.72958384978,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 2,
-      matrixHeight: 2
+      matrixWidth: 262144,
+      matrixHeight: 262144
     },
     {
       type: "TileMatrixType",
-      identifier: "2",
-      scaleDenominator: 139770566007179e-6,
+      identifier: "19",
+      scaleDenominator: 1066.36479192489,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 4,
-      matrixHeight: 4
+      matrixWidth: 524288,
+      matrixHeight: 524288
     },
     {
       type: "TileMatrixType",
-      identifier: "3",
-      scaleDenominator: 698852830035897e-7,
+      identifier: "20",
+      scaleDenominator: 533.182395962445,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 8,
-      matrixHeight: 8
+      matrixWidth: 1048576,
+      matrixHeight: 1048576
     },
     {
       type: "TileMatrixType",
-      identifier: "4",
-      scaleDenominator: 349426415017948e-7,
+      identifier: "21",
+      scaleDenominator: 266.591197981222,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 16,
-      matrixHeight: 16
+      matrixWidth: 2097152,
+      matrixHeight: 2097152
     },
     {
       type: "TileMatrixType",
-      identifier: "5",
-      scaleDenominator: 174713207508974e-7,
+      identifier: "22",
+      scaleDenominator: 133.295598990611,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 32,
-      matrixHeight: 32
+      matrixWidth: 4194304,
+      matrixHeight: 4194304
     },
     {
       type: "TileMatrixType",
-      identifier: "6",
-      scaleDenominator: 873566037544871e-8,
+      identifier: "23",
+      scaleDenominator: 66.6477994953056,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 64,
-      matrixHeight: 64
+      matrixWidth: 8388608,
+      matrixHeight: 8388608
     },
     {
       type: "TileMatrixType",
-      identifier: "7",
-      scaleDenominator: 436783018772435e-8,
+      identifier: "24",
+      scaleDenominator: 33.3238997476528,
       topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 128,
-      matrixHeight: 128
-    },
+      matrixWidth: 16777216,
+      matrixHeight: 16777216
+    }
+  ]
+};
+var GoogleTms = new TileMatrixSet(GoogleTmst);
+
+// ../geo/build/location.transform.js
+function isGoogle(tms) {
+  return tms.identifier === GoogleTms.identifier;
+}
+function locationTransform(location, tileMatrix, targetTileMatrix) {
+  if (tileMatrix.identifier === targetTileMatrix.identifier)
+    return location;
+  if (!isGoogle(tileMatrix) && !isGoogle(targetTileMatrix)) {
+    throw new Error("Either tileMatrix or targetTileMatrix must be GoogleTms");
+  }
+  const coords = Projection.get(tileMatrix).fromWgs84([location.lon, location.lat]);
+  const point = tileMatrix.sourceToPixels(coords[0], coords[1], Math.round(location.zoom));
+  const tile = { x: point.x / tileMatrix.tileSize, y: point.y / tileMatrix.tileSize, z: Math.round(location.zoom) };
+  const source = targetTileMatrix.tileToSource(tile);
+  const lonLat = Projection.get(targetTileMatrix).toWgs84([source.x, source.y]);
+  return { lon: Math.round(lonLat[0] * 1e8) / 1e8, lat: Math.round(lonLat[1] * 1e8) / 1e8, zoom: location.zoom };
+}
+function projectFeature(f, targetTileMatrix) {
+  if (f.geometry.type === "Polygon") {
+    for (const poly2 of f.geometry.coordinates) {
+      for (const coord of poly2) {
+        const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+        coord[0] = output.lon;
+        coord[1] = output.lat;
+      }
+    }
+  } else if (f.geometry.type === "MultiPolygon") {
+    for (const multiPoly of f.geometry.coordinates) {
+      for (const poly2 of multiPoly) {
+        for (const coord of poly2) {
+          const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+          coord[0] = output.lon;
+          coord[1] = output.lat;
+        }
+      }
+    }
+  } else if (f.geometry.type === "Point") {
+    const coord = f.geometry.coordinates;
+    const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+    coord[0] = output.lon;
+    coord[1] = output.lat;
+  } else if (f.geometry.type === "MultiLineString") {
+    for (const line of f.geometry.coordinates) {
+      for (const coord of line) {
+        const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+        coord[0] = output.lon;
+        coord[1] = output.lat;
+      }
+    }
+  } else if (f.geometry.type === "LineString") {
+    for (const coord of f.geometry.coordinates) {
+      const output = locationTransform({ lat: coord[1], lon: coord[0], zoom: targetTileMatrix.maxZoom }, targetTileMatrix, GoogleTms);
+      coord[0] = output.lon;
+      coord[1] = output.lat;
+    }
+  } else {
+    throw new Error(`Geometry feature type: ${f.geometry.type} not supported`);
+  }
+}
+
+// ../geo/build/proj/projection.loader.js
+var ProjectionLoader = class {
+  /**
+   * Ensure that a projection EPSG code is avialable for use in Proj4js
+   *
+   * If its not already loaded, lookup definition from spatialreference.org
+   * @param code
+   */
+  static async load(code) {
+    if (Projection.tryGet(code) != null)
+      return Epsg.get(code);
+    const url = `https://spatialreference.org/ref/epsg/${code}/ogcwkt/`;
+    const res = await this._fetch(url);
+    if (!res.ok)
+      throw new Error("Failed to load projection information for:" + code);
+    let epsg = Epsg.tryGet(code);
+    if (epsg == null)
+      epsg = new Epsg(code);
+    const text = await res.text();
+    Projection.define(epsg, text);
+    return epsg;
+  }
+};
+Object.defineProperty(ProjectionLoader, "_fetch", {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value: fetch
+});
+
+// ../geo/build/proj/tile.set.name.js
+var TileSetName;
+(function(TileSetName2) {
+  TileSetName2["aerial"] = "aerial";
+})(TileSetName || (TileSetName = {}));
+
+// ../geo/build/quad.key.js
+var CHAR_0 = "0".charCodeAt(0);
+var CHAR_1 = "1".charCodeAt(0);
+var CHAR_2 = "2".charCodeAt(0);
+var CHAR_3 = "3".charCodeAt(0);
+
+// ../geo/build/tms/citm2000.js
+var Citm2000Tmst = {
+  type: "TileMatrixSetType",
+  title: "Debug tile matrix for EPSG:3793",
+  abstract: "",
+  identifier: "CITM2000Quad",
+  supportedCRS: "https://www.opengis.net/def/crs/EPSG/0/3793",
+  boundingBox: {
+    type: "BoundingBoxType",
+    crs: "https://www.opengis.net/def/crs/EPSG/0/3793",
+    lowerCorner: [5051234111622438e-9, 3.4301543757978342e6],
+    upperCorner: [5207777145550478e-9, 3.5866974097258747e6]
+  },
+  tileMatrix: [
     {
       type: "TileMatrixType",
-      identifier: "8",
+      identifier: "0",
       scaleDenominator: 218391509386217e-8,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 256,
-      matrixHeight: 256
+      matrixWidth: 1,
+      matrixHeight: 1
     },
     {
       type: "TileMatrixType",
-      identifier: "9",
+      identifier: "1",
       scaleDenominator: 109195754693108e-8,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 512,
-      matrixHeight: 512
+      matrixWidth: 2,
+      matrixHeight: 2
     },
     {
       type: "TileMatrixType",
-      identifier: "10",
+      identifier: "2",
       scaleDenominator: 545978.773465544,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 1024,
-      matrixHeight: 1024
+      matrixWidth: 4,
+      matrixHeight: 4
     },
     {
       type: "TileMatrixType",
-      identifier: "11",
+      identifier: "3",
       scaleDenominator: 272989.386732772,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 2048,
-      matrixHeight: 2048
+      matrixWidth: 8,
+      matrixHeight: 8
     },
     {
       type: "TileMatrixType",
-      identifier: "12",
+      identifier: "4",
       scaleDenominator: 136494.693366386,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 4096,
-      matrixHeight: 4096
+      matrixWidth: 16,
+      matrixHeight: 16
     },
     {
       type: "TileMatrixType",
-      identifier: "13",
+      identifier: "5",
       scaleDenominator: 68247.346683193,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 8192,
-      matrixHeight: 8192
+      matrixWidth: 32,
+      matrixHeight: 32
     },
     {
       type: "TileMatrixType",
-      identifier: "14",
+      identifier: "6",
       scaleDenominator: 34123.6733415964,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 16384,
-      matrixHeight: 16384
+      matrixWidth: 64,
+      matrixHeight: 64
     },
     {
       type: "TileMatrixType",
-      identifier: "15",
+      identifier: "7",
       scaleDenominator: 17061.8366707982,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 32768,
-      matrixHeight: 32768
+      matrixWidth: 128,
+      matrixHeight: 128
     },
     {
       type: "TileMatrixType",
-      identifier: "16",
+      identifier: "8",
       scaleDenominator: 8530.91833539913,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 65536,
-      matrixHeight: 65536
+      matrixWidth: 256,
+      matrixHeight: 256
     },
     {
       type: "TileMatrixType",
-      identifier: "17",
+      identifier: "9",
       scaleDenominator: 4265.45916769956,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 131072,
-      matrixHeight: 131072
+      matrixWidth: 512,
+      matrixHeight: 512
     },
     {
       type: "TileMatrixType",
-      identifier: "18",
+      identifier: "10",
       scaleDenominator: 2132.72958384978,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 262144,
-      matrixHeight: 262144
+      matrixWidth: 1024,
+      matrixHeight: 1024
     },
     {
       type: "TileMatrixType",
-      identifier: "19",
+      identifier: "11",
       scaleDenominator: 1066.36479192489,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 524288,
-      matrixHeight: 524288
+      matrixWidth: 2048,
+      matrixHeight: 2048
     },
     {
       type: "TileMatrixType",
-      identifier: "20",
+      identifier: "12",
       scaleDenominator: 533.182395962445,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 1048576,
-      matrixHeight: 1048576
+      matrixWidth: 4096,
+      matrixHeight: 4096
     },
     {
       type: "TileMatrixType",
-      identifier: "21",
+      identifier: "13",
       scaleDenominator: 266.591197981222,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 2097152,
-      matrixHeight: 2097152
+      matrixWidth: 8192,
+      matrixHeight: 8192
     },
     {
       type: "TileMatrixType",
-      identifier: "22",
+      identifier: "14",
       scaleDenominator: 133.295598990611,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 4194304,
-      matrixHeight: 4194304
+      matrixWidth: 16384,
+      matrixHeight: 16384
     },
     {
       type: "TileMatrixType",
-      identifier: "23",
+      identifier: "15",
       scaleDenominator: 66.6477994953056,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 8388608,
-      matrixHeight: 8388608
+      matrixWidth: 32768,
+      matrixHeight: 32768
     },
     {
       type: "TileMatrixType",
-      identifier: "24",
+      identifier: "16",
       scaleDenominator: 33.3238997476528,
-      topLeftCorner: [-200375083427892e-7, 200375083427892e-7],
+      topLeftCorner: [5207777145550478e-9, 3.4301543757978342e6],
       tileWidth: 256,
       tileHeight: 256,
-      matrixWidth: 16777216,
-      matrixHeight: 16777216
+      matrixWidth: 65536,
+      matrixHeight: 65536
     }
-  ]
+  ],
+  $generated: {
+    package: "@basemaps/cli",
+    version: "v7.14.0-4-g2766010d",
+    hash: "2766010d8d2bb8b673f6bcbef2fe2636f2e0f4ea",
+    createdAt: "2025-02-10T20:34:46.643Z"
+  },
+  $options: {
+    sourceTileMatrix: "WebMercatorQuad",
+    zoomOffset: 8
+  }
 };
-var GoogleTms = new TileMatrixSet(GoogleTmst);
+var Citm2000Tms = new TileMatrixSet(Citm2000Tmst);
 
 // ../geo/build/tms/nztm2000.js
 var Nztm20002 = __toESM(require_src3(), 1);
@@ -90402,7 +90630,8 @@ var zLayer = z.object({
   attributes: zAttributes.optional(),
   style: zStyling,
   simplify: z.array(zSimplify).optional(),
-  tippecanoe: z.array(z.string()).optional()
+  tippecanoe: z.array(z.string()).optional(),
+  includeDerivedArea: z.boolean().optional()
 });
 var zSchema = z.object({
   name: z.string(),
@@ -90416,13 +90645,15 @@ var zSchema = z.object({
 // src/schema-loader/schema.loader.ts
 var LARGE_LAYER_SIZE = 1024 * 1024 * 1024;
 var SchemaLoader = class {
-  constructor(path4, logger, cache) {
+  constructor(path4, tileMatrix, logger, cache) {
     __publicField(this, "path");
     __publicField(this, "logger");
     __publicField(this, "schemas", []);
+    __publicField(this, "tileMatrix");
     __publicField(this, "cache");
     this.path = path4;
     this.logger = logger;
+    this.tileMatrix = tileMatrix;
     this.cache = cache;
   }
   /**
@@ -90476,7 +90707,7 @@ var SchemaLoader = class {
         const configHash = sha256base58(JSON.stringify({ name: schema.name, layer, version: CliInfo.version }));
         if (this.cache != null) {
           const fileName = isLdsFile ? `${layer.id}_${layer.version}_${configHash}.mbtiles` : `${layer.id}_${configHash}.mbtiles`;
-          const path4 = new URL(`${layer.id}/${fileName}`, this.cache);
+          const path4 = new URL(`${this.tileMatrix.projection.code}/${layer.id}/${fileName}`, this.cache);
           const exists = await Fsa.exists(path4);
           const cache = {
             fileName,
@@ -90547,7 +90778,7 @@ var VectorStac = class {
       stac_version: "1.0.0",
       stac_extensions: [],
       geometry: null,
-      bbox: [-180, -90, 180, 90],
+      bbox: tileMatrix.extent.toBbox(),
       links: [
         { href: `./${filename}.json`, rel: "self" },
         { href: "./collection.json", rel: "collection" },
@@ -90555,6 +90786,7 @@ var VectorStac = class {
         ...layers
       ],
       properties: {
+        datetime: CliDate,
         "proj:epsg": tileMatrix.projection.code,
         "linz_basemaps:generated": {
           package: CliInfo.package,
@@ -90637,7 +90869,7 @@ async function createStacFiles(filePaths, targetPath, filename, tileMatrix, titl
   };
   const stacCollection = vectorStac.createStacCollection(unionBbox, layers, filename, title);
   let stacCatalog = vectorStac.createStacCatalog();
-  const catalogPath = new URL("catalog.json", targetPath);
+  const catalogPath = new URL("topographic/catalog.json", targetPath);
   if (await Fsa.exists(catalogPath))
     stacCatalog = await Fsa.readJson(catalogPath);
   stacCatalog.links.push({
@@ -90697,7 +90929,7 @@ var ExtractCommand = (0, import_cmd_ts2.command)({
     if (tileMatrix == null)
       throw new Error(`Tile matrix ${args.tileMatrix} is not supported`);
     logger.info({ schema: args.schema }, "Extract: Start");
-    const schemaLoader = new SchemaLoader(args.schema, logger, cache);
+    const schemaLoader = new SchemaLoader(args.schema, tileMatrix, logger, cache);
     const schemas = await schemaLoader.load();
     const smallLayers = [];
     const largeLayers = [];
@@ -90949,99 +91181,79 @@ function handleKindPeak(feature, logger) {
 }
 
 // src/modify/parser.ts
+var optionalString = z.preprocess((value) => {
+  if (value === "0" || value === null) {
+    return void 0;
+  } else {
+    return value;
+  }
+}, z.string().optional());
 var zPlaceLabelsProperties = z.object({
   /** @example "Kaitaia" */
   label: z.string(),
+  /** @example 8 */
+  zoom_level: z.number(),
   /** @example "TWN1" */
   style: z.string(),
+  /** @example "cape" */
+  natural: optionalString,
   /** @example "city" */
-  place: z.string(),
-  /** @example 7 */
-  adminlevel: z.number(),
-  /** @example "0" */
-  natural: z.string(),
-  /** @example "0" */
-  water: z.string()
-});
-var zPlaceLabelsTippecanoe = z.object({
-  /** @example "place_labels" */
-  layer: z.string(),
-  /** @example 8 */
-  minzoom: z.number(),
-  /** @example 8 */
-  maxzoom: z.number()
+  place: optionalString,
+  /** @example "bay" */
+  water: optionalString
 });
 
 // src/modify/layers/place_labels.ts
 var PlaceLabelsFeatures = /* @__PURE__ */ new Map();
 function handleLayerPlaceLabels(feature, logger) {
   logger.trace({}, "HandlePlaceLabels:Start");
-  feature = structuredClone(feature);
-  const label = feature.properties["label"];
-  if (typeof label !== "string")
-    throw new Error("Label property is not a string");
-  const zoomLevel = feature.properties["zoom_level"];
-  if (typeof zoomLevel !== "number")
-    throw new Error("Zoom level is not a number");
-  const storedFeature = PlaceLabelsFeatures.get(label);
+  const newFeature = createNewFeature(feature, logger);
+  const name = newFeature.properties.name;
+  const storedFeature = PlaceLabelsFeatures.get(name);
   if (storedFeature == null) {
-    const newFeature = createNewFeature(feature, label, zoomLevel, logger);
-    if (newFeature == null)
-      return null;
-    PlaceLabelsFeatures.set(label, newFeature);
+    PlaceLabelsFeatures.set(name, newFeature);
     logger.trace({}, "HandlePlaceLabels:End");
     return newFeature;
   }
-  if (zoomLevel < storedFeature.tippecanoe.minzoom) {
-    storedFeature.tippecanoe.minzoom = zoomLevel;
-    PlaceLabelsFeatures.set(label, storedFeature);
-  }
-  if (zoomLevel > storedFeature.tippecanoe.maxzoom) {
-    storedFeature.tippecanoe.maxzoom = zoomLevel;
-    PlaceLabelsFeatures.set(label, storedFeature);
-  }
+  storedFeature.tippecanoe.minzoom = newFeature.tippecanoe.minzoom;
+  storedFeature.tippecanoe.maxzoom = newFeature.tippecanoe.minzoom;
   logger.trace({}, "HandlePlaceLabels:End");
-  return storedFeature;
+  return structuredClone(storedFeature);
 }
-function createNewFeature(feature, label, zoomLevel, logger) {
-  let properties;
-  let tippecanoe2;
+function createNewFeature(feature, logger) {
   try {
-    properties = zPlaceLabelsProperties.parse({
-      label,
+    const properties = zPlaceLabelsProperties.parse({
+      label: feature.properties["label"],
+      zoom_level: feature.properties["zoom_level"],
       style: feature.properties["style"],
-      place: feature.properties["place"],
-      adminlevel: feature.properties["adminlevel"],
       natural: feature.properties["natural"],
+      place: feature.properties["place"],
       water: feature.properties["water"]
     });
-    tippecanoe2 = zPlaceLabelsTippecanoe.parse({
+    const tippecanoe2 = {
       layer: "place_labels",
-      minzoom: zoomLevel,
-      maxzoom: zoomLevel
-    });
+      minzoom: properties.zoom_level,
+      maxzoom: properties.zoom_level
+    };
+    const newFeature = {
+      type: feature.type,
+      properties: {
+        name: properties.label,
+        kind: convertStyleToKind(properties.style, tippecanoe2.minzoom),
+        natural: properties.natural,
+        place: properties.place,
+        water: properties.water
+      },
+      geometry: feature.geometry,
+      tippecanoe: tippecanoe2
+    };
+    return newFeature;
   } catch (e) {
     if (e instanceof z.ZodError) {
-      logger.trace({ label }, "Failed to parse expected properties. Discarding feature.");
-      return null;
-    } else {
-      throw new Error("An unexpected error occurred.");
-    }
-  }
-  const newFeature = {
-    type: feature.type,
-    properties: {
-      name: properties.label,
-      kind: convertStyleToKind(properties.style, tippecanoe2.minzoom),
-      place: properties.place,
-      adminlevel: properties.adminlevel,
-      natural: properties.natural,
-      water: properties.water
-    },
-    geometry: feature.geometry,
-    tippecanoe: tippecanoe2
-  };
-  return newFeature;
+      logger.trace({ properties: feature.properties }, "Failed to parse required properties.");
+    }
+    throw e;
+  }
 }
 function convertStyleToKind(style, minzoom) {
   if (style.startsWith("ANT"))
@@ -91061,240 +91273,8 @@ function convertStyleToKind(style, minzoom) {
   return "";
 }
 
-// src/modify/layers/pois.ts
-function handleLayerPois(feature, logger) {
-  logger.trace({}, "HandlePois:Start");
-  feature = structuredClone(feature);
-  if (feature.properties["building"] === "building") {
-    const bldgUse = feature.properties["bldg_use"];
-    if (bldgUse == null) {
-      logger.trace({}, "HandlePois:End");
-      return null;
-    }
-    feature.properties["building"] = bldgUse;
-  }
-  logger.trace({}, "HandlePois:End");
-  return feature;
-}
-
-// ../../node_modules/tinyqueue/index.js
-var TinyQueue = class {
-  constructor(data = [], compare = (a, b) => a < b ? -1 : a > b ? 1 : 0) {
-    this.data = data;
-    this.length = this.data.length;
-    this.compare = compare;
-    if (this.length > 0) {
-      for (let i = (this.length >> 1) - 1; i >= 0; i--)
-        this._down(i);
-    }
-  }
-  push(item) {
-    this.data.push(item);
-    this._up(this.length++);
-  }
-  pop() {
-    if (this.length === 0)
-      return void 0;
-    const top = this.data[0];
-    const bottom = this.data.pop();
-    if (--this.length > 0) {
-      this.data[0] = bottom;
-      this._down(0);
-    }
-    return top;
-  }
-  peek() {
-    return this.data[0];
-  }
-  _up(pos) {
-    const { data, compare } = this;
-    const item = data[pos];
-    while (pos > 0) {
-      const parent = pos - 1 >> 1;
-      const current = data[parent];
-      if (compare(item, current) >= 0)
-        break;
-      data[pos] = current;
-      pos = parent;
-    }
-    data[pos] = item;
-  }
-  _down(pos) {
-    const { data, compare } = this;
-    const halfLength = this.length >> 1;
-    const item = data[pos];
-    while (pos < halfLength) {
-      let bestChild = (pos << 1) + 1;
-      const right = bestChild + 1;
-      if (right < this.length && compare(data[right], data[bestChild]) < 0) {
-        bestChild = right;
-      }
-      if (compare(data[bestChild], item) >= 0)
-        break;
-      data[pos] = data[bestChild];
-      pos = bestChild;
-    }
-    data[pos] = item;
-  }
-};
-
-// ../../node_modules/polylabel/polylabel.js
-function polylabel(polygon, precision = 1, debug = false) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const [x, y] of polygon[0]) {
-    if (x < minX)
-      minX = x;
-    if (y < minY)
-      minY = y;
-    if (x > maxX)
-      maxX = x;
-    if (y > maxY)
-      maxY = y;
-  }
-  const width = maxX - minX;
-  const height = maxY - minY;
-  const cellSize = Math.max(precision, Math.min(width, height));
-  if (cellSize === precision) {
-    const result2 = [minX, minY];
-    result2.distance = 0;
-    return result2;
-  }
-  const cellQueue = new TinyQueue([], (a, b) => b.max - a.max);
-  let bestCell = getCentroidCell(polygon);
-  const bboxCell = new Cell(minX + width / 2, minY + height / 2, 0, polygon);
-  if (bboxCell.d > bestCell.d)
-    bestCell = bboxCell;
-  let numProbes = 2;
-  function potentiallyQueue(x, y, h2) {
-    const cell = new Cell(x, y, h2, polygon);
-    numProbes++;
-    if (cell.max > bestCell.d + precision)
-      cellQueue.push(cell);
-    if (cell.d > bestCell.d) {
-      bestCell = cell;
-      if (debug)
-        console.log(`found best ${Math.round(1e4 * cell.d) / 1e4} after ${numProbes} probes`);
-    }
-  }
-  let h = cellSize / 2;
-  for (let x = minX; x < maxX; x += cellSize) {
-    for (let y = minY; y < maxY; y += cellSize) {
-      potentiallyQueue(x + h, y + h, h);
-    }
-  }
-  while (cellQueue.length) {
-    const { max, x, y, h: ch } = cellQueue.pop();
-    if (max - bestCell.d <= precision)
-      break;
-    h = ch / 2;
-    potentiallyQueue(x - h, y - h, h);
-    potentiallyQueue(x + h, y - h, h);
-    potentiallyQueue(x - h, y + h, h);
-    potentiallyQueue(x + h, y + h, h);
-  }
-  if (debug) {
-    console.log(`num probes: ${numProbes}
-best distance: ${bestCell.d}`);
-  }
-  const result = [bestCell.x, bestCell.y];
-  result.distance = bestCell.d;
-  return result;
-}
-function Cell(x, y, h, polygon) {
-  this.x = x;
-  this.y = y;
-  this.h = h;
-  this.d = pointToPolygonDist(x, y, polygon);
-  this.max = this.d + this.h * Math.SQRT2;
-}
-function pointToPolygonDist(x, y, polygon) {
-  let inside = false;
-  let minDistSq = Infinity;
-  for (const ring of polygon) {
-    for (let i = 0, len = ring.length, j = len - 1; i < len; j = i++) {
-      const a = ring[i];
-      const b = ring[j];
-      if (a[1] > y !== b[1] > y && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0])
-        inside = !inside;
-      minDistSq = Math.min(minDistSq, getSegDistSq(x, y, a, b));
-    }
-  }
-  return minDistSq === 0 ? 0 : (inside ? 1 : -1) * Math.sqrt(minDistSq);
-}
-function getCentroidCell(polygon) {
-  let area = 0;
-  let x = 0;
-  let y = 0;
-  const points = polygon[0];
-  for (let i = 0, len = points.length, j = len - 1; i < len; j = i++) {
-    const a = points[i];
-    const b = points[j];
-    const f = a[0] * b[1] - b[0] * a[1];
-    x += (a[0] + b[0]) * f;
-    y += (a[1] + b[1]) * f;
-    area += f * 3;
-  }
-  const centroid = new Cell(x / area, y / area, 0, polygon);
-  if (area === 0 || centroid.d < 0)
-    return new Cell(points[0][0], points[0][1], 0, polygon);
-  return centroid;
-}
-function getSegDistSq(px, py, a, b) {
-  let x = a[0];
-  let y = a[1];
-  let dx = b[0] - x;
-  let dy = b[1] - y;
-  if (dx !== 0 || dy !== 0) {
-    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
-    if (t > 1) {
-      x = b[0];
-      y = b[1];
-    } else if (t > 0) {
-      x += dx * t;
-      y += dy * t;
-    }
-  }
-  dx = px - x;
-  dy = py - y;
-  return dx * dx + dy * dy;
-}
-
-// src/modify/layers/public_transport.ts
-var polylabel2 = polylabel;
-function handleLayerPublicTransport(feature, options, logger) {
-  logger.trace({}, "HandlePublicTransport:Start");
-  const kind = options.layer.tags["kind"];
-  switch (kind) {
-    case "aerodrome":
-      feature = handleKindAerodrome(feature, logger);
-      break;
-  }
-  logger.trace({}, "HandlePublicTransport:End");
-  return feature;
-}
-function handleKindAerodrome(feature, logger) {
-  logger.trace({}, "HandleKindAerodrome:Start");
-  feature = structuredClone(feature);
-  const coordinates = getCoordinates(feature.geometry, logger);
-  const inaccessibilityPole = polylabel2(coordinates);
-  const point = { type: "Point", coordinates: inaccessibilityPole };
-  feature.geometry = point;
-  logger.trace({}, "HandleKindAerodrome:End");
-  return feature;
-}
-function getCoordinates(geometry, logger) {
-  switch (geometry.type) {
-    case "MultiPolygon":
-      return geometry.coordinates[0];
-    case "Polygon":
-      return geometry.coordinates;
-  }
-  logger.error({ type: geometry.type }, "Unsupported geometry type");
-  throw new Error("Unsupported geometry type");
-}
+// src/modify/shared.ts
+var poly = __toESM(require_polylabel(), 1);
 
 // src/modify/consts.ts
 var MajorHighWays = /* @__PURE__ */ new Set([
@@ -91321,19 +91301,22 @@ var MajorHighWays = /* @__PURE__ */ new Set([
 ]);
 
 // src/modify/shared.ts
+var polylabel = poly.default;
 function handleRoadFeature(feature, options, logger) {
   logger.trace({}, "HandleRoadFeature:Start");
   feature = structuredClone(feature);
   const highwayNum = feature.properties["hway_num"];
-  if (typeof highwayNum === "string") {
+  if (highwayNum != null && typeof highwayNum === "string") {
     const kind = "motorway";
     feature.properties["kind"] = kind;
     const ref = highwayNum;
     feature.properties["ref"] = ref;
     logger.trace({ kind, ref }, "new/overidden tags");
-    const minzoom = MajorHighWays.has(highwayNum) ? 2 : 8;
-    feature.tippecanoe.minzoom = minzoom;
-    logger.trace({ minzoom }, "overidden styles");
+    if (feature.tippecanoe.minzoom < 8) {
+      const minzoom = MajorHighWays.has(highwayNum) ? feature.tippecanoe.maxzoom : 8;
+      feature.tippecanoe.minzoom = minzoom;
+      logger.trace({ minzoom }, "overidden styles");
+    }
     logger.trace({}, "HandleRoadFeature:End");
     return feature;
   }
@@ -91351,6 +91334,60 @@ function handleRoadFeature(feature, options, logger) {
   logger.trace({}, "HandleRoadFeature:End");
   return feature;
 }
+function getInaccessibilityPole(geometry, logger) {
+  const coordinates = getCoordinates(geometry, logger);
+  const inaccessibilityPole = polylabel(coordinates);
+  return { type: "Point", coordinates: inaccessibilityPole };
+}
+function getCoordinates(geometry, logger) {
+  switch (geometry.type) {
+    case "MultiPolygon":
+      return geometry.coordinates[0];
+    case "Polygon":
+      return geometry.coordinates;
+  }
+  logger.error({ type: geometry.type }, "Unsupported geometry type");
+  throw new Error("Unsupported geometry type");
+}
+
+// src/modify/layers/pois.ts
+function handleLayerPois(feature, logger) {
+  logger.trace({}, "HandlePois:Start");
+  feature = structuredClone(feature);
+  if (feature.properties["building"] === "building") {
+    const bldgUse = feature.properties["bldg_use"];
+    if (bldgUse == null) {
+      logger.trace({}, "HandlePois:End");
+      return null;
+    }
+    feature.properties["building"] = bldgUse;
+    if (feature.geometry.type === "Polygon" || feature.geometry.type === "MultiPolygon") {
+      feature.geometry = getInaccessibilityPole(feature.geometry, logger);
+    }
+  }
+  logger.trace({}, "HandlePois:End");
+  return feature;
+}
+
+// src/modify/layers/public_transport.ts
+function handleLayerPublicTransport(feature, options, logger) {
+  logger.trace({}, "HandlePublicTransport:Start");
+  const kind = options.layer.tags["kind"];
+  switch (kind) {
+    case "aerodrome":
+      feature = handleKindAerodrome(feature, logger);
+      break;
+  }
+  logger.trace({}, "HandlePublicTransport:End");
+  return feature;
+}
+function handleKindAerodrome(feature, logger) {
+  logger.trace({}, "HandleKindAerodrome:Start");
+  feature = structuredClone(feature);
+  feature.geometry = getInaccessibilityPole(feature.geometry, logger);
+  logger.trace({}, "HandleKindAerodrome:End");
+  return feature;
+}
 
 // src/modify/layers/street_labels.ts
 function handleLayerStreetLabels(feature, options, logger) {
@@ -91416,9 +91453,9 @@ function handleKindTrack(feature, logger) {
   return feature;
 }
 
-// src/modify/layers/water_polygons.ts
+// src/modify/layers/water.ts
 var LargeLakeSize = 4e6;
-function handleLayerWaterPolygons(feature, options, logger) {
+function handleLayerWater(feature, options, logger) {
   logger.trace({}, "HandleWaterPolygons:Start");
   feature = structuredClone(feature);
   const kind = options.layer.tags["kind"];
@@ -91448,15 +91485,14 @@ function handleKindWater(feature, logger) {
     feature.properties["name"] = grpName;
     logger.trace({ name: grpName }, "new/overidden tags");
   }
-  let area = 0;
-  if (feature.geometry.type === "MultiPolygon") {
-    area = Area.multiPolygon(feature.geometry.coordinates);
-  } else if (feature.geometry.type === "Polygon") {
-    area = Area.polygon(feature.geometry.coordinates);
+  if (feature.properties["water"] === "lake") {
+    const aera = feature.properties["_derived_area"];
+    if (aera != null && Number(aera) >= LargeLakeSize) {
+      feature.tippecanoe.minzoom = 1;
+    } else {
+      feature.tippecanoe.minzoom = 9;
+    }
   }
-  const minzoom = area >= LargeLakeSize ? 1 : 9;
-  feature.tippecanoe.minzoom = minzoom;
-  logger.trace({ minzoom }, "overidden styles");
   logger.trace({}, "HandleKindWater:End");
   return feature;
 }
@@ -91465,7 +91501,7 @@ function handleKindRiver(feature, options, logger) {
   feature = structuredClone(feature);
   if (options.layer.style.minZoom < 11) {
     const name = feature.properties["name"];
-    if (name === "") {
+    if (name === "" && feature.tippecanoe.minzoom < 11) {
       const minzoom = 11;
       feature.tippecanoe.minzoom = minzoom;
       logger.trace({ minzoom }, "overidden styles");
@@ -91501,7 +91537,8 @@ function modifyFeature(feature, options, logger) {
       modifiedFeature = handleLayerStreets(feature, options, logger);
       break;
     case "water_polygons":
-      modifiedFeature = handleLayerWaterPolygons(feature, options, logger);
+    case "water_lines":
+      modifiedFeature = handleLayerWater(feature, options, logger);
       break;
     default:
       modifiedFeature = structuredClone(feature);
@@ -91510,6 +91547,17 @@ function modifyFeature(feature, options, logger) {
   return modifiedFeature;
 }
 
+// src/transform/nztm.ts
+function transformNdJson(feature) {
+  projectFeature(feature, Nztm2000QuadTms);
+}
+function transformZoom(z2, tileMatrix) {
+  if (tileMatrix.identifier === Nztm2000QuadTms.identifier)
+    return Math.max(0, z2 - 2);
+  else
+    return z2;
+}
+
 // src/util.ts
 var import_node_fs3 = require("fs");
 var import_fs4 = require("fs");
@@ -91626,7 +91674,7 @@ function simplify(points, tolerance, highestQuality) {
 }
 
 // src/generalization/generalization.ts
-async function generalize(input, output, options, logger) {
+async function generalize(input, output, tileMatrix, options, logger) {
   logger.info({}, "Generalize:Start");
   const fileStream = await createReadStreamSafe(input.pathname);
   const simplify2 = options.layer.simplify;
@@ -91640,20 +91688,23 @@ async function generalize(input, output, options, logger) {
   for await (const line of rl) {
     if (line === "")
       continue;
+    const feature = JSON.parse(line);
+    if (tileMatrix.identifier === "NZTM2000Quad")
+      transformNdJson(feature);
     inputCount++;
     if (simplify2 != null) {
       for (const s of simplify2) {
-        const feature = tag(options, line, s, logger);
-        if (feature == null)
+        const vectorGeofeature = tag(tileMatrix, options, feature, s, logger);
+        if (vectorGeofeature == null)
           continue;
-        writeStream.write(JSON.stringify(feature) + "\n");
+        writeStream.write(JSON.stringify(vectorGeofeature) + "\n");
         outputCount++;
       }
     } else {
-      const feature = tag(options, line, null, logger);
-      if (feature == null)
+      const vectorGeofeature = tag(tileMatrix, options, feature, null, logger);
+      if (vectorGeofeature == null)
         continue;
-      writeStream.write(JSON.stringify(feature) + "\n");
+      writeStream.write(JSON.stringify(vectorGeofeature) + "\n");
       outputCount++;
     }
   }
@@ -91667,36 +91718,40 @@ async function generalize(input, output, options, logger) {
   logger.info({ inputCount, outputCount }, "Generalize:End");
   return metrics;
 }
-function tag(options, line, simplify2, logger) {
-  const feature = {
-    ...JSON.parse(line),
+function tag(tileMatrix, options, feature, simplify2, logger) {
+  const vectorGeofeature = {
+    ...structuredClone(feature),
     tippecanoe: {
       layer: options.name,
       minzoom: options.layer.style.minZoom,
       maxzoom: options.layer.style.maxZoom
     }
   };
-  Object.entries(options.layer.tags).forEach(([key, value]) => feature.properties[key] = value);
-  const modifiedFeature = modifyFeature(feature, options, logger);
-  if (modifiedFeature == null) {
-    return null;
-  }
+  Object.entries(options.layer.tags).forEach(([key, value]) => vectorGeofeature.properties[key] = value);
   if (simplify2 != null) {
-    modifiedFeature["tippecanoe"] = {
+    vectorGeofeature["tippecanoe"] = {
       layer: options.name,
       minzoom: simplify2.style.minZoom,
       maxzoom: simplify2.style.maxZoom
     };
     if (simplify2.tolerance != null) {
-      const geom = modifiedFeature.geometry;
+      const geom = vectorGeofeature.geometry;
       const type = geom.type;
-      const coordinates = simplifyFeature(type, geom, simplify2.tolerance);
-      if (coordinates == null) {
+      const geometry = simplifyFeature(type, geom, simplify2.tolerance);
+      if (geometry == null) {
         return null;
       }
-      modifiedFeature.geometry = coordinates;
+      vectorGeofeature.geometry = geometry;
     }
   }
+  const modifiedFeature = modifyFeature(vectorGeofeature, options, logger);
+  if (modifiedFeature == null) {
+    return null;
+  }
+  if (modifiedFeature.tippecanoe.maxzoom < modifiedFeature.tippecanoe.minzoom)
+    return null;
+  modifiedFeature.tippecanoe.minzoom = transformZoom(modifiedFeature.tippecanoe.minzoom, tileMatrix);
+  modifiedFeature.tippecanoe.maxzoom = transformZoom(modifiedFeature.tippecanoe.maxzoom, tileMatrix);
   const cleanedFeature = removeAttributes(modifiedFeature, options);
   return cleanedFeature;
 }
@@ -91979,32 +92034,54 @@ var CommandExecution = class {
 };
 
 // src/transform/ogr2ogr.ts
-async function ogr2ogrNDJson(input, output, logger) {
+async function ogr2ogrNDJson(input, output, layer, logger) {
   const cmd = Command.create("ogr2ogr");
   cmd.args.push("-f", "GeoJSONSeq");
   cmd.args.push(output.pathname);
   cmd.args.push("-t_srs", Epsg.Wgs84.toEpsgString());
+  if (layer.includeDerivedArea) {
+    const table = await getTableName(input, logger);
+    cmd.args.push("-dialect", "SQLite");
+    cmd.args.push("-sql", `SELECT *, ST_Area(geom) AS _derived_area FROM "${table}"`);
+  }
+  cmd.args.push(input.pathname);
+  const res = await cmd.run();
+  if (res.exitCode !== 0) {
+    logger.fatal({ Gdal: res }, "Failure");
+    throw new Error("Gdal failed to run");
+  }
+}
+async function getTableName(input, logger) {
+  const cmd = Command.create("ogrinfo");
+  cmd.args.push("-ro");
+  cmd.args.push("-q");
+  cmd.args.push("-json");
   cmd.args.push(input.pathname);
   const res = await cmd.run();
   if (res.exitCode !== 0) {
     logger.fatal({ Gdal: res }, "Failure");
     throw new Error("Gdal failed to run");
   }
+  const info = JSON.parse(res.stdout);
+  if (info.layers == null || info.layers.length === 0) {
+    throw new Error(`No layers found in ${input.pathname}`);
+  }
+  return info.layers[0].name;
 }
 
 // src/transform/tippecanoe.ts
 var import_path2 = __toESM(require("path"), 1);
-async function tippecanoe(input, output, layer, logger) {
+async function tippecanoe(input, output, layer, tileMatrix, logger) {
   const cmd = Command.create("tippecanoe");
   cmd.args.push("--read-parallel");
   cmd.args.push("-s", Epsg.Wgs84.toEpsgString());
   if (layer.style != null) {
-    cmd.args.push(`-Z${layer.style.minZoom}`);
-    cmd.args.push(`-z${layer.style.maxZoom}`);
+    cmd.args.push(`-Z${transformZoom(layer.style.minZoom, tileMatrix)}`);
+    cmd.args.push(`-z${transformZoom(layer.style.maxZoom, tileMatrix)}`);
     if (layer.style.detail != null)
       cmd.args.push(`--full-detail=${layer.style.detail}`);
   } else {
-    cmd.args.push(`-z15`);
+    cmd.args.push(`-z${transformZoom(15, tileMatrix)}`);
   }
   cmd.mount((0, import_path2.dirname)(input.pathname));
   cmd.mount((0, import_path2.dirname)(output.pathname));
@@ -92140,16 +92217,19 @@ async function createMbtilesFile({ stac, tmpPaths }, logger) {
     throw new Error(`Stac file missing linz_basemaps:options ${stac.id}`);
   const layer = options.layer;
   const shortbreadLayer = options.name;
+  const tileMatrix = TileMatrixSets.find(options.tileMatrix);
+  if (tileMatrix == null)
+    throw new Error(`Tile matrix ${options.tileMatrix} is not supported`);
   logger.info({ shortbreadLayer, dataset: layer.name }, "CreateMbtilesFile: Start");
   logger.info({ source: tmpPaths.source.path, dataset: layer.name }, "[1/5] Convert source file to ndjson: Start");
   if (!await Fsa.exists(tmpPaths.ndjson)) {
-    await ogr2ogrNDJson(tmpPaths.source.path, tmpPaths.ndjson, logger);
+    await ogr2ogrNDJson(tmpPaths.source.path, tmpPaths.ndjson, layer, logger);
   }
   logger.info({ destination: tmpPaths.ndjson, dataset: layer.name }, "[1/5] Convert source file to ndjson: End");
   logger.info({ source: tmpPaths.ndjson, dataset: layer.name }, "[2/5] Generalise ndjson features: Start");
   let metrics = null;
   if (!await Fsa.exists(tmpPaths.genNdjson)) {
-    metrics = await generalize(tmpPaths.ndjson, tmpPaths.genNdjson, options, logger);
+    metrics = await generalize(tmpPaths.ndjson, tmpPaths.genNdjson, tileMatrix, options, logger);
     if (metrics.output === 0)
       throw new Error(`Failed to generalize ndjson file ${tmpPaths.ndjson.href}`);
   }
@@ -92159,7 +92239,7 @@ async function createMbtilesFile({ stac, tmpPaths }, logger) {
     "[3/5] Transform generalised ndjson into mbtiles: Start"
   );
   if (!await Fsa.exists(tmpPaths.mbtiles)) {
-    await tippecanoe(tmpPaths.genNdjson, tmpPaths.mbtiles, layer, logger);
+    await tippecanoe(tmpPaths.genNdjson, tmpPaths.mbtiles, layer, tileMatrix, logger);
   }
   logger.info(
     { destination: tmpPaths.mbtiles, dataset: layer.name },
@@ -93154,7 +93234,7 @@ async function upload(file, bucketPath, logger) {
   if (path4.protocol === "file:")
     await (0, import_promises.mkdir)((0, import_path3.dirname)(path4.pathname), { recursive: true });
   if (filename.endsWith("catalog.json"))
-    path4 = new URL(filename, bucketPath);
+    path4 = new URL(`topographic/${filename}`, bucketPath);
   await Fsa.write(path4, stream);
   logger.info({ file, path: path4 }, "Load:Finish");
   return path4;
@@ -93234,7 +93314,7 @@ var JoinCommand = (0, import_cmd_ts4.command)({
     }
     if (isArgo()) {
       const target = new URL(`topographic/${CliId}/${args.filename}.tar.co`, bucketPath);
-      await Fsa.write(Fsa.toUrl("/tmp/target"), JSON.stringify([target]));
+      await Fsa.write(Fsa.toUrl("/tmp/target"), urlToString(target));
       const mbTilesTarget = new URL(`topographic/${CliId}/${args.filename}.mbtiles`, bucketPath);
       await Fsa.write(Fsa.toUrl("/tmp/mbTilesTarget"), mbTilesTarget.toString());
       const analyseTarget = new URL(`topographic/${CliId}/`, bucketPath);
@@ -93789,7 +93869,7 @@ var AnalyseCommand = (0, import_cmd_ts5.command)({
             y: row.y,
             z: row.z,
             max: buffer.length,
-            link: `https://basemaps.linz.govt.nz/v1/tiles/topographic/WebMercatorQuad/${row.z}/${row.z}/${row.y}.pbf`
+            link: `https://basemaps.linz.govt.nz/v1/tiles/topographic/WebMercatorQuad/${row.z}/${row.x}/${row.y}.pbf`
           };
         const dis = distribution(buffer.length);
         const value = distributionSum.get(dis);