@basemaps/lambda-tiler 7.3.0 → 7.5.0

package/src/routes/tile.style.json.ts

@@ -1,5 +1,5 @@
-import { ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
-import { GoogleTms, TileMatrixSets } from '@basemaps/geo';
+import { ConfigId, ConfigPrefix, ConfigTileSetRaster, Layer, Sources, StyleJson, TileSetType } from '@basemaps/config';
+import { GoogleTms, TileMatrixSet, TileMatrixSets } from '@basemaps/geo';
 import { Env, toQueryString } from '@basemaps/shared';
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
 import { URL } from 'url';
@@ -15,8 +15,14 @@ import { Validate } from '../util/validate.js';
  * @param apiKey ApiKey to append with ?api= if required
  * @returns Updated Url or empty string if url is empty
  */
-export function convertRelativeUrl(url?: string, apiKey?: string, config?: string | null): string {
+export function convertRelativeUrl(
+  url?: string,
+  tileMatrix?: TileMatrixSet,
+  apiKey?: string,
+  config?: string | null,
+): string {
   if (url == null) return '';
+  if (tileMatrix) url = url.replace('{tileMatrix}', tileMatrix.identifier);
   const host = Env.get(Env.PublicUrlBase) ?? '';
   if (!url.startsWith('/')) return url; // Not relative ignore
   const fullUrl = new URL(url, host);
@@ -31,29 +37,41 @@ export function convertRelativeUrl(url?: string, apiKey?: string, config?: strin
  * @param apiKey api key to inject
  * @returns new stylejson
  */
-export function convertStyleJson(style: StyleJson, apiKey: string, config: string | null, layers?: Layer[]): StyleJson {
-  const sources: Sources = JSON.parse(JSON.stringify(style.sources));
+export function convertStyleJson(
+  style: StyleJson,
+  tileMatrix: TileMatrixSet,
+  apiKey: string,
+  config: string | null,
+  layers?: Layer[],
+): StyleJson {
+  const sources = JSON.parse(JSON.stringify(style.sources)) as Sources;
   for (const [key, value] of Object.entries(sources)) {
     if (value.type === 'vector') {
-      value.url = convertRelativeUrl(value.url, apiKey, config);
-    } else if (value.type === 'raster' && Array.isArray(value.tiles)) {
+      if (tileMatrix !== GoogleTms) {
+        throw new LambdaHttpResponse(400, `TileMatrix is not supported for the vector source ${value.url}.`);
+      }
+      value.url = convertRelativeUrl(value.url, tileMatrix, apiKey, config);
+    } else if ((value.type === 'raster' || value.type === 'raster-dem') && Array.isArray(value.tiles)) {
       for (let i = 0; i < value.tiles.length; i++) {
-        value.tiles[i] = convertRelativeUrl(value.tiles[i], apiKey, config);
+        value.tiles[i] = convertRelativeUrl(value.tiles[i], tileMatrix, apiKey, config);
       }
     }
     sources[key] = value;
   }
 
-  return {
+  const styleJson: StyleJson = {
     version: 8,
     id: style.id,
     name: style.name,
     sources,
     layers: layers ? layers : style.layers,
-    metadata: style.metadata ?? {},
-    glyphs: convertRelativeUrl(style.glyphs, undefined, config),
-    sprite: convertRelativeUrl(style.sprite, undefined, config),
-  } as StyleJson;
+  };
+
+  if (style.metadata) styleJson.metadata = style.metadata;
+  if (style.glyphs) styleJson.glyphs = convertRelativeUrl(style.glyphs, undefined, undefined, config);
+  if (style.sprite) styleJson.sprite = convertRelativeUrl(style.sprite, undefined, undefined, config);
+
+  return styleJson;
 }
 
 export interface StyleGet {
@@ -62,13 +80,42 @@ export interface StyleGet {
   };
 }
 
+function setStyleTerrain(style: StyleJson, terrain: string): void {
+  const source = Object.keys(style.sources).find((s) => s === terrain);
+  if (source == null) throw new LambdaHttpResponse(400, `Terrain: ${terrain} is not exists in the style source.`);
+  style.terrain = {
+    source,
+    exaggeration: 1.2,
+  };
+}
+
+async function ensureTerrain(
+  req: LambdaHttpRequest<StyleGet>,
+  tileMatrix: TileMatrixSet,
+  apiKey: string,
+  style: StyleJson,
+): Promise<void> {
+  const config = await ConfigLoader.load(req);
+  const terrain = await config.TileSet.get('ts_elevation');
+  if (terrain) {
+    const configLocation = ConfigLoader.extract(req);
+    const elevationQuery = toQueryString({ config: configLocation, api: apiKey, pipeline: 'terrain-rgb' });
+    style.sources['LINZ-Terrain'] = {
+      type: 'raster-dem',
+      tileSize: 256,
+      maxzoom: 18,
+      tiles: [convertRelativeUrl(`/v1/tiles/elevation/${tileMatrix.identifier}/{z}/{x}/{y}.png${elevationQuery}`)],
+    };
+  }
+}
+
 export async function tileSetToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
+  tileMatrix: TileMatrixSet,
   apiKey: string,
+  terrain?: string,
 ): Promise<LambdaHttpResponse> {
-  const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
-  if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
   const [tileFormat] = Validate.getRequestedFormats(req) ?? ['webp'];
   if (tileFormat == null) return new LambdaHttpResponse(400, 'Invalid image format');
 
@@ -83,11 +130,20 @@ export async function tileSetToStyle(
     `/v1/tiles/${tileSet.name}/${tileMatrix.identifier}/{z}/{x}/{y}.${tileFormat}${query}`;
 
   const styleId = `basemaps-${tileSet.name}`;
-  const style = {
+  const style: StyleJson = {
+    id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
+    name: tileSet.name,
     version: 8,
     sources: { [styleId]: { type: 'raster', tiles: [tileUrl], tileSize: 256 } },
     layers: [{ id: styleId, type: 'raster', source: styleId }],
   };
+
+  // Ensure elevation for individual tilesets
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
+
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);
@@ -104,11 +160,10 @@ export async function tileSetToStyle(
 export async function tileSetOutputToStyle(
   req: LambdaHttpRequest<StyleGet>,
   tileSet: ConfigTileSetRaster,
+  tileMatrix: TileMatrixSet,
   apiKey: string,
+  terrain?: string,
 ): Promise<LambdaHttpResponse> {
-  const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
-  if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
-
   const configLocation = ConfigLoader.extract(req);
   const query = toQueryString({ config: configLocation, api: apiKey });
 
@@ -158,19 +213,31 @@ export async function tileSetOutputToStyle(
     }
   }
 
-  const style = { version: 8, sources, layers };
+  const style: StyleJson = {
+    id: ConfigId.prefix(ConfigPrefix.Style, tileSet.name),
+    name: tileSet.name,
+    version: 8,
+    sources,
+    layers,
+  };
+
+  // Ensure elevation for style json config
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
 
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);
-  if (Etag.isNotModified(req, cacheKey)) return NotModified();
+  if (Etag.isNotModified(req, cacheKey)) return Promise.resolve(NotModified());
 
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.ETag, cacheKey);
   response.header(HttpHeader.CacheControl, 'no-store');
   response.buffer(data, 'application/json');
   req.set('bytes', data.byteLength);
-  return response;
+  return Promise.resolve(response);
 }
 
 export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<LambdaHttpResponse> {
@@ -178,6 +245,9 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
   const styleName = req.params.styleName;
   const excludeLayers = req.query.getAll('exclude');
   const excluded = new Set(excludeLayers.map((l) => l.toLowerCase()));
+  const tileMatrix = TileMatrixSets.find(req.query.get('tileMatrix') ?? GoogleTms.identifier);
+  if (tileMatrix == null) return new LambdaHttpResponse(400, 'Invalid tile matrix');
+  const terrain = req.query.get('terrain') ?? undefined;
 
   // Get style Config from db
   const config = await ConfigLoader.load(req);
@@ -188,17 +258,26 @@ export async function styleJsonGet(req: LambdaHttpRequest<StyleGet>): Promise<La
     const tileSet = await config.TileSet.get(config.TileSet.id(styleName));
     if (tileSet == null) return NotFound();
     if (tileSet.type !== TileSetType.Raster) return NotFound();
-    if (tileSet.outputs) return tileSetOutputToStyle(req, tileSet, apiKey);
-    else return tileSetToStyle(req, tileSet, apiKey);
+    if (tileSet.outputs) return await tileSetOutputToStyle(req, tileSet, tileMatrix, apiKey, terrain);
+    else return await tileSetToStyle(req, tileSet, tileMatrix, apiKey, terrain);
   }
 
   // Prepare sources and add linz source
   const style = convertStyleJson(
     styleConfig.style,
+    tileMatrix,
     apiKey,
     ConfigLoader.extract(req),
     styleConfig.style.layers.filter((f) => !excluded.has(f.id.toLowerCase())),
   );
+
+  // Ensure elevation for style json config
+  // TODO: We should remove this after adding terrain source into style configs. PR-916
+  await ensureTerrain(req, tileMatrix, apiKey, style);
+
+  // Add terrain in style
+  if (terrain) setStyleTerrain(style, terrain);
+
   const data = Buffer.from(JSON.stringify(style));
 
   const cacheKey = Etag.key(data);

package/src/routes/tile.wmts.ts

@@ -69,6 +69,7 @@ export async function wmtsCapabilitiesGet(req: LambdaHttpRequest<WmtsCapabilitie
     imagery,
     formats: Validate.getRequestedFormats(req) ?? [],
     layers: req.params.tileMatrix == null ? tileSet.layers : undefined,
+    pipeline: req.query.get('pipeline'),
   });
 
   const xml = wmts.toXml();

package/src/routes/tile.xyz.raster.ts

@@ -95,19 +95,21 @@ export const TileXyzRaster = {
       toLoad.push(
         LoadingQueue((): Promise<CloudArchive | null> => {
           if (assetPath.pathname.endsWith('.tar.co')) {
-            return CoSources.getCotar(assetPath).catch((error) => {
-              req.log.warn({ error, tiff: assetPath }, 'Load:Cotar:Failed');
+            return CoSources.getCotar(assetPath).catch((err: unknown) => {
+              req.log.warn({ err, tiff: assetPath }, 'Load:Cotar:Failed');
               return null;
             });
           }
-          return CoSources.getCog(assetPath).catch((error) => {
-            req.log.warn({ error, tiff: assetPath }, 'Load:Tiff:Failed');
+          return CoSources.getCog(assetPath).catch((err: unknown) => {
+            req.log.warn({ err, tiff: assetPath }, 'Load:Tiff:Failed');
             return null;
           });
         }),
       );
     }
 
+    // Remove with typescript >=5.5.0
+
     return (await Promise.all(toLoad)).filter((f) => f != null) as CloudArchive[];
   },
 
@@ -128,7 +130,7 @@ export const TileXyzRaster = {
     const assets = await TileXyzRaster.loadAssets(req, assetPaths);
 
     const tiler = new Tiler(xyz.tileMatrix);
-    const layers = await tiler.tile(assets, xyz.tile.x, xyz.tile.y, xyz.tile.z);
+    const layers = tiler.tile(assets, xyz.tile.x, xyz.tile.y, xyz.tile.z);
 
     const format = getImageFormat(xyz.tileType);
     if (format == null) return new LambdaHttpResponse(400, 'Invalid image format: ' + xyz.tileType);

package/src/routes/version.ts

@@ -1,6 +1,6 @@
 import { HttpHeader, LambdaHttpResponse } from '@linzjs/lambda';
 
-export async function versionGet(): Promise<LambdaHttpResponse> {
+export function versionGet(): Promise<LambdaHttpResponse> {
   const response = new LambdaHttpResponse(200, 'ok');
   response.header(HttpHeader.CacheControl, 'no-store');
   response.json({
@@ -20,5 +20,5 @@ export async function versionGet(): Promise<LambdaHttpResponse> {
      */
     buildId: process.env['BUILD_ID'],
   });
-  return response;
+  return Promise.resolve(response);
 }

package/src/util/__test__/config.loader.test.ts

@@ -42,11 +42,11 @@ describe('ConfigLoader', () => {
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=notapath`, Api.header),
     )
       .then(() => null)
-      .catch((e) => e);
+      .catch((e) => e as LambdaHttpResponse);
 
     assert.equal(error instanceof LambdaHttpResponse, true);
-    assert.equal((error as LambdaHttpResponse).status, 400);
-    assert.equal((error as LambdaHttpResponse).statusDescription, 'Invalid configuration location protocol:file:');
+    assert.equal(error?.status, 400);
+    assert.equal(error?.statusDescription, 'Invalid configuration location protocol:file:');
   });
 
   it('should Not working with wrong protocol', async () => {
@@ -54,11 +54,11 @@ describe('ConfigLoader', () => {
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=memory1://linz-basemaps/config`, Api.header),
     )
       .then(() => null)
-      .catch((e) => e);
+      .catch((e) => e as LambdaHttpResponse);
 
     assert.equal(error instanceof LambdaHttpResponse, true);
-    assert.equal((error as LambdaHttpResponse).status, 400);
-    assert.equal((error as LambdaHttpResponse).statusDescription, 'Invalid configuration location protocol:memory1:');
+    assert.equal(error?.status, 400);
+    assert.equal(error?.statusDescription, 'Invalid configuration location protocol:memory1:');
   });
 
   it('should Not working with wrong s3 bucket', async () => {
@@ -66,28 +66,25 @@ describe('ConfigLoader', () => {
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=s3://wrong-bucket/config`, Api.header),
     )
       .then(() => null)
-      .catch((e) => e);
+      .catch((e) => e as LambdaHttpResponse);
 
     assert.equal(error instanceof LambdaHttpResponse, true);
-    assert.equal((error as LambdaHttpResponse).status, 400);
-    assert.equal(
-      (error as LambdaHttpResponse).statusDescription,
-      'Bucket: "wrong-bucket" is not a allowed bucket location',
-    );
+    assert.equal(error?.status, 400);
+    assert.equal(error?.statusDescription, 'Bucket: "wrong-bucket" is not a allowed bucket location');
   });
 
   const location = new URL('memory://linz-basemaps/config.json');
 
   it('should Not working with no file in the path', async () => {
     const error = await ConfigLoader.load(
-      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location}`, Api.header),
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location.href}`, Api.header),
     )
       .then(() => null)
-      .catch((e) => e);
+      .catch((e) => e as LambdaHttpResponse);
 
     assert.equal(error instanceof LambdaHttpResponse, true);
-    assert.equal((error as LambdaHttpResponse).status, 400);
-    assert.equal((error as LambdaHttpResponse).statusDescription, `Invalid config location at ${location}`);
+    assert.equal(error?.status, 400);
+    assert.equal(error?.statusDescription, `Invalid config location at ${location.href}`);
   });
 
   it('should get expected config file', async () => {
@@ -96,7 +93,7 @@ describe('ConfigLoader', () => {
     await fsa.write(location, Buffer.from(JSON.stringify(expectedConfig.toJson())));
 
     const provider = await ConfigLoader.load(
-      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location}`, Api.header),
+      mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location.href}`, Api.header),
     );
 
     assert.deepEqual(await provider.Imagery.get('aerial'), await expectedConfig.Imagery.get('aerial'));
@@ -124,10 +121,10 @@ describe('ConfigLoader', () => {
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${deletedLocation}`, Api.header),
     )
       .then(() => null)
-      .catch((e) => e);
+      .catch((e) => e as LambdaHttpResponse);
 
     assert.equal(error instanceof LambdaHttpResponse, true);
-    assert.equal((error as LambdaHttpResponse).status, 400);
-    assert.equal((error as LambdaHttpResponse).statusDescription, `Invalid config location at ${deletedLocation}`);
+    assert.equal(error?.status, 400);
+    assert.equal(error?.statusDescription, `Invalid config location at ${deletedLocation}`);
   });
 });

package/src/util/config.cache.ts

@@ -1,5 +1,6 @@
 import { ConfigBundled, ConfigProviderMemory } from '@basemaps/config';
 import { fsa } from '@basemaps/shared';
+import { FsError } from '@chunkd/fs';
 
 import { SwappingLru } from './swapping.lru.js';
 
@@ -15,7 +16,7 @@ class LruConfig {
         return configProvider;
       })
       .catch((e) => {
-        if (e.code === 404) return null;
+        if ((e as FsError).code === 404) return null;
         throw e;
       });
   }

package/src/util/source.cache.ts

@@ -20,7 +20,9 @@ class LruStrutObj<T extends LruStrut> {
   ob: T;
   constructor(ob: T) {
     this.ob = ob;
-    if (this.ob._value == null) this.ob.value.then((c) => (this.ob._value = c));
+    if (this.ob._value == null) {
+      void this.ob.value.then((c) => (this.ob._value = c));
+    }
   }
 
   size = 1;
@@ -37,7 +39,7 @@ export class SourceCache {
 
     if (existing != null) {
       if (existing.type === 'cog') return existing.value;
-      throw new Error(`Existing object of type: ${existing.type} made for location: ${location}`);
+      throw new Error(`Existing object of type: ${existing.type} made for location: ${location.href}`);
     }
     const value = Tiff.create(fsa.source(location));
     this.cache.set(location.href, new LruStrutObj({ type: 'cog', value }));
@@ -48,8 +50,8 @@ export class SourceCache {
     const existing = this.cache.get(location.href)?.ob;
 
     if (existing != null) {
-      if (existing.type === 'cotar') return existing.value as Promise<Cotar>;
-      throw new Error(`Existing object of type: ${existing.type} made for location: ${location}`);
+      if (existing.type === 'cotar') return existing.value;
+      throw new Error(`Existing object of type: ${existing.type} made for location: ${location.href}`);
     }
     const value = Cotar.fromTar(fsa.source(location));
     this.cache.set(location.href, new LruStrutObj({ type: 'cotar', value }));

package/src/util/validate.ts

@@ -138,7 +138,7 @@ export const Validate = {
     }
     // If the tileset has pipelines defined the user MUST specify which one
     if (tileSet.outputs) {
-      throw new LambdaHttpResponse(404, 'TileSet needs pipeline: ' + tileSet.outputs.map((f) => f.name));
+      throw new LambdaHttpResponse(404, 'TileSet needs pipeline: ' + tileSet.outputs.map((f) => f.name).join(', '));
     }
 
     // Generate a default RGBA configuration

package/src/wmts.capability.ts

@@ -38,14 +38,15 @@ export interface WmtsBuilderParams {
   apiKey?: string;
   /** Config location */
   config?: string | null;
-  /** Specific DateRange filter for the wmts layers */
-  filters?: Record<string, string | undefined>;
+  /** Default pipeline to use */
+  pipeline?: string;
 }
 
 export class WmtsBuilder {
   httpBase: string;
   apiKey?: string;
   config?: string | null;
+  pipeline?: string;
   filters?: Record<string, string | undefined>;
 
   /** All the imagery used by the tileSet and tileMatrixes */
@@ -58,7 +59,7 @@ export class WmtsBuilder {
     this.httpBase = params.httpBase;
     this.apiKey = params.apiKey;
     this.config = params.config;
-    this.filters = params.filters;
+    this.pipeline = params.pipeline;
   }
 
   addImagery(...imagery: ConfigImagery[]): void {
@@ -153,17 +154,17 @@ export class WmtsBuilder {
     return V('Style', { isDefault: 'true' }, [V('ows:Title', 'Default Style'), V('ows:Identifier', 'default')]);
   }
 
-  buildResourceUrl(tileSetId: string, suffix: string, addFilter = false): VNodeElement {
+  buildResourceUrl(tileSetId: string, suffix: string): VNodeElement {
     return V('ResourceURL', {
       format: 'image/' + suffix,
       resourceType: 'tile',
-      template: this.buildTileUrl(tileSetId, suffix, addFilter),
+      template: this.buildTileUrl(tileSetId, suffix),
     });
   }
 
-  buildTileUrl(tileSetId: string, suffix: string, addFilter = false): string {
-    let query = { api: this.apiKey, config: this.config };
-    if (addFilter) query = { api: this.apiKey, config: this.config, ...this.filters };
+  buildTileUrl(tileSetId: string, suffix: string): string {
+    // TODO this should restrict the output formats to supported formats in pipelines
+    const query = { api: this.apiKey, config: this.config, pipeline: this.pipeline };
 
     return [
       this.httpBase,
@@ -239,6 +240,8 @@ export interface WmtsCapabilitiesParams {
   formats: ImageFormat[];
   /** Specific layers to add to the WMTS */
   layers?: ConfigLayer[];
+  /** Default output pipeline to use */
+  pipeline?: string | null;
 }
 
 /**
@@ -277,6 +280,10 @@ export class WmtsCapabilities extends WmtsBuilder {
     this.provider = provider;
   }
 
+  addPipeline(pipeline: string): void {
+    this.pipeline = pipeline;
+  }
+
   toProviderVNode(provider?: WmtsProvider): VNodeElement[] | [] {
     if (provider == null) return [];
     const { serviceIdentification, serviceProvider } = provider;
@@ -338,7 +345,7 @@ export class WmtsCapabilities extends WmtsBuilder {
       this.buildStyle(),
       ...this.buildFormats(),
       ...this.buildTileMatrixLink(tileSet),
-      ...this.getFormats().map((fmt) => this.buildResourceUrl(layerNameId, fmt, true)),
+      ...this.getFormats().map((fmt) => this.buildResourceUrl(layerNameId, fmt)),
     ]);
   }
 
@@ -408,5 +415,6 @@ export class WmtsCapabilities extends WmtsBuilder {
     this.addTileSet(params.tileSet);
     this.addLayers(params.layers);
     this.addProvider(params.provider);
+    if (params.pipeline) this.addPipeline(params.pipeline);
   }
 }

package/tsconfig.json

@@ -1,17 +1,17 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./build"
+    "outDir": "./build",
+    "rootDir": "./src"
   },
-  "include": ["src/**/*"],
+  "include": ["src"],
   "references": [
-    { "path": "../config" },
-    { "path": "../config-loader/" },
-    { "path": "../shared" },
-    { "path": "../geo" },
-    { "path": "../tiler" },
-    { "path": "../tiler-sharp" },
-    { "path": "../attribution" }
+    { "path": "../config/tsconfig.json" },
+    { "path": "../config-loader/tsconfig.json" },
+    { "path": "../shared/tsconfig.json" },
+    { "path": "../geo/tsconfig.json" },
+    { "path": "../tiler/tsconfig.json" },
+    { "path": "../tiler-sharp/tsconfig.json" },
+    { "path": "../attribution/tsconfig.json" }
   ]
 }