@basemaps/lambda-tiler 6.20.0 → 6.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basemaps/lambda-tiler",
-  "version": "6.20.0",
+  "version": "6.22.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/linz/basemaps.git",
@@ -22,16 +22,16 @@
   "types": "./build/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@basemaps/config": "^6.18.0",
-    "@basemaps/geo": "^6.10.0",
+    "@basemaps/config": "^6.21.1",
+    "@basemaps/geo": "^6.21.1",
     "@basemaps/lambda": "^6.7.0",
-    "@basemaps/shared": "^6.20.0",
-    "@basemaps/tiler": "^6.20.0",
-    "@basemaps/tiler-sharp": "^6.20.0",
-    "@chunkd/fs": "^8.0.3",
+    "@basemaps/shared": "^6.22.0",
+    "@basemaps/tiler": "^6.21.1",
+    "@basemaps/tiler-sharp": "^6.21.1",
+    "@chunkd/fs": "^8.1.0",
     "@cogeotiff/core": "^6.1.1",
-    "@cotar/core": "^5.1.1",
-    "@linzjs/geojson": "^6.10.0",
+    "@cotar/core": "^5.3.0",
+    "@linzjs/geojson": "^6.21.1",
     "@linzjs/lambda": "^2.0.0",
     "p-limit": "^4.0.0",
     "path-to-regexp": "^6.1.0",
@@ -52,14 +52,12 @@
     "bundle": "./bundle.sh"
   },
   "devDependencies": {
-    "@basemaps/attribution": "^6.17.0",
+    "@basemaps/attribution": "^6.22.0",
     "@types/aws-lambda": "^8.10.75",
-    "@types/express": "^4.17.11",
     "@types/node": "^14.11.2",
     "@types/pixelmatch": "^5.0.0",
     "@types/sharp": "^0.29.3",
-    "express": "^4.17.1",
     "pretty-json-log": "^1.0.0"
   },
-  "gitHead": "ca2a4b302477accd62e80f994d7ef12873808fe5"
+  "gitHead": "3190b6a49a91b3220b429a736484a93f3b76c721"
 }

package/scripts/create.deployment.package.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Create a pacakge.json for the `dist` bundle based off the parent package.json
+ *
+ * This is needed as libsharp has to be "installed" into the dist node_modules so that lambda has access to sharp
+ */
+import * as fs from 'fs';
+
+const parentPackage = JSON.parse(fs.readFileSync('../package.json').toString());
+
+// Find the exact version of a package in the yarn lock
+function getPackageVersion(packageName) {
+  const parentLock = fs.readFileSync('../../../yarn.lock').toString().split('\n');
+
+  for (let i = 0; i < parentLock.length; i++) {
+    if (parentLock[i].startsWith(packageName + '@')) {
+      const versionList = parentLock[i + 1].trim();
+      if (!versionList.startsWith('version ')) throw new Error('Failed to find sharp version');
+      return JSON.parse(versionList.slice('version '.length));
+    }
+  }
+}
+
+// the bundle is a commonjs module
+parentPackage.type = 'commonjs';
+parentPackage.main = 'index.js';
+parentPackage.dependencies = { sharp: getPackageVersion('sharp') };
+
+// Clean up
+delete parentPackage.types;
+delete parentPackage.devDependencies;
+
+console.log('Installing dependencies', parentPackage.dependencies);
+fs.writeFileSync('./package.json', JSON.stringify(parentPackage, null, 2));

package/src/__test__/tile.set.cache.test.ts

@@ -1,4 +1,4 @@
-import { ConfigImagery, ConfigTileSetRaster } from '@basemaps/config';
+import { ConfigImagery, ConfigTileSetRaster, TileSetType } from '@basemaps/config';
 import { Epsg, GoogleTms, Nztm2000Tms } from '@basemaps/geo';
 import { Config, TileSetName } from '@basemaps/shared';
 import o from 'ospec';
@@ -26,14 +26,6 @@ o.spec('TileSetCache', () => {
   const imgMap = new Map<string, ConfigImagery>();
   imgMap.set(imageOne.id, imageOne);
 
-  o.beforeEach(() => {
-    sandbox.stub(Config, 'getTileSetImagery').callsFake(async () => {
-      const imgMap = new Map<string, ConfigImagery>();
-      imgMap.set(imageOne.id, imageOne);
-      return imgMap;
-    });
-  });
-
   o.afterEach(() => {
     TileSets.cache.clear();
     sandbox.restore();
@@ -44,7 +36,7 @@ o.spec('TileSetCache', () => {
       TileSets.add(new TileSetRaster('aerial@head', GoogleTms));
 
       const parentTileSet = await TileSets.get('aerial@head', GoogleTms);
-      if (parentTileSet == null || parentTileSet.isVector()) throw new Error('null parentTileSet');
+      if (parentTileSet == null || parentTileSet.type === TileSetType.Vector) throw new Error('null parentTileSet');
       parentTileSet.imagery = imgMap;
       parentTileSet.tileSet = {
         name: 'parent',
@@ -53,7 +45,7 @@ o.spec('TileSetCache', () => {
       } as ConfigTileSetRaster;
 
       const subTileSet = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
-      if (subTileSet == null || subTileSet.isVector()) throw new Error('null subTileSet');
+      if (subTileSet == null || subTileSet.type === TileSetType.Vector) throw new Error('null subTileSet');
 
       o(subTileSet.title).equals('parent aerial title Tasman rural 2018-19 0.3m');
       o(subTileSet.fullName).equals('aerial@head:tasman_rural_2018-19_0-3m');
@@ -79,7 +71,7 @@ o.spec('TileSetCache', () => {
       TileSets.cache.delete(subTileSet.id);
       delete parentTileSet.tileSet.title;
       const subTileSetB = await TileSets.get('aerial@head:tasman_rural_2018-19_0-3m', GoogleTms);
-      if (subTileSetB == null || subTileSetB.isVector()) throw new Error('null subTileSetB');
+      if (subTileSetB == null || subTileSetB.type === TileSetType.Vector) throw new Error('null subTileSetB');
       o(subTileSetB.title).equals('parent Tasman rural 2018-19 0.3m');
     });
   });

package/src/index.ts

@@ -7,6 +7,7 @@ import { Router } from './router.js';
 import { createHash } from 'crypto';
 import { Imagery } from './routes/imagery.js';
 import { Esri } from './routes/esri/rest.js';
+import { St } from './source.tracer.js';
 
 const app = new Router();
 
@@ -19,6 +20,9 @@ app.get('esri', Esri);
 
 let slowTimer: NodeJS.Timer | null = null;
 export async function handleRequest(req: LambdaHttpRequest): Promise<LambdaHttpResponse> {
+  // Reset the request tracing
+  St.reset();
+
   // Warn if a request takes more than 10 seconds to process
   if (slowTimer) clearTimeout(slowTimer);
   slowTimer = setTimeout(() => req.log.warn(req.logContext, 'Lambda:Slow'), 10_000);
@@ -31,7 +35,13 @@ export async function handleRequest(req: LambdaHttpRequest): Promise<LambdaHttpR
       const apiKeyHash = createHash('sha256').update(apiKey).digest('base64');
       req.set('api', apiKeyHash);
     }
-    return await app.handle(req);
+    const ret = await app.handle(req);
+
+    // TODO this could be relaxed to every say 5% of requests if logging gets too verbose.
+    req.set('requests', St.requests.slice(0, 100)); // limit to 100 requests (some tiles need 100s of requests)
+    req.set('requestCount', St.requests.length);
+
+    return ret;
   } finally {
     if (slowTimer) clearTimeout(slowTimer);
     slowTimer = null;

package/src/routes/__test__/attribution.test.ts

@@ -159,7 +159,6 @@ const ExpectedJson = {
       },
       links: [],
       summaries: {
-        gsd: [0.75],
         'linz:zoom': {
           min: 14,
           max: 16,
@@ -190,7 +189,6 @@ const ExpectedJson = {
       },
       links: [],
       summaries: {
-        gsd: [0.75],
         'linz:zoom': {
           min: 15,
           max: 17,
@@ -221,7 +219,6 @@ const ExpectedJson = {
       },
       links: [],
       summaries: {
-        gsd: [0.75],
         'linz:zoom': {
           min: 16,
           max: 18,
@@ -252,7 +249,6 @@ const ExpectedJson = {
       },
       links: [],
       summaries: {
-        gsd: [0.75],
         'linz:zoom': {
           min: 14,
           max: 16,
@@ -263,15 +259,13 @@ const ExpectedJson = {
   ],
   links: [],
 };
-function makeImageRecord(id: string, name: string, x = 10, year = 2019): ConfigImagery {
+function makeImageRecord(id: string, name: string, x = 10): ConfigImagery {
   return {
     id,
     name,
     projection: EpsgCode.Google,
-    year,
     uri: 's3://bucket/path/' + name,
     bounds: GoogleTms.tileToSourceBounds({ x, y: 10, z: 5 }),
-    resolution: 750,
     files: [0, 1].map((i) => {
       const b = GoogleTms.tileToSourceBounds({ x, y: 10, z: 5 }).toJson() as NamedBounds;
       b.name = name + i;
@@ -351,18 +345,14 @@ o.spec('attribution', () => {
             name: 'p1',
           },
         ],
-        summaries: {
-          gsd: [0.75],
-        },
+        summaries: {},
       };
       mockFs.jsStore['s3://bucket/path/image2/collection.json'] = {
         extent: {
           spatial: { bbox: [5, 6, 7, 8] },
           temporal: { interval: [['2016-02-03T01:02:03Z', '2018-09-13T11:32:43Z']] },
         },
-        summaries: {
-          gsd: [0.5],
-        },
+        summaries: {},
       };
 
       const request = mockRequest(`/v1/attribution/aerial/EPSG:3857/summary.json`);

package/src/routes/attribution.ts

@@ -1,4 +1,4 @@
-import { ConfigImagery, ConfigLayer, ConfigProvider } from '@basemaps/config';
+import { ConfigImagery, ConfigLayer, ConfigProvider, TileSetType } from '@basemaps/config';
 import {
   AttributionCollection,
   AttributionItem,
@@ -11,7 +11,6 @@ import {
   StacExtent,
   TileMatrixSet,
 } from '@basemaps/geo';
-import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import {
   CompositeError,
   Config,
@@ -23,10 +22,11 @@ import {
   titleizeImageryName,
 } from '@basemaps/shared';
 import { BBox, MultiPolygon, multiPolygonToWgs84, Pair, union, Wgs84 } from '@linzjs/geojson';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { createHash } from 'crypto';
+import { Router } from '../router.js';
 import { TileSets } from '../tile.set.cache.js';
 import { TileSetRaster } from '../tile.set.raster.js';
-import { Router } from '../router.js';
 
 /** Amount to pad imagery bounds to avoid fragmenting polygons  */
 const SmoothPadding = 1 + 1e-10; // about 1/100th of a millimeter at equator
@@ -85,16 +85,6 @@ async function readStac(uri: string): Promise<StacCollection | null> {
   }
 }
 
-/** Attempt to find the GSD from a stack summary object */
-function getGsd(un?: Record<string, unknown>): number | null {
-  if (un == null) return null;
-  const gsd = un['gsd'];
-  if (gsd == null) return null;
-  if (!Array.isArray(gsd)) return null;
-  if (isNaN(gsd[0])) return null;
-  return gsd[0];
-}
-
 export function createAttributionCollection(
   tileSet: TileSetRaster,
   stac: StacCollection | null | undefined,
@@ -116,7 +106,6 @@ export function createAttributionCollection(
     extent,
     links: [],
     summaries: {
-      gsd: [getGsd(stac?.summaries) ?? imagery.resolution / 1000],
       'linz:zoom': {
         min: TileMatrixSet.convertZoomLevel(layer.minZoom ? layer.minZoom : 0, GoogleTms, tileMatrix, true),
         max: TileMatrixSet.convertZoomLevel(layer.maxZoom ? layer.maxZoom : 32, GoogleTms, tileMatrix, true),
@@ -140,7 +129,7 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
 
   // read all stac files in parallel
   for (const layer of tileSet.tileSet.layers) {
-    const imgId = Config.getImageId(layer, proj.epsg);
+    const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
     const im = tileSet.imagery.get(imgId);
     if (im == null) continue;
@@ -153,7 +142,7 @@ async function tileSetAttribution(tileSet: TileSetRaster): Promise<AttributionSt
   if (host == null) return null;
 
   for (const layer of tileSet.tileSet.layers) {
-    const imgId = Config.getImageId(layer, proj.epsg);
+    const imgId = layer[proj.epsg.code];
     if (imgId == null) continue;
     const im = tileSet.imagery.get(imgId);
     if (im == null) continue;
@@ -217,7 +206,7 @@ export async function attribution(req: LambdaHttpRequest): Promise<LambdaHttpRes
   req.timer.start('tileset:load');
   const tileSet = await TileSets.get(data.name, data.tileMatrix);
   req.timer.end('tileset:load');
-  if (tileSet == null || tileSet.isVector()) return NotFound;
+  if (tileSet == null || tileSet.type === TileSetType.Vector) return NotFound;
 
   const cacheKey = createHash('sha256').update(JSON.stringify(tileSet.tileSet)).digest('base64');
 

package/src/routes/tile.wmts.ts

@@ -1,4 +1,4 @@
-import { Config } from '@basemaps/config';
+import { Config, TileSetType } from '@basemaps/config';
 import { TileMatrixSet } from '@basemaps/geo';
 import { Env, TileSetName, tileWmtsFromPath } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
@@ -51,7 +51,7 @@ export async function wmts(req: LambdaHttpRequest): Promise<LambdaHttpResponse>
 async function wmtsLoadTileSets(name: string, tileMatrix: TileMatrixSet | null): Promise<TileSetRaster[]> {
   if (tileMatrix != null) {
     const ts = await TileSets.get(name, tileMatrix);
-    if (ts == null || ts.isVector()) return [];
+    if (ts == null || ts.type === TileSetType.Vector) return [];
     return [ts];
   }
   if (name === '') name = TileSetName.aerial;

package/src/source.tracer.ts

@@ -0,0 +1,34 @@
+import { ChunkSource } from '@chunkd/core';
+
+interface SourceRequest {
+  offset: number;
+  length?: number;
+  source: string;
+  duration?: number;
+}
+
+export class SourceTracer {
+  requests: SourceRequest[] = [];
+
+  /** Reset the request tracer */
+  reset(): void {
+    this.requests = [];
+  }
+
+  /** Override the fetchByte function to trace all requests for this source  */
+  trace(source: ChunkSource): void {
+    const originFetch = source.fetchBytes;
+    source.fetchBytes = async (offset: number, length?: number): Promise<ArrayBuffer> => {
+      const request: SourceRequest = { source: source.uri, offset, length };
+      this.requests.push(request);
+      const startTime = Date.now();
+
+      const ret = await originFetch.apply(source, [offset, length]);
+
+      request.duration = Date.now() - startTime;
+      return ret;
+    };
+  }
+}
+
+export const St = new SourceTracer();

package/src/tile.set.cache.ts

@@ -1,4 +1,4 @@
-import { TileSetNameParser } from '@basemaps/config';
+import { TileSetNameParser, TileSetType } from '@basemaps/config';
 import { TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Config } from '@basemaps/shared';
 import { TileSet } from './tile.set.js';
@@ -50,7 +50,7 @@ export class TileSetCache {
     if (nameComp.layer != null) {
       const parentName = TileSetNameParser.componentsToName({ ...nameComp, layer: undefined });
       const parent = await this.get(parentName, tileMatrix);
-      if (parent == null || parent.isVector()) return null;
+      if (parent == null || parent.type === TileSetType.Vector) return null;
       return parent.child(nameComp.layer);
     }
 
@@ -91,7 +91,7 @@ export class TileSetCache {
     const tileSets: TileSetRaster[] = [];
     for (const parent of tileMatrixSets) {
       if (parent == null) continue;
-      if (parent.isVector()) continue;
+      if (parent.type === TileSetType.Vector) continue;
 
       tileSets.push(parent);
       if (nameComp.layer != null) {

package/src/tile.set.raster.ts

@@ -1,4 +1,11 @@
-import { ConfigImagery, ConfigLayer, ConfigTileSetRaster, TileSetNameParser, TileSetType } from '@basemaps/config';
+import {
+  ConfigImagery,
+  ConfigLayer,
+  ConfigTileSetRaster,
+  TileSetNameComponents,
+  TileSetNameParser,
+  TileSetType,
+} from '@basemaps/config';
 import { Bounds, Epsg, Tile, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Config, Env, fsa, LogType, TileDataXyz, titleizeImageryName, VectorFormat } from '@basemaps/shared';
 import { Tiler } from '@basemaps/tiler';
@@ -9,8 +16,9 @@ import { Metrics } from '@linzjs/metrics';
 import pLimit from 'p-limit';
 import { NotFound, NotModified } from './routes/response.js';
 import { TileEtag } from './routes/tile.etag.js';
+import { St } from './source.tracer.js';
 import { TiffCache } from './tiff.cache.js';
-import { TileSetHandler } from './tile.set.js';
+import { TileSets } from './tile.set.cache.js';
 
 const LoadingQueue = pLimit(Env.getNumber(Env.TiffConcurrency, 5));
 
@@ -27,14 +35,17 @@ export interface TileSetResponse {
 const DefaultResizeKernel = { in: 'lanczos3', out: 'lanczos3' } as const;
 const DefaultBackground = { r: 0, g: 0, b: 0, alpha: 0 };
 
-export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
-  type = TileSetType.Raster;
+export class TileSetRaster {
+  type: TileSetType.Raster = TileSetType.Raster;
 
   tileMatrix: TileMatrixSet;
   tiler: Tiler;
   imagery: Map<string, ConfigImagery>;
   extentOverride: Bounds;
 
+  components: TileSetNameComponents;
+  tileSet: ConfigTileSetRaster;
+
   /**
    * Return the location of a imagery `record`
    * @param record
@@ -47,10 +58,19 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
   }
 
   constructor(name: string, tileMatrix: TileMatrixSet) {
-    super(name, tileMatrix);
+    this.components = TileSetNameParser.parse(name);
+    this.tileMatrix = tileMatrix;
     this.tiler = new Tiler(this.tileMatrix);
   }
 
+  get id(): string {
+    return TileSets.id(this.fullName, this.tileMatrix);
+  }
+
+  get fullName(): string {
+    return TileSetNameParser.componentsToName(this.components);
+  }
+
   get title(): string {
     return this.tileSet?.title ?? this.components.name;
   }
@@ -132,7 +152,7 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
       if (layer.maxZoom != null && filterZoom > layer.maxZoom) continue;
       if (layer.minZoom != null && filterZoom < layer.minZoom) continue;
 
-      const imgId = Config.getImageId(layer, this.tileMatrix.projection);
+      const imgId = layer[this.tileMatrix.projection.code];
       if (imgId == null) {
         log?.warn({ layer: layer.name, projection: this.tileMatrix.projection.code }, 'Failed to lookup imagery');
         continue;
@@ -166,6 +186,8 @@ export class TileSetRaster extends TileSetHandler<ConfigTileSetRaster> {
         if (source == null) {
           throw new Error(`Failed to create CogSource from  ${TileSetRaster.basePath(record, c.name)}`);
         }
+
+        St.trace(source);
         existing = new CogTiff(source);
         TiffCache.set(tiffKey, existing);
       }

package/src/tile.set.ts

@@ -1,44 +1,4 @@
-import {
-  ConfigTileSetRaster,
-  ConfigTileSetVector,
-  TileSetNameComponents,
-  TileSetNameParser,
-  TileSetType,
-} from '@basemaps/config';
-import { TileMatrixSet } from '@basemaps/geo';
-import { LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
-import { TileDataXyz } from '@basemaps/shared';
-import { TileSets } from './tile.set.cache.js';
 import { TileSetRaster } from './tile.set.raster.js';
 import { TileSetVector } from './tile.set.vector.js';
 
 export type TileSet = TileSetVector | TileSetRaster;
-
-export abstract class TileSetHandler<T extends ConfigTileSetRaster | ConfigTileSetVector> {
-  type: TileSetType;
-  components: TileSetNameComponents;
-  tileMatrix: TileMatrixSet;
-  tileSet: T;
-  constructor(name: string, tileMatrix: TileMatrixSet) {
-    this.components = TileSetNameParser.parse(name);
-    this.tileMatrix = tileMatrix;
-  }
-
-  get id(): string {
-    return TileSets.id(this.fullName, this.tileMatrix);
-  }
-
-  get fullName(): string {
-    return TileSetNameParser.componentsToName(this.components);
-  }
-
-  isVector(): this is TileSetVector {
-    return this.type === TileSetType.Vector;
-  }
-
-  isRaster(): this is TileSetRaster {
-    return this.type === TileSetType.Raster;
-  }
-
-  abstract tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse>;
-}

package/src/tile.set.vector.ts

@@ -1,9 +1,11 @@
-import { ConfigTileSetVector, TileSetType } from '@basemaps/config';
+import { ConfigTileSetVector, TileSetNameComponents, TileSetNameParser, TileSetType } from '@basemaps/config';
+import { TileMatrixSet } from '@basemaps/geo';
 import { fsa, TileDataXyz, VectorFormat } from '@basemaps/shared';
 import { Cotar } from '@cotar/core';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { NotFound } from './routes/response.js';
-import { TileSetHandler } from './tile.set.js';
+import { TileSets } from './tile.set.cache.js';
+import { St } from './source.tracer.js';
 
 class CotarCache {
   cache = new Map<string, Promise<Cotar | null>>();
@@ -11,7 +13,9 @@ class CotarCache {
   get(uri: string): Promise<Cotar | null> {
     let cotar = this.cache.get(uri);
     if (cotar == null) {
-      cotar = Cotar.fromTar(fsa.source(uri));
+      const source = fsa.source(uri);
+      St.trace(source);
+      cotar = Cotar.fromTar(source);
       this.cache.set(uri, cotar);
     }
     return cotar;
@@ -20,8 +24,23 @@ class CotarCache {
 
 export const Layers = new CotarCache();
 
-export class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
-  type = TileSetType.Vector;
+export class TileSetVector {
+  type: TileSetType.Vector = TileSetType.Vector;
+  components: TileSetNameComponents;
+  tileMatrix: TileMatrixSet;
+  tileSet: ConfigTileSetVector;
+  constructor(name: string, tileMatrix: TileMatrixSet) {
+    this.components = TileSetNameParser.parse(name);
+    this.tileMatrix = tileMatrix;
+  }
+
+  get id(): string {
+    return TileSets.id(this.fullName, this.tileMatrix);
+  }
+
+  get fullName(): string {
+    return TileSetNameParser.componentsToName(this.components);
+  }
 
   async tile(req: LambdaHttpRequest, xyz: TileDataXyz): Promise<LambdaHttpResponse> {
     if (xyz.ext !== VectorFormat.MapboxVectorTiles) return NotFound;
@@ -38,7 +57,7 @@ export class TileSetVector extends TileSetHandler<ConfigTileSetVector> {
     const y = (1 << xyz.z) - 1 - xyz.y;
 
     req.timer.start('cotar:tile');
-    const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`, req.log);
+    const tile = await cotar.get(`tiles/${xyz.z}/${xyz.x}/${y}.pbf.gz`);
     if (tile == null) return NotFound;
     req.timer.end('cotar:tile');