@basemaps/cli-raster 8.9.0 → 8.11.1

package/dist/index.cjs

@@ -4554,7 +4554,7 @@ var require_oneOf = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.oneOf = void 0;
     var util_1 = require("util");
-    function oneOf4(literals) {
+    function oneOf3(literals) {
       const examples = literals.map((x) => (0, util_1.inspect)(x)).join(", ");
       return {
         async from(str) {
@@ -4567,7 +4567,7 @@ var require_oneOf = __commonJS({
         description: `One of ${examples}`
       };
     }
-    exports.oneOf = oneOf4;
+    exports.oneOf = oneOf3;
   }
 });
 
@@ -75271,9 +75271,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.9.0",
-  hash: "55cd25b9f2c402fde88fcef9c43cec3f8eca9e60",
-  buildId: "17570995768-1"
+  version: "v8.14.0",
+  hash: "eb807c6d0f091b41e4d6d972b77c24f584cec230",
+  buildId: "18453645562-1"
 };
 var CliDate = (/* @__PURE__ */ new Date()).toISOString();
 var CliId = ulid2.ulid();
@@ -79554,6 +79554,12 @@ var DefaultColorRampOutput = {
   // Taken from 0 of DefaultColorRamp
   background: { r: 172, g: 204, b: 226, alpha: 1 }
 };
+var DefaultBandExpandOutput = {
+  title: "Gray",
+  name: "expand",
+  pipeline: [{ type: "color-ramp" }],
+  background: { r: 255, g: 255, b: 255, alpha: 1 }
+};
 
 // ../config/build/config/tile.set.pipeline.js
 var ConfigImageFormatParser = z.union([
@@ -79563,15 +79569,39 @@ var ConfigImageFormatParser = z.union([
   z.literal("avif")
 ]);
 var ConfigResizeKernelParser = z.union([z.literal("nearest"), z.literal("lanczos3"), z.literal("lanczos2")]);
-var ConfigTileSetPipelineParser = z.object({
-  /**
-   * type of pipeline function
-   *
-   * @example "terrain-rgb"
-   */
-  type: z.string()
-  // TODO allow custom arguments
+var ColorParser = z.object({
+  r: z.number(),
+  g: z.number(),
+  b: z.number(),
+  alpha: z.number()
 });
+var PipelineTerrainRgbParser = z.object({ type: z.literal("terrain-rgb") });
+var PipelineColorRampParser = z.object({ type: z.literal("color-ramp"), ramp: z.string().optional() });
+var PipelineNdviParser = z.object({
+  type: z.literal("ndvi"),
+  nir: z.number(),
+  r: z.number(),
+  alpha: z.number(),
+  scale: z.object({
+    nir: z.number(),
+    r: z.number(),
+    alpha: z.number()
+  }).optional()
+});
+var PipelineExtractParser = z.object({
+  type: z.literal("extract"),
+  r: z.number(),
+  g: z.number(),
+  b: z.number(),
+  alpha: z.number(),
+  scale: ColorParser.optional()
+});
+var ConfigTileSetPipelineParser = z.discriminatedUnion("type", [
+  PipelineExtractParser,
+  PipelineTerrainRgbParser,
+  PipelineColorRampParser,
+  PipelineNdviParser
+]);
 var ConfigRgbaParser = z.object({ r: z.number(), g: z.number(), b: z.number(), alpha: z.number() });
 var ConfigTileSetOutputParser = z.object({
   /**
@@ -79620,6 +79650,20 @@ var ConfigTileSetOutputParser = z.object({
 // ../config/build/memory/memory.config.js
 var import_ulid2 = __toESM(require_index_umd(), 1);
 
+// ../config/build/config/migration/imagery.js
+function migrateConfigImagery(img) {
+  if (img.v === 2)
+    return img;
+  return {
+    ...img,
+    v: 2,
+    title: img.title ?? img.name,
+    bands: (img.bands ?? []).map((m) => {
+      return { type: m };
+    })
+  };
+}
+
 // ../config/build/name.convertor.js
 function fixChunkGsd(chunk) {
   if (!chunk.endsWith("m"))
@@ -79666,6 +79710,100 @@ function standardizeLayerName(name) {
   return output.join("-");
 }
 
+// ../config/build/memory/imagery.outputs.js
+function addDefaultOutputPipelines(ts, img) {
+  if (ts.outputs != null)
+    return ts.outputs;
+  if (img.bands == null || img.bands.length === 0)
+    return void 0;
+  if (img.bands.length === 1) {
+    if (img.bands[0].color === "gray")
+      return [DefaultBandExpandOutput];
+    return [DefaultTerrainRgbOutput, DefaultColorRampOutput];
+  }
+  const colors = { red: -1, green: -1, blue: -1, nir: -1, alpha: -1 };
+  for (let i = 0; i < img.bands.length; i++) {
+    const band = img.bands[i];
+    if (band.color)
+      colors[band.color] = i;
+  }
+  if (img.bands.length === 3 && colors.red >= 0 && colors.green >= 0 && colors.blue >= 0)
+    return;
+  if (img.bands.length === 4 && colors.red >= 0 && colors.green >= 0 && colors.blue >= 0 && colors.alpha >= 0)
+    return;
+  const pipelines = [];
+  if (colors.red >= 0 && colors.green >= 0 && colors.blue >= 0) {
+    const rgbExtract = {
+      type: "extract",
+      r: colors.red,
+      g: colors.green,
+      b: colors.blue,
+      alpha: colors.alpha
+    };
+    const pipeline2 = { name: "rgb", title: "RGBA", pipeline: [rgbExtract] };
+    rgbExtract.scale = getBandScales(img.bands, rgbExtract);
+    pipelines.push(pipeline2);
+  }
+  if (colors.nir >= 0 && colors.red >= 0) {
+    const ndviArgs = { type: "ndvi", r: colors.red, nir: colors.nir, alpha: colors.alpha };
+    const scale = {
+      r: getScale(img.bands[colors.red], "red"),
+      nir: getScale(img.bands[colors.nir], "nir"),
+      alpha: getAlphaScale(img.bands[colors.alpha])
+    };
+    if (scale.r && scale.nir && scale.alpha)
+      ndviArgs.scale = scale;
+    pipelines.push({
+      name: "ndvi",
+      title: "NDVI",
+      pipeline: [ndviArgs]
+    });
+  }
+  if (colors.red >= 0 && colors.green >= 0 && colors.nir >= 0) {
+    const falseColorExtract = {
+      type: "extract",
+      r: colors.nir,
+      g: colors.red,
+      b: colors.green,
+      alpha: colors.alpha
+    };
+    const pipeline2 = { name: "false-color", title: "FalseColor", pipeline: [falseColorExtract] };
+    falseColorExtract.scale = getBandScales(img.bands, falseColorExtract);
+    pipelines.push(pipeline2);
+  }
+  if (pipelines.length > 0)
+    return pipelines;
+  return void 0;
+}
+function getBandScales(bands, pipe) {
+  const scale = {
+    r: getScale(bands[pipe.r], "red"),
+    g: getScale(bands[pipe.g], "green"),
+    b: getScale(bands[pipe.b], "blue"),
+    alpha: getAlphaScale(bands[pipe.alpha])
+  };
+  if (scale.r && scale.g && scale.b && scale.alpha)
+    return scale;
+  return void 0;
+}
+function getScale(band, color) {
+  if (band.type === "uint8")
+    return void 0;
+  if (band.stats == null)
+    return void 0;
+  const stdDevs = color === "nir" ? 3 : 3;
+  return Math.round(band.stats.mean + stdDevs * band.stats.stddev);
+}
+function getAlphaScale(band) {
+  if (band == null)
+    return void 0;
+  if (band.type === "uint8")
+    return void 0;
+  if (band.stats == null)
+    return void 0;
+  return Math.round(band.stats.max);
+}
+
 // ../config/build/memory/memory.config.js
 function isConfigImagery(i) {
   return ConfigId.getPrefix(i.id) === ConfigPrefix.Imagery;
@@ -79769,14 +79907,14 @@ var ConfigProviderMemory = class _ConfigProviderMemory extends BasemapsConfigPro
   }
   toJson() {
     const cfg = {
+      v: 2,
       id: "",
       hash: "",
       assets: this.assets,
       imagery: [],
       style: [],
       provider: [],
-      tileSet: [],
-      duplicateImagery: this.duplicateImagery
+      tileSet: []
     };
     for (const val2 of this.objects.values()) {
       const prefix = val2.id.slice(0, val2.id.indexOf("_"));
@@ -79833,6 +79971,8 @@ var ConfigProviderMemory = class _ConfigProviderMemory extends BasemapsConfigPro
       const tileSet = this.objects.get(this.TileSet.id(l.name));
       if (tileSet.outputs)
         continue;
+      if (tileSet.category === "Charts")
+        continue;
       const newLayer = { ...l, minZoom: 32 };
       delete newLayer.maxZoom;
       layerByName.set(newLayer.name, { ...layerByName.get(l.name), ...newLayer });
@@ -79867,9 +80007,9 @@ var ConfigProviderMemory = class _ConfigProviderMemory extends BasemapsConfigPro
       };
       removeUndefined(existing);
       this.put(existing);
-      if (i.bands?.length === 1) {
-        existing.outputs = [DefaultTerrainRgbOutput, DefaultColorRampOutput];
-      }
+      const outputs = addDefaultOutputPipelines(existing, i);
+      if (outputs != null)
+        existing.outputs = outputs;
     }
     const existingImageryId = existing.layers[0][i.projection];
     if (existingImageryId) {
@@ -79895,9 +80035,9 @@ var ConfigProviderMemory = class _ConfigProviderMemory extends BasemapsConfigPro
       background: { r: 0, g: 0, b: 0, alpha: 0 },
       updatedAt: Date.now()
     };
-    if (i.bands?.length === 1) {
-      ts.outputs = [DefaultTerrainRgbOutput, DefaultColorRampOutput];
-    }
+    const outputs = addDefaultOutputPipelines(ts, i);
+    if (outputs != null)
+      ts.outputs = outputs;
     return ts;
   }
   /** Load a bundled configuration creating virtual tilesets for all imagery */
@@ -79912,8 +80052,10 @@ var ConfigProviderMemory = class _ConfigProviderMemory extends BasemapsConfigPro
       mem.put(st);
     for (const pv of cfg.provider)
       mem.put(pv);
-    for (const img of cfg.imagery)
-      mem.put(img);
+    for (const img of cfg.imagery) {
+      const parsed = migrateConfigImagery(img);
+      mem.put(parsed);
+    }
     const updatedAt = (0, import_ulid2.decodeTime)(ConfigId.unprefix(ConfigPrefix.ConfigBundle, cfg.id));
     for (const obj of mem.objects.values())
       obj.updatedAt = updatedAt;
@@ -81314,6 +81456,13 @@ var Env = {
     /** Index to use for storing analytic data */
     ElasticIndexName: "ELASTIC_INDEX_NAME"
   },
+  /** Load a environment variable throw a exception if the value is empty */
+  getRequired(envName) {
+    const value = Env.get(envName);
+    if (value == null || value === "")
+      throw new Error(`Missing env $${envName}`);
+    return value;
+  },
   /** Load a environment var defaulting to defaultOutput if it does not exist  */
   get(envName) {
     return process.env[envName];
@@ -81925,11 +82074,11 @@ var Bounds = class _Bounds {
 
 // ../geo/build/epsg.js
 var EpsgCode;
-(function(EpsgCode4) {
-  EpsgCode4[EpsgCode4["Google"] = 3857] = "Google";
-  EpsgCode4[EpsgCode4["Wgs84"] = 4326] = "Wgs84";
-  EpsgCode4[EpsgCode4["Nztm2000"] = 2193] = "Nztm2000";
-  EpsgCode4[EpsgCode4["Citm2000"] = 3793] = "Citm2000";
+(function(EpsgCode3) {
+  EpsgCode3[EpsgCode3["Google"] = 3857] = "Google";
+  EpsgCode3[EpsgCode3["Wgs84"] = 4326] = "Wgs84";
+  EpsgCode3[EpsgCode3["Nztm2000"] = 2193] = "Nztm2000";
+  EpsgCode3[EpsgCode3["Citm2000"] = 3793] = "Citm2000";
 })(EpsgCode || (EpsgCode = {}));
 var EpsgText = {
   google: EpsgCode.Google,
@@ -85274,7 +85423,7 @@ function getTiffTagSize(fieldType) {
     case TiffTagValueType.Ifd8:
       return 8;
     default:
-      throw new Error(`Invalid fieldType ${fieldType}`);
+      throw new Error(`Invalid fieldType ${String(fieldType)}`);
   }
 }
 
@@ -85448,10 +85597,14 @@ async function getValueAt(tiff, tag, index) {
     const bytes = await tiff.source.fetch(tag.dataOffset + index * dataTypeSize, dataTypeSize);
     const view = new DataView(bytes);
     const value2 = readValue(tiff, void 0, view, 0, tag.dataType, 1);
+    if (typeof value2 !== "number")
+      throw new Error("Value is not a number");
     tag.value[index] = value2;
     return value2;
   }
   const value = readValue(tiff, void 0, tag.view, index * dataTypeSize, tag.dataType, 1);
+  if (typeof value !== "number")
+    throw new Error("Value is not a number");
   tag.value[index] = value;
   return value;
 }
@@ -86219,8 +86372,6 @@ var Tiff = class _Tiff {
     const endian = bytes.getUint16(offset, this.isLittleEndian);
     offset += 2;
     this.isLittleEndian = endian === TiffEndian.Little;
-    if (!this.isLittleEndian)
-      throw new Error("Only little endian is supported");
     this.version = bytes.getUint16(offset, this.isLittleEndian);
     offset += 2;
     let nextOffsetIfd;
@@ -86240,7 +86391,7 @@ var Tiff = class _Tiff {
       nextOffsetIfd = getUint(bytes, offset, this.ifdConfig.pointer, this.isLittleEndian);
       offset += this.ifdConfig.pointer;
     } else {
-      throw new Error(`Only tiff supported version:${this.version}`);
+      throw new Error(`Only tiff supported version:${String(this.version)}`);
     }
     const ghostSize = nextOffsetIfd - offset;
     if (ghostSize > 0 && ghostSize < 16 * 1024) {
@@ -86254,7 +86405,7 @@ var Tiff = class _Tiff {
         lastView = new DataView(bytes2);
         lastView.sourceOffset = nextOffsetIfd;
       }
-      nextOffsetIfd = await this.readIfd(nextOffsetIfd, lastView);
+      nextOffsetIfd = this.readIfd(nextOffsetIfd, lastView);
     }
     await Promise.all(this.images.map((i) => i.init()));
     this.isInitialized = true;
@@ -86266,7 +86417,7 @@ var Tiff = class _Tiff {
    * @param offset file offset to read the header from
    * @param view offset that contains the bytes for the header
    */
-  async readIfd(offset, view) {
+  readIfd(offset, view) {
     const viewOffset = offset - view.sourceOffset;
     const tagCount = getUint(view, viewOffset, this.ifdConfig.offset, this.isLittleEndian);
     const tags = /* @__PURE__ */ new Map();
@@ -86720,17 +86871,59 @@ var lzw = {
     overviewResampling: "bilinear"
   }
 };
+var zstd_17 = {
+  name: "zstd_17",
+  options: {
+    blockSize: 512,
+    compression: "zstd",
+    predictor: 2,
+    level: 17,
+    warpResampling: "bilinear",
+    overviewResampling: "lanczos"
+  }
+};
 var Presets = {
   [webP.name]: webP,
   [webP80.name]: webP80,
   [lerc1mm.name]: lerc1mm,
   [lerc10mm.name]: lerc10mm,
-  [lzw.name]: lzw
+  [lzw.name]: lzw,
+  [zstd_17.name]: zstd_17
+};
+var BandPresets = {
+  /**
+   * 4 band image, generally [uint8,uint8,uint8,uint8]
+   * - Red,Green,Blue,Alpha
+   */
+  rgba: ["red", "green", "blue", "alpha"],
+  /**
+   * 4 Band image, generally [uint8/16,uint8/16,uint8/16,uint8/16]
+   * - Red,Green,Blue,Near Infrared
+   */
+  rgbi: ["red", "green", "blue", "nir", "alpha"],
+  rgbna: ["red", "green", "blue", "nir", "alpha"],
+  /**
+   * One band image, generally [float32]
+   */
+  elevation: ["undefined"],
+  /** One band image, generally 0-255 greyscale */
+  hillshade: ["gray"]
+};
+var allPresets = Object.keys(BandPresets);
+var AllowedPresets = {
+  // Webp is only suitable for RGB(A) images
+  [webP.name]: ["rgba"],
+  [webP80.name]: ["rgba"],
+  [lerc1mm.name]: allPresets,
+  [lerc10mm.name]: allPresets,
+  [lzw.name]: allPresets,
+  [zstd_17.name]: allPresets
 };
 
 // src/cogify/gdal/gdal.command.ts
 var isPowerOfTwo = (x) => (x & x - 1) === 0;
-var DefaultTrimPixelRight = 1.7;
+var PixelTrimTop = 1;
+var PixelTrimRight = 4;
 function gdalBuildVrt(targetVrt, source, addalpha) {
   if (source.length === 0)
     throw new Error("No source files given for :" + targetVrt.href);
@@ -86751,8 +86944,6 @@ function gdalBuildVrtWarp(targetVrt, sourceVrt, sourceProjection, cutline, opt)
     args: [
       ["-of", "vrt"],
       // Output as a VRT
-      // ['-co', 'compress=lzw'],
-      // ['-co', 'bigtiff=yes'],
       "-multi",
       // Mutithread IO
       ["-wo", "NUM_THREADS=ALL_CPUS"],
@@ -86769,6 +86960,24 @@ function gdalBuildVrtWarp(targetVrt, sourceVrt, sourceProjection, cutline, opt)
     ].filter((f) => f != null).flat().map(String)
   };
 }
+function getCompressionArgs(cfg) {
+  if (cfg.compression === "lerc") {
+    return [
+      ["-co", `MAX_Z_ERROR=${cfg.maxZError}`],
+      ["-co", `MAX_Z_ERROR_OVERVIEW=${cfg.maxZErrorOverview}`]
+    ];
+  }
+  if (cfg.compression === "zstd") {
+    return [cfg.predictor ? ["-co", `PREDICTOR=${cfg.predictor}`] : [], ["-co", `LEVEL=${cfg.level}`]];
+  }
+  if (cfg.compression === "webp" || cfg.compression === "jpeg") {
+    return [["-co", `QUALITY=${cfg.quality}`]];
+  }
+  if (cfg.compression === "lzw") {
+    return [cfg.predictor ? ["-co", `PREDICTOR=${cfg.predictor}`] : []];
+  }
+  throw new Error("Unknown compression preset:" + String(cfg["compression"]));
+}
 function gdalBuildCog(targetTiff, sourceVrt, opt) {
   const cfg = { ...Presets[opt.preset], ...opt };
   const tileMatrix = TileMatrixSets.find(cfg.tileMatrix);
@@ -86789,8 +86998,6 @@ function gdalBuildCog(targetTiff, sourceVrt, opt) {
       ["-of", "COG"],
       ["-co", "NUM_THREADS=ALL_CPUS"],
       // Use all CPUS
-      ["--config", "GDAL_NUM_THREADS", "all_cpus"],
-      // Also required to NUM_THREADS till gdal 3.7.x
       ["-co", "BIGTIFF=IF_NEEDED"],
       // BigTiff is somewhat slower and most (All?) of the COGS should be well below 4GB
       ["-co", "ADD_ALPHA=YES"],
@@ -86800,16 +87007,15 @@ function gdalBuildCog(targetTiff, sourceVrt, opt) {
        */
       ["-co", "OVERVIEWS=IGNORE_EXISTING"],
       ["-co", `BLOCKSIZE=${cfg.blockSize}`],
-      // ['-co', 'RESAMPLING=cubic'],
       ["-co", `WARP_RESAMPLING=${cfg.warpResampling}`],
       ["-co", `OVERVIEW_RESAMPLING=${cfg.overviewResampling}`],
       ["-co", `COMPRESS=${cfg.compression}`],
-      cfg.quality ? ["-co", `QUALITY=${cfg.quality}`] : void 0,
-      cfg.maxZError ? ["-co", `MAX_Z_ERROR=${cfg.maxZError}`] : void 0,
-      cfg.maxZErrorOverview ? ["-co", `MAX_Z_ERROR_OVERVIEW=${cfg.maxZErrorOverview}`] : void 0,
+      ...getCompressionArgs(cfg),
+      cfg.presetBands ? ["-colorinterp", cfg.presetBands.join(",")] : void 0,
       ["-co", "SPARSE_OK=YES"],
       ["-co", `TARGET_SRS=${tileMatrix.projection.toEpsgString()}`],
       ["-co", `EXTENT=${tileExtent.join(",")},`],
+      ["-stats"],
       ["-tr", targetResolution, targetResolution],
       urlToString(sourceVrt),
       urlToString(targetTiff)
@@ -86854,7 +87060,7 @@ function gdalBuildTopoRasterCommands(targetTiff, sourceVrt, opt, width, height)
       // Force stats (re)computation
       ["-of", "COG"],
       // Output format
-      ["-srcwin", "0", "0", `${width - DefaultTrimPixelRight}`, `${height}`],
+      ["-srcwin", 0, PixelTrimTop, width - PixelTrimRight, height - PixelTrimTop],
       ["-a_srs", `EPSG:${opt.sourceEpsg}`],
       // https://gdal.org/en/latest/drivers/raster/cog.html#creation-options
       ["-co", "BIGTIFF=NO"],
@@ -86886,7 +87092,9 @@ function gdalBuildChartsCommand(target, source, cutline, tileMatrix) {
       "-multi",
       ["-wo", "NUM_THREADS=ALL_CPUS"],
       ["-t_srs", tileMatrix.projection.toEpsgString()],
-      "-dstalpha",
+      ["-b", "1", "-b", "2", "-b", "3"],
+      // Drop dummy band 4 if it exists
+      ["-dstalpha"],
       ["-cutline", urlToString(cutline)],
       ["-crop_to_cutline"],
       ["-co", "BIGTIFF=NO"],
@@ -86903,7 +87111,7 @@ var import_events = require("events");
 var import_path = require("path");
 function getDockerContainer() {
   const containerPath = process.env["GDAL_DOCKER_CONTAINER"] ?? "ghcr.io/osgeo/gdal";
-  const tag = process.env["GDAL_DOCKER_CONTAINER_TAG"] ?? "ubuntu-small-3.8.0";
+  const tag = process.env["GDAL_DOCKER_CONTAINER_TAG"] ?? "ubuntu-small-3.11.3";
   return `${containerPath}:${tag}`;
 }
 function toDockerArgs(cmd) {
@@ -87095,13 +87303,6 @@ var ChartsCreationCommand = (0, import_cmd_ts2.command)({
       long: "target",
       description: "Target location for the output files"
     }),
-    tileMatrix: (0, import_cmd_ts2.option)({
-      type: (0, import_cmd_ts2.oneOf)([Nztm2000QuadTms.identifier, GoogleTms.identifier]),
-      long: "tile-matrix",
-      description: `Output TileMatrix to use. Either: ${Nztm2000QuadTms.identifier}, or ${GoogleTms.identifier}.`,
-      defaultValue: () => GoogleTms.identifier,
-      defaultValueIsSerializable: true
-    }),
     cutline: (0, import_cmd_ts2.option)({
       type: UrlFolder,
       long: "cutline",
@@ -87129,9 +87330,6 @@ var ChartsCreationCommand = (0, import_cmd_ts2.command)({
     const logger = getLogger(this, args, "cli-raster");
     logger.info("Charts:Start");
     const files = args.source ? await Fsa.toArray(Fsa.list(args.source)) : args.paths;
-    const tileMatrix = TileMatrixSets.find(args.tileMatrix);
-    if (tileMatrix == null)
-      throw new Error(`Tile matrix ${args.tileMatrix} is not supported`);
     await (0, import_promises.mkdir)(tmpFolder, { recursive: true });
     const outputs = /* @__PURE__ */ new Set();
     const toProcess = files.map(
@@ -87150,39 +87348,15 @@ var ChartsCreationCommand = (0, import_cmd_ts2.command)({
         }
         const sourceTiff = await downloadCharts(file, filename, logger);
         const cutline = await downloadCutlines(new import_url2.URL(args.cutline.href), chartCode, logger);
-        logger.info({ file: file.href, tileMatrix: tileMatrix.identifier, chartCode }, "Charts:Processing");
+        logger.info({ file: file.href, chartCode }, "Charts:Processing");
         const tiff = await new Tiff(Fsa.source(file)).init();
         const backUpUrl = new import_url2.URL(filename, args.backup);
         const metadata = await fetchMetadata(tiff, backUpUrl, logger);
-        const bufferedCutline = await prepareCutline(
-          cutline,
-          chartCode,
-          tileMatrix,
-          metadata.gsd,
-          args.bufferPixels,
-          logger
-        );
-        const { item, collection } = await createStacFiles(
-          chartCode,
-          tileMatrix,
-          metadata,
-          cutline,
-          bufferedCutline,
-          logger
-        );
-        logger.info({ file: file.href, chartCode, tileMatrix: tileMatrix.identifier }, "Charts:GdalBuildCharts");
-        const cogFile = new import_url2.URL(`${chartCode}-${tileMatrix.identifier}.tif`, tmpFolder);
-        await new GdalRunner(gdalBuildChartsCommand(cogFile, sourceTiff, bufferedCutline, tileMatrix)).run(logger);
-        const targetPath = new import_url2.URL(`${tileMatrix.projection.code}/${chartCode}/`, args.target);
-        logger.info({ file: file.href, target: targetPath.href }, "Charts:Uploading");
+        const bufferedCutline = await prepareCutline(cutline, chartCode, metadata.gsd, args.bufferPixels, logger);
+        const targetPath = new import_url2.URL(`${GoogleTms.projection.code}/${CliId}/${chartCode}/`, args.target);
         if (targetPath.protocol === "file:")
           await (0, import_promises.mkdir)(targetPath, { recursive: true });
-        const targetTiff = new import_url2.URL(filename, targetPath);
-        await Fsa.write(targetTiff, Fsa.readStream(cogFile));
-        const targetItem = new import_url2.URL(`${chartCode}.json`, targetPath);
-        await Fsa.write(targetItem, JSON.stringify(item, null, 2));
-        const targetCollection = new import_url2.URL("collection.json", targetPath);
-        await Fsa.write(targetCollection, JSON.stringify(collection, null, 2));
+        await createCogs(sourceTiff, cutline, chartCode, bufferedCutline, metadata, targetPath, logger);
         outputs.add(urlToString(targetPath));
         await tiff.source.close?.();
       })
@@ -87215,17 +87389,17 @@ async function downloadCutlines(cutline, chartCode, logger) {
   }
   return new import_url2.URL(`${chartCode}.shp`, tmpFolder);
 }
-async function prepareCutline(cutline, chartCode, tileMatrix, gsd, bufferPixels, logger) {
+async function prepareCutline(cutline, chartCode, gsd, bufferPixels, logger) {
   logger.info({ cutline: cutline.href, chartCode }, "Charts:WrapCutline");
   const wrappedCutline = new import_url2.URL(`${chartCode}-wrapped.shp`, tmpFolder);
   await new GdalRunner(wrapCutline(wrappedCutline, cutline)).run(logger);
-  logger.info({ cutline: cutline.href, chartCode, tileMatrix: tileMatrix.identifier }, "Charts:ReprojectCutline");
-  const reprojectedCutline = new import_url2.URL(`${chartCode}-${tileMatrix.identifier}.shp`, tmpFolder);
-  await new GdalRunner(reprojectCutline(reprojectedCutline, wrappedCutline, tileMatrix)).run(logger);
+  logger.info({ cutline: cutline.href, chartCode, tileMatrix: GoogleTms.identifier }, "Charts:ReprojectCutline");
+  const reprojectedCutline = new import_url2.URL(`${chartCode}-${GoogleTms.identifier}.shp`, tmpFolder);
+  await new GdalRunner(reprojectCutline(reprojectedCutline, wrappedCutline, GoogleTms)).run(logger);
   logger.info({ cutline: cutline.href, chartCode, gsd, bufferPixels }, "Charts:BufferCutline");
   const bufferedCutline = new import_url2.URL(`${chartCode}-buffered.geojson`, tmpFolder);
   await new GdalRunner(
-    bufferCutline(bufferedCutline, reprojectedCutline, `${chartCode}-${tileMatrix.identifier}`, gsd, bufferPixels)
+    bufferCutline(bufferedCutline, reprojectedCutline, `${chartCode}-${GoogleTms.identifier}`, gsd, bufferPixels)
   ).run(logger);
   return bufferedCutline;
 }
@@ -87276,9 +87450,9 @@ function geojsonToBbox(geojson) {
     throw new Error("No union found in GeoJSON features");
   return union2.toBbox();
 }
-async function createStacFiles(chartCode, tileMatrix, metadata, sourceCutline, bufferedCutline, logger) {
+async function createStacItem(chartCode, metadata, sourceCutline, cutline, logger) {
+  const geojson = await Fsa.readJson(cutline);
   logger.info({ chartCode }, "Charts:CreateStacItem");
-  const geojson = await Fsa.readJson(bufferedCutline);
   const item = {
     id: `${CliId}/${chartCode}`,
     type: "Feature",
@@ -87305,9 +87479,9 @@ async function createStacFiles(chartCode, tileMatrix, metadata, sourceCutline, b
     ],
     properties: {
       datetime: CliDate,
-      "proj:epsg": tileMatrix.projection.code,
+      "proj:epsg": GoogleTms.projection.code,
       "linz_basemaps:options": {
-        tileMatrix: tileMatrix.identifier,
+        tileMatrix: GoogleTms.identifier,
         sourceEpsg: metadata.epsg
       },
       "linz_basemaps:generated": {
@@ -87319,6 +87493,9 @@ async function createStacFiles(chartCode, tileMatrix, metadata, sourceCutline, b
     },
     assets: {}
   };
+  return item;
+}
+function CreateStacCollection(chartCode, items, logger) {
   logger.info({ chartCode }, "Charts:CreateStacCollection");
   const collection = {
     id: CliId,
@@ -87327,21 +87504,73 @@ async function createStacFiles(chartCode, tileMatrix, metadata, sourceCutline, b
     stac_extensions: [],
     license: "CC-BY-4.0",
     title: `New Zealand Charts Mapsheets - ${chartCode}`,
-    description: `New Zealand Charts Mapsheets - ${chartCode} - ${tileMatrix.identifier}`,
+    description: `New Zealand Charts Mapsheets - ${chartCode} - ${GoogleTms.identifier}`,
     extent: {
-      spatial: { bbox: [item.bbox] },
+      spatial: { bbox: items.map((i) => i.bbox) },
       temporal: { interval: [[CliDate, null]] }
     },
     links: [
       { rel: "self", href: "./collection.json", type: "application/json" },
-      {
+      ...items.map((item) => ({
         href: `./${item.id}.json`,
         rel: "item",
         type: "application/json"
-      }
+      }))
     ]
   };
-  return { item, collection };
+  for (const item of items) {
+    collection.extent.spatial.bbox.push(item.bbox);
+  }
+  return collection;
+}
+async function createCogs(sourceTiff, sourceCutline, chartCode, bufferedCutline, metadata, targetPath, logger) {
+  const geojson = await Fsa.readJson(bufferedCutline);
+  let index = 0;
+  const items = [];
+  for (const feature of geojson.features) {
+    if (feature.geometry.type === "Polygon") {
+      const splitCutline = {
+        type: "FeatureCollection",
+        crs: { type: "name", properties: { name: "urn:ogc:def:crs:EPSG::3857" } },
+        features: [feature]
+      };
+      const cutlineFile = new import_url2.URL(`cutline-${index}.geojson`, tmpFolder);
+      await Fsa.write(cutlineFile, JSON.stringify(splitCutline));
+      const item = await createStacItem(`${chartCode}-${index}`, metadata, sourceCutline, cutlineFile, logger);
+      await Fsa.write(new import_url2.URL(`${chartCode}-${index}.json`, targetPath), JSON.stringify(item, null, 2));
+      items.push(item);
+      const cog = new import_url2.URL(`${chartCode}-${index}.tif`, tmpFolder);
+      await new GdalRunner(gdalBuildChartsCommand(cog, sourceTiff, cutlineFile, GoogleTms)).run(logger);
+      await Fsa.write(new import_url2.URL(`${chartCode}-${index}.tif`, targetPath), Fsa.readStream(cog));
+      index++;
+    } else if (feature.geometry.type === "MultiPolygon") {
+      for (const coords of feature.geometry.coordinates) {
+        const splitCutline = {
+          type: "FeatureCollection",
+          crs: { type: "name", properties: { name: "urn:ogc:def:crs:EPSG::3857" } },
+          features: [
+            {
+              type: "Feature",
+              geometry: { type: "Polygon", coordinates: coords }
+            }
+          ]
+        };
+        const cutlineFile = new import_url2.URL(`cutline-${index}.geojson`, tmpFolder);
+        await Fsa.write(cutlineFile, JSON.stringify(splitCutline));
+        const item = await createStacItem(`${chartCode}-${index}`, metadata, sourceCutline, cutlineFile, logger);
+        await Fsa.write(new import_url2.URL(`${chartCode}-${index}.json`, targetPath), JSON.stringify(item, null, 2));
+        items.push(item);
+        const cog = new import_url2.URL(`${chartCode}-${index}.tif`, tmpFolder);
+        await new GdalRunner(gdalBuildChartsCommand(cog, sourceTiff, cutlineFile, GoogleTms)).run(logger);
+        await Fsa.write(new import_url2.URL(`${chartCode}-${index}.tif`, targetPath), Fsa.readStream(cog));
+        index++;
+      }
+    } else {
+      throw new Error("GeoJSON must contain Polygon or MultiPolygon geometries");
+    }
+  }
+  const collection = CreateStacCollection(chartCode, items, logger);
+  await Fsa.write(new import_url2.URL("collection.json", targetPath), JSON.stringify(collection, null, 2));
 }
 
 // ../config-loader/build/json/json.config.js
@@ -87511,8 +87740,15 @@ function ensureBandsSimilar(tiff, existingBands, newBands) {
     const bB = newBands[i];
     if (bA == null || bB == null)
       continue;
-    if (bA !== bB) {
-      throw new Error(`Band:${i} datatype mismatch: ${tiff.source.url.href} ${bA} vs ${bB}`);
+    if (bA.type !== bB.type) {
+      throw new Error(`Band:${i} datatype mismatch: ${tiff.source.url.href} ${bA.type} vs ${bB.type}`);
+    }
+    if (bA.stats == null && bB.stats) {
+      bA.stats = bB.stats;
+    } else if (bA.stats && bB.stats) {
+      bA.stats.min = Math.min(bA.stats.min, bB.stats.min);
+      bA.stats.max = Math.max(bA.stats.max, bB.stats.max);
+      bA.stats.mean = (bA.stats.mean + bB.stats.mean) / 2;
     }
   }
   if (existingBands.length >= newBands.length)
@@ -87533,12 +87769,13 @@ async function computeTiffSummary(target, tiffs) {
     else if (res.projection !== epsg) {
       throw new Error(`ESPG projection mismatch on imagery ${res.projection} vs ${epsg} source: ${tiff.source.url.href}`);
     }
-    const [dataType, bitsPerSample, noData] = await Promise.all([
+    const [dataType, bitsPerSample, noData, gdalMetadata] = await Promise.all([
       /** firstImage.fetch(TiffTag.Photometric), **/
       // TODO enable RGB detection
       firstImage.fetch(TiffTag.SampleFormat),
       firstImage.fetch(TiffTag.BitsPerSample),
-      firstImage.fetch(TiffTag.GdalNoData)
+      firstImage.fetch(TiffTag.GdalNoData),
+      firstImage.fetch(TiffTag.GdalMetadata)
     ]);
     if (bitsPerSample == null) {
       throw new Error(`Failed to extract band information from : ${tiff.source.url.href}`);
@@ -87550,8 +87787,9 @@ async function computeTiffSummary(target, tiffs) {
     for (let i = 0; i < bitsPerSample.length; i++) {
       const type = getDataType(dataType ? dataType[i] : SampleFormat.Uint);
       const bits = bitsPerSample[i];
-      imageBands.push(`${type}${bits}`);
+      imageBands.push({ type: `${type}${bits}` });
     }
+    parseGdalMetadata(gdalMetadata, imageBands);
     res.bands = ensureBandsSimilar(tiff, res.bands, imageBands);
     const imageNoData = noData ? Number(noData) : null;
     if (res.noData != null && imageNoData !== res.noData) {
@@ -87596,6 +87834,62 @@ async function computeTiffSummary(target, tiffs) {
     throw new Error(`Failed to extract imagery from: ${target.href}`);
   return res;
 }
+var MetadataSetter = {
+  COLORINTERP: (val2, meta) => meta.color = val2.toLowerCase(),
+  STATISTICS_MEAN: (val2, meta) => {
+    meta.stats = meta.stats ?? { min: NaN, mean: NaN, max: NaN, stddev: NaN };
+    meta.stats.mean = Number(val2);
+  },
+  STATISTICS_MAXIMUM: (val2, meta) => {
+    meta.stats = meta.stats ?? { min: NaN, mean: NaN, max: NaN, stddev: NaN };
+    meta.stats.max = Number(val2);
+  },
+  STATISTICS_MINIMUM: (val2, meta) => {
+    meta.stats = meta.stats ?? { min: NaN, mean: NaN, max: NaN, stddev: NaN };
+    meta.stats.min = Number(val2);
+  },
+  // Ignored
+  STATISTICS_STDDEV: (val2, meta) => {
+    meta.stats = meta.stats ?? { min: NaN, mean: NaN, max: NaN, stddev: NaN };
+    meta.stats.stddev = Number(val2);
+  },
+  STATISTICS_VALIDPERCENT: () => {
+  }
+};
+function parseGdalMetadata(dat, bands, log) {
+  if (dat == null)
+    return;
+  const items = dat.split("\n").map((f) => f.trim()).filter((f) => f.startsWith("<Item"));
+  for (const item of items) {
+    const name = item.match(/name="([A-Z_]+)"/);
+    if (name == null)
+      continue;
+    const sample = item.match(/sample="([0-9]+)"/);
+    if (sample == null)
+      continue;
+    const value = item.match(/>(.*)<\/Item>/);
+    if (value == null)
+      continue;
+    const sampleId = Number(sample[1]);
+    if (isNaN(sampleId))
+      continue;
+    if (bands[sampleId] == null) {
+      log?.warn({ sampleId }, "GdalMetadataParser:InvalidBand");
+      return;
+    }
+    MetadataSetter[name[1]]?.(value[1], bands[sampleId]);
+    if (MetadataSetter[name[1]] == null) {
+      log?.debug({ gdalConfigName: name[1] }, "GdalMetadataParser:UnknownKey:" + name[1]);
+    }
+  }
+  for (const band of bands) {
+    if (band.stats == null)
+      continue;
+    if (isNaN(band.stats?.max) || isNaN(band.stats.min) || isNaN(band.stats.mean)) {
+      delete band.stats;
+    }
+  }
+}
 function toRelative(base, other) {
   if (!other.href.startsWith(base.href))
     throw new Error("Paths are not relative");
@@ -87682,6 +87976,7 @@ async function initImageryFromTiffUrl(target, Q3, configCache, log) {
     const title = stac?.title ?? imageryName;
     const tileMatrix = params.projection === EpsgCode.Nztm2000 ? Nztm2000QuadTms : TileMatrixSets.tryGet(params.projection);
     const imagery = {
+      v: 2,
       id: `im_${sha256base58(target.href)}`,
       name: imageryName,
       title,
@@ -87717,7 +88012,8 @@ async function initConfigFromUrls(provider, targets, concurrency = 25, configCac
     title: "Basemaps",
     category: "Basemaps",
     type: TileSetType.Raster,
-    layers: []
+    layers: [],
+    outputs: []
   };
   const elevationTileSet = {
     id: "ts_elevation",
@@ -87763,7 +88059,7 @@ function isRgbOrRgba(img) {
   if (img.bands.length > 4)
     return false;
   for (const b of img.bands) {
-    if (b !== "uint8")
+    if (b.type !== "uint8")
       return false;
   }
   return true;
@@ -87923,11 +88219,12 @@ var ConfigJson = class _ConfigJson {
     const imageryFetch = [];
     if (ts.type === TileSetType.Raster) {
       for (const layer of ts.layers) {
+        const category = layer.category ?? ts.category;
         if (layer[2193] != null) {
-          imageryFetch.push(this.loadImagery(stringToUrlFolder(layer[2193]), layer.name, layer.title));
+          imageryFetch.push(this.loadImagery(stringToUrlFolder(layer[2193]), layer.name, layer.title, category));
         }
         if (layer[3857] != null) {
-          imageryFetch.push(this.loadImagery(stringToUrlFolder(layer[3857]), layer.name, layer.title));
+          imageryFetch.push(this.loadImagery(stringToUrlFolder(layer[3857]), layer.name, layer.title, category));
         }
       }
     }
@@ -87992,10 +88289,10 @@ var ConfigJson = class _ConfigJson {
     tileSet.aliases = ts.aliases;
     return tileSet;
   }
-  loadImagery(url, name, title) {
+  loadImagery(url, name, title, category) {
     let existing = this.cache.get(url.href);
     if (existing == null) {
-      existing = this._loadImagery(url, name, title);
+      existing = this._loadImagery(url, name, title, category);
       this.cache.set(url.href, existing);
     }
     return existing;
@@ -88004,7 +88301,7 @@ var ConfigJson = class _ConfigJson {
   initImageryFromTiffUrl(url) {
     return initImageryFromTiffUrl(url, this.Q, this.imageryConfigCache, this.logger);
   }
-  async _loadImagery(url, name, title) {
+  async _loadImagery(url, name, title, category) {
     const imageId = guessIdFromUri(url.href) ?? sha256base58(url.href);
     const id = ConfigId.prefix(ConfigPrefix.Imagery, imageId);
     this.logger.trace({ url: url.href, imageId: id }, "Imagery:Fetch");
@@ -88012,6 +88309,8 @@ var ConfigJson = class _ConfigJson {
     img.id = id;
     img.name = name;
     img.title = title;
+    if (category)
+      img.category = category;
     delete img.collection;
     this.mem.put(img);
     return img;
@@ -88618,7 +88917,11 @@ async function createCog(ctx) {
   if (tileMatrix == null)
     throw new Error("Failed to find tile matrix: " + options.tileMatrix);
   logger?.debug({ tileId }, "Cog:Create:VrtSource");
-  const vrtSourceCommand = gdalBuildVrt(new URL(`${tileId}-source.vrt`, ctx.tempFolder), ctx.sourceFiles);
+  let addAlpha = false;
+  if (options.presetBands?.includes("alpha") && options.presetBands.length > options.sourceBands.length) {
+    addAlpha = true;
+  }
+  const vrtSourceCommand = gdalBuildVrt(new URL(`${tileId}-source.vrt`, ctx.tempFolder), ctx.sourceFiles, addAlpha);
   await new GdalRunner(vrtSourceCommand).run(logger);
   logger?.debug({ tileId }, "Cog:Create:VrtWarp");
   const cutlineProperties = { url: null, blend: ctx.cutline.blend };
@@ -88648,10 +88951,11 @@ async function createCog(ctx) {
   }
   const gdalCreateCommand = gdalCreate(new URL(`${tileId}-bg.tiff`, ctx.tempFolder), options.background, options);
   await new GdalRunner(gdalCreateCommand).run(logger);
-  const vrtMergeCommand = gdalBuildVrt(new URL(`${tileId}-merged.vrt`, ctx.tempFolder), [
-    gdalCreateCommand.output,
-    vrtWarpCommand.output
-  ]);
+  const vrtMergeCommand = gdalBuildVrt(
+    new URL(`${tileId}-merged.vrt`, ctx.tempFolder),
+    [gdalCreateCommand.output, vrtWarpCommand.output],
+    false
+  );
   await new GdalRunner(vrtMergeCommand).run(logger);
   const cogCreateCommand = gdalBuildCog(new URL(`${tileId}.tiff`, ctx.tempFolder), vrtMergeCommand.output, options);
   await new GdalRunner(cogCreateCommand).run(logger);
@@ -88841,10 +89145,16 @@ function getTargetBaseZoom(tileMatrix, resolution, targetZoomOffset) {
     return Projection.getTiffResZoom(tileMatrix, resolution);
   return Projection.getTiffResZoom(tileMatrix, resolution) + targetZoomOffset;
 }
+var TargetZoomOffset = {
+  zstd_17: 6,
+  lzw: 6
+};
 async function createTileCover(ctx) {
   await ProjectionLoader.load(ctx.imagery.projection);
+  await ProjectionLoader.load(EpsgCode.Wgs84);
   const targetBaseZoom = getTargetBaseZoom(ctx.tileMatrix, ctx.imagery.gsd, ctx.targetZoomOffset);
-  const optimalCoveringZoom = Math.max(1, targetBaseZoom - 7);
+  const targetZoomOffset = TargetZoomOffset[ctx.preset] ?? 7;
+  const optimalCoveringZoom = Math.max(1, targetBaseZoom - targetZoomOffset);
   ctx.logger?.debug({ targetBaseZoom, cogOverZoom: optimalCoveringZoom }, "Imagery:ZoomLevel");
   const sourceBounds = projectPolygon(
     polygonFromBounds(ctx.imagery.files),
@@ -88881,8 +89191,10 @@ async function createTileCover(ctx) {
   for (const tile of covering) {
     const bounds = ctx.tileMatrix.tileToSourceBounds(tile);
     const scaledBounds = bounds.scaleFromCenter(1.05);
-    const tileBounds = Projection.get(ctx.tileMatrix).projectMultipolygon(
-      [scaledBounds.toPolygon()],
+    const projection = Projection.get(ctx.tileMatrix);
+    const wsg84Bounds = multiPolygonToWgs84([scaledBounds.toPolygon()], projection.toWgs84, true);
+    const tileBounds = Projection.get(EpsgCode.Wgs84).projectMultipolygon(
+      wsg84Bounds,
       Projection.get(ctx.imagery.projection)
     );
     const source = imageryBounds.filter((f) => intersection(tileBounds, f.polygon).length > 0);
@@ -88909,9 +89221,11 @@ async function createTileCover(ctx) {
         "linz_basemaps:options": {
           preset: ctx.preset,
           ...Presets[ctx.preset].options,
+          presetBands: ctx.presetBands,
           tile,
           tileMatrix: ctx.tileMatrix.identifier,
           sourceEpsg: ctx.imagery.projection,
+          sourceBands: ctx.imagery.bands,
           zoomLevel: targetBaseZoom
         },
         "linz_basemaps:generated": {
@@ -89027,6 +89341,11 @@ var BasemapsCogifyCoverCommand = (0, import_cmd_ts4.command)({
       defaultValue: () => "webp",
       defaultValueIsSerializable: true
     }),
+    presetBand: (0, import_cmd_ts4.option)({
+      type: (0, import_cmd_ts4.optional)((0, import_cmd_ts4.oneOf)(Object.keys(BandPresets))),
+      long: "preset-bands",
+      description: "Tell GDAL what the bands in the source image represent see `-colorinterp` in GDAL"
+    }),
     tileMatrix: (0, import_cmd_ts4.option)({
       type: import_cmd_ts4.string,
       long: "tile-matrix",
@@ -89052,6 +89371,9 @@ var BasemapsCogifyCoverCommand = (0, import_cmd_ts4.command)({
   async handler(args) {
     const metrics = new Metrics();
     const logger = getLogger(this, args, "cli-raster");
+    if (args.presetBand != null && !AllowedPresets[args.preset].includes(args.presetBand)) {
+      throw new Error(`Preset ${args.preset} does not support band option ${args.presetBand}`);
+    }
     const mem = new ConfigProviderMemory();
     metrics.start("imagery:load");
     const cfg = await initConfigFromUrls(mem, args.paths);
@@ -89060,6 +89382,21 @@ var BasemapsCogifyCoverCommand = (0, import_cmd_ts4.command)({
       throw new Error("No imagery found");
     const im = cfg.imagery[0];
     logger.info({ files: im.files.length, title: im.title, duration: imageryLoadTime }, "Imagery:Loaded");
+    if (args.presetBand != null && im.bands != null) {
+      const bandList = BandPresets[args.presetBand];
+      if (bandList && im.bands.length !== bandList.length) {
+        if (bandList.includes("alpha") && im.bands.length === bandList.length - 1) {
+          logger.warn(
+            { title: im.title, bands: im.bands.length, expectedBands: bandList.length },
+            `Imagery:Bands:MissingAlpha - Adding alpha to source`
+          );
+        } else {
+          throw new Error(
+            `Imagery has ${im.bands.length} bands, preset ${args.presetBand} requires ${bandList.join(", ")}`
+          );
+        }
+      }
+    }
     if (im.collection == null && args.requireStacCollection) {
       throw new Error(`No collection.json found with imagery: ${im.url.href}`);
     }
@@ -89081,6 +89418,7 @@ var BasemapsCogifyCoverCommand = (0, import_cmd_ts4.command)({
       metrics,
       cutline,
       preset: args.preset,
+      presetBands: BandPresets[args.presetBand] ?? void 0,
       background: args.background,
       targetZoomOffset: args.baseZoomOffset
     };
@@ -89169,12 +89507,12 @@ function extractBoundsFromTiff(tiff, logger) {
 }
 var GeotagToEpsgCode = {
   // global
-  "Universal Transverse Mercator Zone": 4326,
+  "Universal Transverse Mercator Zone": EpsgCode.Wgs84,
   // antarctic
   "McMurdo Sound Lambert Conformal 2000": 5479,
   // new zealand
-  "Chatham Islands Transverse Mercator 2000": 2193,
-  "New Zealand Transverse Mercator 2000": 3793,
+  "New Zealand Transverse Mercator 2000": EpsgCode.Nztm2000,
+  "Chatham Islands Transverse Mercator 2000": EpsgCode.Citm2000,
   // new zealand offshore islands
   "Auckland Islands Transverse Mercator": 3788,
   "Campbell Island Transverse Mercator": 3789,
@@ -89484,6 +89822,7 @@ async function writeStacFiles(target, items, collection, logger) {
 
 // src/cogify/cli/cli.topo.ts
 var Q2 = pLimit(10);
+var Format = ["gridded", "gridless"];
 var MapSeries = ["topo25", "topo50", "topo250"];
 var MapSeriesTitle = {
   topo25: "Raster Topographic Maps 25k",
@@ -89509,7 +89848,12 @@ var TopoStacCreationCommand = (0, import_cmd_ts5.command)({
     mapSeries: (0, import_cmd_ts5.option)({
       type: (0, import_cmd_ts5.oneOf)(MapSeries),
       long: "map-series",
-      description: `Map series name. Either ${MapSeries.join(", ")}`
+      description: `Map series scale. Either ${MapSeries.join(", ")}`
+    }),
+    format: (0, import_cmd_ts5.option)({
+      type: (0, import_cmd_ts5.oneOf)(Format),
+      long: "format",
+      description: `Map sheet format. Either ${Format.join(", ")}`
     }),
     latestOnly: (0, import_cmd_ts5.flag)({
       type: import_cmd_ts5.boolean,
@@ -89533,6 +89877,7 @@ var TopoStacCreationCommand = (0, import_cmd_ts5.command)({
     const startTime = performance.now();
     logger.info("TopoCogify:Start");
     const mapSeries = args.mapSeries;
+    const format = args.format;
     const title = args.title ?? MapSeriesTitle[mapSeries];
     const ctx = {
       latestOnly: args.latestOnly,
@@ -89540,6 +89885,7 @@ var TopoStacCreationCommand = (0, import_cmd_ts5.command)({
       target: args.target,
       title,
       mapSeries,
+      format,
       output: args.output,
       logger
     };
@@ -89583,7 +89929,7 @@ async function loadTiffsToCreateStacs(ctx) {
   const epsgDirectoryPaths = [];
   const stacItemPaths = [];
   const mapSeries = ctx.mapSeries;
-  const resolution = "gridless_600dpi";
+  const resolution = `${ctx.format}_600dpi`;
   for (const [epsg, tiffItems] of allTiffItems.entries()) {
     logger?.info({ epsg }, "CreateStacFiles:Start");
     const latestTiffItems = extractLatestTiffItemsByMapCode(tiffItems);