@basemaps/lambda-tiler 7.0.0 → 7.1.0

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

@@ -1,92 +1,96 @@
+import assert from 'node:assert';
+import { afterEach, before, beforeEach, describe, it } from 'node:test';
+
 import { base58, ConfigProviderMemory } from '@basemaps/config';
 import { fsa } from '@basemaps/shared';
+import { FsMemory } from '@chunkd/fs';
 import { LambdaHttpResponse } from '@linzjs/lambda';
-import o from 'ospec';
 import { createSandbox } from 'sinon';
-import { FsMemory } from '@chunkd/source-memory';
+
 import { FakeData } from '../../__tests__/config.data.js';
 import { Api, mockRequest, mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { CachedConfig } from '../config.cache.js';
 import { ConfigLoader } from '../config.loader.js';
 
-o.spec('ConfigLoader', () => {
+describe('ConfigLoader', () => {
   const memory = new FsMemory();
   const config = new ConfigProviderMemory();
   const sandbox = createSandbox();
 
-  o.before(() => {
+  before(() => {
     fsa.register('memory://', memory);
   });
 
-  o.beforeEach(() => {
+  beforeEach(() => {
     sandbox.stub(ConfigLoader, 'getDefaultConfig').resolves(config);
   });
 
-  o.afterEach(() => {
+  afterEach(() => {
     sandbox.restore();
     config.objects.clear();
     memory.files.clear();
     CachedConfig.cache.clear();
   });
 
-  o('should return default config', async () => {
+  it('should return default config', async () => {
     const provider = await ConfigLoader.load(mockRequest('/v1/fonts.json'));
-    o(provider).deepEquals(config);
+    assert.deepEqual(provider, config);
   });
 
-  o('should Not working with wrong config url', async () => {
+  it('should Not working with wrong config url', async () => {
     const error = await ConfigLoader.load(
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=notapath`, Api.header),
     )
       .then(() => null)
       .catch((e) => e);
 
-    o(error instanceof LambdaHttpResponse).equals(true);
-    o((error as LambdaHttpResponse).status).equals(400);
-    o((error as LambdaHttpResponse).statusDescription).equals('Invalid config location');
+    assert.equal(error instanceof LambdaHttpResponse, true);
+    assert.equal((error as LambdaHttpResponse).status, 400);
+    assert.equal((error as LambdaHttpResponse).statusDescription, 'Invalid configuration location protocol:file:');
   });
 
-  o('should Not working with wrong protocol', async () => {
+  it('should Not working with wrong protocol', async () => {
     const error = await ConfigLoader.load(
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=memory1://linz-basemaps/config`, Api.header),
     )
       .then(() => null)
       .catch((e) => e);
 
-    o(error instanceof LambdaHttpResponse).equals(true);
-    o((error as LambdaHttpResponse).status).equals(400);
-    o((error as LambdaHttpResponse).statusDescription).equals('Invalid configuration location protocol:memory1');
+    assert.equal(error instanceof LambdaHttpResponse, true);
+    assert.equal((error as LambdaHttpResponse).status, 400);
+    assert.equal((error as LambdaHttpResponse).statusDescription, 'Invalid configuration location protocol:memory1:');
   });
 
-  o('should Not working with wrong s3 bucket', async () => {
+  it('should Not working with wrong s3 bucket', async () => {
     const error = await ConfigLoader.load(
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=s3://wrong-bucket/config`, Api.header),
     )
       .then(() => null)
       .catch((e) => e);
 
-    o(error instanceof LambdaHttpResponse).equals(true);
-    o((error as LambdaHttpResponse).status).equals(400);
-    o((error as LambdaHttpResponse).statusDescription).equals(
+    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',
     );
   });
 
-  const location = 'memory://linz-basemaps/config.json';
+  const location = new URL('memory://linz-basemaps/config.json');
 
-  o('should Not working with no file in the path', async () => {
+  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),
     )
       .then(() => null)
       .catch((e) => e);
 
-    o(error instanceof LambdaHttpResponse).equals(true);
-    o((error as LambdaHttpResponse).status).equals(400);
-    o((error as LambdaHttpResponse).statusDescription).equals(`Invalid config location at ${location}`);
+    assert.equal(error instanceof LambdaHttpResponse, true);
+    assert.equal((error as LambdaHttpResponse).status, 400);
+    assert.equal((error as LambdaHttpResponse).statusDescription, `Invalid config location at ${location}`);
   });
 
-  o('should get expected config file', async () => {
+  it('should get expected config file', async () => {
     const expectedConfig = new ConfigProviderMemory();
     expectedConfig.put(FakeData.tileSetRaster('aerial'));
     await fsa.write(location, Buffer.from(JSON.stringify(expectedConfig.toJson())));
@@ -95,10 +99,10 @@ o.spec('ConfigLoader', () => {
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${location}`, Api.header),
     );
 
-    o(await provider.Imagery.get('aerial')).deepEquals(await expectedConfig.Imagery.get('aerial'));
+    assert.deepEqual(await provider.Imagery.get('aerial'), await expectedConfig.Imagery.get('aerial'));
   });
 
-  o('should get expected config file with base58 location', async () => {
+  it('should get expected config file with base58 location', async () => {
     const expectedConfig = new ConfigProviderMemory();
     expectedConfig.put(FakeData.tileSetVector('topographic'));
     await fsa.write(location, Buffer.from(JSON.stringify(expectedConfig.toJson())));
@@ -106,24 +110,24 @@ o.spec('ConfigLoader', () => {
     const provider = await ConfigLoader.load(
       mockUrlRequest(
         '/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json',
-        `?config=${base58.encode(Buffer.from(location))}`,
+        `?config=${base58.encode(Buffer.from(location.href))}`,
         Api.header,
       ),
     );
 
-    o(await provider.Imagery.get('topographic')).deepEquals(await expectedConfig.Imagery.get('topographic'));
+    assert.deepEqual(await provider.Imagery.get('topographic'), await expectedConfig.Imagery.get('topographic'));
   });
 
   const deletedLocation = 'memory://linz-basemaps/config-deleted.json';
-  o('should Error 400 if config file not exists', async () => {
+  it('should Error 400 if config file not exists', async () => {
     const error = await ConfigLoader.load(
       mockUrlRequest('/v1/tiles/🦄 🌈/NZTM2000Quad/tile.json', `?config=${deletedLocation}`, Api.header),
     )
       .then(() => null)
       .catch((e) => e);
 
-    o(error instanceof LambdaHttpResponse).equals(true);
-    o((error as LambdaHttpResponse).status).equals(400);
-    o((error as LambdaHttpResponse).statusDescription).equals(`Invalid config location at ${deletedLocation}`);
+    assert.equal(error instanceof LambdaHttpResponse, true);
+    assert.equal((error as LambdaHttpResponse).status, 400);
+    assert.equal((error as LambdaHttpResponse).statusDescription, `Invalid config location at ${deletedLocation}`);
   });
 });

package/src/util/__test__/filter.test.ts

@@ -1,9 +1,12 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
 import { ConfigLayer } from '@basemaps/config';
-import o from 'ospec';
+
 import { mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { filterLayers } from '../filter.js';
 
-o.spec('filterLayers', () => {
+describe('filterLayers', () => {
   const sourceLayers: ConfigLayer[] = [
     {
       name: 'waikato-0_625m-snc12836-2004',
@@ -23,38 +26,38 @@ o.spec('filterLayers', () => {
     },
   ];
 
-  o('should not filter with empty parameters', () => {
+  it('should not filter with empty parameters', () => {
     const layers = filterLayers(mockUrlRequest('/foo/bar,js'), sourceLayers);
-    o(layers).deepEquals(sourceLayers);
+    assert.deepEqual(layers, sourceLayers);
   });
 
-  o('should filter date[after]', () => {
+  it('should filter date[after]', () => {
     const dateAfter = '2003-12-31T23:59:59.999';
     const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), sourceLayers);
-    o(layers).deepEquals([sourceLayers[0]]);
+    assert.deepEqual(layers, [sourceLayers[0]]);
   });
 
-  o('should filter date[before]', () => {
+  it('should filter date[before]', () => {
     const dateBefore = '2003-01-01T00:00:00.000Z';
     const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), sourceLayers);
-    o(layers).deepEquals(sourceLayers.slice(1));
+    assert.deepEqual(layers, sourceLayers.slice(1));
   });
 
-  o('should filter date[before] in between years', () => {
+  it('should filter date[before] in between years', () => {
     const dateBefore = '2026-01-01T00:00:00.000Z';
     const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
     const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[before]=${dateBefore}`), layer);
-    o(layers).deepEquals(layer);
+    assert.deepEqual(layers, layer);
   });
 
-  o('should filter date[after] in between years', () => {
+  it('should filter date[after] in between years', () => {
     const dateAfter = '2026-12-31T23:59:59.999Z';
     const layer = [{ name: '', title: 'Waikato 0.625m SNC12836 (2020-2028)' }];
     const layers = filterLayers(mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}`), layer);
-    o(layers).deepEquals(layer);
+    assert.deepEqual(layers, layer);
   });
 
-  o('should filter date[after] and date[before] in between years', () => {
+  it('should filter date[after] and date[before] in between years', () => {
     const dateAfter = '2026-12-31T23:59:59.999Z';
     const dateBefore = '2028-01-01T00:00:00.000Z';
 
@@ -63,10 +66,10 @@ o.spec('filterLayers', () => {
       mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
       layer,
     );
-    o(layers).deepEquals(layer);
+    assert.deepEqual(layers, layer);
   });
 
-  o('should filter date[after] and date[before] in between years with single year', () => {
+  it('should filter date[after] and date[before] in between years with single year', () => {
     const dateAfter = '2026-12-31T23:59:59.999Z';
     const dateBefore = '2028-01-01T00:00:00.000Z';
 
@@ -75,6 +78,6 @@ o.spec('filterLayers', () => {
       mockUrlRequest('/foo/bar,js', `?date[after]=${dateAfter}&date[before]=${dateBefore}`),
       layer,
     );
-    o(layers).deepEquals(layer);
+    assert.deepEqual(layers, layer);
   });
 });

package/src/util/__test__/validate.test.ts

@@ -1,74 +1,59 @@
-import { GoogleTms, ImageFormat, Nztm2000QuadTms, Nztm2000Tms, VectorFormat } from '@basemaps/geo';
-import o from 'ospec';
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+
+import { GoogleTms, Nztm2000QuadTms, Nztm2000Tms } from '@basemaps/geo';
+
 import { mockUrlRequest } from '../../__tests__/xyz.util.js';
 import { Validate } from '../validate.js';
 
-o.spec('GetImageFormats', () => {
-  o('should parse all formats', () => {
+describe('GetImageFormats', () => {
+  it('should parse all formats', () => {
     const req = mockUrlRequest('/v1/blank', 'format=png&format=jpeg');
     const formats = Validate.getRequestedFormats(req);
-    o(formats).deepEquals([ImageFormat.Png, ImageFormat.Jpeg]);
+    assert.deepEqual(formats, ['png', 'jpeg']);
   });
 
-  o('should ignore bad formats', () => {
+  it('should ignore bad formats', () => {
     const req = mockUrlRequest('/v1/blank', 'format=fake&format=mvt');
     const formats = Validate.getRequestedFormats(req);
-    o(formats).equals(null);
+    assert.equal(formats, null);
   });
 
-  o('should de-dupe formats', () => {
+  it('should de-dupe formats', () => {
     const req = mockUrlRequest('/v1/blank', 'format=png&format=jpeg&format=png&format=jpeg&format=png&format=jpeg');
     const formats = Validate.getRequestedFormats(req);
-    o(formats).deepEquals([ImageFormat.Png, ImageFormat.Jpeg]);
+    assert.deepEqual(formats, ['png', 'jpeg']);
   });
 
-  o('should support "tileFormat" Alias all formats', () => {
+  it('should support "tileFormat" Alias all formats', () => {
     const req = mockUrlRequest('/v1/blank', 'tileFormat=png&format=jpeg');
     const formats = Validate.getRequestedFormats(req);
-    o(formats).deepEquals([ImageFormat.Jpeg, ImageFormat.Png]);
+    assert.deepEqual(formats, ['jpeg', 'png']);
   });
 
-  o('should not duplicate "tileFormat" alias all formats', () => {
+  it('should not duplicate "tileFormat" alias all formats', () => {
     const req = mockUrlRequest('/v1/blank', 'tileFormat=jpeg&format=jpeg');
     const formats = Validate.getRequestedFormats(req);
-    o(formats).deepEquals([ImageFormat.Jpeg]);
+    assert.deepEqual(formats, ['jpeg']);
   });
 });
 
-o.spec('getTileMatrixSet', () => {
-  o('should lookup epsg codes', () => {
-    o(Validate.getTileMatrixSet('EPSG:3857')?.identifier).equals(GoogleTms.identifier);
-    o(Validate.getTileMatrixSet('EPSG:2193')?.identifier).equals(Nztm2000Tms.identifier);
+describe('getTileMatrixSet', () => {
+  it('should lookup epsg codes', () => {
+    assert.equal(Validate.getTileMatrixSet('EPSG:3857')?.identifier, GoogleTms.identifier);
+    assert.equal(Validate.getTileMatrixSet('EPSG:2193')?.identifier, Nztm2000Tms.identifier);
 
-    o(Validate.getTileMatrixSet('3857')?.identifier).equals(GoogleTms.identifier);
-    o(Validate.getTileMatrixSet('2193')?.identifier).equals(Nztm2000Tms.identifier);
+    assert.equal(Validate.getTileMatrixSet('3857')?.identifier, GoogleTms.identifier);
+    assert.equal(Validate.getTileMatrixSet('2193')?.identifier, Nztm2000Tms.identifier);
   });
 
-  o('should lookup by identifier', () => {
-    o(Validate.getTileMatrixSet('WebMercatorQuad')?.identifier).equals(GoogleTms.identifier);
-    o(Validate.getTileMatrixSet('NZTM2000Quad')?.identifier).equals(Nztm2000QuadTms.identifier);
-    o(Validate.getTileMatrixSet('Nztm2000')?.identifier).equals(Nztm2000Tms.identifier);
+  it('should lookup by identifier', () => {
+    assert.equal(Validate.getTileMatrixSet('WebMercatorQuad')?.identifier, GoogleTms.identifier);
+    assert.equal(Validate.getTileMatrixSet('NZTM2000Quad')?.identifier, Nztm2000QuadTms.identifier);
+    assert.equal(Validate.getTileMatrixSet('Nztm2000')?.identifier, Nztm2000Tms.identifier);
   });
 
-  o('should be case sensitive', () => {
-    o(Validate.getTileMatrixSet('Nztm2000Quad')?.identifier).equals(undefined);
+  it('should be case sensitive', () => {
+    assert.equal(Validate.getTileMatrixSet('Nztm2000Quad')?.identifier, undefined);
   });
 });
-
-o.spec('getTileFormat', () => {
-  for (const ext of Object.values(ImageFormat)) {
-    o('should support image format:' + ext, () => {
-      o(Validate.getTileFormat(ext)).equals(ext);
-    });
-  }
-
-  o('should support vector format: mvt', () => {
-    o(Validate.getTileFormat('pbf')).equals(VectorFormat.MapboxVectorTiles);
-  });
-
-  for (const fmt of ['FAKE', /* 'JPEG' // TODO should this be case sensitive ,*/ 'mvt', 'json']) {
-    o('should not support format:' + fmt, () => {
-      o(Validate.getTileFormat(fmt)).equals(null);
-    });
-  }
-});

package/src/util/assets.provider.ts

@@ -1,5 +1,6 @@
-import { fsa } from '@chunkd/fs';
-import { LambdaHttpResponse, LambdaHttpRequest, HttpHeader } from '@linzjs/lambda';
+import { fsa } from '@basemaps/shared';
+import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { ConfigLoader } from './config.loader.js';
 import { isGzip } from './cotar.serve.js';
 import { Etag } from './etag.js';
@@ -16,21 +17,21 @@ export class AssetProvider {
    * s3://linz-basemaps/assets/assets-b4ff211a.tar.co # Remote Cotar
    */
 
-  async get(path: string, fileName: string): Promise<Buffer | null> {
+  async get(url: URL, fileName: string): Promise<Buffer | null> {
     // get assets file from cotar
-    if (path.endsWith('.tar.co')) return await this.getFromCotar(path, fileName);
+    if (url.pathname.endsWith('.tar.co')) return await this.getFromCotar(url, fileName);
 
     // get assets file for directory
     try {
-      const filePath = fsa.join(path, fileName);
+      const filePath = new URL(fileName, url);
       return await fsa.read(filePath);
-    } catch (e: any) {
-      if (e.code === 404) return null;
+    } catch (e) {
+      if ((e as { code: number })?.code === 404) return null;
       throw e;
     }
   }
 
-  async getFromCotar(path: string, fileName: string): Promise<Buffer | null> {
+  async getFromCotar(path: URL, fileName: string): Promise<Buffer | null> {
     const cotar = await CoSources.getCotar(path);
     const data = await cotar.get(fileName);
     return data ? Buffer.from(data) : data;
@@ -47,7 +48,7 @@ export class AssetProvider {
     const config = await ConfigLoader.load(req);
     if (config == null) return NotFound();
     if (config.assets == null) return NotFound();
-    const buf = await assetProvider.get(config.assets, file);
+    const buf = await assetProvider.get(fsa.toUrl(config.assets), file);
     if (buf == null) return NotFound();
     const cacheKey = Etag.key(buf);
     if (Etag.isNotModified(req, cacheKey)) return NotModified();

package/src/util/config.cache.ts

@@ -1,5 +1,6 @@
 import { ConfigBundled, ConfigProviderMemory } from '@basemaps/config';
 import { fsa } from '@basemaps/shared';
+
 import { SwappingLru } from './swapping.lru.js';
 
 class LruConfig {
@@ -31,14 +32,14 @@ export class ConfigCache {
     this.cache = new SwappingLru<LruConfig>(maxSize);
   }
 
-  get(location: string): Promise<ConfigProviderMemory | null> {
-    const existing = this.cache.get(location)?.configProvider;
+  get(location: URL): Promise<ConfigProviderMemory | null> {
+    const existing = this.cache.get(location.href)?.configProvider;
     if (existing != null) return existing;
     const configJson = fsa.readJson<ConfigBundled>(location).catch(() => {
       return null;
     });
     const config = new LruConfig(configJson);
-    this.cache.set(location, config);
+    this.cache.set(location.href, config);
     return config.configProvider;
   }
 }

package/src/util/config.loader.ts

@@ -1,11 +1,11 @@
 import { base58, BasemapsConfigProvider, isBase58 } from '@basemaps/config';
+import { fsa, getDefaultConfig } from '@basemaps/shared';
 import { LambdaHttpResponse } from '@linzjs/lambda';
-import { parseUri } from '@chunkd/core';
 import { LambdaHttpRequest } from '@linzjs/lambda';
+
 import { CachedConfig } from './config.cache.js';
-import { getDefaultConfig } from '@basemaps/shared';
 
-// FIXME load this from process.env COG BUCKETS?
+// TODO load this from process.env COG BUCKETS?
 const SafeBuckets = new Set([
   'linz-workflows-scratch',
   'linz-workflow-artifacts',
@@ -13,7 +13,8 @@ const SafeBuckets = new Set([
   'linz-basemaps-staging',
   'linz-basemaps-scratch',
 ]);
-const SafeProtocols = new Set(['s3', 'memory']);
+
+const SafeProtocols = new Set([new URL('s3://foo').protocol, new URL('memory://foo.json').protocol]);
 
 export class ConfigLoader {
   /** Exposed for testing */
@@ -39,20 +40,19 @@ export class ConfigLoader {
     if (rawLocation == null) return this.getDefaultConfig();
 
     const configLocation = isBase58(rawLocation) ? Buffer.from(base58.decode(rawLocation)).toString() : rawLocation;
+    const configUrl = fsa.toUrl(configLocation);
 
-    const r = parseUri(configLocation);
-
-    if (r == null) throw new LambdaHttpResponse(400, 'Invalid config location');
-    if (!SafeProtocols.has(r.protocol)) {
-      throw new LambdaHttpResponse(400, `Invalid configuration location protocol:${r.protocol}`);
+    if (configUrl == null) throw new LambdaHttpResponse(400, 'Invalid config location');
+    if (!SafeProtocols.has(configUrl.protocol)) {
+      throw new LambdaHttpResponse(400, `Invalid configuration location protocol:${configUrl.protocol}`);
     }
-    if (!SafeBuckets.has(r.bucket)) {
-      throw new LambdaHttpResponse(400, `Bucket: "${r.bucket}" is not a allowed bucket location`);
+    if (!SafeBuckets.has(configUrl.hostname)) {
+      throw new LambdaHttpResponse(400, `Bucket: "${configUrl.hostname}" is not a allowed bucket location`);
     }
 
-    req.set('config', configLocation);
+    req.set('config', configUrl.href);
     req.timer.start('config:load');
-    return CachedConfig.get(configLocation).then((f) => {
+    return CachedConfig.get(configUrl).then((f) => {
       req.timer.end('config:load');
       if (f == null) throw new LambdaHttpResponse(400, `Invalid config location at ${configLocation}`);
       return f;

package/src/util/cotar.serve.ts

@@ -1,4 +1,5 @@
 import { HttpHeader, LambdaHttpRequest, LambdaHttpResponse } from '@linzjs/lambda';
+
 import { Etag } from './etag.js';
 import { NotFound, NotModified } from './response.js';
 import { CoSources } from './source.cache.js';
@@ -12,11 +13,11 @@ import { CoSources } from './source.cache.js';
  */
 export async function serveFromCotar(
   req: LambdaHttpRequest,
-  cotarPath: string,
+  url: URL,
   assetPath: string,
   contentType: string,
 ): Promise<LambdaHttpResponse> {
-  const cotar = await CoSources.getCotar(cotarPath);
+  const cotar = await CoSources.getCotar(url);
   if (cotar == null) return NotFound();
   const fileData = await cotar.get(assetPath);
   if (fileData == null) return NotFound();

package/src/util/source.cache.ts

@@ -1,8 +1,5 @@
-import { fsa } from '@basemaps/shared';
-import { ChunkSourceBase } from '@chunkd/core';
-import { CogTiff } from '@cogeotiff/core';
-import { Cotar } from '@cotar/core';
-import { St } from './source.tracer.js';
+import { Cotar, fsa, Tiff } from '@basemaps/shared';
+
 import { SwappingLru } from './swapping.lru.js';
 
 export type LruStrut = LruStrutCotar | LruStrutCog;
@@ -15,8 +12,8 @@ export interface LruStrutCotar {
 
 export interface LruStrutCog {
   type: 'cog';
-  value: Promise<CogTiff>;
-  _value?: CogTiff;
+  value: Promise<Tiff>;
+  _value?: Tiff;
 }
 
 class LruStrutObj<T extends LruStrut> {
@@ -26,11 +23,7 @@ class LruStrutObj<T extends LruStrut> {
     if (this.ob._value == null) this.ob.value.then((c) => (this.ob._value = c));
   }
 
-  get size(): number {
-    const val = this.ob._value;
-    if (val == null) return 0;
-    return val.source.chunkSize * (val.source as ChunkSourceBase).chunks.size;
-  }
+  size = 1;
 }
 
 export class SourceCache {
@@ -39,34 +32,30 @@ export class SourceCache {
     this.cache = new SwappingLru<LruStrutObj<LruStrut>>(maxSize);
   }
 
-  getCog(location: string): Promise<CogTiff> {
-    const existing = this.cache.get(location)?.ob;
+  getCog(location: URL): Promise<Tiff> {
+    const existing = this.cache.get(location.href)?.ob;
 
     if (existing != null) {
       if (existing.type === 'cog') return existing.value;
       throw new Error(`Existing object of type: ${existing.type} made for location: ${location}`);
     }
-    const source = fsa.source(location);
-    St.trace(source);
-    const value = CogTiff.create(source);
-    this.cache.set(location, new LruStrutObj({ type: 'cog', value }));
+    const value = Tiff.create(fsa.source(location));
+    this.cache.set(location.href, new LruStrutObj({ type: 'cog', value }));
     return value;
   }
 
-  getCotar(location: string): Promise<Cotar> {
-    const existing = this.cache.get(location)?.ob;
+  getCotar(location: URL): Promise<Cotar> {
+    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}`);
     }
-    const source = fsa.source(location);
-    St.trace(source);
-    const value = Cotar.fromTar(source);
-    this.cache.set(location, new LruStrutObj({ type: 'cotar', value }));
+    const value = Cotar.fromTar(fsa.source(location));
+    this.cache.set(location.href, new LruStrutObj({ type: 'cotar', value }));
     return value;
   }
 }
 
-/** Approx ~1.4GB 2x~700MB caches */
-export const CoSources = new SourceCache(700 * 1000 * 1000);
+/** Cache the last 5,000 tiff/tar files accessed, generally it is only <100KB of memory used per tiff file so approx 50MB of cache */
+export const CoSources = new SourceCache(5000);