@cogeotiff/cli 9.0.7 → 9.1.0

package/CHANGELOG.md

@@ -24,6 +24,20 @@
   * dependencies
     * @cogeotiff/core bumped from ^9.1.1 to ^9.1.2
 
+## [9.1.0](https://github.com/blacha/cogeotiff/compare/cli-v9.0.7...cli-v9.1.0) (2026-02-20)
+
+
+### Features
+
+* **cli:** trace how a tiff is loaded with fetch-tile ([#1414](https://github.com/blacha/cogeotiff/issues/1414)) ([8a69302](https://github.com/blacha/cogeotiff/commit/8a693021e2c07fd08c6e2470d00106126e5b9f70))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @cogeotiff/core bumped from ^9.2.0 to ^9.3.0
+
 ## [9.0.7](https://github.com/blacha/cogeotiff/compare/cli-v9.0.6...cli-v9.0.7) (2026-02-18)
 
 

package/build/commands/fetch-tile.d.ts

@@ -0,0 +1,20 @@
+export declare const commandFetchTile: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
+    parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
+        tile: string;
+        output: URL | undefined;
+        readSize: number;
+        path: URL;
+        verbose: boolean;
+        extraVerbose: boolean;
+    }>>;
+} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
+    tile: string;
+    output: URL | undefined;
+    readSize: number;
+    path: URL;
+    verbose: boolean;
+    extraVerbose: boolean;
+}, Promise<void>> & {
+    run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<Promise<void>>>;
+} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
+//# sourceMappingURL=fetch-tile.d.ts.map

package/build/commands/fetch-tile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-tile.d.ts","sourceRoot":"","sources":["../../src/commands/fetch-tile.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;6JAsF3B,CAAC"}

package/build/commands/fetch-tile.js

@@ -0,0 +1,85 @@
+import { fsa } from '@chunkd/fs';
+import { Tiff, TiffTag } from '@cogeotiff/core';
+import { command, number, option, optional, positional, string } from 'cmd-ts';
+import { DefaultArgs, Url } from '../common.js';
+import { FetchLog } from '../fs.js';
+import { setupLogger } from '../log.js';
+export const commandFetchTile = command({
+    name: 'fetch-tile',
+    args: {
+        ...DefaultArgs,
+        tile: option({
+            short: 't',
+            long: 'tile',
+            description: 'tile to process "z-x-y" multiple tiles can be fetched by comma separating them "z-x-y,z-x-y"',
+            type: string,
+            defaultValue: () => '0-0-0',
+        }),
+        output: option({ short: 'o', long: 'output', type: optional(Url) }),
+        readSize: option({
+            long: 'read-size',
+            description: 'Size of bytes to read for the tile, default is to read the whole tile in KB',
+            type: number,
+            defaultValue: () => 16,
+        }),
+        path: positional({ type: Url, description: 'File to process' }),
+    },
+    async handler(args) {
+        const logger = setupLogger(args);
+        if (logger.level === 'warn')
+            logger.level = 'info';
+        fsa.middleware = [FetchLog]; // reset middleware so we don't cache or chunk requests
+        const tiles = args.tile.split(',').map((t) => t.split('-').map((s) => parseInt(s, 10)));
+        for (const t of tiles) {
+            if (isNaN(t[0]) || isNaN(t[1]) || isNaN(t[2])) {
+                logger.error('Invalid tile format, expected {z-x-y}', { tile: args.tile });
+                return;
+            }
+        }
+        const tiff = new Tiff(fsa.source(args.path));
+        tiff.defaultReadSize = args.readSize * 1024;
+        logger.debug('Tiff:load', { path: args.path.href });
+        const loadStart = performance.now();
+        await tiff.init();
+        const loadEnd = performance.now();
+        logger.info('Tiff:loaded', {
+            path: args.path.href,
+            fetches: FetchLog.fetches.length,
+            bytesRead: FetchLog.bytesRead,
+            duration: loadEnd - loadStart,
+        });
+        for (const i of tiff.images) {
+            const byteCount = i.tags.get(TiffTag.TileByteCounts);
+            const tileOffsets = i.tags.get(TiffTag.TileOffsets);
+            logger.debug('Image:TileInfo', {
+                image: i.id,
+                toLoaded: tileOffsets?.isLoaded,
+                bcLoaded: byteCount?.isLoaded,
+                bcOffset: byteCount?.dataOffset,
+                toOffset: tileOffsets?.dataOffset,
+                count: byteCount?.count,
+            });
+        }
+        for (const t of tiles) {
+            const [z, x, y] = t;
+            if (tiff.images.length < z || z < 0) {
+                logger.error('Invalid tile z level', { z, max: tiff.images.length });
+                return;
+            }
+            const image = tiff.images[z];
+            const tile = await image.getTile(x, y);
+            if (tile == null) {
+                logger.error('Failed to fetch tile', { z, x, y });
+                return;
+            }
+            logger.info('Tile:fetched', {
+                z,
+                x,
+                y,
+                bytes: tile.bytes.byteLength,
+                fetches: FetchLog.fetches.length,
+                bytesRead: FetchLog.bytesRead,
+            });
+        }
+    },
+});

package/build/fs.js

@@ -4,7 +4,7 @@ export const FetchLog = {
     fetch(req, next) {
         this.fetches.push(req);
         this.bytesRead += req.length ?? 0;
-        logger.info('Tiff:fetch', { href: req.source.url.href, offset: req.offset, length: req.length });
+        logger.debug('Tiff:fetch', { href: req.source.url.href, offset: req.offset, length: req.length });
         return next(req);
     },
     reset() {

package/build/index.d.ts

@@ -9,6 +9,16 @@ export declare const cmd: Partial<import("cmd-ts/dist/cjs/argparser.js").Registe
             verbose: boolean;
             extraVerbose: boolean;
         };
+    } | {
+        command: "fetch-tile";
+        args: {
+            tile: string;
+            output: URL | undefined;
+            readSize: number;
+            path: URL;
+            verbose: boolean;
+            extraVerbose: boolean;
+        };
     } | {
         command: "info";
         args: {
@@ -31,6 +41,16 @@ export declare const cmd: Partial<import("cmd-ts/dist/cjs/argparser.js").Registe
         verbose: boolean;
         extraVerbose: boolean;
     };
+} | {
+    command: "fetch-tile";
+    args: {
+        tile: string;
+        output: URL | undefined;
+        readSize: number;
+        path: URL;
+        verbose: boolean;
+        extraVerbose: boolean;
+    };
 } | {
     command: "info";
     args: {
@@ -45,6 +65,9 @@ export declare const cmd: Partial<import("cmd-ts/dist/cjs/argparser.js").Registe
 }, {
     command: "dump";
     value: Promise<void>;
+} | {
+    command: "fetch-tile";
+    value: Promise<void>;
 } | {
     command: "info";
     value: Promise<void>;
@@ -52,6 +75,9 @@ export declare const cmd: Partial<import("cmd-ts/dist/cjs/argparser.js").Registe
     run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
         command: "dump";
         value: Promise<void>;
+    } | {
+        command: "fetch-tile";
+        value: Promise<void>;
     } | {
         command: "info";
         value: Promise<void>;

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOd,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQd,CAAC"}

package/build/index.js

@@ -1,5 +1,6 @@
 import { subcommands } from 'cmd-ts';
 import { commandDump } from './commands/dump.js';
+import { commandFetchTile } from './commands/fetch-tile.js';
 import { commandInfo } from './commands/info.js';
 export const cmd = subcommands({
     name: 'cogeotiff',
@@ -7,5 +8,6 @@ export const cmd = subcommands({
     cmds: {
         info: commandInfo,
         dump: commandDump,
+        'fetch-tile': commandFetchTile,
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogeotiff/cli",
-  "version": "9.0.7",
+  "version": "9.1.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/blacha/cogeotiff.git",
@@ -21,7 +21,7 @@
     "@chunkd/fs-aws": "^11.0.2",
     "@chunkd/middleware": "^11.0.0",
     "@chunkd/source": "^11.0.0",
-    "@cogeotiff/core": "^9.2.0",
+    "@cogeotiff/core": "^9.3.0",
     "@linzjs/tracing": "^1.1.1",
     "ansi-colors": "^4.1.1",
     "cmd-ts": "^0.14.3",
@@ -35,5 +35,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "62a59096f2df47bd12cc969afdda1d90c31d679e"
+  "gitHead": "82b82e9d9f8996dfb0cb48827c143e134acc9865"
 }

package/src/commands/fetch-tile.ts

@@ -0,0 +1,95 @@
+import { fsa } from '@chunkd/fs';
+import { TagOffset, Tiff, TiffTag } from '@cogeotiff/core';
+import { command, number, option, optional, positional, string } from 'cmd-ts';
+
+import { DefaultArgs, Url } from '../common.js';
+import { FetchLog } from '../fs.js';
+import { setupLogger } from '../log.js';
+
+export const commandFetchTile = command({
+  name: 'fetch-tile',
+  args: {
+    ...DefaultArgs,
+    tile: option({
+      short: 't',
+      long: 'tile',
+      description: 'tile to process "z-x-y" multiple tiles can be fetched by comma separating them "z-x-y,z-x-y"',
+      type: string,
+      defaultValue: () => '0-0-0',
+    }),
+    output: option({ short: 'o', long: 'output', type: optional(Url) }),
+    readSize: option({
+      long: 'read-size',
+      description: 'Size of bytes to read for the tile, default is to read the whole tile in KB',
+      type: number,
+      defaultValue: () => 16,
+    }),
+    path: positional({ type: Url, description: 'File to process' }),
+  },
+
+  async handler(args) {
+    const logger = setupLogger(args);
+    if (logger.level === 'warn') logger.level = 'info';
+    fsa.middleware = [FetchLog]; // reset middleware so we don't cache or chunk requests
+
+    const tiles = args.tile.split(',').map((t) => t.split('-').map((s) => parseInt(s, 10)));
+    for (const t of tiles) {
+      if (isNaN(t[0]) || isNaN(t[1]) || isNaN(t[2])) {
+        logger.error('Invalid tile format, expected {z-x-y}', { tile: args.tile });
+        return;
+      }
+    }
+
+    const tiff = new Tiff(fsa.source(args.path));
+    tiff.defaultReadSize = args.readSize * 1024;
+
+    logger.debug('Tiff:load', { path: args.path.href });
+    const loadStart = performance.now();
+    await tiff.init();
+    const loadEnd = performance.now();
+    logger.info('Tiff:loaded', {
+      path: args.path.href,
+      fetches: FetchLog.fetches.length,
+      bytesRead: FetchLog.bytesRead,
+      duration: loadEnd - loadStart,
+    });
+
+    for (const i of tiff.images) {
+      const byteCount = i.tags.get(TiffTag.TileByteCounts) as TagOffset | undefined;
+      const tileOffsets = i.tags.get(TiffTag.TileOffsets) as TagOffset | undefined;
+      logger.debug('Image:TileInfo', {
+        image: i.id,
+        toLoaded: tileOffsets?.isLoaded,
+        bcLoaded: byteCount?.isLoaded,
+        bcOffset: byteCount?.dataOffset,
+        toOffset: tileOffsets?.dataOffset,
+        count: byteCount?.count,
+      });
+    }
+
+    for (const t of tiles) {
+      const [z, x, y] = t;
+
+      if (tiff.images.length < z || z < 0) {
+        logger.error('Invalid tile z level', { z, max: tiff.images.length });
+        return;
+      }
+
+      const image = tiff.images[z];
+      const tile = await image.getTile(x, y);
+      if (tile == null) {
+        logger.error('Failed to fetch tile', { z, x, y });
+        return;
+      }
+
+      logger.info('Tile:fetched', {
+        z,
+        x,
+        y,
+        bytes: tile.bytes.byteLength,
+        fetches: FetchLog.fetches.length,
+        bytesRead: FetchLog.bytesRead,
+      });
+    }
+  },
+});

package/src/fs.ts

@@ -7,7 +7,7 @@ export const FetchLog: SourceMiddleware & { reset(): void; fetches: SourceReques
   fetch(req: SourceRequest, next: SourceCallback) {
     this.fetches.push(req);
     this.bytesRead += req.length ?? 0;
-    logger.info('Tiff:fetch', { href: req.source.url.href, offset: req.offset, length: req.length });
+    logger.debug('Tiff:fetch', { href: req.source.url.href, offset: req.offset, length: req.length });
     return next(req);
   },
   reset() {

package/src/index.ts

@@ -1,6 +1,7 @@
 import { subcommands } from 'cmd-ts';
 
 import { commandDump } from './commands/dump.js';
+import { commandFetchTile } from './commands/fetch-tile.js';
 import { commandInfo } from './commands/info.js';
 
 export const cmd = subcommands({
@@ -9,5 +10,6 @@ export const cmd = subcommands({
   cmds: {
     info: commandInfo,
     dump: commandDump,
+    'fetch-tile': commandFetchTile,
   },
 });